���ѧۧݧ�ӧ�� �ާ֧ߧ֧էا֧� - ���֧էѧܧ�ڧ��ӧѧ�� - /home/ukubnwwtacc0unt/chapelbellstudios.com/uploads/cover/cffi.zip
���ѧ٧ѧ�
PK %�\2��t� � ffiplatform.pynu �[��� import sys, os from .error import VerificationError LIST_OF_FILE_NAMES = ['sources', 'include_dirs', 'library_dirs', 'extra_objects', 'depends'] def get_extension(srcfilename, modname, sources=(), **kwds): _hack_at_distutils() from distutils.core import Extension allsources = [srcfilename] for src in sources: allsources.append(os.path.normpath(src)) return Extension(name=modname, sources=allsources, **kwds) def compile(tmpdir, ext, compiler_verbose=0, debug=None): """Compile a C extension module using distutils.""" _hack_at_distutils() saved_environ = os.environ.copy() try: outputfilename = _build(tmpdir, ext, compiler_verbose, debug) outputfilename = os.path.abspath(outputfilename) finally: # workaround for a distutils bugs where some env vars can # become longer and longer every time it is used for key, value in saved_environ.items(): if os.environ.get(key) != value: os.environ[key] = value return outputfilename def _build(tmpdir, ext, compiler_verbose=0, debug=None): # XXX compact but horrible :-( from distutils.core import Distribution import distutils.errors, distutils.log # dist = Distribution({'ext_modules': [ext]}) dist.parse_config_files() options = dist.get_option_dict('build_ext') if debug is None: debug = sys.flags.debug options['debug'] = ('ffiplatform', debug) options['force'] = ('ffiplatform', True) options['build_lib'] = ('ffiplatform', tmpdir) options['build_temp'] = ('ffiplatform', tmpdir) # try: old_level = distutils.log.set_threshold(0) or 0 try: distutils.log.set_verbosity(compiler_verbose) dist.run_command('build_ext') cmd_obj = dist.get_command_obj('build_ext') [soname] = cmd_obj.get_outputs() finally: distutils.log.set_threshold(old_level) except (distutils.errors.CompileError, distutils.errors.LinkError) as e: raise VerificationError('%s: %s' % (e.__class__.__name__, e)) # return soname try: from os.path import samefile except ImportError: def samefile(f1, f2): return os.path.abspath(f1) == os.path.abspath(f2) def maybe_relative_path(path): if not os.path.isabs(path): return path # already relative dir = path names = [] while True: prevdir = dir dir, name = os.path.split(prevdir) if dir == prevdir or not dir: return path # failed to make it relative names.append(name) try: if samefile(dir, os.curdir): names.reverse() return os.path.join(*names) except OSError: pass # ____________________________________________________________ try: int_or_long = (int, long) import cStringIO except NameError: int_or_long = int # Python 3 import io as cStringIO def _flatten(x, f): if isinstance(x, str): f.write('%ds%s' % (len(x), x)) elif isinstance(x, dict): keys = sorted(x.keys()) f.write('%dd' % len(keys)) for key in keys: _flatten(key, f) _flatten(x[key], f) elif isinstance(x, (list, tuple)): f.write('%dl' % len(x)) for value in x: _flatten(value, f) elif isinstance(x, int_or_long): f.write('%di' % (x,)) else: raise TypeError( "the keywords to verify() contains unsupported object %r" % (x,)) def flatten(x): f = cStringIO.StringIO() _flatten(x, f) return f.getvalue() def _hack_at_distutils(): # Windows-only workaround for some configurations: see # https://bugs.python.org/issue23246 (Python 2.7 with # a specific MS compiler suite download) if sys.platform == "win32": try: import setuptools # for side-effects, patches distutils except ImportError: pass PK %�\�`C�4h 4h vengine_gen.pynu �[��� # # DEPRECATED: implementation for ffi.verify() # import sys, os import types from . import model from .error import VerificationError class VGenericEngine(object): _class_key = 'g' _gen_python_module = False def __init__(self, verifier): self.verifier = verifier self.ffi = verifier.ffi self.export_symbols = [] self._struct_pending_verification = {} def patch_extension_kwds(self, kwds): # add 'export_symbols' to the dictionary. Note that we add the # list before filling it. When we fill it, it will thus also show # up in kwds['export_symbols']. kwds.setdefault('export_symbols', self.export_symbols) def find_module(self, module_name, path, so_suffixes): for so_suffix in so_suffixes: basename = module_name + so_suffix if path is None: path = sys.path for dirname in path: filename = os.path.join(dirname, basename) if os.path.isfile(filename): return filename def collect_types(self): pass # not needed in the generic engine def _prnt(self, what=''): self._f.write(what + '\n') def write_source_to_f(self): prnt = self._prnt # first paste some standard set of lines that are mostly '#include' prnt(cffimod_header) # then paste the C source given by the user, verbatim. prnt(self.verifier.preamble) # # call generate_gen_xxx_decl(), for every xxx found from # ffi._parser._declarations. This generates all the functions. self._generate('decl') # # on Windows, distutils insists on putting init_cffi_xyz in # 'export_symbols', so instead of fighting it, just give up and # give it one if sys.platform == 'win32': if sys.version_info >= (3,): prefix = 'PyInit_' else: prefix = 'init' modname = self.verifier.get_module_name() prnt("void %s%s(void) { }\n" % (prefix, modname)) def load_library(self, flags=0): # import it with the CFFI backend backend = self.ffi._backend # needs to make a path that contains '/', on Posix filename = os.path.join(os.curdir, self.verifier.modulefilename) module = backend.load_library(filename, flags) # # call loading_gen_struct() to get the struct layout inferred by # the C compiler self._load(module, 'loading') # build the FFILibrary class and instance, this is a module subclass # because modules are expected to have usually-constant-attributes and # in PyPy this means the JIT is able to treat attributes as constant, # which we want. class FFILibrary(types.ModuleType): _cffi_generic_module = module _cffi_ffi = self.ffi _cffi_dir = [] def __dir__(self): return FFILibrary._cffi_dir library = FFILibrary("") # # finally, call the loaded_gen_xxx() functions. This will set # up the 'library' object. self._load(module, 'loaded', library=library) return library def _get_declarations(self): lst = [(key, tp) for (key, (tp, qual)) in self.ffi._parser._declarations.items()] lst.sort() return lst def _generate(self, step_name): for name, tp in self._get_declarations(): kind, realname = name.split(' ', 1) try: method = getattr(self, '_generate_gen_%s_%s' % (kind, step_name)) except AttributeError: raise VerificationError( "not implemented in verify(): %r" % name) try: method(tp, realname) except Exception as e: model.attach_exception_info(e, name) raise def _load(self, module, step_name, **kwds): for name, tp in self._get_declarations(): kind, realname = name.split(' ', 1) method = getattr(self, '_%s_gen_%s' % (step_name, kind)) try: method(tp, realname, module, **kwds) except Exception as e: model.attach_exception_info(e, name) raise def _generate_nothing(self, tp, name): pass def _loaded_noop(self, tp, name, module, **kwds): pass # ---------- # typedefs: generates no code so far _generate_gen_typedef_decl = _generate_nothing _loading_gen_typedef = _loaded_noop _loaded_gen_typedef = _loaded_noop # ---------- # function declarations def _generate_gen_function_decl(self, tp, name): assert isinstance(tp, model.FunctionPtrType) if tp.ellipsis: # cannot support vararg functions better than this: check for its # exact type (including the fixed arguments), and build it as a # constant function pointer (no _cffi_f_%s wrapper) self._generate_gen_const(False, name, tp) return prnt = self._prnt numargs = len(tp.args) argnames = [] for i, type in enumerate(tp.args): indirection = '' if isinstance(type, model.StructOrUnion): indirection = '*' argnames.append('%sx%d' % (indirection, i)) context = 'argument of %s' % name arglist = [type.get_c_name(' %s' % arg, context) for type, arg in zip(tp.args, argnames)] tpresult = tp.result if isinstance(tpresult, model.StructOrUnion): arglist.insert(0, tpresult.get_c_name(' *r', context)) tpresult = model.void_type arglist = ', '.join(arglist) or 'void' wrappername = '_cffi_f_%s' % name self.export_symbols.append(wrappername) if tp.abi: abi = tp.abi + ' ' else: abi = '' funcdecl = ' %s%s(%s)' % (abi, wrappername, arglist) context = 'result of %s' % name prnt(tpresult.get_c_name(funcdecl, context)) prnt('{') # if isinstance(tp.result, model.StructOrUnion): result_code = '*r = ' elif not isinstance(tp.result, model.VoidType): result_code = 'return ' else: result_code = '' prnt(' %s%s(%s);' % (result_code, name, ', '.join(argnames))) prnt('}') prnt() _loading_gen_function = _loaded_noop def _loaded_gen_function(self, tp, name, module, library): assert isinstance(tp, model.FunctionPtrType) if tp.ellipsis: newfunction = self._load_constant(False, tp, name, module) else: indirections = [] base_tp = tp if (any(isinstance(typ, model.StructOrUnion) for typ in tp.args) or isinstance(tp.result, model.StructOrUnion)): indirect_args = [] for i, typ in enumerate(tp.args): if isinstance(typ, model.StructOrUnion): typ = model.PointerType(typ) indirections.append((i, typ)) indirect_args.append(typ) indirect_result = tp.result if isinstance(indirect_result, model.StructOrUnion): if indirect_result.fldtypes is None: raise TypeError("'%s' is used as result type, " "but is opaque" % ( indirect_result._get_c_name(),)) indirect_result = model.PointerType(indirect_result) indirect_args.insert(0, indirect_result) indirections.insert(0, ("result", indirect_result)) indirect_result = model.void_type tp = model.FunctionPtrType(tuple(indirect_args), indirect_result, tp.ellipsis) BFunc = self.ffi._get_cached_btype(tp) wrappername = '_cffi_f_%s' % name newfunction = module.load_function(BFunc, wrappername) for i, typ in indirections: newfunction = self._make_struct_wrapper(newfunction, i, typ, base_tp) setattr(library, name, newfunction) type(library)._cffi_dir.append(name) def _make_struct_wrapper(self, oldfunc, i, tp, base_tp): backend = self.ffi._backend BType = self.ffi._get_cached_btype(tp) if i == "result": ffi = self.ffi def newfunc(*args): res = ffi.new(BType) oldfunc(res, *args) return res[0] else: def newfunc(*args): args = args[:i] + (backend.newp(BType, args[i]),) + args[i+1:] return oldfunc(*args) newfunc._cffi_base_type = base_tp return newfunc # ---------- # named structs def _generate_gen_struct_decl(self, tp, name): assert name == tp.name self._generate_struct_or_union_decl(tp, 'struct', name) def _loading_gen_struct(self, tp, name, module): self._loading_struct_or_union(tp, 'struct', name, module) def _loaded_gen_struct(self, tp, name, module, **kwds): self._loaded_struct_or_union(tp) def _generate_gen_union_decl(self, tp, name): assert name == tp.name self._generate_struct_or_union_decl(tp, 'union', name) def _loading_gen_union(self, tp, name, module): self._loading_struct_or_union(tp, 'union', name, module) def _loaded_gen_union(self, tp, name, module, **kwds): self._loaded_struct_or_union(tp) def _generate_struct_or_union_decl(self, tp, prefix, name): if tp.fldnames is None: return # nothing to do with opaque structs checkfuncname = '_cffi_check_%s_%s' % (prefix, name) layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name) cname = ('%s %s' % (prefix, name)).strip() # prnt = self._prnt prnt('static void %s(%s *p)' % (checkfuncname, cname)) prnt('{') prnt(' /* only to generate compile-time warnings or errors */') prnt(' (void)p;') for fname, ftype, fbitsize, fqual in tp.enumfields(): if (isinstance(ftype, model.PrimitiveType) and ftype.is_integer_type()) or fbitsize >= 0: # accept all integers, but complain on float or double prnt(' (void)((p->%s) << 1);' % fname) else: # only accept exactly the type declared. try: prnt(' { %s = &p->%s; (void)tmp; }' % ( ftype.get_c_name('*tmp', 'field %r'%fname, quals=fqual), fname)) except VerificationError as e: prnt(' /* %s */' % str(e)) # cannot verify it, ignore prnt('}') self.export_symbols.append(layoutfuncname) prnt('intptr_t %s(intptr_t i)' % (layoutfuncname,)) prnt('{') prnt(' struct _cffi_aligncheck { char x; %s y; };' % cname) prnt(' static intptr_t nums[] = {') prnt(' sizeof(%s),' % cname) prnt(' offsetof(struct _cffi_aligncheck, y),') for fname, ftype, fbitsize, fqual in tp.enumfields(): if fbitsize >= 0: continue # xxx ignore fbitsize for now prnt(' offsetof(%s, %s),' % (cname, fname)) if isinstance(ftype, model.ArrayType) and ftype.length is None: prnt(' 0, /* %s */' % ftype._get_c_name()) else: prnt(' sizeof(((%s *)0)->%s),' % (cname, fname)) prnt(' -1') prnt(' };') prnt(' return nums[i];') prnt(' /* the next line is not executed, but compiled */') prnt(' %s(0);' % (checkfuncname,)) prnt('}') prnt() def _loading_struct_or_union(self, tp, prefix, name, module): if tp.fldnames is None: return # nothing to do with opaque structs layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name) # BFunc = self.ffi._typeof_locked("intptr_t(*)(intptr_t)")[0] function = module.load_function(BFunc, layoutfuncname) layout = [] num = 0 while True: x = function(num) if x < 0: break layout.append(x) num += 1 if isinstance(tp, model.StructOrUnion) and tp.partial: # use the function()'s sizes and offsets to guide the # layout of the struct totalsize = layout[0] totalalignment = layout[1] fieldofs = layout[2::2] fieldsize = layout[3::2] tp.force_flatten() assert len(fieldofs) == len(fieldsize) == len(tp.fldnames) tp.fixedlayout = fieldofs, fieldsize, totalsize, totalalignment else: cname = ('%s %s' % (prefix, name)).strip() self._struct_pending_verification[tp] = layout, cname def _loaded_struct_or_union(self, tp): if tp.fldnames is None: return # nothing to do with opaque structs self.ffi._get_cached_btype(tp) # force 'fixedlayout' to be considered if tp in self._struct_pending_verification: # check that the layout sizes and offsets match the real ones def check(realvalue, expectedvalue, msg): if realvalue != expectedvalue: raise VerificationError( "%s (we have %d, but C compiler says %d)" % (msg, expectedvalue, realvalue)) ffi = self.ffi BStruct = ffi._get_cached_btype(tp) layout, cname = self._struct_pending_verification.pop(tp) check(layout[0], ffi.sizeof(BStruct), "wrong total size") check(layout[1], ffi.alignof(BStruct), "wrong total alignment") i = 2 for fname, ftype, fbitsize, fqual in tp.enumfields(): if fbitsize >= 0: continue # xxx ignore fbitsize for now check(layout[i], ffi.offsetof(BStruct, fname), "wrong offset for field %r" % (fname,)) if layout[i+1] != 0: BField = ffi._get_cached_btype(ftype) check(layout[i+1], ffi.sizeof(BField), "wrong size for field %r" % (fname,)) i += 2 assert i == len(layout) # ---------- # 'anonymous' declarations. These are produced for anonymous structs # or unions; the 'name' is obtained by a typedef. def _generate_gen_anonymous_decl(self, tp, name): if isinstance(tp, model.EnumType): self._generate_gen_enum_decl(tp, name, '') else: self._generate_struct_or_union_decl(tp, '', name) def _loading_gen_anonymous(self, tp, name, module): if isinstance(tp, model.EnumType): self._loading_gen_enum(tp, name, module, '') else: self._loading_struct_or_union(tp, '', name, module) def _loaded_gen_anonymous(self, tp, name, module, **kwds): if isinstance(tp, model.EnumType): self._loaded_gen_enum(tp, name, module, **kwds) else: self._loaded_struct_or_union(tp) # ---------- # constants, likely declared with '#define' def _generate_gen_const(self, is_int, name, tp=None, category='const', check_value=None): prnt = self._prnt funcname = '_cffi_%s_%s' % (category, name) self.export_symbols.append(funcname) if check_value is not None: assert is_int assert category == 'const' prnt('int %s(char *out_error)' % funcname) prnt('{') self._check_int_constant_value(name, check_value) prnt(' return 0;') prnt('}') elif is_int: assert category == 'const' prnt('int %s(long long *out_value)' % funcname) prnt('{') prnt(' *out_value = (long long)(%s);' % (name,)) prnt(' return (%s) <= 0;' % (name,)) prnt('}') else: assert tp is not None assert check_value is None if category == 'var': ampersand = '&' else: ampersand = '' extra = '' if category == 'const' and isinstance(tp, model.StructOrUnion): extra = 'const *' ampersand = '&' prnt(tp.get_c_name(' %s%s(void)' % (extra, funcname), name)) prnt('{') prnt(' return (%s%s);' % (ampersand, name)) prnt('}') prnt() def _generate_gen_constant_decl(self, tp, name): is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type() self._generate_gen_const(is_int, name, tp) _loading_gen_constant = _loaded_noop def _load_constant(self, is_int, tp, name, module, check_value=None): funcname = '_cffi_const_%s' % name if check_value is not None: assert is_int self._load_known_int_constant(module, funcname) value = check_value elif is_int: BType = self.ffi._typeof_locked("long long*")[0] BFunc = self.ffi._typeof_locked("int(*)(long long*)")[0] function = module.load_function(BFunc, funcname) p = self.ffi.new(BType) negative = function(p) value = int(p[0]) if value < 0 and not negative: BLongLong = self.ffi._typeof_locked("long long")[0] value += (1 << (8*self.ffi.sizeof(BLongLong))) else: assert check_value is None fntypeextra = '(*)(void)' if isinstance(tp, model.StructOrUnion): fntypeextra = '*' + fntypeextra BFunc = self.ffi._typeof_locked(tp.get_c_name(fntypeextra, name))[0] function = module.load_function(BFunc, funcname) value = function() if isinstance(tp, model.StructOrUnion): value = value[0] return value def _loaded_gen_constant(self, tp, name, module, library): is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type() value = self._load_constant(is_int, tp, name, module) setattr(library, name, value) type(library)._cffi_dir.append(name) # ---------- # enums def _check_int_constant_value(self, name, value): prnt = self._prnt if value <= 0: prnt(' if ((%s) > 0 || (long)(%s) != %dL) {' % ( name, name, value)) else: prnt(' if ((%s) <= 0 || (unsigned long)(%s) != %dUL) {' % ( name, name, value)) prnt(' char buf[64];') prnt(' if ((%s) <= 0)' % name) prnt(' sprintf(buf, "%%ld", (long)(%s));' % name) prnt(' else') prnt(' sprintf(buf, "%%lu", (unsigned long)(%s));' % name) prnt(' sprintf(out_error, "%s has the real value %s, not %s",') prnt(' "%s", buf, "%d");' % (name[:100], value)) prnt(' return -1;') prnt(' }') def _load_known_int_constant(self, module, funcname): BType = self.ffi._typeof_locked("char[]")[0] BFunc = self.ffi._typeof_locked("int(*)(char*)")[0] function = module.load_function(BFunc, funcname) p = self.ffi.new(BType, 256) if function(p) < 0: error = self.ffi.string(p) if sys.version_info >= (3,): error = str(error, 'utf-8') raise VerificationError(error) def _enum_funcname(self, prefix, name): # "$enum_$1" => "___D_enum____D_1" name = name.replace('$', '___D_') return '_cffi_e_%s_%s' % (prefix, name) def _generate_gen_enum_decl(self, tp, name, prefix='enum'): if tp.partial: for enumerator in tp.enumerators: self._generate_gen_const(True, enumerator) return # funcname = self._enum_funcname(prefix, name) self.export_symbols.append(funcname) prnt = self._prnt prnt('int %s(char *out_error)' % funcname) prnt('{') for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues): self._check_int_constant_value(enumerator, enumvalue) prnt(' return 0;') prnt('}') prnt() def _loading_gen_enum(self, tp, name, module, prefix='enum'): if tp.partial: enumvalues = [self._load_constant(True, tp, enumerator, module) for enumerator in tp.enumerators] tp.enumvalues = tuple(enumvalues) tp.partial_resolved = True else: funcname = self._enum_funcname(prefix, name) self._load_known_int_constant(module, funcname) def _loaded_gen_enum(self, tp, name, module, library): for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues): setattr(library, enumerator, enumvalue) type(library)._cffi_dir.append(enumerator) # ---------- # macros: for now only for integers def _generate_gen_macro_decl(self, tp, name): if tp == '...': check_value = None else: check_value = tp # an integer self._generate_gen_const(True, name, check_value=check_value) _loading_gen_macro = _loaded_noop def _loaded_gen_macro(self, tp, name, module, library): if tp == '...': check_value = None else: check_value = tp # an integer value = self._load_constant(True, tp, name, module, check_value=check_value) setattr(library, name, value) type(library)._cffi_dir.append(name) # ---------- # global variables def _generate_gen_variable_decl(self, tp, name): if isinstance(tp, model.ArrayType): if tp.length == '...': prnt = self._prnt funcname = '_cffi_sizeof_%s' % (name,) self.export_symbols.append(funcname) prnt("size_t %s(void)" % funcname) prnt("{") prnt(" return sizeof(%s);" % (name,)) prnt("}") tp_ptr = model.PointerType(tp.item) self._generate_gen_const(False, name, tp_ptr) else: tp_ptr = model.PointerType(tp) self._generate_gen_const(False, name, tp_ptr, category='var') _loading_gen_variable = _loaded_noop def _loaded_gen_variable(self, tp, name, module, library): if isinstance(tp, model.ArrayType): # int a[5] is "constant" in the # sense that "a=..." is forbidden if tp.length == '...': funcname = '_cffi_sizeof_%s' % (name,) BFunc = self.ffi._typeof_locked('size_t(*)(void)')[0] function = module.load_function(BFunc, funcname) size = function() BItemType = self.ffi._get_cached_btype(tp.item) length, rest = divmod(size, self.ffi.sizeof(BItemType)) if rest != 0: raise VerificationError( "bad size: %r does not seem to be an array of %s" % (name, tp.item)) tp = tp.resolve_length(length) tp_ptr = model.PointerType(tp.item) value = self._load_constant(False, tp_ptr, name, module) # 'value' is a <cdata 'type *'> which we have to replace with # a <cdata 'type[N]'> if the N is actually known if tp.length is not None: BArray = self.ffi._get_cached_btype(tp) value = self.ffi.cast(BArray, value) setattr(library, name, value) type(library)._cffi_dir.append(name) return # remove ptr=<cdata 'int *'> from the library instance, and replace # it by a property on the class, which reads/writes into ptr[0]. funcname = '_cffi_var_%s' % name BFunc = self.ffi._typeof_locked(tp.get_c_name('*(*)(void)', name))[0] function = module.load_function(BFunc, funcname) ptr = function() def getter(library): return ptr[0] def setter(library, value): ptr[0] = value setattr(type(library), name, property(getter, setter)) type(library)._cffi_dir.append(name) cffimod_header = r''' #include <stdio.h> #include <stddef.h> #include <stdarg.h> #include <errno.h> #include <sys/types.h> /* XXX for ssize_t on some platforms */ /* this block of #ifs should be kept exactly identical between c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py and cffi/_cffi_include.h */ #if defined(_MSC_VER) # include <malloc.h> /* for alloca() */ # if _MSC_VER < 1600 /* MSVC < 2010 */ typedef __int8 int8_t; typedef __int16 int16_t; typedef __int32 int32_t; typedef __int64 int64_t; typedef unsigned __int8 uint8_t; typedef unsigned __int16 uint16_t; typedef unsigned __int32 uint32_t; typedef unsigned __int64 uint64_t; typedef __int8 int_least8_t; typedef __int16 int_least16_t; typedef __int32 int_least32_t; typedef __int64 int_least64_t; typedef unsigned __int8 uint_least8_t; typedef unsigned __int16 uint_least16_t; typedef unsigned __int32 uint_least32_t; typedef unsigned __int64 uint_least64_t; typedef __int8 int_fast8_t; typedef __int16 int_fast16_t; typedef __int32 int_fast32_t; typedef __int64 int_fast64_t; typedef unsigned __int8 uint_fast8_t; typedef unsigned __int16 uint_fast16_t; typedef unsigned __int32 uint_fast32_t; typedef unsigned __int64 uint_fast64_t; typedef __int64 intmax_t; typedef unsigned __int64 uintmax_t; # else # include <stdint.h> # endif # if _MSC_VER < 1800 /* MSVC < 2013 */ # ifndef __cplusplus typedef unsigned char _Bool; # endif # endif #else # include <stdint.h> # if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) # include <alloca.h> # endif #endif ''' PK %�\ � � � __init__.pynu �[��� __all__ = ['FFI', 'VerificationError', 'VerificationMissing', 'CDefError', 'FFIError'] from .api import FFI from .error import CDefError, FFIError, VerificationError, VerificationMissing __version__ = "1.11.5" __version_info__ = (1, 11, 5) # The verifier module file names are based on the CRC32 of a string that # contains the following version number. It may be older than __version__ # if nothing is clearly incompatible. __version_verifier_modules__ = "0.8.6" PK %�\��kX X parse_c_type.hnu �[��� /* This part is from file 'cffi/parse_c_type.h'. It is copied at the beginning of C sources generated by CFFI's ffi.set_source(). */ typedef void *_cffi_opcode_t; #define _CFFI_OP(opcode, arg) (_cffi_opcode_t)(opcode | (((uintptr_t)(arg)) << 8)) #define _CFFI_GETOP(cffi_opcode) ((unsigned char)(uintptr_t)cffi_opcode) #define _CFFI_GETARG(cffi_opcode) (((intptr_t)cffi_opcode) >> 8) #define _CFFI_OP_PRIMITIVE 1 #define _CFFI_OP_POINTER 3 #define _CFFI_OP_ARRAY 5 #define _CFFI_OP_OPEN_ARRAY 7 #define _CFFI_OP_STRUCT_UNION 9 #define _CFFI_OP_ENUM 11 #define _CFFI_OP_FUNCTION 13 #define _CFFI_OP_FUNCTION_END 15 #define _CFFI_OP_NOOP 17 #define _CFFI_OP_BITFIELD 19 #define _CFFI_OP_TYPENAME 21 #define _CFFI_OP_CPYTHON_BLTN_V 23 // varargs #define _CFFI_OP_CPYTHON_BLTN_N 25 // noargs #define _CFFI_OP_CPYTHON_BLTN_O 27 // O (i.e. a single arg) #define _CFFI_OP_CONSTANT 29 #define _CFFI_OP_CONSTANT_INT 31 #define _CFFI_OP_GLOBAL_VAR 33 #define _CFFI_OP_DLOPEN_FUNC 35 #define _CFFI_OP_DLOPEN_CONST 37 #define _CFFI_OP_GLOBAL_VAR_F 39 #define _CFFI_OP_EXTERN_PYTHON 41 #define _CFFI_PRIM_VOID 0 #define _CFFI_PRIM_BOOL 1 #define _CFFI_PRIM_CHAR 2 #define _CFFI_PRIM_SCHAR 3 #define _CFFI_PRIM_UCHAR 4 #define _CFFI_PRIM_SHORT 5 #define _CFFI_PRIM_USHORT 6 #define _CFFI_PRIM_INT 7 #define _CFFI_PRIM_UINT 8 #define _CFFI_PRIM_LONG 9 #define _CFFI_PRIM_ULONG 10 #define _CFFI_PRIM_LONGLONG 11 #define _CFFI_PRIM_ULONGLONG 12 #define _CFFI_PRIM_FLOAT 13 #define _CFFI_PRIM_DOUBLE 14 #define _CFFI_PRIM_LONGDOUBLE 15 #define _CFFI_PRIM_WCHAR 16 #define _CFFI_PRIM_INT8 17 #define _CFFI_PRIM_UINT8 18 #define _CFFI_PRIM_INT16 19 #define _CFFI_PRIM_UINT16 20 #define _CFFI_PRIM_INT32 21 #define _CFFI_PRIM_UINT32 22 #define _CFFI_PRIM_INT64 23 #define _CFFI_PRIM_UINT64 24 #define _CFFI_PRIM_INTPTR 25 #define _CFFI_PRIM_UINTPTR 26 #define _CFFI_PRIM_PTRDIFF 27 #define _CFFI_PRIM_SIZE 28 #define _CFFI_PRIM_SSIZE 29 #define _CFFI_PRIM_INT_LEAST8 30 #define _CFFI_PRIM_UINT_LEAST8 31 #define _CFFI_PRIM_INT_LEAST16 32 #define _CFFI_PRIM_UINT_LEAST16 33 #define _CFFI_PRIM_INT_LEAST32 34 #define _CFFI_PRIM_UINT_LEAST32 35 #define _CFFI_PRIM_INT_LEAST64 36 #define _CFFI_PRIM_UINT_LEAST64 37 #define _CFFI_PRIM_INT_FAST8 38 #define _CFFI_PRIM_UINT_FAST8 39 #define _CFFI_PRIM_INT_FAST16 40 #define _CFFI_PRIM_UINT_FAST16 41 #define _CFFI_PRIM_INT_FAST32 42 #define _CFFI_PRIM_UINT_FAST32 43 #define _CFFI_PRIM_INT_FAST64 44 #define _CFFI_PRIM_UINT_FAST64 45 #define _CFFI_PRIM_INTMAX 46 #define _CFFI_PRIM_UINTMAX 47 #define _CFFI_PRIM_FLOATCOMPLEX 48 #define _CFFI_PRIM_DOUBLECOMPLEX 49 #define _CFFI_PRIM_CHAR16 50 #define _CFFI_PRIM_CHAR32 51 #define _CFFI__NUM_PRIM 52 #define _CFFI__UNKNOWN_PRIM (-1) #define _CFFI__UNKNOWN_FLOAT_PRIM (-2) #define _CFFI__UNKNOWN_LONG_DOUBLE (-3) #define _CFFI__IO_FILE_STRUCT (-1) struct _cffi_global_s { const char *name; void *address; _cffi_opcode_t type_op; void *size_or_direct_fn; // OP_GLOBAL_VAR: size, or 0 if unknown // OP_CPYTHON_BLTN_*: addr of direct function }; struct _cffi_getconst_s { unsigned long long value; const struct _cffi_type_context_s *ctx; int gindex; }; struct _cffi_struct_union_s { const char *name; int type_index; // -> _cffi_types, on a OP_STRUCT_UNION int flags; // _CFFI_F_* flags below size_t size; int alignment; int first_field_index; // -> _cffi_fields array int num_fields; }; #define _CFFI_F_UNION 0x01 // is a union, not a struct #define _CFFI_F_CHECK_FIELDS 0x02 // complain if fields are not in the // "standard layout" or if some are missing #define _CFFI_F_PACKED 0x04 // for CHECK_FIELDS, assume a packed struct #define _CFFI_F_EXTERNAL 0x08 // in some other ffi.include() #define _CFFI_F_OPAQUE 0x10 // opaque struct _cffi_field_s { const char *name; size_t field_offset; size_t field_size; _cffi_opcode_t field_type_op; }; struct _cffi_enum_s { const char *name; int type_index; // -> _cffi_types, on a OP_ENUM int type_prim; // _CFFI_PRIM_xxx const char *enumerators; // comma-delimited string }; struct _cffi_typename_s { const char *name; int type_index; /* if opaque, points to a possibly artificial OP_STRUCT which is itself opaque */ }; struct _cffi_type_context_s { _cffi_opcode_t *types; const struct _cffi_global_s *globals; const struct _cffi_field_s *fields; const struct _cffi_struct_union_s *struct_unions; const struct _cffi_enum_s *enums; const struct _cffi_typename_s *typenames; int num_globals; int num_struct_unions; int num_enums; int num_typenames; const char *const *includes; int num_types; int flags; /* future extension */ }; struct _cffi_parse_info_s { const struct _cffi_type_context_s *ctx; _cffi_opcode_t *output; unsigned int output_size; size_t error_location; const char *error_message; }; struct _cffi_externpy_s { const char *name; size_t size_of_result; void *reserved1, *reserved2; }; #ifdef _CFFI_INTERNAL static int parse_c_type(struct _cffi_parse_info_s *info, const char *input); static int search_in_globals(const struct _cffi_type_context_s *ctx, const char *search, size_t search_len); static int search_in_struct_unions(const struct _cffi_type_context_s *ctx, const char *search, size_t search_len); #endif PK %�\��;�f� f� backend_ctypes.pynu �[��� import ctypes, ctypes.util, operator, sys from . import model if sys.version_info < (3,): bytechr = chr else: unicode = str long = int xrange = range bytechr = lambda num: bytes([num]) class CTypesType(type): pass class CTypesData(object): __metaclass__ = CTypesType __slots__ = ['__weakref__'] __name__ = '<cdata>' def __init__(self, *args): raise TypeError("cannot instantiate %r" % (self.__class__,)) @classmethod def _newp(cls, init): raise TypeError("expected a pointer or array ctype, got '%s'" % (cls._get_c_name(),)) @staticmethod def _to_ctypes(value): raise TypeError @classmethod def _arg_to_ctypes(cls, *value): try: ctype = cls._ctype except AttributeError: raise TypeError("cannot create an instance of %r" % (cls,)) if value: res = cls._to_ctypes(*value) if not isinstance(res, ctype): res = cls._ctype(res) else: res = cls._ctype() return res @classmethod def _create_ctype_obj(cls, init): if init is None: return cls._arg_to_ctypes() else: return cls._arg_to_ctypes(init) @staticmethod def _from_ctypes(ctypes_value): raise TypeError @classmethod def _get_c_name(cls, replace_with=''): return cls._reftypename.replace(' &', replace_with) @classmethod def _fix_class(cls): cls.__name__ = 'CData<%s>' % (cls._get_c_name(),) cls.__qualname__ = 'CData<%s>' % (cls._get_c_name(),) cls.__module__ = 'ffi' def _get_own_repr(self): raise NotImplementedError def _addr_repr(self, address): if address == 0: return 'NULL' else: if address < 0: address += 1 << (8*ctypes.sizeof(ctypes.c_void_p)) return '0x%x' % address def __repr__(self, c_name=None): own = self._get_own_repr() return '<cdata %r %s>' % (c_name or self._get_c_name(), own) def _convert_to_address(self, BClass): if BClass is None: raise TypeError("cannot convert %r to an address" % ( self._get_c_name(),)) else: raise TypeError("cannot convert %r to %r" % ( self._get_c_name(), BClass._get_c_name())) @classmethod def _get_size(cls): return ctypes.sizeof(cls._ctype) def _get_size_of_instance(self): return ctypes.sizeof(self._ctype) @classmethod def _cast_from(cls, source): raise TypeError("cannot cast to %r" % (cls._get_c_name(),)) def _cast_to_integer(self): return self._convert_to_address(None) @classmethod def _alignment(cls): return ctypes.alignment(cls._ctype) def __iter__(self): raise TypeError("cdata %r does not support iteration" % ( self._get_c_name()),) def _make_cmp(name): cmpfunc = getattr(operator, name) def cmp(self, other): v_is_ptr = not isinstance(self, CTypesGenericPrimitive) w_is_ptr = (isinstance(other, CTypesData) and not isinstance(other, CTypesGenericPrimitive)) if v_is_ptr and w_is_ptr: return cmpfunc(self._convert_to_address(None), other._convert_to_address(None)) elif v_is_ptr or w_is_ptr: return NotImplemented else: if isinstance(self, CTypesGenericPrimitive): self = self._value if isinstance(other, CTypesGenericPrimitive): other = other._value return cmpfunc(self, other) cmp.func_name = name return cmp __eq__ = _make_cmp('__eq__') __ne__ = _make_cmp('__ne__') __lt__ = _make_cmp('__lt__') __le__ = _make_cmp('__le__') __gt__ = _make_cmp('__gt__') __ge__ = _make_cmp('__ge__') def __hash__(self): return hash(self._convert_to_address(None)) def _to_string(self, maxlen): raise TypeError("string(): %r" % (self,)) class CTypesGenericPrimitive(CTypesData): __slots__ = [] def __hash__(self): return hash(self._value) def _get_own_repr(self): return repr(self._from_ctypes(self._value)) class CTypesGenericArray(CTypesData): __slots__ = [] @classmethod def _newp(cls, init): return cls(init) def __iter__(self): for i in xrange(len(self)): yield self[i] def _get_own_repr(self): return self._addr_repr(ctypes.addressof(self._blob)) class CTypesGenericPtr(CTypesData): __slots__ = ['_address', '_as_ctype_ptr'] _automatic_casts = False kind = "pointer" @classmethod def _newp(cls, init): return cls(init) @classmethod def _cast_from(cls, source): if source is None: address = 0 elif isinstance(source, CTypesData): address = source._cast_to_integer() elif isinstance(source, (int, long)): address = source else: raise TypeError("bad type for cast to %r: %r" % (cls, type(source).__name__)) return cls._new_pointer_at(address) @classmethod def _new_pointer_at(cls, address): self = cls.__new__(cls) self._address = address self._as_ctype_ptr = ctypes.cast(address, cls._ctype) return self def _get_own_repr(self): try: return self._addr_repr(self._address) except AttributeError: return '???' def _cast_to_integer(self): return self._address def __nonzero__(self): return bool(self._address) __bool__ = __nonzero__ @classmethod def _to_ctypes(cls, value): if not isinstance(value, CTypesData): raise TypeError("unexpected %s object" % type(value).__name__) address = value._convert_to_address(cls) return ctypes.cast(address, cls._ctype) @classmethod def _from_ctypes(cls, ctypes_ptr): address = ctypes.cast(ctypes_ptr, ctypes.c_void_p).value or 0 return cls._new_pointer_at(address) @classmethod def _initialize(cls, ctypes_ptr, value): if value: ctypes_ptr.contents = cls._to_ctypes(value).contents def _convert_to_address(self, BClass): if (BClass in (self.__class__, None) or BClass._automatic_casts or self._automatic_casts): return self._address else: return CTypesData._convert_to_address(self, BClass) class CTypesBaseStructOrUnion(CTypesData): __slots__ = ['_blob'] @classmethod def _create_ctype_obj(cls, init): # may be overridden raise TypeError("cannot instantiate opaque type %s" % (cls,)) def _get_own_repr(self): return self._addr_repr(ctypes.addressof(self._blob)) @classmethod def _offsetof(cls, fieldname): return getattr(cls._ctype, fieldname).offset def _convert_to_address(self, BClass): if getattr(BClass, '_BItem', None) is self.__class__: return ctypes.addressof(self._blob) else: return CTypesData._convert_to_address(self, BClass) @classmethod def _from_ctypes(cls, ctypes_struct_or_union): self = cls.__new__(cls) self._blob = ctypes_struct_or_union return self @classmethod def _to_ctypes(cls, value): return value._blob def __repr__(self, c_name=None): return CTypesData.__repr__(self, c_name or self._get_c_name(' &')) class CTypesBackend(object): PRIMITIVE_TYPES = { 'char': ctypes.c_char, 'short': ctypes.c_short, 'int': ctypes.c_int, 'long': ctypes.c_long, 'long long': ctypes.c_longlong, 'signed char': ctypes.c_byte, 'unsigned char': ctypes.c_ubyte, 'unsigned short': ctypes.c_ushort, 'unsigned int': ctypes.c_uint, 'unsigned long': ctypes.c_ulong, 'unsigned long long': ctypes.c_ulonglong, 'float': ctypes.c_float, 'double': ctypes.c_double, '_Bool': ctypes.c_bool, } for _name in ['unsigned long long', 'unsigned long', 'unsigned int', 'unsigned short', 'unsigned char']: _size = ctypes.sizeof(PRIMITIVE_TYPES[_name]) PRIMITIVE_TYPES['uint%d_t' % (8*_size)] = PRIMITIVE_TYPES[_name] if _size == ctypes.sizeof(ctypes.c_void_p): PRIMITIVE_TYPES['uintptr_t'] = PRIMITIVE_TYPES[_name] if _size == ctypes.sizeof(ctypes.c_size_t): PRIMITIVE_TYPES['size_t'] = PRIMITIVE_TYPES[_name] for _name in ['long long', 'long', 'int', 'short', 'signed char']: _size = ctypes.sizeof(PRIMITIVE_TYPES[_name]) PRIMITIVE_TYPES['int%d_t' % (8*_size)] = PRIMITIVE_TYPES[_name] if _size == ctypes.sizeof(ctypes.c_void_p): PRIMITIVE_TYPES['intptr_t'] = PRIMITIVE_TYPES[_name] PRIMITIVE_TYPES['ptrdiff_t'] = PRIMITIVE_TYPES[_name] if _size == ctypes.sizeof(ctypes.c_size_t): PRIMITIVE_TYPES['ssize_t'] = PRIMITIVE_TYPES[_name] def __init__(self): self.RTLD_LAZY = 0 # not supported anyway by ctypes self.RTLD_NOW = 0 self.RTLD_GLOBAL = ctypes.RTLD_GLOBAL self.RTLD_LOCAL = ctypes.RTLD_LOCAL def set_ffi(self, ffi): self.ffi = ffi def _get_types(self): return CTypesData, CTypesType def load_library(self, path, flags=0): cdll = ctypes.CDLL(path, flags) return CTypesLibrary(self, cdll) def new_void_type(self): class CTypesVoid(CTypesData): __slots__ = [] _reftypename = 'void &' @staticmethod def _from_ctypes(novalue): return None @staticmethod def _to_ctypes(novalue): if novalue is not None: raise TypeError("None expected, got %s object" % (type(novalue).__name__,)) return None CTypesVoid._fix_class() return CTypesVoid def new_primitive_type(self, name): if name == 'wchar_t': raise NotImplementedError(name) ctype = self.PRIMITIVE_TYPES[name] if name == 'char': kind = 'char' elif name in ('float', 'double'): kind = 'float' else: if name in ('signed char', 'unsigned char'): kind = 'byte' elif name == '_Bool': kind = 'bool' else: kind = 'int' is_signed = (ctype(-1).value == -1) # def _cast_source_to_int(source): if isinstance(source, (int, long, float)): source = int(source) elif isinstance(source, CTypesData): source = source._cast_to_integer() elif isinstance(source, bytes): source = ord(source) elif source is None: source = 0 else: raise TypeError("bad type for cast to %r: %r" % (CTypesPrimitive, type(source).__name__)) return source # kind1 = kind class CTypesPrimitive(CTypesGenericPrimitive): __slots__ = ['_value'] _ctype = ctype _reftypename = '%s &' % name kind = kind1 def __init__(self, value): self._value = value @staticmethod def _create_ctype_obj(init): if init is None: return ctype() return ctype(CTypesPrimitive._to_ctypes(init)) if kind == 'int' or kind == 'byte': @classmethod def _cast_from(cls, source): source = _cast_source_to_int(source) source = ctype(source).value # cast within range return cls(source) def __int__(self): return self._value if kind == 'bool': @classmethod def _cast_from(cls, source): if not isinstance(source, (int, long, float)): source = _cast_source_to_int(source) return cls(bool(source)) def __int__(self): return self._value if kind == 'char': @classmethod def _cast_from(cls, source): source = _cast_source_to_int(source) source = bytechr(source & 0xFF) return cls(source) def __int__(self): return ord(self._value) if kind == 'float': @classmethod def _cast_from(cls, source): if isinstance(source, float): pass elif isinstance(source, CTypesGenericPrimitive): if hasattr(source, '__float__'): source = float(source) else: source = int(source) else: source = _cast_source_to_int(source) source = ctype(source).value # fix precision return cls(source) def __int__(self): return int(self._value) def __float__(self): return self._value _cast_to_integer = __int__ if kind == 'int' or kind == 'byte' or kind == 'bool': @staticmethod def _to_ctypes(x): if not isinstance(x, (int, long)): if isinstance(x, CTypesData): x = int(x) else: raise TypeError("integer expected, got %s" % type(x).__name__) if ctype(x).value != x: if not is_signed and x < 0: raise OverflowError("%s: negative integer" % name) else: raise OverflowError("%s: integer out of bounds" % name) return x if kind == 'char': @staticmethod def _to_ctypes(x): if isinstance(x, bytes) and len(x) == 1: return x if isinstance(x, CTypesPrimitive): # <CData <char>> return x._value raise TypeError("character expected, got %s" % type(x).__name__) def __nonzero__(self): return ord(self._value) != 0 else: def __nonzero__(self): return self._value != 0 __bool__ = __nonzero__ if kind == 'float': @staticmethod def _to_ctypes(x): if not isinstance(x, (int, long, float, CTypesData)): raise TypeError("float expected, got %s" % type(x).__name__) return ctype(x).value @staticmethod def _from_ctypes(value): return getattr(value, 'value', value) @staticmethod def _initialize(blob, init): blob.value = CTypesPrimitive._to_ctypes(init) if kind == 'char': def _to_string(self, maxlen): return self._value if kind == 'byte': def _to_string(self, maxlen): return chr(self._value & 0xff) # CTypesPrimitive._fix_class() return CTypesPrimitive def new_pointer_type(self, BItem): getbtype = self.ffi._get_cached_btype if BItem is getbtype(model.PrimitiveType('char')): kind = 'charp' elif BItem in (getbtype(model.PrimitiveType('signed char')), getbtype(model.PrimitiveType('unsigned char'))): kind = 'bytep' elif BItem is getbtype(model.void_type): kind = 'voidp' else: kind = 'generic' # class CTypesPtr(CTypesGenericPtr): __slots__ = ['_own'] if kind == 'charp': __slots__ += ['__as_strbuf'] _BItem = BItem if hasattr(BItem, '_ctype'): _ctype = ctypes.POINTER(BItem._ctype) _bitem_size = ctypes.sizeof(BItem._ctype) else: _ctype = ctypes.c_void_p if issubclass(BItem, CTypesGenericArray): _reftypename = BItem._get_c_name('(* &)') else: _reftypename = BItem._get_c_name(' * &') def __init__(self, init): ctypeobj = BItem._create_ctype_obj(init) if kind == 'charp': self.__as_strbuf = ctypes.create_string_buffer( ctypeobj.value + b'\x00') self._as_ctype_ptr = ctypes.cast( self.__as_strbuf, self._ctype) else: self._as_ctype_ptr = ctypes.pointer(ctypeobj) self._address = ctypes.cast(self._as_ctype_ptr, ctypes.c_void_p).value self._own = True def __add__(self, other): if isinstance(other, (int, long)): return self._new_pointer_at(self._address + other * self._bitem_size) else: return NotImplemented def __sub__(self, other): if isinstance(other, (int, long)): return self._new_pointer_at(self._address - other * self._bitem_size) elif type(self) is type(other): return (self._address - other._address) // self._bitem_size else: return NotImplemented def __getitem__(self, index): if getattr(self, '_own', False) and index != 0: raise IndexError return BItem._from_ctypes(self._as_ctype_ptr[index]) def __setitem__(self, index, value): self._as_ctype_ptr[index] = BItem._to_ctypes(value) if kind == 'charp' or kind == 'voidp': @classmethod def _arg_to_ctypes(cls, *value): if value and isinstance(value[0], bytes): return ctypes.c_char_p(value[0]) else: return super(CTypesPtr, cls)._arg_to_ctypes(*value) if kind == 'charp' or kind == 'bytep': def _to_string(self, maxlen): if maxlen < 0: maxlen = sys.maxsize p = ctypes.cast(self._as_ctype_ptr, ctypes.POINTER(ctypes.c_char)) n = 0 while n < maxlen and p[n] != b'\x00': n += 1 return b''.join([p[i] for i in range(n)]) def _get_own_repr(self): if getattr(self, '_own', False): return 'owning %d bytes' % ( ctypes.sizeof(self._as_ctype_ptr.contents),) return super(CTypesPtr, self)._get_own_repr() # if (BItem is self.ffi._get_cached_btype(model.void_type) or BItem is self.ffi._get_cached_btype(model.PrimitiveType('char'))): CTypesPtr._automatic_casts = True # CTypesPtr._fix_class() return CTypesPtr def new_array_type(self, CTypesPtr, length): if length is None: brackets = ' &[]' else: brackets = ' &[%d]' % length BItem = CTypesPtr._BItem getbtype = self.ffi._get_cached_btype if BItem is getbtype(model.PrimitiveType('char')): kind = 'char' elif BItem in (getbtype(model.PrimitiveType('signed char')), getbtype(model.PrimitiveType('unsigned char'))): kind = 'byte' else: kind = 'generic' # class CTypesArray(CTypesGenericArray): __slots__ = ['_blob', '_own'] if length is not None: _ctype = BItem._ctype * length else: __slots__.append('_ctype') _reftypename = BItem._get_c_name(brackets) _declared_length = length _CTPtr = CTypesPtr def __init__(self, init): if length is None: if isinstance(init, (int, long)): len1 = init init = None elif kind == 'char' and isinstance(init, bytes): len1 = len(init) + 1 # extra null else: init = tuple(init) len1 = len(init) self._ctype = BItem._ctype * len1 self._blob = self._ctype() self._own = True if init is not None: self._initialize(self._blob, init) @staticmethod def _initialize(blob, init): if isinstance(init, bytes): init = [init[i:i+1] for i in range(len(init))] else: init = tuple(init) if len(init) > len(blob): raise IndexError("too many initializers") addr = ctypes.cast(blob, ctypes.c_void_p).value PTR = ctypes.POINTER(BItem._ctype) itemsize = ctypes.sizeof(BItem._ctype) for i, value in enumerate(init): p = ctypes.cast(addr + i * itemsize, PTR) BItem._initialize(p.contents, value) def __len__(self): return len(self._blob) def __getitem__(self, index): if not (0 <= index < len(self._blob)): raise IndexError return BItem._from_ctypes(self._blob[index]) def __setitem__(self, index, value): if not (0 <= index < len(self._blob)): raise IndexError self._blob[index] = BItem._to_ctypes(value) if kind == 'char' or kind == 'byte': def _to_string(self, maxlen): if maxlen < 0: maxlen = len(self._blob) p = ctypes.cast(self._blob, ctypes.POINTER(ctypes.c_char)) n = 0 while n < maxlen and p[n] != b'\x00': n += 1 return b''.join([p[i] for i in range(n)]) def _get_own_repr(self): if getattr(self, '_own', False): return 'owning %d bytes' % (ctypes.sizeof(self._blob),) return super(CTypesArray, self)._get_own_repr() def _convert_to_address(self, BClass): if BClass in (CTypesPtr, None) or BClass._automatic_casts: return ctypes.addressof(self._blob) else: return CTypesData._convert_to_address(self, BClass) @staticmethod def _from_ctypes(ctypes_array): self = CTypesArray.__new__(CTypesArray) self._blob = ctypes_array return self @staticmethod def _arg_to_ctypes(value): return CTypesPtr._arg_to_ctypes(value) def __add__(self, other): if isinstance(other, (int, long)): return CTypesPtr._new_pointer_at( ctypes.addressof(self._blob) + other * ctypes.sizeof(BItem._ctype)) else: return NotImplemented @classmethod def _cast_from(cls, source): raise NotImplementedError("casting to %r" % ( cls._get_c_name(),)) # CTypesArray._fix_class() return CTypesArray def _new_struct_or_union(self, kind, name, base_ctypes_class): # class struct_or_union(base_ctypes_class): pass struct_or_union.__name__ = '%s_%s' % (kind, name) kind1 = kind # class CTypesStructOrUnion(CTypesBaseStructOrUnion): __slots__ = ['_blob'] _ctype = struct_or_union _reftypename = '%s &' % (name,) _kind = kind = kind1 # CTypesStructOrUnion._fix_class() return CTypesStructOrUnion def new_struct_type(self, name): return self._new_struct_or_union('struct', name, ctypes.Structure) def new_union_type(self, name): return self._new_struct_or_union('union', name, ctypes.Union) def complete_struct_or_union(self, CTypesStructOrUnion, fields, tp, totalsize=-1, totalalignment=-1, sflags=0): if totalsize >= 0 or totalalignment >= 0: raise NotImplementedError("the ctypes backend of CFFI does not support " "structures completed by verify(); please " "compile and install the _cffi_backend module.") struct_or_union = CTypesStructOrUnion._ctype fnames = [fname for (fname, BField, bitsize) in fields] btypes = [BField for (fname, BField, bitsize) in fields] bitfields = [bitsize for (fname, BField, bitsize) in fields] # bfield_types = {} cfields = [] for (fname, BField, bitsize) in fields: if bitsize < 0: cfields.append((fname, BField._ctype)) bfield_types[fname] = BField else: cfields.append((fname, BField._ctype, bitsize)) bfield_types[fname] = Ellipsis if sflags & 8: struct_or_union._pack_ = 1 struct_or_union._fields_ = cfields CTypesStructOrUnion._bfield_types = bfield_types # @staticmethod def _create_ctype_obj(init): result = struct_or_union() if init is not None: initialize(result, init) return result CTypesStructOrUnion._create_ctype_obj = _create_ctype_obj # def initialize(blob, init): if is_union: if len(init) > 1: raise ValueError("union initializer: %d items given, but " "only one supported (use a dict if needed)" % (len(init),)) if not isinstance(init, dict): if isinstance(init, (bytes, unicode)): raise TypeError("union initializer: got a str") init = tuple(init) if len(init) > len(fnames): raise ValueError("too many values for %s initializer" % CTypesStructOrUnion._get_c_name()) init = dict(zip(fnames, init)) addr = ctypes.addressof(blob) for fname, value in init.items(): BField, bitsize = name2fieldtype[fname] assert bitsize < 0, \ "not implemented: initializer with bit fields" offset = CTypesStructOrUnion._offsetof(fname) PTR = ctypes.POINTER(BField._ctype) p = ctypes.cast(addr + offset, PTR) BField._initialize(p.contents, value) is_union = CTypesStructOrUnion._kind == 'union' name2fieldtype = dict(zip(fnames, zip(btypes, bitfields))) # for fname, BField, bitsize in fields: if fname == '': raise NotImplementedError("nested anonymous structs/unions") if hasattr(CTypesStructOrUnion, fname): raise ValueError("the field name %r conflicts in " "the ctypes backend" % fname) if bitsize < 0: def getter(self, fname=fname, BField=BField, offset=CTypesStructOrUnion._offsetof(fname), PTR=ctypes.POINTER(BField._ctype)): addr = ctypes.addressof(self._blob) p = ctypes.cast(addr + offset, PTR) return BField._from_ctypes(p.contents) def setter(self, value, fname=fname, BField=BField): setattr(self._blob, fname, BField._to_ctypes(value)) # if issubclass(BField, CTypesGenericArray): setter = None if BField._declared_length == 0: def getter(self, fname=fname, BFieldPtr=BField._CTPtr, offset=CTypesStructOrUnion._offsetof(fname), PTR=ctypes.POINTER(BField._ctype)): addr = ctypes.addressof(self._blob) p = ctypes.cast(addr + offset, PTR) return BFieldPtr._from_ctypes(p) # else: def getter(self, fname=fname, BField=BField): return BField._from_ctypes(getattr(self._blob, fname)) def setter(self, value, fname=fname, BField=BField): # xxx obscure workaround value = BField._to_ctypes(value) oldvalue = getattr(self._blob, fname) setattr(self._blob, fname, value) if value != getattr(self._blob, fname): setattr(self._blob, fname, oldvalue) raise OverflowError("value too large for bitfield") setattr(CTypesStructOrUnion, fname, property(getter, setter)) # CTypesPtr = self.ffi._get_cached_btype(model.PointerType(tp)) for fname in fnames: if hasattr(CTypesPtr, fname): raise ValueError("the field name %r conflicts in " "the ctypes backend" % fname) def getter(self, fname=fname): return getattr(self[0], fname) def setter(self, value, fname=fname): setattr(self[0], fname, value) setattr(CTypesPtr, fname, property(getter, setter)) def new_function_type(self, BArgs, BResult, has_varargs): nameargs = [BArg._get_c_name() for BArg in BArgs] if has_varargs: nameargs.append('...') nameargs = ', '.join(nameargs) # class CTypesFunctionPtr(CTypesGenericPtr): __slots__ = ['_own_callback', '_name'] _ctype = ctypes.CFUNCTYPE(getattr(BResult, '_ctype', None), *[BArg._ctype for BArg in BArgs], use_errno=True) _reftypename = BResult._get_c_name('(* &)(%s)' % (nameargs,)) def __init__(self, init, error=None): # create a callback to the Python callable init() import traceback assert not has_varargs, "varargs not supported for callbacks" if getattr(BResult, '_ctype', None) is not None: error = BResult._from_ctypes( BResult._create_ctype_obj(error)) else: error = None def callback(*args): args2 = [] for arg, BArg in zip(args, BArgs): args2.append(BArg._from_ctypes(arg)) try: res2 = init(*args2) res2 = BResult._to_ctypes(res2) except: traceback.print_exc() res2 = error if issubclass(BResult, CTypesGenericPtr): if res2: res2 = ctypes.cast(res2, ctypes.c_void_p).value # .value: http://bugs.python.org/issue1574593 else: res2 = None #print repr(res2) return res2 if issubclass(BResult, CTypesGenericPtr): # The only pointers callbacks can return are void*s: # http://bugs.python.org/issue5710 callback_ctype = ctypes.CFUNCTYPE( ctypes.c_void_p, *[BArg._ctype for BArg in BArgs], use_errno=True) else: callback_ctype = CTypesFunctionPtr._ctype self._as_ctype_ptr = callback_ctype(callback) self._address = ctypes.cast(self._as_ctype_ptr, ctypes.c_void_p).value self._own_callback = init @staticmethod def _initialize(ctypes_ptr, value): if value: raise NotImplementedError("ctypes backend: not supported: " "initializers for function pointers") def __repr__(self): c_name = getattr(self, '_name', None) if c_name: i = self._reftypename.index('(* &)') if self._reftypename[i-1] not in ' )*': c_name = ' ' + c_name c_name = self._reftypename.replace('(* &)', c_name) return CTypesData.__repr__(self, c_name) def _get_own_repr(self): if getattr(self, '_own_callback', None) is not None: return 'calling %r' % (self._own_callback,) return super(CTypesFunctionPtr, self)._get_own_repr() def __call__(self, *args): if has_varargs: assert len(args) >= len(BArgs) extraargs = args[len(BArgs):] args = args[:len(BArgs)] else: assert len(args) == len(BArgs) ctypes_args = [] for arg, BArg in zip(args, BArgs): ctypes_args.append(BArg._arg_to_ctypes(arg)) if has_varargs: for i, arg in enumerate(extraargs): if arg is None: ctypes_args.append(ctypes.c_void_p(0)) # NULL continue if not isinstance(arg, CTypesData): raise TypeError( "argument %d passed in the variadic part " "needs to be a cdata object (got %s)" % (1 + len(BArgs) + i, type(arg).__name__)) ctypes_args.append(arg._arg_to_ctypes(arg)) result = self._as_ctype_ptr(*ctypes_args) return BResult._from_ctypes(result) # CTypesFunctionPtr._fix_class() return CTypesFunctionPtr def new_enum_type(self, name, enumerators, enumvalues, CTypesInt): assert isinstance(name, str) reverse_mapping = dict(zip(reversed(enumvalues), reversed(enumerators))) # class CTypesEnum(CTypesInt): __slots__ = [] _reftypename = '%s &' % name def _get_own_repr(self): value = self._value try: return '%d: %s' % (value, reverse_mapping[value]) except KeyError: return str(value) def _to_string(self, maxlen): value = self._value try: return reverse_mapping[value] except KeyError: return str(value) # CTypesEnum._fix_class() return CTypesEnum def get_errno(self): return ctypes.get_errno() def set_errno(self, value): ctypes.set_errno(value) def string(self, b, maxlen=-1): return b._to_string(maxlen) def buffer(self, bptr, size=-1): raise NotImplementedError("buffer() with ctypes backend") def sizeof(self, cdata_or_BType): if isinstance(cdata_or_BType, CTypesData): return cdata_or_BType._get_size_of_instance() else: assert issubclass(cdata_or_BType, CTypesData) return cdata_or_BType._get_size() def alignof(self, BType): assert issubclass(BType, CTypesData) return BType._alignment() def newp(self, BType, source): if not issubclass(BType, CTypesData): raise TypeError return BType._newp(source) def cast(self, BType, source): return BType._cast_from(source) def callback(self, BType, source, error, onerror): assert onerror is None # XXX not implemented return BType(source, error) _weakref_cache_ref = None def gcp(self, cdata, destructor, size=0): if self._weakref_cache_ref is None: import weakref class MyRef(weakref.ref): def __eq__(self, other): myref = self() return self is other or ( myref is not None and myref is other()) def __ne__(self, other): return not (self == other) def __hash__(self): try: return self._hash except AttributeError: self._hash = hash(self()) return self._hash self._weakref_cache_ref = {}, MyRef weak_cache, MyRef = self._weakref_cache_ref if destructor is None: try: del weak_cache[MyRef(cdata)] except KeyError: raise TypeError("Can remove destructor only on a object " "previously returned by ffi.gc()") return None def remove(k): cdata, destructor = weak_cache.pop(k, (None, None)) if destructor is not None: destructor(cdata) new_cdata = self.cast(self.typeof(cdata), cdata) assert new_cdata is not cdata weak_cache[MyRef(new_cdata, remove)] = (cdata, destructor) return new_cdata typeof = type def getcname(self, BType, replace_with): return BType._get_c_name(replace_with) def typeoffsetof(self, BType, fieldname, num=0): if isinstance(fieldname, str): if num == 0 and issubclass(BType, CTypesGenericPtr): BType = BType._BItem if not issubclass(BType, CTypesBaseStructOrUnion): raise TypeError("expected a struct or union ctype") BField = BType._bfield_types[fieldname] if BField is Ellipsis: raise TypeError("not supported for bitfields") return (BField, BType._offsetof(fieldname)) elif isinstance(fieldname, (int, long)): if issubclass(BType, CTypesGenericArray): BType = BType._CTPtr if not issubclass(BType, CTypesGenericPtr): raise TypeError("expected an array or ptr ctype") BItem = BType._BItem offset = BItem._get_size() * fieldname if offset > sys.maxsize: raise OverflowError return (BItem, offset) else: raise TypeError(type(fieldname)) def rawaddressof(self, BTypePtr, cdata, offset=None): if isinstance(cdata, CTypesBaseStructOrUnion): ptr = ctypes.pointer(type(cdata)._to_ctypes(cdata)) elif isinstance(cdata, CTypesGenericPtr): if offset is None or not issubclass(type(cdata)._BItem, CTypesBaseStructOrUnion): raise TypeError("unexpected cdata type") ptr = type(cdata)._to_ctypes(cdata) elif isinstance(cdata, CTypesGenericArray): ptr = type(cdata)._to_ctypes(cdata) else: raise TypeError("expected a <cdata 'struct-or-union'>") if offset: ptr = ctypes.cast( ctypes.c_void_p( ctypes.cast(ptr, ctypes.c_void_p).value + offset), type(ptr)) return BTypePtr._from_ctypes(ptr) class CTypesLibrary(object): def __init__(self, backend, cdll): self.backend = backend self.cdll = cdll def load_function(self, BType, name): c_func = getattr(self.cdll, name) funcobj = BType._from_ctypes(c_func) funcobj._name = name return funcobj def read_variable(self, BType, name): try: ctypes_obj = BType._ctype.in_dll(self.cdll, name) except AttributeError as e: raise NotImplementedError(e) return BType._from_ctypes(ctypes_obj) def write_variable(self, BType, name, value): new_ctypes_obj = BType._to_ctypes(value) ctypes_obj = BType._ctype.in_dll(self.cdll, name) ctypes.memmove(ctypes.addressof(ctypes_obj), ctypes.addressof(new_ctypes_obj), ctypes.sizeof(BType._ctype)) PK %�\2@�� � api.pynu �[��� import sys, types from .lock import allocate_lock from .error import CDefError from . import model try: callable except NameError: # Python 3.1 from collections import Callable callable = lambda x: isinstance(x, Callable) try: basestring except NameError: # Python 3.x basestring = str class FFI(object): r''' The main top-level class that you instantiate once, or once per module. Example usage: ffi = FFI() ffi.cdef(""" int printf(const char *, ...); """) C = ffi.dlopen(None) # standard library -or- C = ffi.verify() # use a C compiler: verify the decl above is right C.printf("hello, %s!\n", ffi.new("char[]", "world")) ''' def __init__(self, backend=None): """Create an FFI instance. The 'backend' argument is used to select a non-default backend, mostly for tests. """ if backend is None: # You need PyPy (>= 2.0 beta), or a CPython (>= 2.6) with # _cffi_backend.so compiled. import _cffi_backend as backend from . import __version__ if backend.__version__ != __version__: # bad version! Try to be as explicit as possible. if hasattr(backend, '__file__'): # CPython raise Exception("Version mismatch: this is the 'cffi' package version %s, located in %r. When we import the top-level '_cffi_backend' extension module, we get version %s, located in %r. The two versions should be equal; check your installation." % ( __version__, __file__, backend.__version__, backend.__file__)) else: # PyPy raise Exception("Version mismatch: this is the 'cffi' package version %s, located in %r. This interpreter comes with a built-in '_cffi_backend' module, which is version %s. The two versions should be equal; check your installation." % ( __version__, __file__, backend.__version__)) # (If you insist you can also try to pass the option # 'backend=backend_ctypes.CTypesBackend()', but don't # rely on it! It's probably not going to work well.) from . import cparser self._backend = backend self._lock = allocate_lock() self._parser = cparser.Parser() self._cached_btypes = {} self._parsed_types = types.ModuleType('parsed_types').__dict__ self._new_types = types.ModuleType('new_types').__dict__ self._function_caches = [] self._libraries = [] self._cdefsources = [] self._included_ffis = [] self._windows_unicode = None self._init_once_cache = {} self._cdef_version = None self._embedding = None self._typecache = model.get_typecache(backend) if hasattr(backend, 'set_ffi'): backend.set_ffi(self) for name in list(backend.__dict__): if name.startswith('RTLD_'): setattr(self, name, getattr(backend, name)) # with self._lock: self.BVoidP = self._get_cached_btype(model.voidp_type) self.BCharA = self._get_cached_btype(model.char_array_type) if isinstance(backend, types.ModuleType): # _cffi_backend: attach these constants to the class if not hasattr(FFI, 'NULL'): FFI.NULL = self.cast(self.BVoidP, 0) FFI.CData, FFI.CType = backend._get_types() else: # ctypes backend: attach these constants to the instance self.NULL = self.cast(self.BVoidP, 0) self.CData, self.CType = backend._get_types() self.buffer = backend.buffer def cdef(self, csource, override=False, packed=False): """Parse the given C source. This registers all declared functions, types, and global variables. The functions and global variables can then be accessed via either 'ffi.dlopen()' or 'ffi.verify()'. The types can be used in 'ffi.new()' and other functions. If 'packed' is specified as True, all structs declared inside this cdef are packed, i.e. laid out without any field alignment at all. """ self._cdef(csource, override=override, packed=packed) def embedding_api(self, csource, packed=False): self._cdef(csource, packed=packed, dllexport=True) if self._embedding is None: self._embedding = '' def _cdef(self, csource, override=False, **options): if not isinstance(csource, str): # unicode, on Python 2 if not isinstance(csource, basestring): raise TypeError("cdef() argument must be a string") csource = csource.encode('ascii') with self._lock: self._cdef_version = object() self._parser.parse(csource, override=override, **options) self._cdefsources.append(csource) if override: for cache in self._function_caches: cache.clear() finishlist = self._parser._recomplete if finishlist: self._parser._recomplete = [] for tp in finishlist: tp.finish_backend_type(self, finishlist) def dlopen(self, name, flags=0): """Load and return a dynamic library identified by 'name'. The standard C library can be loaded by passing None. Note that functions and types declared by 'ffi.cdef()' are not linked to a particular library, just like C headers; in the library we only look for the actual (untyped) symbols. """ assert isinstance(name, basestring) or name is None with self._lock: lib, function_cache = _make_ffi_library(self, name, flags) self._function_caches.append(function_cache) self._libraries.append(lib) return lib def dlclose(self, lib): """Close a library obtained with ffi.dlopen(). After this call, access to functions or variables from the library will fail (possibly with a segmentation fault). """ type(lib).__cffi_close__(lib) def _typeof_locked(self, cdecl): # call me with the lock! key = cdecl if key in self._parsed_types: return self._parsed_types[key] # if not isinstance(cdecl, str): # unicode, on Python 2 cdecl = cdecl.encode('ascii') # type = self._parser.parse_type(cdecl) really_a_function_type = type.is_raw_function if really_a_function_type: type = type.as_function_pointer() btype = self._get_cached_btype(type) result = btype, really_a_function_type self._parsed_types[key] = result return result def _typeof(self, cdecl, consider_function_as_funcptr=False): # string -> ctype object try: result = self._parsed_types[cdecl] except KeyError: with self._lock: result = self._typeof_locked(cdecl) # btype, really_a_function_type = result if really_a_function_type and not consider_function_as_funcptr: raise CDefError("the type %r is a function type, not a " "pointer-to-function type" % (cdecl,)) return btype def typeof(self, cdecl): """Parse the C type given as a string and return the corresponding <ctype> object. It can also be used on 'cdata' instance to get its C type. """ if isinstance(cdecl, basestring): return self._typeof(cdecl) if isinstance(cdecl, self.CData): return self._backend.typeof(cdecl) if isinstance(cdecl, types.BuiltinFunctionType): res = _builtin_function_type(cdecl) if res is not None: return res if (isinstance(cdecl, types.FunctionType) and hasattr(cdecl, '_cffi_base_type')): with self._lock: return self._get_cached_btype(cdecl._cffi_base_type) raise TypeError(type(cdecl)) def sizeof(self, cdecl): """Return the size in bytes of the argument. It can be a string naming a C type, or a 'cdata' instance. """ if isinstance(cdecl, basestring): BType = self._typeof(cdecl) return self._backend.sizeof(BType) else: return self._backend.sizeof(cdecl) def alignof(self, cdecl): """Return the natural alignment size in bytes of the C type given as a string. """ if isinstance(cdecl, basestring): cdecl = self._typeof(cdecl) return self._backend.alignof(cdecl) def offsetof(self, cdecl, *fields_or_indexes): """Return the offset of the named field inside the given structure or array, which must be given as a C type name. You can give several field names in case of nested structures. You can also give numeric values which correspond to array items, in case of an array type. """ if isinstance(cdecl, basestring): cdecl = self._typeof(cdecl) return self._typeoffsetof(cdecl, *fields_or_indexes)[1] def new(self, cdecl, init=None): """Allocate an instance according to the specified C type and return a pointer to it. The specified C type must be either a pointer or an array: ``new('X *')`` allocates an X and returns a pointer to it, whereas ``new('X[n]')`` allocates an array of n X'es and returns an array referencing it (which works mostly like a pointer, like in C). You can also use ``new('X[]', n)`` to allocate an array of a non-constant length n. The memory is initialized following the rules of declaring a global variable in C: by default it is zero-initialized, but an explicit initializer can be given which can be used to fill all or part of the memory. When the returned <cdata> object goes out of scope, the memory is freed. In other words the returned <cdata> object has ownership of the value of type 'cdecl' that it points to. This means that the raw data can be used as long as this object is kept alive, but must not be used for a longer time. Be careful about that when copying the pointer to the memory somewhere else, e.g. into another structure. """ if isinstance(cdecl, basestring): cdecl = self._typeof(cdecl) return self._backend.newp(cdecl, init) def new_allocator(self, alloc=None, free=None, should_clear_after_alloc=True): """Return a new allocator, i.e. a function that behaves like ffi.new() but uses the provided low-level 'alloc' and 'free' functions. 'alloc' is called with the size as argument. If it returns NULL, a MemoryError is raised. 'free' is called with the result of 'alloc' as argument. Both can be either Python function or directly C functions. If 'free' is None, then no free function is called. If both 'alloc' and 'free' are None, the default is used. If 'should_clear_after_alloc' is set to False, then the memory returned by 'alloc' is assumed to be already cleared (or you are fine with garbage); otherwise CFFI will clear it. """ compiled_ffi = self._backend.FFI() allocator = compiled_ffi.new_allocator(alloc, free, should_clear_after_alloc) def allocate(cdecl, init=None): if isinstance(cdecl, basestring): cdecl = self._typeof(cdecl) return allocator(cdecl, init) return allocate def cast(self, cdecl, source): """Similar to a C cast: returns an instance of the named C type initialized with the given 'source'. The source is casted between integers or pointers of any type. """ if isinstance(cdecl, basestring): cdecl = self._typeof(cdecl) return self._backend.cast(cdecl, source) def string(self, cdata, maxlen=-1): """Return a Python string (or unicode string) from the 'cdata'. If 'cdata' is a pointer or array of characters or bytes, returns the null-terminated string. The returned string extends until the first null character, or at most 'maxlen' characters. If 'cdata' is an array then 'maxlen' defaults to its length. If 'cdata' is a pointer or array of wchar_t, returns a unicode string following the same rules. If 'cdata' is a single character or byte or a wchar_t, returns it as a string or unicode string. If 'cdata' is an enum, returns the value of the enumerator as a string, or 'NUMBER' if the value is out of range. """ return self._backend.string(cdata, maxlen) def unpack(self, cdata, length): """Unpack an array of C data of the given length, returning a Python string/unicode/list. If 'cdata' is a pointer to 'char', returns a byte string. It does not stop at the first null. This is equivalent to: ffi.buffer(cdata, length)[:] If 'cdata' is a pointer to 'wchar_t', returns a unicode string. 'length' is measured in wchar_t's; it is not the size in bytes. If 'cdata' is a pointer to anything else, returns a list of 'length' items. This is a faster equivalent to: [cdata[i] for i in range(length)] """ return self._backend.unpack(cdata, length) #def buffer(self, cdata, size=-1): # """Return a read-write buffer object that references the raw C data # pointed to by the given 'cdata'. The 'cdata' must be a pointer or # an array. Can be passed to functions expecting a buffer, or directly # manipulated with: # # buf[:] get a copy of it in a regular string, or # buf[idx] as a single character # buf[:] = ... # buf[idx] = ... change the content # """ # note that 'buffer' is a type, set on this instance by __init__ def from_buffer(self, python_buffer, require_writable=False): """Return a <cdata 'char[]'> that points to the data of the given Python object, which must support the buffer interface. Note that this is not meant to be used on the built-in types str or unicode (you can build 'char[]' arrays explicitly) but only on objects containing large quantities of raw data in some other format, like 'array.array' or numpy arrays. """ return self._backend.from_buffer(self.BCharA, python_buffer, require_writable) def memmove(self, dest, src, n): """ffi.memmove(dest, src, n) copies n bytes of memory from src to dest. Like the C function memmove(), the memory areas may overlap; apart from that it behaves like the C function memcpy(). 'src' can be any cdata ptr or array, or any Python buffer object. 'dest' can be any cdata ptr or array, or a writable Python buffer object. The size to copy, 'n', is always measured in bytes. Unlike other methods, this one supports all Python buffer including byte strings and bytearrays---but it still does not support non-contiguous buffers. """ return self._backend.memmove(dest, src, n) def callback(self, cdecl, python_callable=None, error=None, onerror=None): """Return a callback object or a decorator making such a callback object. 'cdecl' must name a C function pointer type. The callback invokes the specified 'python_callable' (which may be provided either directly or via a decorator). Important: the callback object must be manually kept alive for as long as the callback may be invoked from the C level. """ def callback_decorator_wrap(python_callable): if not callable(python_callable): raise TypeError("the 'python_callable' argument " "is not callable") return self._backend.callback(cdecl, python_callable, error, onerror) if isinstance(cdecl, basestring): cdecl = self._typeof(cdecl, consider_function_as_funcptr=True) if python_callable is None: return callback_decorator_wrap # decorator mode else: return callback_decorator_wrap(python_callable) # direct mode def getctype(self, cdecl, replace_with=''): """Return a string giving the C type 'cdecl', which may be itself a string or a <ctype> object. If 'replace_with' is given, it gives extra text to append (or insert for more complicated C types), like a variable name, or '*' to get actually the C type 'pointer-to-cdecl'. """ if isinstance(cdecl, basestring): cdecl = self._typeof(cdecl) replace_with = replace_with.strip() if (replace_with.startswith('*') and '&[' in self._backend.getcname(cdecl, '&')): replace_with = '(%s)' % replace_with elif replace_with and not replace_with[0] in '[(': replace_with = ' ' + replace_with return self._backend.getcname(cdecl, replace_with) def gc(self, cdata, destructor, size=0): """Return a new cdata object that points to the same data. Later, when this new cdata object is garbage-collected, 'destructor(old_cdata_object)' will be called. The optional 'size' gives an estimate of the size, used to trigger the garbage collection more eagerly. So far only used on PyPy. It tells the GC that the returned object keeps alive roughly 'size' bytes of external memory. """ return self._backend.gcp(cdata, destructor, size) def _get_cached_btype(self, type): assert self._lock.acquire(False) is False # call me with the lock! try: BType = self._cached_btypes[type] except KeyError: finishlist = [] BType = type.get_cached_btype(self, finishlist) for type in finishlist: type.finish_backend_type(self, finishlist) return BType def verify(self, source='', tmpdir=None, **kwargs): """Verify that the current ffi signatures compile on this machine, and return a dynamic library object. The dynamic library can be used to call functions and access global variables declared in this 'ffi'. The library is compiled by the C compiler: it gives you C-level API compatibility (including calling macros). This is unlike 'ffi.dlopen()', which requires binary compatibility in the signatures. """ from .verifier import Verifier, _caller_dir_pycache # # If set_unicode(True) was called, insert the UNICODE and # _UNICODE macro declarations if self._windows_unicode: self._apply_windows_unicode(kwargs) # # Set the tmpdir here, and not in Verifier.__init__: it picks # up the caller's directory, which we want to be the caller of # ffi.verify(), as opposed to the caller of Veritier(). tmpdir = tmpdir or _caller_dir_pycache() # # Make a Verifier() and use it to load the library. self.verifier = Verifier(self, source, tmpdir, **kwargs) lib = self.verifier.load_library() # # Save the loaded library for keep-alive purposes, even # if the caller doesn't keep it alive itself (it should). self._libraries.append(lib) return lib def _get_errno(self): return self._backend.get_errno() def _set_errno(self, errno): self._backend.set_errno(errno) errno = property(_get_errno, _set_errno, None, "the value of 'errno' from/to the C calls") def getwinerror(self, code=-1): return self._backend.getwinerror(code) def _pointer_to(self, ctype): with self._lock: return model.pointer_cache(self, ctype) def addressof(self, cdata, *fields_or_indexes): """Return the address of a <cdata 'struct-or-union'>. If 'fields_or_indexes' are given, returns the address of that field or array item in the structure or array, recursively in case of nested structures. """ try: ctype = self._backend.typeof(cdata) except TypeError: if '__addressof__' in type(cdata).__dict__: return type(cdata).__addressof__(cdata, *fields_or_indexes) raise if fields_or_indexes: ctype, offset = self._typeoffsetof(ctype, *fields_or_indexes) else: if ctype.kind == "pointer": raise TypeError("addressof(pointer)") offset = 0 ctypeptr = self._pointer_to(ctype) return self._backend.rawaddressof(ctypeptr, cdata, offset) def _typeoffsetof(self, ctype, field_or_index, *fields_or_indexes): ctype, offset = self._backend.typeoffsetof(ctype, field_or_index) for field1 in fields_or_indexes: ctype, offset1 = self._backend.typeoffsetof(ctype, field1, 1) offset += offset1 return ctype, offset def include(self, ffi_to_include): """Includes the typedefs, structs, unions and enums defined in another FFI instance. Usage is similar to a #include in C, where a part of the program might include types defined in another part for its own usage. Note that the include() method has no effect on functions, constants and global variables, which must anyway be accessed directly from the lib object returned by the original FFI instance. """ if not isinstance(ffi_to_include, FFI): raise TypeError("ffi.include() expects an argument that is also of" " type cffi.FFI, not %r" % ( type(ffi_to_include).__name__,)) if ffi_to_include is self: raise ValueError("self.include(self)") with ffi_to_include._lock: with self._lock: self._parser.include(ffi_to_include._parser) self._cdefsources.append('[') self._cdefsources.extend(ffi_to_include._cdefsources) self._cdefsources.append(']') self._included_ffis.append(ffi_to_include) def new_handle(self, x): return self._backend.newp_handle(self.BVoidP, x) def from_handle(self, x): return self._backend.from_handle(x) def set_unicode(self, enabled_flag): """Windows: if 'enabled_flag' is True, enable the UNICODE and _UNICODE defines in C, and declare the types like TCHAR and LPTCSTR to be (pointers to) wchar_t. If 'enabled_flag' is False, declare these types to be (pointers to) plain 8-bit characters. This is mostly for backward compatibility; you usually want True. """ if self._windows_unicode is not None: raise ValueError("set_unicode() can only be called once") enabled_flag = bool(enabled_flag) if enabled_flag: self.cdef("typedef wchar_t TBYTE;" "typedef wchar_t TCHAR;" "typedef const wchar_t *LPCTSTR;" "typedef const wchar_t *PCTSTR;" "typedef wchar_t *LPTSTR;" "typedef wchar_t *PTSTR;" "typedef TBYTE *PTBYTE;" "typedef TCHAR *PTCHAR;") else: self.cdef("typedef char TBYTE;" "typedef char TCHAR;" "typedef const char *LPCTSTR;" "typedef const char *PCTSTR;" "typedef char *LPTSTR;" "typedef char *PTSTR;" "typedef TBYTE *PTBYTE;" "typedef TCHAR *PTCHAR;") self._windows_unicode = enabled_flag def _apply_windows_unicode(self, kwds): defmacros = kwds.get('define_macros', ()) if not isinstance(defmacros, (list, tuple)): raise TypeError("'define_macros' must be a list or tuple") defmacros = list(defmacros) + [('UNICODE', '1'), ('_UNICODE', '1')] kwds['define_macros'] = defmacros def _apply_embedding_fix(self, kwds): # must include an argument like "-lpython2.7" for the compiler def ensure(key, value): lst = kwds.setdefault(key, []) if value not in lst: lst.append(value) # if '__pypy__' in sys.builtin_module_names: import os if sys.platform == "win32": # we need 'libpypy-c.lib'. Current distributions of # pypy (>= 4.1) contain it as 'libs/python27.lib'. pythonlib = "python27" if hasattr(sys, 'prefix'): ensure('library_dirs', os.path.join(sys.prefix, 'libs')) else: # we need 'libpypy-c.{so,dylib}', which should be by # default located in 'sys.prefix/bin' for installed # systems. if sys.version_info < (3,): pythonlib = "pypy-c" else: pythonlib = "pypy3-c" if hasattr(sys, 'prefix'): ensure('library_dirs', os.path.join(sys.prefix, 'bin')) # On uninstalled pypy's, the libpypy-c is typically found in # .../pypy/goal/. if hasattr(sys, 'prefix'): ensure('library_dirs', os.path.join(sys.prefix, 'pypy', 'goal')) else: if sys.platform == "win32": template = "python%d%d" if hasattr(sys, 'gettotalrefcount'): template += '_d' else: try: import sysconfig except ImportError: # 2.6 from distutils import sysconfig template = "python%d.%d" if sysconfig.get_config_var('DEBUG_EXT'): template += sysconfig.get_config_var('DEBUG_EXT') pythonlib = (template % (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff)) if hasattr(sys, 'abiflags'): pythonlib += sys.abiflags ensure('libraries', pythonlib) if sys.platform == "win32": ensure('extra_link_args', '/MANIFEST') def set_source(self, module_name, source, source_extension='.c', **kwds): import os if hasattr(self, '_assigned_source'): raise ValueError("set_source() cannot be called several times " "per ffi object") if not isinstance(module_name, basestring): raise TypeError("'module_name' must be a string") if os.sep in module_name or (os.altsep and os.altsep in module_name): raise ValueError("'module_name' must not contain '/': use a dotted " "name to make a 'package.module' location") self._assigned_source = (str(module_name), source, source_extension, kwds) def distutils_extension(self, tmpdir='build', verbose=True): from distutils.dir_util import mkpath from .recompiler import recompile # if not hasattr(self, '_assigned_source'): if hasattr(self, 'verifier'): # fallback, 'tmpdir' ignored return self.verifier.get_extension() raise ValueError("set_source() must be called before" " distutils_extension()") module_name, source, source_extension, kwds = self._assigned_source if source is None: raise TypeError("distutils_extension() is only for C extension " "modules, not for dlopen()-style pure Python " "modules") mkpath(tmpdir) ext, updated = recompile(self, module_name, source, tmpdir=tmpdir, extradir=tmpdir, source_extension=source_extension, call_c_compiler=False, **kwds) if verbose: if updated: sys.stderr.write("regenerated: %r\n" % (ext.sources[0],)) else: sys.stderr.write("not modified: %r\n" % (ext.sources[0],)) return ext def emit_c_code(self, filename): from .recompiler import recompile # if not hasattr(self, '_assigned_source'): raise ValueError("set_source() must be called before emit_c_code()") module_name, source, source_extension, kwds = self._assigned_source if source is None: raise TypeError("emit_c_code() is only for C extension modules, " "not for dlopen()-style pure Python modules") recompile(self, module_name, source, c_file=filename, call_c_compiler=False, **kwds) def emit_python_code(self, filename): from .recompiler import recompile # if not hasattr(self, '_assigned_source'): raise ValueError("set_source() must be called before emit_c_code()") module_name, source, source_extension, kwds = self._assigned_source if source is not None: raise TypeError("emit_python_code() is only for dlopen()-style " "pure Python modules, not for C extension modules") recompile(self, module_name, source, c_file=filename, call_c_compiler=False, **kwds) def compile(self, tmpdir='.', verbose=0, target=None, debug=None): """The 'target' argument gives the final file name of the compiled DLL. Use '*' to force distutils' choice, suitable for regular CPython C API modules. Use a file name ending in '.*' to ask for the system's default extension for dynamic libraries (.so/.dll/.dylib). The default is '*' when building a non-embedded C API extension, and (module_name + '.*') when building an embedded library. """ from .recompiler import recompile # if not hasattr(self, '_assigned_source'): raise ValueError("set_source() must be called before compile()") module_name, source, source_extension, kwds = self._assigned_source return recompile(self, module_name, source, tmpdir=tmpdir, target=target, source_extension=source_extension, compiler_verbose=verbose, debug=debug, **kwds) def init_once(self, func, tag): # Read _init_once_cache[tag], which is either (False, lock) if # we're calling the function now in some thread, or (True, result). # Don't call setdefault() in most cases, to avoid allocating and # immediately freeing a lock; but still use setdefaut() to avoid # races. try: x = self._init_once_cache[tag] except KeyError: x = self._init_once_cache.setdefault(tag, (False, allocate_lock())) # Common case: we got (True, result), so we return the result. if x[0]: return x[1] # Else, it's a lock. Acquire it to serialize the following tests. with x[1]: # Read again from _init_once_cache the current status. x = self._init_once_cache[tag] if x[0]: return x[1] # Call the function and store the result back. result = func() self._init_once_cache[tag] = (True, result) return result def embedding_init_code(self, pysource): if self._embedding: raise ValueError("embedding_init_code() can only be called once") # fix 'pysource' before it gets dumped into the C file: # - remove empty lines at the beginning, so it starts at "line 1" # - dedent, if all non-empty lines are indented # - check for SyntaxErrors import re match = re.match(r'\s*\n', pysource) if match: pysource = pysource[match.end():] lines = pysource.splitlines() or [''] prefix = re.match(r'\s*', lines[0]).group() for i in range(1, len(lines)): line = lines[i] if line.rstrip(): while not line.startswith(prefix): prefix = prefix[:-1] i = len(prefix) lines = [line[i:]+'\n' for line in lines] pysource = ''.join(lines) # compile(pysource, "cffi_init", "exec") # self._embedding = pysource def def_extern(self, *args, **kwds): raise ValueError("ffi.def_extern() is only available on API-mode FFI " "objects") def list_types(self): """Returns the user type names known to this FFI instance. This returns a tuple containing three lists of names: (typedef_names, names_of_structs, names_of_unions) """ typedefs = [] structs = [] unions = [] for key in self._parser._declarations: if key.startswith('typedef '): typedefs.append(key[8:]) elif key.startswith('struct '): structs.append(key[7:]) elif key.startswith('union '): unions.append(key[6:]) typedefs.sort() structs.sort() unions.sort() return (typedefs, structs, unions) def _load_backend_lib(backend, name, flags): import os if name is None: if sys.platform != "win32": return backend.load_library(None, flags) name = "c" # Windows: load_library(None) fails, but this works # on Python 2 (backward compatibility hack only) first_error = None if '.' in name or '/' in name or os.sep in name: try: return backend.load_library(name, flags) except OSError as e: first_error = e import ctypes.util path = ctypes.util.find_library(name) if path is None: if name == "c" and sys.platform == "win32" and sys.version_info >= (3,): raise OSError("dlopen(None) cannot work on Windows for Python 3 " "(see http://bugs.python.org/issue23606)") msg = ("ctypes.util.find_library() did not manage " "to locate a library called %r" % (name,)) if first_error is not None: msg = "%s. Additionally, %s" % (first_error, msg) raise OSError(msg) return backend.load_library(path, flags) def _make_ffi_library(ffi, libname, flags): backend = ffi._backend backendlib = _load_backend_lib(backend, libname, flags) # def accessor_function(name): key = 'function ' + name tp, _ = ffi._parser._declarations[key] BType = ffi._get_cached_btype(tp) value = backendlib.load_function(BType, name) library.__dict__[name] = value # def accessor_variable(name): key = 'variable ' + name tp, _ = ffi._parser._declarations[key] BType = ffi._get_cached_btype(tp) read_variable = backendlib.read_variable write_variable = backendlib.write_variable setattr(FFILibrary, name, property( lambda self: read_variable(BType, name), lambda self, value: write_variable(BType, name, value))) # def addressof_var(name): try: return addr_variables[name] except KeyError: with ffi._lock: if name not in addr_variables: key = 'variable ' + name tp, _ = ffi._parser._declarations[key] BType = ffi._get_cached_btype(tp) if BType.kind != 'array': BType = model.pointer_cache(ffi, BType) p = backendlib.load_function(BType, name) addr_variables[name] = p return addr_variables[name] # def accessor_constant(name): raise NotImplementedError("non-integer constant '%s' cannot be " "accessed from a dlopen() library" % (name,)) # def accessor_int_constant(name): library.__dict__[name] = ffi._parser._int_constants[name] # accessors = {} accessors_version = [False] addr_variables = {} # def update_accessors(): if accessors_version[0] is ffi._cdef_version: return # for key, (tp, _) in ffi._parser._declarations.items(): if not isinstance(tp, model.EnumType): tag, name = key.split(' ', 1) if tag == 'function': accessors[name] = accessor_function elif tag == 'variable': accessors[name] = accessor_variable elif tag == 'constant': accessors[name] = accessor_constant else: for i, enumname in enumerate(tp.enumerators): def accessor_enum(name, tp=tp, i=i): tp.check_not_partial() library.__dict__[name] = tp.enumvalues[i] accessors[enumname] = accessor_enum for name in ffi._parser._int_constants: accessors.setdefault(name, accessor_int_constant) accessors_version[0] = ffi._cdef_version # def make_accessor(name): with ffi._lock: if name in library.__dict__ or name in FFILibrary.__dict__: return # added by another thread while waiting for the lock if name not in accessors: update_accessors() if name not in accessors: raise AttributeError(name) accessors[name](name) # class FFILibrary(object): def __getattr__(self, name): make_accessor(name) return getattr(self, name) def __setattr__(self, name, value): try: property = getattr(self.__class__, name) except AttributeError: make_accessor(name) setattr(self, name, value) else: property.__set__(self, value) def __dir__(self): with ffi._lock: update_accessors() return accessors.keys() def __addressof__(self, name): if name in library.__dict__: return library.__dict__[name] if name in FFILibrary.__dict__: return addressof_var(name) make_accessor(name) if name in library.__dict__: return library.__dict__[name] if name in FFILibrary.__dict__: return addressof_var(name) raise AttributeError("cffi library has no function or " "global variable named '%s'" % (name,)) def __cffi_close__(self): backendlib.close_lib() self.__dict__.clear() # if libname is not None: try: if not isinstance(libname, str): # unicode, on Python 2 libname = libname.encode('utf-8') FFILibrary.__name__ = 'FFILibrary_%s' % libname except UnicodeError: pass library = FFILibrary() return library, library.__dict__ def _builtin_function_type(func): # a hack to make at least ffi.typeof(builtin_function) work, # if the builtin function was obtained by 'vengine_cpy'. import sys try: module = sys.modules[func.__module__] ffi = module._cffi_original_ffi types_of_builtin_funcs = module._cffi_types_of_builtin_funcs tp = types_of_builtin_funcs[func] except (KeyError, AttributeError, TypeError): return None else: with ffi._lock: return ffi._get_cached_btype(tp) PK %�\��3�R� R� cparser.pynu �[��� from . import model from .commontypes import COMMON_TYPES, resolve_common_type from .error import FFIError, CDefError try: from . import _pycparser as pycparser except ImportError: import pycparser import weakref, re, sys try: if sys.version_info < (3,): import thread as _thread else: import _thread lock = _thread.allocate_lock() except ImportError: lock = None CDEF_SOURCE_STRING = "<cdef source string>" _r_comment = re.compile(r"/\*.*?\*/|//([^\n\\]|\\.)*?$", re.DOTALL | re.MULTILINE) _r_define = re.compile(r"^\s*#\s*define\s+([A-Za-z_][A-Za-z_0-9]*)" r"\b((?:[^\n\\]|\\.)*?)$", re.DOTALL | re.MULTILINE) _r_partial_enum = re.compile(r"=\s*\.\.\.\s*[,}]|\.\.\.\s*\}") _r_enum_dotdotdot = re.compile(r"__dotdotdot\d+__$") _r_partial_array = re.compile(r"\[\s*\.\.\.\s*\]") _r_words = re.compile(r"\w+|\S") _parser_cache = None _r_int_literal = re.compile(r"-?0?x?[0-9a-f]+[lu]*$", re.IGNORECASE) _r_stdcall1 = re.compile(r"\b(__stdcall|WINAPI)\b") _r_stdcall2 = re.compile(r"[(]\s*(__stdcall|WINAPI)\b") _r_cdecl = re.compile(r"\b__cdecl\b") _r_extern_python = re.compile(r'\bextern\s*"' r'(Python|Python\s*\+\s*C|C\s*\+\s*Python)"\s*.') _r_star_const_space = re.compile( # matches "* const " r"[*]\s*((const|volatile|restrict)\b\s*)+") _r_int_dotdotdot = re.compile(r"(\b(int|long|short|signed|unsigned|char)\s*)+" r"\.\.\.") _r_float_dotdotdot = re.compile(r"\b(double|float)\s*\.\.\.") def _get_parser(): global _parser_cache if _parser_cache is None: _parser_cache = pycparser.CParser() return _parser_cache def _workaround_for_old_pycparser(csource): # Workaround for a pycparser issue (fixed between pycparser 2.10 and # 2.14): "char*const***" gives us a wrong syntax tree, the same as # for "char***(*const)". This means we can't tell the difference # afterwards. But "char(*const(***))" gives us the right syntax # tree. The issue only occurs if there are several stars in # sequence with no parenthesis inbetween, just possibly qualifiers. # Attempt to fix it by adding some parentheses in the source: each # time we see "* const" or "* const *", we add an opening # parenthesis before each star---the hard part is figuring out where # to close them. parts = [] while True: match = _r_star_const_space.search(csource) if not match: break #print repr(''.join(parts)+csource), '=>', parts.append(csource[:match.start()]) parts.append('('); closing = ')' parts.append(match.group()) # e.g. "* const " endpos = match.end() if csource.startswith('*', endpos): parts.append('('); closing += ')' level = 0 i = endpos while i < len(csource): c = csource[i] if c == '(': level += 1 elif c == ')': if level == 0: break level -= 1 elif c in ',;=': if level == 0: break i += 1 csource = csource[endpos:i] + closing + csource[i:] #print repr(''.join(parts)+csource) parts.append(csource) return ''.join(parts) def _preprocess_extern_python(csource): # input: `extern "Python" int foo(int);` or # `extern "Python" { int foo(int); }` # output: # void __cffi_extern_python_start; # int foo(int); # void __cffi_extern_python_stop; # # input: `extern "Python+C" int foo(int);` # output: # void __cffi_extern_python_plus_c_start; # int foo(int); # void __cffi_extern_python_stop; parts = [] while True: match = _r_extern_python.search(csource) if not match: break endpos = match.end() - 1 #print #print ''.join(parts)+csource #print '=>' parts.append(csource[:match.start()]) if 'C' in match.group(1): parts.append('void __cffi_extern_python_plus_c_start; ') else: parts.append('void __cffi_extern_python_start; ') if csource[endpos] == '{': # grouping variant closing = csource.find('}', endpos) if closing < 0: raise CDefError("'extern \"Python\" {': no '}' found") if csource.find('{', endpos + 1, closing) >= 0: raise NotImplementedError("cannot use { } inside a block " "'extern \"Python\" { ... }'") parts.append(csource[endpos+1:closing]) csource = csource[closing+1:] else: # non-grouping variant semicolon = csource.find(';', endpos) if semicolon < 0: raise CDefError("'extern \"Python\": no ';' found") parts.append(csource[endpos:semicolon+1]) csource = csource[semicolon+1:] parts.append(' void __cffi_extern_python_stop;') #print ''.join(parts)+csource #print parts.append(csource) return ''.join(parts) def _preprocess(csource): # Remove comments. NOTE: this only work because the cdef() section # should not contain any string literal! csource = _r_comment.sub(' ', csource) # Remove the "#define FOO x" lines macros = {} for match in _r_define.finditer(csource): macroname, macrovalue = match.groups() macrovalue = macrovalue.replace('\\\n', '').strip() macros[macroname] = macrovalue csource = _r_define.sub('', csource) # if pycparser.__version__ < '2.14': csource = _workaround_for_old_pycparser(csource) # # BIG HACK: replace WINAPI or __stdcall with "volatile const". # It doesn't make sense for the return type of a function to be # "volatile volatile const", so we abuse it to detect __stdcall... # Hack number 2 is that "int(volatile *fptr)();" is not valid C # syntax, so we place the "volatile" before the opening parenthesis. csource = _r_stdcall2.sub(' volatile volatile const(', csource) csource = _r_stdcall1.sub(' volatile volatile const ', csource) csource = _r_cdecl.sub(' ', csource) # # Replace `extern "Python"` with start/end markers csource = _preprocess_extern_python(csource) # # Replace "[...]" with "[__dotdotdotarray__]" csource = _r_partial_array.sub('[__dotdotdotarray__]', csource) # # Replace "...}" with "__dotdotdotNUM__}". This construction should # occur only at the end of enums; at the end of structs we have "...;}" # and at the end of vararg functions "...);". Also replace "=...[,}]" # with ",__dotdotdotNUM__[,}]": this occurs in the enums too, when # giving an unknown value. matches = list(_r_partial_enum.finditer(csource)) for number, match in enumerate(reversed(matches)): p = match.start() if csource[p] == '=': p2 = csource.find('...', p, match.end()) assert p2 > p csource = '%s,__dotdotdot%d__ %s' % (csource[:p], number, csource[p2+3:]) else: assert csource[p:p+3] == '...' csource = '%s __dotdotdot%d__ %s' % (csource[:p], number, csource[p+3:]) # Replace "int ..." or "unsigned long int..." with "__dotdotdotint__" csource = _r_int_dotdotdot.sub(' __dotdotdotint__ ', csource) # Replace "float ..." or "double..." with "__dotdotdotfloat__" csource = _r_float_dotdotdot.sub(' __dotdotdotfloat__ ', csource) # Replace all remaining "..." with the same name, "__dotdotdot__", # which is declared with a typedef for the purpose of C parsing. return csource.replace('...', ' __dotdotdot__ '), macros def _common_type_names(csource): # Look in the source for what looks like usages of types from the # list of common types. A "usage" is approximated here as the # appearance of the word, minus a "definition" of the type, which # is the last word in a "typedef" statement. Approximative only # but should be fine for all the common types. look_for_words = set(COMMON_TYPES) look_for_words.add(';') look_for_words.add(',') look_for_words.add('(') look_for_words.add(')') look_for_words.add('typedef') words_used = set() is_typedef = False paren = 0 previous_word = '' for word in _r_words.findall(csource): if word in look_for_words: if word == ';': if is_typedef: words_used.discard(previous_word) look_for_words.discard(previous_word) is_typedef = False elif word == 'typedef': is_typedef = True paren = 0 elif word == '(': paren += 1 elif word == ')': paren -= 1 elif word == ',': if is_typedef and paren == 0: words_used.discard(previous_word) look_for_words.discard(previous_word) else: # word in COMMON_TYPES words_used.add(word) previous_word = word return words_used class Parser(object): def __init__(self): self._declarations = {} self._included_declarations = set() self._anonymous_counter = 0 self._structnode2type = weakref.WeakKeyDictionary() self._options = {} self._int_constants = {} self._recomplete = [] self._uses_new_feature = None def _parse(self, csource): csource, macros = _preprocess(csource) # XXX: for more efficiency we would need to poke into the # internals of CParser... the following registers the # typedefs, because their presence or absence influences the # parsing itself (but what they are typedef'ed to plays no role) ctn = _common_type_names(csource) typenames = [] for name in sorted(self._declarations): if name.startswith('typedef '): name = name[8:] typenames.append(name) ctn.discard(name) typenames += sorted(ctn) # csourcelines = [] csourcelines.append('# 1 "<cdef automatic initialization code>"') for typename in typenames: csourcelines.append('typedef int %s;' % typename) csourcelines.append('typedef int __dotdotdotint__, __dotdotdotfloat__,' ' __dotdotdot__;') # this forces pycparser to consider the following in the file # called <cdef source string> from line 1 csourcelines.append('# 1 "%s"' % (CDEF_SOURCE_STRING,)) csourcelines.append(csource) fullcsource = '\n'.join(csourcelines) if lock is not None: lock.acquire() # pycparser is not thread-safe... try: ast = _get_parser().parse(fullcsource) except pycparser.c_parser.ParseError as e: self.convert_pycparser_error(e, csource) finally: if lock is not None: lock.release() # csource will be used to find buggy source text return ast, macros, csource def _convert_pycparser_error(self, e, csource): # xxx look for "<cdef source string>:NUM:" at the start of str(e) # and interpret that as a line number. This will not work if # the user gives explicit ``# NUM "FILE"`` directives. line = None msg = str(e) match = re.match(r"%s:(\d+):" % (CDEF_SOURCE_STRING,), msg) if match: linenum = int(match.group(1), 10) csourcelines = csource.splitlines() if 1 <= linenum <= len(csourcelines): line = csourcelines[linenum-1] return line def convert_pycparser_error(self, e, csource): line = self._convert_pycparser_error(e, csource) msg = str(e) if line: msg = 'cannot parse "%s"\n%s' % (line.strip(), msg) else: msg = 'parse error\n%s' % (msg,) raise CDefError(msg) def parse(self, csource, override=False, packed=False, dllexport=False): prev_options = self._options try: self._options = {'override': override, 'packed': packed, 'dllexport': dllexport} self._internal_parse(csource) finally: self._options = prev_options def _internal_parse(self, csource): ast, macros, csource = self._parse(csource) # add the macros self._process_macros(macros) # find the first "__dotdotdot__" and use that as a separator # between the repeated typedefs and the real csource iterator = iter(ast.ext) for decl in iterator: if decl.name == '__dotdotdot__': break else: assert 0 current_decl = None # try: self._inside_extern_python = '__cffi_extern_python_stop' for decl in iterator: current_decl = decl if isinstance(decl, pycparser.c_ast.Decl): self._parse_decl(decl) elif isinstance(decl, pycparser.c_ast.Typedef): if not decl.name: raise CDefError("typedef does not declare any name", decl) quals = 0 if (isinstance(decl.type.type, pycparser.c_ast.IdentifierType) and decl.type.type.names[-1].startswith('__dotdotdot')): realtype = self._get_unknown_type(decl) elif (isinstance(decl.type, pycparser.c_ast.PtrDecl) and isinstance(decl.type.type, pycparser.c_ast.TypeDecl) and isinstance(decl.type.type.type, pycparser.c_ast.IdentifierType) and decl.type.type.type.names[-1].startswith('__dotdotdot')): realtype = self._get_unknown_ptr_type(decl) else: realtype, quals = self._get_type_and_quals( decl.type, name=decl.name, partial_length_ok=True) self._declare('typedef ' + decl.name, realtype, quals=quals) elif decl.__class__.__name__ == 'Pragma': pass # skip pragma, only in pycparser 2.15 else: raise CDefError("unexpected <%s>: this construct is valid " "C but not valid in cdef()" % decl.__class__.__name__, decl) except CDefError as e: if len(e.args) == 1: e.args = e.args + (current_decl,) raise except FFIError as e: msg = self._convert_pycparser_error(e, csource) if msg: e.args = (e.args[0] + "\n *** Err: %s" % msg,) raise def _add_constants(self, key, val): if key in self._int_constants: if self._int_constants[key] == val: return # ignore identical double declarations raise FFIError( "multiple declarations of constant: %s" % (key,)) self._int_constants[key] = val def _add_integer_constant(self, name, int_str): int_str = int_str.lower().rstrip("ul") neg = int_str.startswith('-') if neg: int_str = int_str[1:] # "010" is not valid oct in py3 if (int_str.startswith("0") and int_str != '0' and not int_str.startswith("0x")): int_str = "0o" + int_str[1:] pyvalue = int(int_str, 0) if neg: pyvalue = -pyvalue self._add_constants(name, pyvalue) self._declare('macro ' + name, pyvalue) def _process_macros(self, macros): for key, value in macros.items(): value = value.strip() if _r_int_literal.match(value): self._add_integer_constant(key, value) elif value == '...': self._declare('macro ' + key, value) else: raise CDefError( 'only supports one of the following syntax:\n' ' #define %s ... (literally dot-dot-dot)\n' ' #define %s NUMBER (with NUMBER an integer' ' constant, decimal/hex/octal)\n' 'got:\n' ' #define %s %s' % (key, key, key, value)) def _declare_function(self, tp, quals, decl): tp = self._get_type_pointer(tp, quals) if self._options.get('dllexport'): tag = 'dllexport_python ' elif self._inside_extern_python == '__cffi_extern_python_start': tag = 'extern_python ' elif self._inside_extern_python == '__cffi_extern_python_plus_c_start': tag = 'extern_python_plus_c ' else: tag = 'function ' self._declare(tag + decl.name, tp) def _parse_decl(self, decl): node = decl.type if isinstance(node, pycparser.c_ast.FuncDecl): tp, quals = self._get_type_and_quals(node, name=decl.name) assert isinstance(tp, model.RawFunctionType) self._declare_function(tp, quals, decl) else: if isinstance(node, pycparser.c_ast.Struct): self._get_struct_union_enum_type('struct', node) elif isinstance(node, pycparser.c_ast.Union): self._get_struct_union_enum_type('union', node) elif isinstance(node, pycparser.c_ast.Enum): self._get_struct_union_enum_type('enum', node) elif not decl.name: raise CDefError("construct does not declare any variable", decl) # if decl.name: tp, quals = self._get_type_and_quals(node, partial_length_ok=True) if tp.is_raw_function: self._declare_function(tp, quals, decl) elif (tp.is_integer_type() and hasattr(decl, 'init') and hasattr(decl.init, 'value') and _r_int_literal.match(decl.init.value)): self._add_integer_constant(decl.name, decl.init.value) elif (tp.is_integer_type() and isinstance(decl.init, pycparser.c_ast.UnaryOp) and decl.init.op == '-' and hasattr(decl.init.expr, 'value') and _r_int_literal.match(decl.init.expr.value)): self._add_integer_constant(decl.name, '-' + decl.init.expr.value) elif (tp is model.void_type and decl.name.startswith('__cffi_extern_python_')): # hack: `extern "Python"` in the C source is replaced # with "void __cffi_extern_python_start;" and # "void __cffi_extern_python_stop;" self._inside_extern_python = decl.name else: if self._inside_extern_python !='__cffi_extern_python_stop': raise CDefError( "cannot declare constants or " "variables with 'extern \"Python\"'") if (quals & model.Q_CONST) and not tp.is_array_type: self._declare('constant ' + decl.name, tp, quals=quals) else: self._declare('variable ' + decl.name, tp, quals=quals) def parse_type(self, cdecl): return self.parse_type_and_quals(cdecl)[0] def parse_type_and_quals(self, cdecl): ast, macros = self._parse('void __dummy(\n%s\n);' % cdecl)[:2] assert not macros exprnode = ast.ext[-1].type.args.params[0] if isinstance(exprnode, pycparser.c_ast.ID): raise CDefError("unknown identifier '%s'" % (exprnode.name,)) return self._get_type_and_quals(exprnode.type) def _declare(self, name, obj, included=False, quals=0): if name in self._declarations: prevobj, prevquals = self._declarations[name] if prevobj is obj and prevquals == quals: return if not self._options.get('override'): raise FFIError( "multiple declarations of %s (for interactive usage, " "try cdef(xx, override=True))" % (name,)) assert '__dotdotdot__' not in name.split() self._declarations[name] = (obj, quals) if included: self._included_declarations.add(obj) def _extract_quals(self, type): quals = 0 if isinstance(type, (pycparser.c_ast.TypeDecl, pycparser.c_ast.PtrDecl)): if 'const' in type.quals: quals |= model.Q_CONST if 'volatile' in type.quals: quals |= model.Q_VOLATILE if 'restrict' in type.quals: quals |= model.Q_RESTRICT return quals def _get_type_pointer(self, type, quals, declname=None): if isinstance(type, model.RawFunctionType): return type.as_function_pointer() if (isinstance(type, model.StructOrUnionOrEnum) and type.name.startswith('$') and type.name[1:].isdigit() and type.forcename is None and declname is not None): return model.NamedPointerType(type, declname, quals) return model.PointerType(type, quals) def _get_type_and_quals(self, typenode, name=None, partial_length_ok=False): # first, dereference typedefs, if we have it already parsed, we're good if (isinstance(typenode, pycparser.c_ast.TypeDecl) and isinstance(typenode.type, pycparser.c_ast.IdentifierType) and len(typenode.type.names) == 1 and ('typedef ' + typenode.type.names[0]) in self._declarations): tp, quals = self._declarations['typedef ' + typenode.type.names[0]] quals |= self._extract_quals(typenode) return tp, quals # if isinstance(typenode, pycparser.c_ast.ArrayDecl): # array type if typenode.dim is None: length = None else: length = self._parse_constant( typenode.dim, partial_length_ok=partial_length_ok) tp, quals = self._get_type_and_quals(typenode.type, partial_length_ok=partial_length_ok) return model.ArrayType(tp, length), quals # if isinstance(typenode, pycparser.c_ast.PtrDecl): # pointer type itemtype, itemquals = self._get_type_and_quals(typenode.type) tp = self._get_type_pointer(itemtype, itemquals, declname=name) quals = self._extract_quals(typenode) return tp, quals # if isinstance(typenode, pycparser.c_ast.TypeDecl): quals = self._extract_quals(typenode) type = typenode.type if isinstance(type, pycparser.c_ast.IdentifierType): # assume a primitive type. get it from .names, but reduce # synonyms to a single chosen combination names = list(type.names) if names != ['signed', 'char']: # keep this unmodified prefixes = {} while names: name = names[0] if name in ('short', 'long', 'signed', 'unsigned'): prefixes[name] = prefixes.get(name, 0) + 1 del names[0] else: break # ignore the 'signed' prefix below, and reorder the others newnames = [] for prefix in ('unsigned', 'short', 'long'): for i in range(prefixes.get(prefix, 0)): newnames.append(prefix) if not names: names = ['int'] # implicitly if names == ['int']: # but kill it if 'short' or 'long' if 'short' in prefixes or 'long' in prefixes: names = [] names = newnames + names ident = ' '.join(names) if ident == 'void': return model.void_type, quals if ident == '__dotdotdot__': raise FFIError(':%d: bad usage of "..."' % typenode.coord.line) tp0, quals0 = resolve_common_type(self, ident) return tp0, (quals | quals0) # if isinstance(type, pycparser.c_ast.Struct): # 'struct foobar' tp = self._get_struct_union_enum_type('struct', type, name) return tp, quals # if isinstance(type, pycparser.c_ast.Union): # 'union foobar' tp = self._get_struct_union_enum_type('union', type, name) return tp, quals # if isinstance(type, pycparser.c_ast.Enum): # 'enum foobar' tp = self._get_struct_union_enum_type('enum', type, name) return tp, quals # if isinstance(typenode, pycparser.c_ast.FuncDecl): # a function type return self._parse_function_type(typenode, name), 0 # # nested anonymous structs or unions end up here if isinstance(typenode, pycparser.c_ast.Struct): return self._get_struct_union_enum_type('struct', typenode, name, nested=True), 0 if isinstance(typenode, pycparser.c_ast.Union): return self._get_struct_union_enum_type('union', typenode, name, nested=True), 0 # raise FFIError(":%d: bad or unsupported type declaration" % typenode.coord.line) def _parse_function_type(self, typenode, funcname=None): params = list(getattr(typenode.args, 'params', [])) for i, arg in enumerate(params): if not hasattr(arg, 'type'): raise CDefError("%s arg %d: unknown type '%s'" " (if you meant to use the old C syntax of giving" " untyped arguments, it is not supported)" % (funcname or 'in expression', i + 1, getattr(arg, 'name', '?'))) ellipsis = ( len(params) > 0 and isinstance(params[-1].type, pycparser.c_ast.TypeDecl) and isinstance(params[-1].type.type, pycparser.c_ast.IdentifierType) and params[-1].type.type.names == ['__dotdotdot__']) if ellipsis: params.pop() if not params: raise CDefError( "%s: a function with only '(...)' as argument" " is not correct C" % (funcname or 'in expression')) args = [self._as_func_arg(*self._get_type_and_quals(argdeclnode.type)) for argdeclnode in params] if not ellipsis and args == [model.void_type]: args = [] result, quals = self._get_type_and_quals(typenode.type) # the 'quals' on the result type are ignored. HACK: we absure them # to detect __stdcall functions: we textually replace "__stdcall" # with "volatile volatile const" above. abi = None if hasattr(typenode.type, 'quals'): # else, probable syntax error anyway if typenode.type.quals[-3:] == ['volatile', 'volatile', 'const']: abi = '__stdcall' return model.RawFunctionType(tuple(args), result, ellipsis, abi) def _as_func_arg(self, type, quals): if isinstance(type, model.ArrayType): return model.PointerType(type.item, quals) elif isinstance(type, model.RawFunctionType): return type.as_function_pointer() else: return type def _get_struct_union_enum_type(self, kind, type, name=None, nested=False): # First, a level of caching on the exact 'type' node of the AST. # This is obscure, but needed because pycparser "unrolls" declarations # such as "typedef struct { } foo_t, *foo_p" and we end up with # an AST that is not a tree, but a DAG, with the "type" node of the # two branches foo_t and foo_p of the trees being the same node. # It's a bit silly but detecting "DAG-ness" in the AST tree seems # to be the only way to distinguish this case from two independent # structs. See test_struct_with_two_usages. try: return self._structnode2type[type] except KeyError: pass # # Note that this must handle parsing "struct foo" any number of # times and always return the same StructType object. Additionally, # one of these times (not necessarily the first), the fields of # the struct can be specified with "struct foo { ...fields... }". # If no name is given, then we have to create a new anonymous struct # with no caching; in this case, the fields are either specified # right now or never. # force_name = name name = type.name # # get the type or create it if needed if name is None: # 'force_name' is used to guess a more readable name for # anonymous structs, for the common case "typedef struct { } foo". if force_name is not None: explicit_name = '$%s' % force_name else: self._anonymous_counter += 1 explicit_name = '$%d' % self._anonymous_counter tp = None else: explicit_name = name key = '%s %s' % (kind, name) tp, _ = self._declarations.get(key, (None, None)) # if tp is None: if kind == 'struct': tp = model.StructType(explicit_name, None, None, None) elif kind == 'union': tp = model.UnionType(explicit_name, None, None, None) elif kind == 'enum': if explicit_name == '__dotdotdot__': raise CDefError("Enums cannot be declared with ...") tp = self._build_enum_type(explicit_name, type.values) else: raise AssertionError("kind = %r" % (kind,)) if name is not None: self._declare(key, tp) else: if kind == 'enum' and type.values is not None: raise NotImplementedError( "enum %s: the '{}' declaration should appear on the first " "time the enum is mentioned, not later" % explicit_name) if not tp.forcename: tp.force_the_name(force_name) if tp.forcename and '$' in tp.name: self._declare('anonymous %s' % tp.forcename, tp) # self._structnode2type[type] = tp # # enums: done here if kind == 'enum': return tp # # is there a 'type.decls'? If yes, then this is the place in the # C sources that declare the fields. If no, then just return the # existing type, possibly still incomplete. if type.decls is None: return tp # if tp.fldnames is not None: raise CDefError("duplicate declaration of struct %s" % name) fldnames = [] fldtypes = [] fldbitsize = [] fldquals = [] for decl in type.decls: if (isinstance(decl.type, pycparser.c_ast.IdentifierType) and ''.join(decl.type.names) == '__dotdotdot__'): # XXX pycparser is inconsistent: 'names' should be a list # of strings, but is sometimes just one string. Use # str.join() as a way to cope with both. self._make_partial(tp, nested) continue if decl.bitsize is None: bitsize = -1 else: bitsize = self._parse_constant(decl.bitsize) self._partial_length = False type, fqual = self._get_type_and_quals(decl.type, partial_length_ok=True) if self._partial_length: self._make_partial(tp, nested) if isinstance(type, model.StructType) and type.partial: self._make_partial(tp, nested) fldnames.append(decl.name or '') fldtypes.append(type) fldbitsize.append(bitsize) fldquals.append(fqual) tp.fldnames = tuple(fldnames) tp.fldtypes = tuple(fldtypes) tp.fldbitsize = tuple(fldbitsize) tp.fldquals = tuple(fldquals) if fldbitsize != [-1] * len(fldbitsize): if isinstance(tp, model.StructType) and tp.partial: raise NotImplementedError("%s: using both bitfields and '...;'" % (tp,)) tp.packed = self._options.get('packed') if tp.completed: # must be re-completed: it is not opaque any more tp.completed = 0 self._recomplete.append(tp) return tp def _make_partial(self, tp, nested): if not isinstance(tp, model.StructOrUnion): raise CDefError("%s cannot be partial" % (tp,)) if not tp.has_c_name() and not nested: raise NotImplementedError("%s is partial but has no C name" %(tp,)) tp.partial = True def _parse_constant(self, exprnode, partial_length_ok=False): # for now, limited to expressions that are an immediate number # or positive/negative number if isinstance(exprnode, pycparser.c_ast.Constant): s = exprnode.value if s.startswith('0'): if s.startswith('0x') or s.startswith('0X'): return int(s, 16) return int(s, 8) elif '1' <= s[0] <= '9': return int(s, 10) elif s[0] == "'" and s[-1] == "'" and ( len(s) == 3 or (len(s) == 4 and s[1] == "\\")): return ord(s[-2]) else: raise CDefError("invalid constant %r" % (s,)) # if (isinstance(exprnode, pycparser.c_ast.UnaryOp) and exprnode.op == '+'): return self._parse_constant(exprnode.expr) # if (isinstance(exprnode, pycparser.c_ast.UnaryOp) and exprnode.op == '-'): return -self._parse_constant(exprnode.expr) # load previously defined int constant if (isinstance(exprnode, pycparser.c_ast.ID) and exprnode.name in self._int_constants): return self._int_constants[exprnode.name] # if (isinstance(exprnode, pycparser.c_ast.ID) and exprnode.name == '__dotdotdotarray__'): if partial_length_ok: self._partial_length = True return '...' raise FFIError(":%d: unsupported '[...]' here, cannot derive " "the actual array length in this context" % exprnode.coord.line) # if (isinstance(exprnode, pycparser.c_ast.BinaryOp) and exprnode.op == '+'): return (self._parse_constant(exprnode.left) + self._parse_constant(exprnode.right)) # if (isinstance(exprnode, pycparser.c_ast.BinaryOp) and exprnode.op == '-'): return (self._parse_constant(exprnode.left) - self._parse_constant(exprnode.right)) # raise FFIError(":%d: unsupported expression: expected a " "simple numeric constant" % exprnode.coord.line) def _build_enum_type(self, explicit_name, decls): if decls is not None: partial = False enumerators = [] enumvalues = [] nextenumvalue = 0 for enum in decls.enumerators: if _r_enum_dotdotdot.match(enum.name): partial = True continue if enum.value is not None: nextenumvalue = self._parse_constant(enum.value) enumerators.append(enum.name) enumvalues.append(nextenumvalue) self._add_constants(enum.name, nextenumvalue) nextenumvalue += 1 enumerators = tuple(enumerators) enumvalues = tuple(enumvalues) tp = model.EnumType(explicit_name, enumerators, enumvalues) tp.partial = partial else: # opaque enum tp = model.EnumType(explicit_name, (), ()) return tp def include(self, other): for name, (tp, quals) in other._declarations.items(): if name.startswith('anonymous $enum_$'): continue # fix for test_anonymous_enum_include kind = name.split(' ', 1)[0] if kind in ('struct', 'union', 'enum', 'anonymous', 'typedef'): self._declare(name, tp, included=True, quals=quals) for k, v in other._int_constants.items(): self._add_constants(k, v) def _get_unknown_type(self, decl): typenames = decl.type.type.names if typenames == ['__dotdotdot__']: return model.unknown_type(decl.name) if typenames == ['__dotdotdotint__']: if self._uses_new_feature is None: self._uses_new_feature = "'typedef int... %s'" % decl.name return model.UnknownIntegerType(decl.name) if typenames == ['__dotdotdotfloat__']: # note: not for 'long double' so far if self._uses_new_feature is None: self._uses_new_feature = "'typedef float... %s'" % decl.name return model.UnknownFloatType(decl.name) raise FFIError(':%d: unsupported usage of "..." in typedef' % decl.coord.line) def _get_unknown_ptr_type(self, decl): if decl.type.type.type.names == ['__dotdotdot__']: return model.unknown_ptr_type(decl.name) raise FFIError(':%d: unsupported usage of "..." in typedef' % decl.coord.line) PK %�\�M� � _cffi_errors.hnu �[��� #ifndef CFFI_MESSAGEBOX # ifdef _MSC_VER # define CFFI_MESSAGEBOX 1 # else # define CFFI_MESSAGEBOX 0 # endif #endif #if CFFI_MESSAGEBOX /* Windows only: logic to take the Python-CFFI embedding logic initialization errors and display them in a background thread with MessageBox. The idea is that if the whole program closes as a result of this problem, then likely it is already a console program and you can read the stderr output in the console too. If it is not a console program, then it will likely show its own dialog to complain, or generally not abruptly close, and for this case the background thread should stay alive. */ static void *volatile _cffi_bootstrap_text; static PyObject *_cffi_start_error_capture(void) { PyObject *result = NULL; PyObject *x, *m, *bi; if (InterlockedCompareExchangePointer(&_cffi_bootstrap_text, (void *)1, NULL) != NULL) return (PyObject *)1; m = PyImport_AddModule("_cffi_error_capture"); if (m == NULL) goto error; result = PyModule_GetDict(m); if (result == NULL) goto error; #if PY_MAJOR_VERSION >= 3 bi = PyImport_ImportModule("builtins"); #else bi = PyImport_ImportModule("__builtin__"); #endif if (bi == NULL) goto error; PyDict_SetItemString(result, "__builtins__", bi); Py_DECREF(bi); x = PyRun_String( "import sys\n" "class FileLike:\n" " def write(self, x):\n" " of.write(x)\n" " self.buf += x\n" "fl = FileLike()\n" "fl.buf = ''\n" "of = sys.stderr\n" "sys.stderr = fl\n" "def done():\n" " sys.stderr = of\n" " return fl.buf\n", /* make sure the returned value stays alive */ Py_file_input, result, result); Py_XDECREF(x); error: if (PyErr_Occurred()) { PyErr_WriteUnraisable(Py_None); PyErr_Clear(); } return result; } #pragma comment(lib, "user32.lib") static DWORD WINAPI _cffi_bootstrap_dialog(LPVOID ignored) { Sleep(666); /* may be interrupted if the whole process is closing */ #if PY_MAJOR_VERSION >= 3 MessageBoxW(NULL, (wchar_t *)_cffi_bootstrap_text, L"Python-CFFI error", MB_OK | MB_ICONERROR); #else MessageBoxA(NULL, (char *)_cffi_bootstrap_text, "Python-CFFI error", MB_OK | MB_ICONERROR); #endif _cffi_bootstrap_text = NULL; return 0; } static void _cffi_stop_error_capture(PyObject *ecap) { PyObject *s; void *text; if (ecap == (PyObject *)1) return; if (ecap == NULL) goto error; s = PyRun_String("done()", Py_eval_input, ecap, ecap); if (s == NULL) goto error; /* Show a dialog box, but in a background thread, and never show multiple dialog boxes at once. */ #if PY_MAJOR_VERSION >= 3 text = PyUnicode_AsWideCharString(s, NULL); #else text = PyString_AsString(s); #endif _cffi_bootstrap_text = text; if (text != NULL) { HANDLE h; h = CreateThread(NULL, 0, _cffi_bootstrap_dialog, NULL, 0, NULL); if (h != NULL) CloseHandle(h); } /* decref the string, but it should stay alive as 'fl.buf' in the small module above. It will really be freed only if we later get another similar error. So it's a leak of at most one copy of the small module. That's fine for this situation which is usually a "fatal error" anyway. */ Py_DECREF(s); PyErr_Clear(); return; error: _cffi_bootstrap_text = NULL; PyErr_Clear(); } #else static PyObject *_cffi_start_error_capture(void) { return NULL; } static void _cffi_stop_error_capture(PyObject *ecap) { } #endif PK %�\ �au/ u/ _cffi_include.hnu �[��� #define _CFFI_ /* We try to define Py_LIMITED_API before including Python.h. Mess: we can only define it if Py_DEBUG, Py_TRACE_REFS and Py_REF_DEBUG are not defined. This is a best-effort approximation: we can learn about Py_DEBUG from pyconfig.h, but it is unclear if the same works for the other two macros. Py_DEBUG implies them, but not the other way around. Issue #350 is still open: on Windows, the code here causes it to link with PYTHON36.DLL (for example) instead of PYTHON3.DLL. A fix was attempted in 164e526a5515 and 14ce6985e1c3, but reverted: virtualenv does not make PYTHON3.DLL available, and so the "correctly" compiled version would not run inside a virtualenv. We will re-apply the fix after virtualenv has been fixed for some time. For explanation, see issue #355. For a workaround if you want PYTHON3.DLL and don't worry about virtualenv, see issue #350. See also 'py_limited_api' in setuptools_ext.py. */ #if !defined(_CFFI_USE_EMBEDDING) && !defined(Py_LIMITED_API) # include <pyconfig.h> # if !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG) # define Py_LIMITED_API # endif #endif #include <Python.h> #ifdef __cplusplus extern "C" { #endif #include <stddef.h> #include "parse_c_type.h" /* this block of #ifs should be kept exactly identical between c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py and cffi/_cffi_include.h */ #if defined(_MSC_VER) # include <malloc.h> /* for alloca() */ # if _MSC_VER < 1600 /* MSVC < 2010 */ typedef __int8 int8_t; typedef __int16 int16_t; typedef __int32 int32_t; typedef __int64 int64_t; typedef unsigned __int8 uint8_t; typedef unsigned __int16 uint16_t; typedef unsigned __int32 uint32_t; typedef unsigned __int64 uint64_t; typedef __int8 int_least8_t; typedef __int16 int_least16_t; typedef __int32 int_least32_t; typedef __int64 int_least64_t; typedef unsigned __int8 uint_least8_t; typedef unsigned __int16 uint_least16_t; typedef unsigned __int32 uint_least32_t; typedef unsigned __int64 uint_least64_t; typedef __int8 int_fast8_t; typedef __int16 int_fast16_t; typedef __int32 int_fast32_t; typedef __int64 int_fast64_t; typedef unsigned __int8 uint_fast8_t; typedef unsigned __int16 uint_fast16_t; typedef unsigned __int32 uint_fast32_t; typedef unsigned __int64 uint_fast64_t; typedef __int64 intmax_t; typedef unsigned __int64 uintmax_t; # else # include <stdint.h> # endif # if _MSC_VER < 1800 /* MSVC < 2013 */ # ifndef __cplusplus typedef unsigned char _Bool; # endif # endif #else # include <stdint.h> # if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) # include <alloca.h> # endif #endif #ifdef __GNUC__ # define _CFFI_UNUSED_FN __attribute__((unused)) #else # define _CFFI_UNUSED_FN /* nothing */ #endif #ifdef __cplusplus # ifndef _Bool typedef bool _Bool; /* semi-hackish: C++ has no _Bool; bool is builtin */ # endif #endif /********** CPython-specific section **********/ #ifndef PYPY_VERSION #if PY_MAJOR_VERSION >= 3 # define PyInt_FromLong PyLong_FromLong #endif #define _cffi_from_c_double PyFloat_FromDouble #define _cffi_from_c_float PyFloat_FromDouble #define _cffi_from_c_long PyInt_FromLong #define _cffi_from_c_ulong PyLong_FromUnsignedLong #define _cffi_from_c_longlong PyLong_FromLongLong #define _cffi_from_c_ulonglong PyLong_FromUnsignedLongLong #define _cffi_from_c__Bool PyBool_FromLong #define _cffi_to_c_double PyFloat_AsDouble #define _cffi_to_c_float PyFloat_AsDouble #define _cffi_from_c_int(x, type) \ (((type)-1) > 0 ? /* unsigned */ \ (sizeof(type) < sizeof(long) ? \ PyInt_FromLong((long)x) : \ sizeof(type) == sizeof(long) ? \ PyLong_FromUnsignedLong((unsigned long)x) : \ PyLong_FromUnsignedLongLong((unsigned long long)x)) : \ (sizeof(type) <= sizeof(long) ? \ PyInt_FromLong((long)x) : \ PyLong_FromLongLong((long long)x))) #define _cffi_to_c_int(o, type) \ ((type)( \ sizeof(type) == 1 ? (((type)-1) > 0 ? (type)_cffi_to_c_u8(o) \ : (type)_cffi_to_c_i8(o)) : \ sizeof(type) == 2 ? (((type)-1) > 0 ? (type)_cffi_to_c_u16(o) \ : (type)_cffi_to_c_i16(o)) : \ sizeof(type) == 4 ? (((type)-1) > 0 ? (type)_cffi_to_c_u32(o) \ : (type)_cffi_to_c_i32(o)) : \ sizeof(type) == 8 ? (((type)-1) > 0 ? (type)_cffi_to_c_u64(o) \ : (type)_cffi_to_c_i64(o)) : \ (Py_FatalError("unsupported size for type " #type), (type)0))) #define _cffi_to_c_i8 \ ((int(*)(PyObject *))_cffi_exports[1]) #define _cffi_to_c_u8 \ ((int(*)(PyObject *))_cffi_exports[2]) #define _cffi_to_c_i16 \ ((int(*)(PyObject *))_cffi_exports[3]) #define _cffi_to_c_u16 \ ((int(*)(PyObject *))_cffi_exports[4]) #define _cffi_to_c_i32 \ ((int(*)(PyObject *))_cffi_exports[5]) #define _cffi_to_c_u32 \ ((unsigned int(*)(PyObject *))_cffi_exports[6]) #define _cffi_to_c_i64 \ ((long long(*)(PyObject *))_cffi_exports[7]) #define _cffi_to_c_u64 \ ((unsigned long long(*)(PyObject *))_cffi_exports[8]) #define _cffi_to_c_char \ ((int(*)(PyObject *))_cffi_exports[9]) #define _cffi_from_c_pointer \ ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[10]) #define _cffi_to_c_pointer \ ((char *(*)(PyObject *, struct _cffi_ctypedescr *))_cffi_exports[11]) #define _cffi_get_struct_layout \ not used any more #define _cffi_restore_errno \ ((void(*)(void))_cffi_exports[13]) #define _cffi_save_errno \ ((void(*)(void))_cffi_exports[14]) #define _cffi_from_c_char \ ((PyObject *(*)(char))_cffi_exports[15]) #define _cffi_from_c_deref \ ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[16]) #define _cffi_to_c \ ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[17]) #define _cffi_from_c_struct \ ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[18]) #define _cffi_to_c_wchar_t \ ((_cffi_wchar_t(*)(PyObject *))_cffi_exports[19]) #define _cffi_from_c_wchar_t \ ((PyObject *(*)(_cffi_wchar_t))_cffi_exports[20]) #define _cffi_to_c_long_double \ ((long double(*)(PyObject *))_cffi_exports[21]) #define _cffi_to_c__Bool \ ((_Bool(*)(PyObject *))_cffi_exports[22]) #define _cffi_prepare_pointer_call_argument \ ((Py_ssize_t(*)(struct _cffi_ctypedescr *, \ PyObject *, char **))_cffi_exports[23]) #define _cffi_convert_array_from_object \ ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[24]) #define _CFFI_CPIDX 25 #define _cffi_call_python \ ((void(*)(struct _cffi_externpy_s *, char *))_cffi_exports[_CFFI_CPIDX]) #define _cffi_to_c_wchar3216_t \ ((int(*)(PyObject *))_cffi_exports[26]) #define _cffi_from_c_wchar3216_t \ ((PyObject *(*)(int))_cffi_exports[27]) #define _CFFI_NUM_EXPORTS 28 struct _cffi_ctypedescr; static void *_cffi_exports[_CFFI_NUM_EXPORTS]; #define _cffi_type(index) ( \ assert((((uintptr_t)_cffi_types[index]) & 1) == 0), \ (struct _cffi_ctypedescr *)_cffi_types[index]) static PyObject *_cffi_init(const char *module_name, Py_ssize_t version, const struct _cffi_type_context_s *ctx) { PyObject *module, *o_arg, *new_module; void *raw[] = { (void *)module_name, (void *)version, (void *)_cffi_exports, (void *)ctx, }; module = PyImport_ImportModule("_cffi_backend"); if (module == NULL) goto failure; o_arg = PyLong_FromVoidPtr((void *)raw); if (o_arg == NULL) goto failure; new_module = PyObject_CallMethod( module, (char *)"_init_cffi_1_0_external_module", (char *)"O", o_arg); Py_DECREF(o_arg); Py_DECREF(module); return new_module; failure: Py_XDECREF(module); return NULL; } #ifdef HAVE_WCHAR_H typedef wchar_t _cffi_wchar_t; #else typedef uint16_t _cffi_wchar_t; /* same random pick as _cffi_backend.c */ #endif _CFFI_UNUSED_FN static uint16_t _cffi_to_c_char16_t(PyObject *o) { if (sizeof(_cffi_wchar_t) == 2) return (uint16_t)_cffi_to_c_wchar_t(o); else return (uint16_t)_cffi_to_c_wchar3216_t(o); } _CFFI_UNUSED_FN static PyObject *_cffi_from_c_char16_t(uint16_t x) { if (sizeof(_cffi_wchar_t) == 2) return _cffi_from_c_wchar_t((_cffi_wchar_t)x); else return _cffi_from_c_wchar3216_t((int)x); } _CFFI_UNUSED_FN static int _cffi_to_c_char32_t(PyObject *o) { if (sizeof(_cffi_wchar_t) == 4) return (int)_cffi_to_c_wchar_t(o); else return (int)_cffi_to_c_wchar3216_t(o); } _CFFI_UNUSED_FN static PyObject *_cffi_from_c_char32_t(int x) { if (sizeof(_cffi_wchar_t) == 4) return _cffi_from_c_wchar_t((_cffi_wchar_t)x); else return _cffi_from_c_wchar3216_t(x); } /********** end CPython-specific section **********/ #else _CFFI_UNUSED_FN static void (*_cffi_call_python_org)(struct _cffi_externpy_s *, char *); # define _cffi_call_python _cffi_call_python_org #endif #define _cffi_array_len(array) (sizeof(array) / sizeof((array)[0])) #define _cffi_prim_int(size, sign) \ ((size) == 1 ? ((sign) ? _CFFI_PRIM_INT8 : _CFFI_PRIM_UINT8) : \ (size) == 2 ? ((sign) ? _CFFI_PRIM_INT16 : _CFFI_PRIM_UINT16) : \ (size) == 4 ? ((sign) ? _CFFI_PRIM_INT32 : _CFFI_PRIM_UINT32) : \ (size) == 8 ? ((sign) ? _CFFI_PRIM_INT64 : _CFFI_PRIM_UINT64) : \ _CFFI__UNKNOWN_PRIM) #define _cffi_prim_float(size) \ ((size) == sizeof(float) ? _CFFI_PRIM_FLOAT : \ (size) == sizeof(double) ? _CFFI_PRIM_DOUBLE : \ (size) == sizeof(long double) ? _CFFI__UNKNOWN_LONG_DOUBLE : \ _CFFI__UNKNOWN_FLOAT_PRIM) #define _cffi_check_int(got, got_nonpos, expected) \ ((got_nonpos) == (expected <= 0) && \ (got) == (unsigned long long)expected) #ifdef MS_WIN32 # define _cffi_stdcall __stdcall #else # define _cffi_stdcall /* nothing */ #endif #ifdef __cplusplus } #endif PK %�\JЁ�1R 1R & __pycache__/vengine_gen.cpython-36.pycnu �[��� 3 M��Z4h � @ sH d dl Z d dlZd dlZddlmZ ddlmZ G dd� de�ZdZ dS )� N� )�model)�VerificationErrorc @ s� e Zd ZdZdZdd� Zdd� Zdd� Zd d � ZdZd d �Z dd� Z d[dd�Z dd� Z dd� Z dd� Zdd� Zdd � ZeZeZeZd d � ZeZd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Z d-d.� Z d/d0� Z d1d2� Z d3d4� Z d5d6� Z!d7d8� Z"d9d:� Z#d\d=d>�Z$d?d@� Z%eZ&d]dAdB�Z'dCdD� Z(dEdF� Z)dGdH� Z*dIdJ� Z+d^dLdM�Z,d_dNdO�Z-dPdQ� Z.dRdS� Z/eZ0dTdU� Z1dVdW� Z2eZ3dXdY� Z4d;S )`�VGenericEngine�gFc C s || _ |j| _g | _i | _d S )N)�verifier�ffi�export_symbols� _struct_pending_verification)�selfr � r �#/usr/lib64/python3.6/vengine_gen.py�__init__ s zVGenericEngine.__init__c C s |j d| j� d S )Nr )� setdefaultr )r �kwdsr r r �patch_extension_kwds s z#VGenericEngine.patch_extension_kwdsc C sT xN|D ]F}|| }|d kr t j}x*|D ]"}tjj||�}tjj|�r&|S q&W qW d S )N)�sys�path�os�join�isfile)r Z module_namer Z so_suffixesZ so_suffix�basename�dirname�filenamer r r � find_module s zVGenericEngine.find_modulec C s d S )Nr )r r r r � collect_types% s z VGenericEngine.collect_types� c C s | j j|d � d S )N� )Z_f�write)r Zwhatr r r �_prnt( s zVGenericEngine._prntc C s` | j }|t� || jj� | jd� tjdkr\tjdkr>d}nd}| jj� }|d||f � d S )NZdeclZwin32� ZPyInit_Zinitzvoid %s%s(void) { } )r ) r �cffimod_headerr Zpreamble� _generater �platform� version_infoZget_module_name)r �prnt�prefix�modnamer r r �write_source_to_f+ s z VGenericEngine.write_source_to_fr c sj �j j}tjjtj�jj�}|j||���j �d� G � ��fdd�dt j �� � d�}�j �d|d� |S )NZloadingc s& e Zd Z�Z�jZg Z� fdd�ZdS )z/VGenericEngine.load_library.<locals>.FFILibraryc s � j S )N)� _cffi_dir)r )� FFILibraryr r �__dir__T s z7VGenericEngine.load_library.<locals>.FFILibrary.__dir__N)�__name__� __module__� __qualname__Z_cffi_generic_moduler Z _cffi_ffir) r+ r )r* �moduler r r r* P s r* r Zloaded)�library) r �_backendr r r �curdirr Zmodulefilename� load_library�_load�types� ModuleType)r �flags�backendr r0 r )r* r/ r r r3 A s zVGenericEngine.load_libraryc C s$ dd� | j jjj� D �}|j� |S )Nc S s g | ]\}\}}||f�qS r r )�.0�key�tpZqualr r r � <listcomp>^ s z4VGenericEngine._get_declarations.<locals>.<listcomp>)r Z_parserZ _declarations�items�sort)r Zlstr r r �_get_declarations] s z VGenericEngine._get_declarationsc C s� x�| j � D ]�\}}|jdd�\}}yt| d||f �}W n tk rX td| ��Y nX y|||� W q tk r� } ztj||� � W Y d d }~X q X q W d S )N� r z_generate_gen_%s_%sz not implemented in verify(): %r)r? �split�getattr�AttributeErrorr � Exceptionr �attach_exception_info)r � step_name�namer; �kind�realname�method�er r r r" c s zVGenericEngine._generatec K s� x|| j � D ]p\}}|jdd�\}}t| d||f �}y||||f|� W q tk rx } ztj| |� � W Y d d } ~ X q X q W d S )Nr@ r z _%s_gen_%s)r? rA rB rD r rE ) r r/ rF r rG r; rH rI rJ rK r r r r4 r s zVGenericEngine._loadc C s d S )Nr )r r; rG r r r �_generate_nothing| s z VGenericEngine._generate_nothingc K s d S )Nr )r r; rG r/ r r r r � _loaded_noop s zVGenericEngine._loaded_noopc s� t |tj�st�|jr(| jd||� d S | j}t|j�}g }x<t |j�D ].\}}d}t |tj �rdd}|j d||f � qHW d| � � fdd�t |j|�D �} |j } t | tj �r�| jd| jd � �� tj} d j| �p�d } d | } | jj | � |jr�|jd } nd} d| | | f } d| � || j| � �� |d� t |j tj ��rDd}nt |j tj��sZd}nd}|d||d j|�f � |d� |� d S )NFr �*z%sx%dzargument of %sc s g | ]\}}|j d | � ��qS )z %s)� get_c_name)r9 �type�arg)�contextr r r< � s z>VGenericEngine._generate_gen_function_decl.<locals>.<listcomp>r z *rz, �voidz _cffi_f_%sr@ z %s%s(%s)z result of %s�{z*r = zreturn z %s%s(%s);�})� isinstancer �FunctionPtrType�AssertionError�ellipsis�_generate_gen_constr �len�args� enumerate� StructOrUnion�append�zip�result�insertrO � void_typer r �abiZVoidType)r r; rG r% ZnumargsZargnames�irP Z indirectionZarglistZtpresult� wrappernamerd ZfuncdeclZ result_coder )rR r �_generate_gen_function_decl� sJ z*VGenericEngine._generate_gen_function_declc C sr t |tj�st�|jr*| jd|||�}�n(g }|}tdd� |jD ��sVt |jtj ��rg }xDt |j�D ]6\} } t | tj �r�tj | �} |j | | f� |j | � qfW |j} t | tj �r�| j d kr�td| j� f ��tj | �} |jd| � |jdd| f� tj} tjt|�| |j�}| jj|�} d| } |j| | �}x"|D ]\} } | j|| | |�}�q4W t|||� t|�jj |� d S )NFc s s | ]}t |tj�V qd S )N)rV r r^ )r9 �typr r r � <genexpr>� s z6VGenericEngine._loaded_gen_function.<locals>.<genexpr>z*'%s' is used as result type, but is opaquer ra z _cffi_f_%s)rV r rW rX rY �_load_constant�anyr\ ra r^ r] � PointerTyper_ Zfldtypes� TypeError� _get_c_namerb rc �tupler �_get_cached_btype� load_function�_make_struct_wrapper�setattrrP r) )r r; rG r/ r0 Z newfunctionZ indirections�base_tpZ indirect_argsre rh Zindirect_result�BFuncrf r r r �_loaded_gen_function� s@ z#VGenericEngine._loaded_gen_functionc sP | j j�| j j|�� �dkr4| j �� ��fdd�}n� ���fdd�}||_|S )Nra c s �j � �}�|f| �� |d S )Nr )�new)r\ �res)�BTyper �oldfuncr r �newfunc� s z4VGenericEngine._make_struct_wrapper.<locals>.newfuncc s6 | d �� �j � | � �f | �d d � } �| � S )Nr )Znewp)r\ )ry r8 re rz r r r{ � s .)r r1 rp Z_cffi_base_type)r rz re r; rt r{ r )ry r8 r re rz r rr � s z#VGenericEngine._make_struct_wrapperc C s ||j kst�| j|d|� d S )N�struct)rG rX � _generate_struct_or_union_decl)r r; rG r r r �_generate_gen_struct_decl� s z(VGenericEngine._generate_gen_struct_declc C s | j |d||� d S )Nr| )�_loading_struct_or_union)r r; rG r/ r r r �_loading_gen_struct� s z"VGenericEngine._loading_gen_structc K s | j |� d S )N)�_loaded_struct_or_union)r r; rG r/ r r r r �_loaded_gen_struct� s z!VGenericEngine._loaded_gen_structc C s ||j kst�| j|d|� d S )N�union)rG rX r} )r r; rG r r r �_generate_gen_union_decl� s z'VGenericEngine._generate_gen_union_declc C s | j |d||� d S )Nr� )r )r r; rG r/ r r r �_loading_gen_union s z!VGenericEngine._loading_gen_unionc K s | j |� d S )N)r� )r r; rG r/ r r r r �_loaded_gen_union s z VGenericEngine._loaded_gen_unionc C s |j d krd S d||f }d||f }d||f j� }| j}|d||f � |d� |d� |d� x�|j� D ]�\}} } } t| tj�r�| j� s�| dkr�|d | � qny$|d | jd d | | d �|f � W qn t k r� } z|dt | � � W Y d d } ~ X qnX qnW |d� | j j |� |d|f � |d� |d| � |d� |d| � |d� xt|j� D ]h\}} } } | dk�rv�q\|d||f � t| tj ��r�| jd k�r�|d| j� � n|d||f � �q\W |d� |d� |d� |d� |d |f � |d� |� d S ) Nz_cffi_check_%s_%sz_cffi_layout_%s_%sz%s %szstatic void %s(%s *p)rT z8 /* only to generate compile-time warnings or errors */z (void)p;r z (void)((p->%s) << 1);z { %s = &p->%s; (void)tmp; }z*tmpzfield %r)Zqualsz /* %s */rU zintptr_t %s(intptr_t i)z, struct _cffi_aligncheck { char x; %s y; };z static intptr_t nums[] = {z sizeof(%s),z) offsetof(struct _cffi_aligncheck, y),z offsetof(%s, %s),z 0, /* %s */z sizeof(((%s *)0)->%s),z -1z };z return nums[i];z3 /* the next line is not executed, but compiled */z %s(0);)�fldnames�stripr � enumfieldsrV r � PrimitiveType�is_integer_typerO r �strr r_ � ArrayType�lengthrn ) r r; r& rG Z checkfuncname�layoutfuncname�cnamer% �fname�ftype�fbitsize�fqualrK r r r r} sT & z-VGenericEngine._generate_struct_or_union_declc C s |j d krd S d||f }| jjd�d }|j||�}g }d} x(|| �} | dk rRP |j| � | d7 } q@W t|tj�r�|jr�|d } |d } |dd d� } |dd d� }|j � t | �t |� ko�t |j �kn s�t �| || | f|_ n d||f j � }||f| j|< d S )Nz_cffi_layout_%s_%szintptr_t(*)(intptr_t)r r � r z%s %s)r� r �_typeof_lockedrq r_ rV r r^ �partialZ force_flattenr[ rX Z fixedlayoutr� r )r r; r& rG r/ r� ru �function�layoutZnum�xZ totalsizeZtotalalignmentZfieldofsZ fieldsizer� r r r r 7 s. *z'VGenericEngine._loading_struct_or_unionc C s |j d krd S | jj|� || jk�rdd� }| j}|j|�}| jj|�\}}||d |j|�d� ||d |j|�d� d}x�|j� D ]v\}} } } | dkr�q�||| |j||�d|f � ||d dkr�|j| �} |||d |j| �d |f � |d7 }q�W |t |�k�st �d S ) Nc S s | |krt d||| f ��d S )Nz'%s (we have %d, but C compiler says %d))r )Z realvalueZ expectedvalue�msgr r r �checkZ s z5VGenericEngine._loaded_struct_or_union.<locals>.checkr zwrong total sizer zwrong total alignmentr� zwrong offset for field %rzwrong size for field %r) r� r rp r �pop�sizeofZalignofr� Zoffsetofr[ rX ) r r; r� r ZBStructr� r� re r� r� r� r� ZBFieldr r r r� S s, z&VGenericEngine._loaded_struct_or_unionc C s. t |tj�r | j||d� n| j|d|� d S )Nr )rV r �EnumType�_generate_gen_enum_declr} )r r; rG r r r � _generate_gen_anonymous_declu s z+VGenericEngine._generate_gen_anonymous_declc C s2 t |tj�r | j|||d� n| j|d||� d S )Nr )rV r r� �_loading_gen_enumr )r r; rG r/ r r r �_loading_gen_anonymous{ s z%VGenericEngine._loading_gen_anonymousc K s. t |tj�r | j|||f|� n | j|� d S )N)rV r r� �_loaded_gen_enumr� )r r; rG r/ r r r r �_loaded_gen_anonymous� s z$VGenericEngine._loaded_gen_anonymousN�constc C sD | j }d||f }| jj|� |d k rl|s.t�|dks:t�|d| � |d� | j||� |d� |d� n�|r�|dks|t�|d| � |d� |d|f � |d |f � |d� n�|d k s�t�|d ks�t�|d kr�d }nd }d } |dko�t|tj��rd } d }||jd| |f |�� |d� |d||f � |d� |� d S )Nz _cffi_%s_%sr� zint %s(char *out_error)rT z return 0;rU z int %s(long long *out_value)z *out_value = (long long)(%s);z return (%s) <= 0;�var�&r zconst *z %s%s(void)z return (%s%s);) r r r_ rX �_check_int_constant_valuerV r r^ rO ) r �is_intrG r; �category� check_valuer% �funcnameZ ampersandZextrar r r rZ � s@ z"VGenericEngine._generate_gen_constc C s& t |tj�o|j� }| j|||� d S )N)rV r r� r� rZ )r r; rG r� r r r �_generate_gen_constant_decl� s z*VGenericEngine._generate_gen_constant_declc C s d| }|d k r*|st �| j||� |}n�|r�| jjd�d }| jjd�d } |j| |�} | jj|�} | | �} t| d �}|dk r�| r�| jjd�d } |dd| jj| � > 7 }nd|d ks�t �d}t|t j �r�d | }| jj|j ||��d } |j| |�} | � }t|t j ��r|d }|S ) Nz_cffi_const_%sz long long*r zint(*)(long long*)z long longr � z (*)(void)rN ) rX �_load_known_int_constantr r� rq rw �intr� rV r r^ rO )r r� r; rG r/ r� r� �valuery ru r� �p�negativeZ BLongLongZ fntypeextrar r r rj � s2 z VGenericEngine._load_constantc C sD t |tj�o|j� }| j||||�}t|||� t|�jj|� d S )N) rV r r� r� rj rs rP r) r_ )r r; rG r/ r0 r� r� r r r �_loaded_gen_constant� s z#VGenericEngine._loaded_gen_constantc C s� | j }|dkr"|d|||f � n|d|||f � |d� |d| � |d| � |d� |d| � |d � |d |d d � |f � |d � |d � d S )Nr z& if ((%s) > 0 || (long)(%s) != %dL) {z1 if ((%s) <= 0 || (unsigned long)(%s) != %dUL) {z char buf[64];z if ((%s) <= 0)z) sprintf(buf, "%%ld", (long)(%s));z elsez2 sprintf(buf, "%%lu", (unsigned long)(%s));z: sprintf(out_error, "%s has the real value %s, not %s",z "%s", buf, "%d");�d z return -1;z })r )r rG r� r% r r r r� � s z(VGenericEngine._check_int_constant_valuec C sr | j jd�d }| j jd�d }|j||�}| j j|d�}||�dk rn| j j|�}tjdkrft|d�}t|��d S )Nzchar[]r z int(*)(char*)� r zutf-8)r ) r r� rq rw �stringr r$ r� r )r r/ r� ry ru r� r� �errorr r r r� � s z'VGenericEngine._load_known_int_constantc C s |j dd�}d||f S )N�$Z___D_z _cffi_e_%s_%s)�replace)r r& rG r r r �_enum_funcname� s z VGenericEngine._enum_funcname�enumc C s� |j r&x|jD ]}| jd|� qW d S | j||�}| jj|� | j}|d| � |d� x&t|j|j�D ]\}}| j ||� qhW |d� |d� |� d S )NTzint %s(char *out_error)rT z return 0;rU ) r� � enumeratorsrZ r� r r_ r r` � enumvaluesr� )r r; rG r& � enumeratorr� r% � enumvaluer r r r� � s z&VGenericEngine._generate_gen_enum_declc sL �j r0� ��fdd��jD �}t|��_d�_n�j||�}�j� |� d S )Nc s g | ]}�j d �|� ��qS )T)rj )r9 r� )r/ r r; r r r< s z4VGenericEngine._loading_gen_enum.<locals>.<listcomp>T)r� r� ro r� Zpartial_resolvedr� r� )r r; rG r/ r& r� r� r )r/ r r; r r� s z VGenericEngine._loading_gen_enumc C s< x6t |j|j�D ]$\}}t|||� t|�jj|� qW d S )N)r` r� r� rs rP r) r_ )r r; rG r/ r0 r� r� r r r r� s z VGenericEngine._loaded_gen_enumc C s& |dkrd }n|}| j d||d� d S )Nz...T)r� )rZ )r r; rG r� r r r �_generate_gen_macro_decl s z'VGenericEngine._generate_gen_macro_declc C sF |dkrd }n|}| j d||||d�}t|||� t|�jj|� d S )Nz...T)r� )rj rs rP r) r_ )r r; rG r/ r0 r� r� r r r �_loaded_gen_macro) s z VGenericEngine._loaded_gen_macroc C s� t |tj�rx|jdkr\| j}d|f }| jj|� |d| � |d� |d|f � |d� tj|j�}| j d||� n tj|�}| j d||dd � d S ) Nz...z_cffi_sizeof_%szsize_t %s(void)rT z return sizeof(%s);rU Fr� )r� ) rV r r� r� r r r_ rl �itemrZ )r r; rG r% r� �tp_ptrr r r �_generate_gen_variable_decl6 s z*VGenericEngine._generate_gen_variable_declc s^ t |tj�r�|jdkr�d|f }| jjd�d }|j||�}|� }| jj|j�} t || jj | ��\} } | dkr�t d||jf ��|j | �}tj |j�} | jd| ||�} |jd k r�| jj|�}| jj|| �} t||| � t|�jj|� d S d| }| jj|jd|��d }|j||�}|� � � fd d �}� fd d �}tt|�|t||�� t|�jj|� d S ) Nz...z_cffi_sizeof_%szsize_t(*)(void)r z/bad size: %r does not seem to be an array of %sFz _cffi_var_%sz *(*)(void)c s � d S )Nr r )r0 )�ptrr r �getterg s z3VGenericEngine._loaded_gen_variable.<locals>.getterc s |� d< d S )Nr r )r0 r� )r� r r �setteri s z3VGenericEngine._loaded_gen_variable.<locals>.setter)rV r r� r� r r� rq rp r� �divmodr� r Zresolve_lengthrl rj �castrs rP r) r_ rO �property)r r; rG r/ r0 r� ru r� �sizeZ BItemTyper� �restr� r� ZBArrayr� r� r )r� r �_loaded_gen_variableH s: z#VGenericEngine._loaded_gen_variable)r )r )Nr� N)N)r� )r� )5r, r- r. Z _class_keyZ_gen_python_moduler r r r r r( r3 r? r" r4 rL rM Z_generate_gen_typedef_declZ_loading_gen_typedefZ_loaded_gen_typedefrg Z_loading_gen_functionrv rr r~ r� r� r� r� r� r} r r� r� r� r� rZ r� Z_loading_gen_constantrj r� r� r� r� r� r� r� r� Z_loading_gen_macror� r� Z_loading_gen_variabler� r r r r r sf -$1 " $ r ad #include <stdio.h> #include <stddef.h> #include <stdarg.h> #include <errno.h> #include <sys/types.h> /* XXX for ssize_t on some platforms */ /* this block of #ifs should be kept exactly identical between c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py and cffi/_cffi_include.h */ #if defined(_MSC_VER) # include <malloc.h> /* for alloca() */ # if _MSC_VER < 1600 /* MSVC < 2010 */ typedef __int8 int8_t; typedef __int16 int16_t; typedef __int32 int32_t; typedef __int64 int64_t; typedef unsigned __int8 uint8_t; typedef unsigned __int16 uint16_t; typedef unsigned __int32 uint32_t; typedef unsigned __int64 uint64_t; typedef __int8 int_least8_t; typedef __int16 int_least16_t; typedef __int32 int_least32_t; typedef __int64 int_least64_t; typedef unsigned __int8 uint_least8_t; typedef unsigned __int16 uint_least16_t; typedef unsigned __int32 uint_least32_t; typedef unsigned __int64 uint_least64_t; typedef __int8 int_fast8_t; typedef __int16 int_fast16_t; typedef __int32 int_fast32_t; typedef __int64 int_fast64_t; typedef unsigned __int8 uint_fast8_t; typedef unsigned __int16 uint_fast16_t; typedef unsigned __int32 uint_fast32_t; typedef unsigned __int64 uint_fast64_t; typedef __int64 intmax_t; typedef unsigned __int64 uintmax_t; # else # include <stdint.h> # endif # if _MSC_VER < 1800 /* MSVC < 2013 */ # ifndef __cplusplus typedef unsigned char _Bool; # endif # endif #else # include <stdint.h> # if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) # include <alloca.h> # endif #endif ) r r r5 r r r� r �objectr r! r r r r �<module> s PK %�\�v�!� � & __pycache__/error.cpython-36.opt-1.pycnu �[��� 3 M��Z� � @ sD G d d� de �ZG dd� de �ZG dd� de �ZG dd� de �ZdS ) c @ s e Zd ZdS )�FFIErrorN)�__name__� __module__� __qualname__� r r � /usr/lib64/python3.6/error.pyr s r c @ s e Zd Zdd� ZdS )� CDefErrorc C s\ y*| j d }|jj}|jj}d||f }W n tttfk rH d}Y nX d|| j d f S )N� z%s:%d: � z%s%s� )�argsZcoord�file�line�AttributeError� TypeError� IndexError)�selfZ current_decl�filenameZlinenum�prefixr r r �__str__ s zCDefError.__str__N)r r r r r r r r r s r c @ s e Zd ZdZdS )�VerificationErrorz- An error raised when verification fails N)r r r �__doc__r r r r r s r c @ s e Zd ZdZdS )�VerificationMissingzl An error raised when incomplete structures are passed into cdef, but no verification has been done N)r r r r r r r r r s r N)� Exceptionr r r r r r r r �<module> s PK %�\���@� @� & __pycache__/vengine_cpy.cpython-36.pycnu �[��� 3 M��Z�� � @ s@ d dl Z d dlZddlmZ ddlmZ G dd� de�ZdZdS )� N� )�model)�VerificationErrorc @ s e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zdnd d �Z dd� Z dd� Z dd� Z dodd�Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� ZeZeZeZeZeZd)d*� Z d+d,� Z d-d.� Z eZ d/d0� Z eZ!d1d2� Z"d3d4� Z#d5d6� Z$d7d8� Z%eZ&d9d:� Z'd;d<� Z(d=d>� Z)d?d@� Z*dAdB� Z+dCdD� Z,dEdF� Z-dGdH� Z.eZ/dIdJ� Z0dKdL� Z1dMdN� Z2dOdP� Z3dpdSdT�Z4dUdV� Z5dWdX� Z6eZ7eZ8eZ9dqdYdZ�Z:d[d\� Z;drd^d_�Z<eZ=eZ>d`da� Z?dbdc� Z@ddde� ZAeZBeZCeZDeZEdfdg� ZFdhdi� ZGeZHeZIdjdk� ZJdldm� ZKdS )s�VCPythonEngine�xTc C s || _ |j| _i | _i | _d S )N)�verifier�ffi� _struct_pending_verification�_types_of_builtin_functions)�selfr � r �#/usr/lib64/python3.6/vengine_cpy.py�__init__ s zVCPythonEngine.__init__c C s d S )Nr )r �kwdsr r r �patch_extension_kwds s z#VCPythonEngine.patch_extension_kwdsc C sP yt j||�\}}}W n tk r* d S X |d k r<|j� |d |krLd S |S )Nr )�imp� find_module� ImportError�close)r Z module_name�pathZ so_suffixes�f�filenameZdescrr r r r s zVCPythonEngine.find_modulec C s i | _ | jd� d S )NZ collecttype)� _typesdict� _generate)r r r r � collect_types$ s z VCPythonEngine.collect_types� c C s | j j|d � d S )N� )Z_f�write)r Zwhatr r r �_prnt( s zVCPythonEngine._prntc C s | j | S )N)r )r �typer r r � _gettypenum+ s zVCPythonEngine._gettypenumc C s: t |tj� s|jdkr6|| jkr6t| j�}|| j|< d S )Nz long double)� isinstancer � PrimitiveType�namer �len)r �tpZnumr r r �_do_collect_type/ s z VCPythonEngine._do_collect_typec C s� | j � ddg| _| j}|t� |� || jj� |� | jd� | j� |� |d� | jd� |d� |d� |d� |� | jj� }| jd }|d � |� |d � |d � |d | � |d � |d� |d� |d� |d� |� |d� |d| � |d� |d� |d� |d� |d� |d|f � |d� |d� |d� |d� |d � |� |d � |� |d� |d | � |d� |d� |d | � |d� |d � |d!|f � |d � |d"� |d � |� |d#� d S )$Nz ((void)lib,0)�declz&static PyMethodDef _cffi_methods[] = {�methodz3 {"_cffi_setup", _cffi_setup, METH_VARARGS, NULL},z) {NULL, NULL, 0, NULL} /* Sentinel */z};Fz#if PY_MAJOR_VERSION >= 3z.static struct PyModuleDef _cffi_module_def = {z PyModuleDef_HEAD_INIT,z "%s",z NULL,z -1,z _cffi_methods,z NULL, NULL, NULL, NULLZPyMODINIT_FUNCzPyInit_%s(void)�{z PyObject *lib;z+ lib = PyModule_Create(&_cffi_module_def);z if (lib == NULL)z return NULL;z# if (%s < 0 || _cffi_init() < 0) {z Py_DECREF(lib);z }z return lib;�}z#elsez init%s(void)z+ lib = Py_InitModule("%s", _cffi_methods);z return;z! if (%s < 0 || _cffi_init() < 0)z return;z#endif) r �_chained_list_constantsr �cffimod_headerr Zpreambler �_generate_setup_custom�get_module_name)r �prnt�modnameZ constantsr r r �write_source_to_f6 st z VCPythonEngine.write_source_to_fNc sv t j� z�ttd�r tj� }zvy6ttd�r<|d k r<tj|� t j�jj� �jj ��W n: t k r� } z d�jj |f }t |��W Y d d }~X nX W d ttd�r�tj|� X W d t j � X �j �d� tdd� �jj� D ����fdd�tt���D �}tt�jj|��}G � ��fdd �d t�� � � }�j|t |��rRd d l}|jd �jj� � �j �d |d � �j�_�j �_ |S )N�getdlopenflags�setdlopenflagszimporting %r: %sZloadingc S s g | ]\}}||f�qS r r )�.0�key�valuer r r � <listcomp>� s z/VCPythonEngine.load_library.<locals>.<listcomp>c s g | ] }� | �qS r r )r4 �i)� revmappingr r r7 � s c s& e Zd Z�Z�jZg Z� fdd�ZdS )z/VCPythonEngine.load_library.<locals>.FFILibraryc s � j t| j� S )N)� _cffi_dir�list�__dict__)r )� FFILibraryr r �__dir__� s z7VCPythonEngine.load_library.<locals>.FFILibrary.__dir__N)�__name__� __module__� __qualname__Z_cffi_python_moduler Z _cffi_ffir: r> r )r= �moduler r r r= � s r= r z0reimporting %r might overwrite older definitionsZloaded)�library) r � acquire_lock�hasattr�sysr2 r3 Z load_dynamicr r. Zmodulefilenamer r � release_lock�_load�dictr �items�ranger$ r; �mapr �_get_cached_btype�objectZ _cffi_setup�warnings�warnZ_cffi_original_ffir Z _cffi_types_of_builtin_funcs)r �flagsZprevious_flags�e�error�lstrC rO r )r= rB r9 r r � load_library� s< zVCPythonEngine.load_libraryc C s$ dd� | j jjj� D �}|j� |S )Nc S s g | ]\}\}}||f�qS r r )r4 r5 r% Zqualr r r r7 � s z4VCPythonEngine._get_declarations.<locals>.<listcomp>)r Z_parserZ _declarationsrJ �sort)r rT r r r �_get_declarations� s z VCPythonEngine._get_declarationsc C s� x�| j � D ]�\}}|jdd�\}}yt| d||f �}W n tk rX td| ��Y nX y|||� W q tk r� } ztj||� � W Y d d }~X q X q W d S )N� r z_generate_cpy_%s_%sz not implemented in verify(): %r)rW �split�getattr�AttributeErrorr � Exceptionr �attach_exception_info)r � step_namer# r% �kind�realnamer( rR r r r r � s zVCPythonEngine._generatec K s� x|| j � D ]p\}}|jdd�\}}t| d||f �}y||||f|� W q tk rx } ztj| |� � W Y d d } ~ X q X q W d S )NrX r z _%s_cpy_%s)rW rY rZ r\ r r] ) r rB r^ r r# r% r_ r` r( rR r r r rH � s zVCPythonEngine._loadc C s d S )Nr )r r% r# r r r �_generate_nothing� s z VCPythonEngine._generate_nothingc K s d S )Nr )r r% r# rB r r r r � _loaded_noop� s zVCPythonEngine._loaded_noopc C s* d}t |tj�rT|j� r2|jdkr2d}d|j }n d|jd�|jjdd�f }d}n�t |tj�rt| j||||� d S t |tj tj f�r�| j d || j |�|f � | j d | � d S t |tj �r�d |jd� }d | j |� }d }nt|��| j d||||f � | j d||jd�|f � | j d | � d S )Nr �_BoolZ_cffi_to_c_intz, %sz(%s)_cffi_to_c_%srX �_z-1z6 if (_cffi_to_c((char *)&%s, _cffi_type(%d), %s) < 0)z %s;z(%s)_cffi_to_c_pointerz, _cffi_type(%d)ZNULLz %s = %s(%s%s);z' if (%s == (%s)%s && PyErr_Occurred()))r! r r" �is_integer_typer# � get_c_name�replace� PointerType�"_convert_funcarg_to_c_ptr_or_array� StructOrUnion�EnumTyper r �FunctionPtrType�NotImplementedError)r r% �fromvar�tovar�errcodeZextraargZ converterZerrvaluer r r �_convert_funcarg_to_c� s4 z$VCPythonEngine._convert_funcarg_to_cc C s t |tj�r|jd� d S )NzPy_ssize_t datasize)r! r rh �add)r r% � localvarsr r r �_extra_local_variables s z%VCPythonEngine._extra_local_variablesc C s� | j d� | j d| j|�||f � | j d� | j d� | j d| � | j d|f � | j d|f � | j d|| j|�|f � | j d| � | j d � d S ) Nz1 datasize = _cffi_prepare_pointer_call_argument(z( _cffi_type(%d), %s, (char **)&%s);z if (datasize != 0) {z if (datasize < 0)z %s;z" %s = alloca((size_t)datasize);z, memset((void *)%s, 0, (size_t)datasize);zL if (_cffi_convert_array_from_object((char *)%s, _cffi_type(%d), %s) < 0)z })r r )r r% rn ro rp r r r ri s z1VCPythonEngine._convert_funcarg_to_c_ptr_or_arrayc C s t |tj�r`|j� r,|jdkr,d||jf S |jdkrLd|jjdd�|f S d|| j|�f S n�t |tjtjf�r�d|| j|�f S t |tj �r�d|| jtj|j ��f S t |tj �r�|j d kr�t d |j� |f ��d || j|�f S t |tj��rd|| j|�f S t|��d S ) Nrc z_cffi_from_c_int(%s, %s)z long doublez_cffi_from_c_%s(%s)rX rd z/_cffi_from_c_deref((char *)&%s, _cffi_type(%d))z0_cffi_from_c_pointer((char *)%s, _cffi_type(%d))z!'%s' is used as %s, but is opaquez0_cffi_from_c_struct((char *)&%s, _cffi_type(%d)))r! r r" re r# rg r rh rl � ArrayType�itemrj �fldnames� TypeError� _get_c_namerk rm )r r% �var�contextr r r �_convert_expr_from_c) s. z#VCPythonEngine._convert_expr_from_cc C sL t |tj�st�|jr"| j|� n&x|jD ]}| j|� q*W | j|j� d S )N)r! r rl �AssertionError�ellipsisr& �args�result)r r% r# r r r r �"_generate_cpy_function_collecttypeP s z1VCPythonEngine._generate_cpy_function_collecttypec C s� t |tj�st�|jr(| jd||� d S | j}t|j�}|dkrFd}n|dkrTd}nd}|d� |d||f � |d � d | }x.t |j�D ] \}}|d |j d | |� � q�W t � } x|jD ]}| j || � q�W x| D ]} |d | f � q�W t |j tj��s"d } d| }|d |j j d|� � nd} t|j�dk�r�tt|j��} x| D ]}|d| � �qJW |� |dd| |djdd� | D ��f � |d� |� x6t |j�D ](\}}| j|d| d| d� |� �q�W |d� |d � |d | |djd d� tt|j��D ��f � |d � |d � |� |d!� |dk�r>|d"� | �r^|d#| j|j d$d%� � n|d&� |d'� |d(� |� d S ))NFr Znoargr Zarg0r zstatic PyObject *z(_cffi_f_%s(PyObject *self, PyObject *%s)r) zargument of %sz %s;z x%dz result = z result of %sz resultr z PyObject *arg%d;z+ if (!PyArg_ParseTuple(args, "%s:%s", %s))�Oz, c S s g | ] }d | �qS )z&arg%dr )r4 r8 r r r r7 � s z>VCPythonEngine._generate_cpy_function_decl.<locals>.<listcomp>z return NULL;zarg%dzx%dz return NULLz Py_BEGIN_ALLOW_THREADSz _cffi_restore_errno();z { %s%s(%s); }c S s g | ] }d | �qS )zx%dr )r4 r8 r r r r7 � s z _cffi_save_errno();z Py_END_ALLOW_THREADSz (void)self; /* unused */z (void)noarg; /* unused */z return %s;r� z result typez Py_INCREF(Py_None);z return Py_None;r* )r! r rl r} r~ �_generate_cpy_constr r$ r � enumeraterf �setrt r� ZVoidTyperK �joinrq r| ) r r% r# r/ �numargsZargnamer{ r8 r rs r' Z result_code�rngr r r �_generate_cpy_function_decl[ st " $ z*VCPythonEngine._generate_cpy_function_declc C sL |j r d S t|j�}|dkr"d}n|dkr0d}nd}| jd|||f � d S )Nr Z METH_NOARGSr ZMETH_OZ METH_VARARGSz {"%s", _cffi_f_%s, %s, NULL},)r~ r$ r r )r r% r# r� �methr r r � _generate_cpy_function_method� s z,VCPythonEngine._generate_cpy_function_methodc C s. |j r d S t||�}t|||� || j|< d S )N)r~ rZ �setattrr )r r% r# rB rC �funcr r r �_loaded_cpy_function� s z#VCPythonEngine._loaded_cpy_functionc C s ||j kst�| j|d|� d S )N�struct)r# r} � _generate_struct_or_union_decl)r r% r# r r r �_generate_cpy_struct_decl� s z(VCPythonEngine._generate_cpy_struct_declc C s | j |d|� d S )Nr� )� _generate_struct_or_union_method)r r% r# r r r �_generate_cpy_struct_method� s z*VCPythonEngine._generate_cpy_struct_methodc C s | j |d||� d S )Nr� )�_loading_struct_or_union)r r% r# rB r r r �_loading_cpy_struct� s z"VCPythonEngine._loading_cpy_structc K s | j |� d S )N)�_loaded_struct_or_union)r r% r# rB r r r r �_loaded_cpy_struct� s z!VCPythonEngine._loaded_cpy_structc C s ||j kst�| j|d|� d S )N�union)r# r} r� )r r% r# r r r �_generate_cpy_union_decl� s z'VCPythonEngine._generate_cpy_union_declc C s | j |d|� d S )Nr� )r� )r r% r# r r r �_generate_cpy_union_method� s z)VCPythonEngine._generate_cpy_union_methodc C s | j |d||� d S )Nr� )r� )r r% r# rB r r r �_loading_cpy_union� s z!VCPythonEngine._loading_cpy_unionc K s | j |� d S )N)r� )r r% r# rB r r r r �_loaded_cpy_union� s z VCPythonEngine._loaded_cpy_unionc C s |j d krd S d||f }d||f }d||f j� }| j}|d||f � |d� |d� |d� x�|j� D ]�\}} } } t| tj�r�| j� s�| dkr�|d | � qny$|d | jd d | | d �|f � W qn t k r� } z|dt | � � W Y d d } ~ X qnX qnW |d� |d� |d|f � |d� |d| � |d� |d| � |d� xt|j� D ]h\}} } } | dk�rr�qX|d||f � t| tj ��r�| j d k�r�|d| j � � n|d||f � �qXW |d� |d� |d� |d � |d � |d � |d |f � |d� |� d S ) Nz_cffi_check_%s_%sz_cffi_layout_%s_%sz%s %szstatic void %s(%s *p)r) z8 /* only to generate compile-time warnings or errors */z (void)p;r z (void)((p->%s) << 1);z { %s = &p->%s; (void)tmp; }z*tmpzfield %r)Zqualsz /* %s */r* zstatic PyObject *z#%s(PyObject *self, PyObject *noarg)z, struct _cffi_aligncheck { char x; %s y; };z static Py_ssize_t nums[] = {z sizeof(%s),z) offsetof(struct _cffi_aligncheck, y),z offsetof(%s, %s),z 0, /* %s */z sizeof(((%s *)0)->%s),z -1z };z (void)self; /* unused */z (void)noarg; /* unused */z' return _cffi_get_struct_layout(nums);z3 /* the next line is not executed, but compiled */z %s(0);)rw �stripr � enumfieldsr! r r" re rf r �strru �lengthry ) r r% �prefixr# Z checkfuncname�layoutfuncname�cnamer/ �fname�ftype�fbitsize�fqualrR r r r r� � sX & z-VCPythonEngine._generate_struct_or_union_declc C s0 |j d krd S d||f }| jd||f � d S )Nz_cffi_layout_%s_%sz {"%s", %s, METH_NOARGS, NULL},)rw r )r r% r� r# r� r r r r� s z/VCPythonEngine._generate_struct_or_union_methodc C s� |j d krd S d||f }t||�}|� }t|tj�r�|jr�|d }|d } |dd d� } |dd d� } |j� t| �t| � ko�t|j �kn s�t�| | || f|_ n d||f j � } || f| j |< d S )Nz_cffi_layout_%s_%sr r � � z%s %s) rw rZ r! r rj �partialZ force_flattenr$ r} Z fixedlayoutr� r ) r r% r� r# rB r� Zfunction�layoutZ totalsizeZtotalalignmentZfieldofsZ fieldsizer� r r r r� s *z'VCPythonEngine._loading_struct_or_unionc C s |j d krd S | jj|� || jk�rdd� }| j}|j|�}| jj|�\}}||d |j|�d� ||d |j|�d� d}x�|j� D ]v\}} } } | dkr�q�||| |j||�d|f � ||d dkr�|j| �} |||d |j| �d |f � |d7 }q�W |t |�k�st �d S ) Nc S s | |krt d||| f ��d S )Nz'%s (we have %d, but C compiler says %d))r )Z realvalueZ expectedvalue�msgr r r �check( s z5VCPythonEngine._loaded_struct_or_union.<locals>.checkr zwrong total sizer zwrong total alignmentr� zwrong offset for field %rzwrong size for field %r) rw r rM r �pop�sizeofZalignofr� Zoffsetofr$ r} ) r r% r� r ZBStructr� r� r8 r� r� r� r� ZBFieldr r r r� ! s, z&VCPythonEngine._loaded_struct_or_unionc C s. t |tj�r | j||d� n| j|d|� d S )Nr )r! r rk �_generate_cpy_enum_declr� )r r% r# r r r � _generate_cpy_anonymous_declE s z+VCPythonEngine._generate_cpy_anonymous_declc C s t |tj�s| j|d|� d S )Nr )r! r rk r� )r r% r# r r r � _generate_cpy_anonymous_methodK s z-VCPythonEngine._generate_cpy_anonymous_methodc C s0 t |tj�r | j|||� n| j|d||� d S )Nr )r! r rk �_loading_cpy_enumr� )r r% r# rB r r r �_loading_cpy_anonymousO s z%VCPythonEngine._loading_cpy_anonymousc K s. t |tj�r | j|||f|� n | j|� d S )N)r! r rk �_loaded_cpy_enumr� )r r% r# rB r r r r �_loaded_cpy_anonymousU s z$VCPythonEngine._loaded_cpy_anonymous�constFc C st | j } d||f } | d| � | d� | d� | d� |sT| d|pD|jd|� � n |dks`t�|d k rt| j||� |s�|d kr�d | } n|} | d | f � | d | j|d d�f � |s�t�n | d| � | d� | d� |�r | d� | d� | d|f � | d� | d� | d� | d� | d| � | d� | d� | d� | d | j| � | d | j|< | d � | � d S ) Nz _cffi_%s_%sz static int %s(PyObject *lib)r) z PyObject *o;z int res;z %s;z ir� rz �&z i = (%s);z o = %s;r8 z variable typez! o = _cffi_from_c_int_const(%s);z if (o == NULL)z return -1;z {z PyObject *o1 = o;z8 o = Py_BuildValue("On", o1, (Py_ssize_t)sizeof(%s));z Py_DECREF(o1);z if (o == NULL)z return -1;z }z- res = PyObject_SetAttrString(lib, "%s", o);z Py_DECREF(o);z if (res < 0)z return %s;z(lib)r* )r rf r} �_check_int_constant_valuer| r+ ) r �is_intr# r% �category�vartp�delayed�size_too� check_valuer/ �funcnameZrealexprr r r r� ^ sN z"VCPythonEngine._generate_cpy_constc C s& t |tj�o|j� }|s"| j|� d S )N)r! r r" re r& )r r% r# r� r r r �"_generate_cpy_constant_collecttype� s z1VCPythonEngine._generate_cpy_constant_collecttypec C s& t |tj�o|j� }| j|||� d S )N)r! r r" re r� )r r% r# r� r r r �_generate_cpy_constant_decl� s z*VCPythonEngine._generate_cpy_constant_declc C s� | j }|dkr"|d|||f � n|d|||f � |d� |d| � |d| � |d� |d| � |d � |d � |d |||f � |d � |d � d S )Nr z& if ((%s) > 0 || (long)(%s) != %dL) {z1 if ((%s) <= 0 || (unsigned long)(%s) != %dUL) {z char buf[64];z if ((%s) <= 0)z. snprintf(buf, 63, "%%ld", (long)(%s));z elsez7 snprintf(buf, 63, "%%lu", (unsigned long)(%s));z) PyErr_Format(_cffi_VerificationError,z6 "%s%s has the real value %s, not %s",z( "%s", "%s", buf, "%d");z return -1;z })r )r r# r6 Z err_prefixr/ r r r r� � s$ z(VCPythonEngine._check_int_constant_valuec C s |j dd�}d||f S )N�$Z___D_z _cffi_e_%s_%s)rg )r r� r# r r r �_enum_funcname� s z VCPythonEngine._enum_funcname�enumc C s� |j r*x |jD ]}| jd|dd� qW d S | j||�}| j}|d| � |d� x,t|j|j�D ]\}}| j||d| � q`W |d| jd � |d | jd< |d � |� d S ) NTF)r� z static int %s(PyObject *lib)r) z enum %s: z return %s;z(lib)r* ) r� � enumeratorsr� r� r �zip� enumvaluesr� r+ )r r% r# r� � enumeratorr� r/ � enumvaluer r r r� � s z&VCPythonEngine._generate_cpy_enum_declc s. |j r*� fdd�|jD �}t|�|_d|_d S )Nc s g | ]}t � |��qS r )rZ )r4 r� )rB r r r7 � s z4VCPythonEngine._loading_cpy_enum.<locals>.<listcomp>T)r� r� �tupler� Zpartial_resolved)r r% r# rB r� r )rB r r� � s z VCPythonEngine._loading_cpy_enumc C s, x&t |j|j�D ]\}}t|||� qW d S )N)r� r� r� r� )r r% r# rB rC r� r� r r r r� � s z VCPythonEngine._loaded_cpy_enumc C s& |dkrd }n|}| j d||d� d S )Nz...T)r� )r� )r r% r# r� r r r �_generate_cpy_macro_decl� s z'VCPythonEngine._generate_cpy_macro_declc C s2 t |tj�rtj|j�}n tj|�}| j|� d S )N)r! r ru rh rv r& )r r% r# �tp_ptrr r r �"_generate_cpy_variable_collecttype� s z1VCPythonEngine._generate_cpy_variable_collecttypec C sT t |tj�r4tj|j�}| jd||||jdkd� n tj|�}| jd||dd� d S )NFz...)r� r� rz )r� )r! r ru rh rv r� r� )r r% r# r� r r r �_generate_cpy_variable_decl� s z*VCPythonEngine._generate_cpy_variable_declc s t ||�}t|tj�r�|jdkr~t|t�s.t�|\}}| jj|j �}t || jj |��\}} | dkrtt d||j f ��|j |�}|jd k r�| jj|�} | jj| |�}t|||� d S |� t||� � fdd�} � fdd�} tt|�|t| | �� t|�jj|� d S )Nz...r z/bad size: %r does not seem to be an array of %sc s � d S )Nr r )rC )�ptrr r �getter s z3VCPythonEngine._loaded_cpy_variable.<locals>.getterc s |� d< d S )Nr r )rC r6 )r� r r �setter s z3VCPythonEngine._loaded_cpy_variable.<locals>.setter)rZ r! r ru r� r� r} r rM rv �divmodr� r Zresolve_length�castr� �delattrr �propertyr: �append) r r% r# rB rC r6 �sizeZ BItemTyper� �restZBArrayr� r� r )r� r �_loaded_cpy_variable� s. z#VCPythonEngine._loaded_cpy_variablec C s4 | j }|d� |d� |d| jd � |d� d S )Nz,static int _cffi_setup_custom(PyObject *lib)r) z return %s;Tr* )r r+ )r r/ r r r r- s z%VCPythonEngine._generate_setup_custom)r )N)Nr� NTFN)r )r� )Lr? r@ rA Z _class_keyZ_gen_python_moduler r r r r r r& r1 rU rW r rH ra rb rq rt ri r| Z!_generate_cpy_typedef_collecttypeZ_generate_cpy_typedef_declZ _generate_cpy_typedef_methodZ_loading_cpy_typedefZ_loaded_cpy_typedefr� r� r� Z_loading_cpy_functionr� Z _generate_cpy_struct_collecttyper� r� r� r� Z _generate_cpy_union_collecttyper� r� r� r� r� r� r� r� Z#_generate_cpy_anonymous_collecttyper� r� r� r� r� r� r� Z _generate_cpy_constant_methodZ_loading_cpy_constantZ_loaded_cpy_constantr� r� r� Z _generate_cpy_enum_collecttypeZ_generate_cpy_enum_methodr� r� r� Z _generate_cpy_macro_collecttypeZ_generate_cpy_macro_methodZ_loading_cpy_macroZ_loaded_cpy_macror� r� Z _generate_cpy_variable_methodZ_loading_cpy_variabler� r- r r r r r s� [ : $ I 3" . "r at# #include <Python.h> #include <stddef.h> /* this block of #ifs should be kept exactly identical between c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py and cffi/_cffi_include.h */ #if defined(_MSC_VER) # include <malloc.h> /* for alloca() */ # if _MSC_VER < 1600 /* MSVC < 2010 */ typedef __int8 int8_t; typedef __int16 int16_t; typedef __int32 int32_t; typedef __int64 int64_t; typedef unsigned __int8 uint8_t; typedef unsigned __int16 uint16_t; typedef unsigned __int32 uint32_t; typedef unsigned __int64 uint64_t; typedef __int8 int_least8_t; typedef __int16 int_least16_t; typedef __int32 int_least32_t; typedef __int64 int_least64_t; typedef unsigned __int8 uint_least8_t; typedef unsigned __int16 uint_least16_t; typedef unsigned __int32 uint_least32_t; typedef unsigned __int64 uint_least64_t; typedef __int8 int_fast8_t; typedef __int16 int_fast16_t; typedef __int32 int_fast32_t; typedef __int64 int_fast64_t; typedef unsigned __int8 uint_fast8_t; typedef unsigned __int16 uint_fast16_t; typedef unsigned __int32 uint_fast32_t; typedef unsigned __int64 uint_fast64_t; typedef __int64 intmax_t; typedef unsigned __int64 uintmax_t; # else # include <stdint.h> # endif # if _MSC_VER < 1800 /* MSVC < 2013 */ # ifndef __cplusplus typedef unsigned char _Bool; # endif # endif #else # include <stdint.h> # if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) # include <alloca.h> # endif #endif #if PY_MAJOR_VERSION < 3 # undef PyCapsule_CheckExact # undef PyCapsule_GetPointer # define PyCapsule_CheckExact(capsule) (PyCObject_Check(capsule)) # define PyCapsule_GetPointer(capsule, name) \ (PyCObject_AsVoidPtr(capsule)) #endif #if PY_MAJOR_VERSION >= 3 # define PyInt_FromLong PyLong_FromLong #endif #define _cffi_from_c_double PyFloat_FromDouble #define _cffi_from_c_float PyFloat_FromDouble #define _cffi_from_c_long PyInt_FromLong #define _cffi_from_c_ulong PyLong_FromUnsignedLong #define _cffi_from_c_longlong PyLong_FromLongLong #define _cffi_from_c_ulonglong PyLong_FromUnsignedLongLong #define _cffi_from_c__Bool PyBool_FromLong #define _cffi_to_c_double PyFloat_AsDouble #define _cffi_to_c_float PyFloat_AsDouble #define _cffi_from_c_int_const(x) \ (((x) > 0) ? \ ((unsigned long long)(x) <= (unsigned long long)LONG_MAX) ? \ PyInt_FromLong((long)(x)) : \ PyLong_FromUnsignedLongLong((unsigned long long)(x)) : \ ((long long)(x) >= (long long)LONG_MIN) ? \ PyInt_FromLong((long)(x)) : \ PyLong_FromLongLong((long long)(x))) #define _cffi_from_c_int(x, type) \ (((type)-1) > 0 ? /* unsigned */ \ (sizeof(type) < sizeof(long) ? \ PyInt_FromLong((long)x) : \ sizeof(type) == sizeof(long) ? \ PyLong_FromUnsignedLong((unsigned long)x) : \ PyLong_FromUnsignedLongLong((unsigned long long)x)) : \ (sizeof(type) <= sizeof(long) ? \ PyInt_FromLong((long)x) : \ PyLong_FromLongLong((long long)x))) #define _cffi_to_c_int(o, type) \ ((type)( \ sizeof(type) == 1 ? (((type)-1) > 0 ? (type)_cffi_to_c_u8(o) \ : (type)_cffi_to_c_i8(o)) : \ sizeof(type) == 2 ? (((type)-1) > 0 ? (type)_cffi_to_c_u16(o) \ : (type)_cffi_to_c_i16(o)) : \ sizeof(type) == 4 ? (((type)-1) > 0 ? (type)_cffi_to_c_u32(o) \ : (type)_cffi_to_c_i32(o)) : \ sizeof(type) == 8 ? (((type)-1) > 0 ? (type)_cffi_to_c_u64(o) \ : (type)_cffi_to_c_i64(o)) : \ (Py_FatalError("unsupported size for type " #type), (type)0))) #define _cffi_to_c_i8 \ ((int(*)(PyObject *))_cffi_exports[1]) #define _cffi_to_c_u8 \ ((int(*)(PyObject *))_cffi_exports[2]) #define _cffi_to_c_i16 \ ((int(*)(PyObject *))_cffi_exports[3]) #define _cffi_to_c_u16 \ ((int(*)(PyObject *))_cffi_exports[4]) #define _cffi_to_c_i32 \ ((int(*)(PyObject *))_cffi_exports[5]) #define _cffi_to_c_u32 \ ((unsigned int(*)(PyObject *))_cffi_exports[6]) #define _cffi_to_c_i64 \ ((long long(*)(PyObject *))_cffi_exports[7]) #define _cffi_to_c_u64 \ ((unsigned long long(*)(PyObject *))_cffi_exports[8]) #define _cffi_to_c_char \ ((int(*)(PyObject *))_cffi_exports[9]) #define _cffi_from_c_pointer \ ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[10]) #define _cffi_to_c_pointer \ ((char *(*)(PyObject *, CTypeDescrObject *))_cffi_exports[11]) #define _cffi_get_struct_layout \ ((PyObject *(*)(Py_ssize_t[]))_cffi_exports[12]) #define _cffi_restore_errno \ ((void(*)(void))_cffi_exports[13]) #define _cffi_save_errno \ ((void(*)(void))_cffi_exports[14]) #define _cffi_from_c_char \ ((PyObject *(*)(char))_cffi_exports[15]) #define _cffi_from_c_deref \ ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[16]) #define _cffi_to_c \ ((int(*)(char *, CTypeDescrObject *, PyObject *))_cffi_exports[17]) #define _cffi_from_c_struct \ ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[18]) #define _cffi_to_c_wchar_t \ ((wchar_t(*)(PyObject *))_cffi_exports[19]) #define _cffi_from_c_wchar_t \ ((PyObject *(*)(wchar_t))_cffi_exports[20]) #define _cffi_to_c_long_double \ ((long double(*)(PyObject *))_cffi_exports[21]) #define _cffi_to_c__Bool \ ((_Bool(*)(PyObject *))_cffi_exports[22]) #define _cffi_prepare_pointer_call_argument \ ((Py_ssize_t(*)(CTypeDescrObject *, PyObject *, char **))_cffi_exports[23]) #define _cffi_convert_array_from_object \ ((int(*)(char *, CTypeDescrObject *, PyObject *))_cffi_exports[24]) #define _CFFI_NUM_EXPORTS 25 typedef struct _ctypedescr CTypeDescrObject; static void *_cffi_exports[_CFFI_NUM_EXPORTS]; static PyObject *_cffi_types, *_cffi_VerificationError; static int _cffi_setup_custom(PyObject *lib); /* forward */ static PyObject *_cffi_setup(PyObject *self, PyObject *args) { PyObject *library; int was_alive = (_cffi_types != NULL); (void)self; /* unused */ if (!PyArg_ParseTuple(args, "OOO", &_cffi_types, &_cffi_VerificationError, &library)) return NULL; Py_INCREF(_cffi_types); Py_INCREF(_cffi_VerificationError); if (_cffi_setup_custom(library) < 0) return NULL; return PyBool_FromLong(was_alive); } static int _cffi_init(void) { PyObject *module, *c_api_object = NULL; module = PyImport_ImportModule("_cffi_backend"); if (module == NULL) goto failure; c_api_object = PyObject_GetAttrString(module, "_C_API"); if (c_api_object == NULL) goto failure; if (!PyCapsule_CheckExact(c_api_object)) { PyErr_SetNone(PyExc_ImportError); goto failure; } memcpy(_cffi_exports, PyCapsule_GetPointer(c_api_object, "cffi"), _CFFI_NUM_EXPORTS * sizeof(void *)); Py_DECREF(module); Py_DECREF(c_api_object); return 0; failure: Py_XDECREF(module); Py_XDECREF(c_api_object); return -1; } #define _cffi_type(num) ((CTypeDescrObject *)PyList_GET_ITEM(_cffi_types, num)) /**********/ ) rF r r r rS r rN r r, r r r r �<module> s uPK %�\�4� *� *� __pycache__/api.cpython-36.pycnu �[��� 3 '+e� � @ s� d dl Z d dlZddlmZ ddlmZ ddlmZ ye W n( e k rd d dl m Z dd� ZY nX ye W n e k r� e Z Y nX G d d � d e�Zd d � Zd d� Zdd� ZdS )� N� )� allocate_lock)� CDefError)�model)�Callablec C s t | t�S )N)� isinstancer )�x� r �/usr/lib64/python3.6/api.py�<lambda> s r c @ s� e Zd ZdZdfdd�Zdgdd�Zdhdd �Zdid d �Zdjd d�Zdd� Z dd� Z dkdd�Z dd� Z dd� Z dd� Zdd � Zdld d �Zdmd d!�Zd"d#� Zdod%d&�Zd'd(� Zdpd)d*�Zd+d,� Zdqd-d.�Zdrd0d1�Zdsd2d3�Zd4d5� Zdtd6d7�Zd8d9� Z d:d;� Z e e e dd<�Z dvd=d>�Z d?d@� Z!dAdB� Z"dCdD� Z#dEdF� Z$dGdH� Z%dIdJ� Z&dKdL� Z'dMdN� Z(dOdP� Z)dwdRdS�Z*dxdUdV�Z+dWdX� Z,dYdZ� Z-dyd\d]�Z.d^d_� Z/d`da� Z0dbdc� Z1ddde� Z2dS )z�FFIa� The main top-level class that you instantiate once, or once per module. Example usage: ffi = FFI() ffi.cdef(""" int printf(const char *, ...); """) C = ffi.dlopen(None) # standard library -or- C = ffi.verify() # use a C compiler: verify the decl above is right C.printf("hello, %s!\n", ffi.new("char[]", "world")) Nc C s� |dkr^ddl }ddlm} |j|kr^t|d�rJtd|t|j|jf ��ntd|t|jf ��ddlm} || _t� | _ |j � | _ i | _ t jd �j| _t jd �j| _g | _g | _g | _g | _d| _i | _d| _d| _tj|�| _ t|d �r�|j | � x2t |j�D ]$}|j d ��r t | |t!||�� �q W | j �" | j"tj#�| _$| j"tj%�| _&W dQ R X t'|t j��r�tt(d ��s�| j)| j$d�t(_*|j+� \t(_,t(_-n | j)| j$d�| _*|j+� \| _,| _-|j.| _.dS )z{Create an FFI instance. The 'backend' argument is used to select a non-default backend, mostly for tests. Nr r )� __version__�__file__z�Version mismatch: this is the 'cffi' package version %s, located in %r. When we import the top-level '_cffi_backend' extension module, we get version %s, located in %r. The two versions should be equal; check your installation.z�Version mismatch: this is the 'cffi' package version %s, located in %r. This interpreter comes with a built-in '_cffi_backend' module, which is version %s. The two versions should be equal; check your installation.)�cparserZ parsed_typesZ new_types�set_ffiZRTLD_�NULL)/Z _cffi_backend� r �hasattr� Exceptionr r �_backendr �_lockZParser�_parser�_cached_btypes�types� ModuleType�__dict__� _parsed_typesZ _new_types�_function_caches� _libraries� _cdefsources�_included_ffis�_windows_unicode�_init_once_cache� _cdef_version� _embeddingr Z get_typecacheZ _typecacher �list� startswith�setattr�getattr�_get_cached_btypeZ voidp_type�BVoidPZchar_array_type�BCharAr r �castr Z _get_types�CDataZCType�buffer)�self�backendr r �namer r r �__init__' sR z FFI.__init__Fc C s | j |||d� dS )a� Parse the given C source. This registers all declared functions, types, and global variables. The functions and global variables can then be accessed via either 'ffi.dlopen()' or 'ffi.verify()'. The types can be used in 'ffi.new()' and other functions. If 'packed' is specified as True, all structs declared inside this cdef are packed, i.e. laid out without any field alignment at all. )�override�packedN)�_cdef)r/ �csourcer3 r4 r r r �cdefc s zFFI.cdefc C s$ | j ||dd� | jd kr d| _d S )NT)r4 Z dllexportr )r5 r$ )r/ r6 r4 r r r � embedding_apim s zFFI.embedding_apic K s� t |t�s&t |t�s td��|jd�}| j�| t� | _| jj |fd|i|�� | j j |� |rvx| j D ] }|j � qfW | jj}|r�g | j_x|D ]}|j| |� q�W W d Q R X d S )Nz cdef() argument must be a string�asciir3 )r �str� basestring� TypeError�encoder �objectr# r �parser �appendr �clearZ _recomplete�finish_backend_type)r/ r6 r3 Zoptions�cache� finishlist�tpr r r r5 r s z FFI._cdefr c C sT t |t�s|dkst�| j�. t| ||�\}}| jj|� | jj|� W dQ R X |S )aH Load and return a dynamic library identified by 'name'. The standard C library can be loaded by passing None. Note that functions and types declared by 'ffi.cdef()' are not linked to a particular library, just like C headers; in the library we only look for the actual (untyped) symbols. N)r r; �AssertionErrorr �_make_ffi_libraryr r@ r )r/ r1 �flags�libZfunction_cacher r r �dlopen� s z FFI.dlopenc C s t |�j|� dS )z�Close a library obtained with ffi.dlopen(). After this call, access to functions or variables from the library will fail (possibly with a segmentation fault). N)�type�__cffi_close__)r/ rI r r r �dlclose� s z FFI.dlclosec C sj |}|| j kr| j | S t|t�s,|jd�}| jj|�}|j}|rJ|j� }| j|�}||f}|| j |< |S )Nr9 ) r r r: r= r Z parse_typeZis_raw_functionZas_function_pointerr) )r/ �cdecl�keyrK �really_a_function_type�btype�resultr r r �_typeof_locked� s zFFI._typeof_lockedc C sd y| j | }W n0 tk r> | j� | j|�}W d Q R X Y nX |\}}|r`| r`td|f ��|S )Nz>the type %r is a function type, not a pointer-to-function type)r �KeyErrorr rS r )r/ rN � consider_function_as_funcptrrR rQ rP r r r �_typeof� s z FFI._typeofc C s� t |t�r| j|�S t || j�r,| jj|�S t |tj�rLt|�}|dk rL|S t |tj �r|t |d�r|| j � | j |j �S Q R X tt|���dS )z�Parse the C type given as a string and return the corresponding <ctype> object. It can also be used on 'cdata' instance to get its C type. N�_cffi_base_type)r r; rV r- r �typeofr �BuiltinFunctionType�_builtin_function_type� FunctionTyper r r) rW r< rK )r/ rN �resr r r rX � s z FFI.typeofc C s0 t |t�r | j|�}| jj|�S | jj|�S dS )zvReturn the size in bytes of the argument. It can be a string naming a C type, or a 'cdata' instance. N)r r; rV r �sizeof)r/ rN �BTyper r r r] � s z FFI.sizeofc C s t |t�r| j|�}| jj|�S )z\Return the natural alignment size in bytes of the C type given as a string. )r r; rV r �alignof)r/ rN r r r r_ � s z FFI.alignofc G s( t |t�r| j|�}| j|f|�� d S )a3 Return the offset of the named field inside the given structure or array, which must be given as a C type name. You can give several field names in case of nested structures. You can also give numeric values which correspond to array items, in case of an array type. r )r r; rV � _typeoffsetof)r/ rN �fields_or_indexesr r r �offsetof� s z FFI.offsetofc C s" t |t�r| j|�}| jj||�S )a� Allocate an instance according to the specified C type and return a pointer to it. The specified C type must be either a pointer or an array: ``new('X *')`` allocates an X and returns a pointer to it, whereas ``new('X[n]')`` allocates an array of n X'es and returns an array referencing it (which works mostly like a pointer, like in C). You can also use ``new('X[]', n)`` to allocate an array of a non-constant length n. The memory is initialized following the rules of declaring a global variable in C: by default it is zero-initialized, but an explicit initializer can be given which can be used to fill all or part of the memory. When the returned <cdata> object goes out of scope, the memory is freed. In other words the returned <cdata> object has ownership of the value of type 'cdecl' that it points to. This means that the raw data can be used as long as this object is kept alive, but must not be used for a longer time. Be careful about that when copying the pointer to the memory somewhere else, e.g. into another structure. )r r; rV r Znewp)r/ rN �initr r r �new� s zFFI.newTc s, �j j� }|j|||�� d� �fdd� }|S )a� Return a new allocator, i.e. a function that behaves like ffi.new() but uses the provided low-level 'alloc' and 'free' functions. 'alloc' is called with the size as argument. If it returns NULL, a MemoryError is raised. 'free' is called with the result of 'alloc' as argument. Both can be either Python function or directly C functions. If 'free' is None, then no free function is called. If both 'alloc' and 'free' are None, the default is used. If 'should_clear_after_alloc' is set to False, then the memory returned by 'alloc' is assumed to be already cleared (or you are fine with garbage); otherwise CFFI will clear it. Nc s t | t�r�j| �} � | |�S )N)r r; rV )rN rc )� allocatorr/ r r �allocate s z#FFI.new_allocator.<locals>.allocate)N)r r � new_allocator)r/ ZallocZfreeZshould_clear_after_allocZ compiled_ffirf r )re r/ r rg s zFFI.new_allocatorc C s" t |t�r| j|�}| jj||�S )z�Similar to a C cast: returns an instance of the named C type initialized with the given 'source'. The source is casted between integers or pointers of any type. )r r; rV r r, )r/ rN �sourcer r r r, s zFFI.castr c C s | j j||�S )a� Return a Python string (or unicode string) from the 'cdata'. If 'cdata' is a pointer or array of characters or bytes, returns the null-terminated string. The returned string extends until the first null character, or at most 'maxlen' characters. If 'cdata' is an array then 'maxlen' defaults to its length. If 'cdata' is a pointer or array of wchar_t, returns a unicode string following the same rules. If 'cdata' is a single character or byte or a wchar_t, returns it as a string or unicode string. If 'cdata' is an enum, returns the value of the enumerator as a string, or 'NUMBER' if the value is out of range. )r �string)r/ �cdata�maxlenr r r ri % s z FFI.stringc C s | j j||�S )aL Unpack an array of C data of the given length, returning a Python string/unicode/list. If 'cdata' is a pointer to 'char', returns a byte string. It does not stop at the first null. This is equivalent to: ffi.buffer(cdata, length)[:] If 'cdata' is a pointer to 'wchar_t', returns a unicode string. 'length' is measured in wchar_t's; it is not the size in bytes. If 'cdata' is a pointer to anything else, returns a list of 'length' items. This is a faster equivalent to: [cdata[i] for i in range(length)] )r �unpack)r/ rj Zlengthr r r rl 7 s z FFI.unpackc C s | j j| j||�S )a� Return a <cdata 'char[]'> that points to the data of the given Python object, which must support the buffer interface. Note that this is not meant to be used on the built-in types str or unicode (you can build 'char[]' arrays explicitly) but only on objects containing large quantities of raw data in some other format, like 'array.array' or numpy arrays. )r � from_bufferr+ )r/ Z python_bufferZrequire_writabler r r rm U s zFFI.from_bufferc C s | j j|||�S )a_ ffi.memmove(dest, src, n) copies n bytes of memory from src to dest. Like the C function memmove(), the memory areas may overlap; apart from that it behaves like the C function memcpy(). 'src' can be any cdata ptr or array, or any Python buffer object. 'dest' can be any cdata ptr or array, or a writable Python buffer object. The size to copy, 'n', is always measured in bytes. Unlike other methods, this one supports all Python buffer including byte strings and bytearrays---but it still does not support non-contiguous buffers. )r �memmove)r/ �dest�src�nr r r rn ` s z FFI.memmovec sB � ���fdd�}t � t�r*�j� dd�� |dkr6|S ||�S dS )a� Return a callback object or a decorator making such a callback object. 'cdecl' must name a C function pointer type. The callback invokes the specified 'python_callable' (which may be provided either directly or via a decorator). Important: the callback object must be manually kept alive for as long as the callback may be invoked from the C level. c s" t | �std���jj� | ���S )Nz.the 'python_callable' argument is not callable)�callabler< r �callback)�python_callable)rN �error�onerrorr/ r r �callback_decorator_wrapx s z-FFI.callback.<locals>.callback_decorator_wrapT)rU N)r r; rV )r/ rN rt ru rv rw r )rN ru rv r/ r rs p s z FFI.callbackr c C sh t |t�r| j|�}|j� }|jd�rBd| jj|d�krBd| }n|rZ|d dkrZd| }| jj||�S )a. Return a string giving the C type 'cdecl', which may be itself a string or a <ctype> object. If 'replace_with' is given, it gives extra text to append (or insert for more complicated C types), like a variable name, or '*' to get actually the C type 'pointer-to-cdecl'. �*z&[�&z(%s)r z[(� )r r; rV �stripr& r Zgetcname)r/ rN Z replace_withr r r �getctype� s z FFI.getctypec C s | j j|||�S )a� Return a new cdata object that points to the same data. Later, when this new cdata object is garbage-collected, 'destructor(old_cdata_object)' will be called. The optional 'size' gives an estimate of the size, used to trigger the garbage collection more eagerly. So far only used on PyPy. It tells the GC that the returned object keeps alive roughly 'size' bytes of external memory. )r Zgcp)r/ rj Z destructor�sizer r r �gc� s zFFI.gcc C sf | j jd�dkst�y| j| }W n> tk r` g }|j| |�}x|D ]}|j| |� qHW Y nX |S )NF)r �acquirerF r rT Zget_cached_btyperB )r/ rK r^ rD r r r r) � s zFFI._get_cached_btypec K sV ddl m}m} | jr | j|� |p(|� }|| ||f|�| _ | j j� }| jj|� |S )a� Verify that the current ffi signatures compile on this machine, and return a dynamic library object. The dynamic library can be used to call functions and access global variables declared in this 'ffi'. The library is compiled by the C compiler: it gives you C-level API compatibility (including calling macros). This is unlike 'ffi.dlopen()', which requires binary compatibility in the signatures. r )�Verifier�_caller_dir_pycache)�verifierr� r� r! �_apply_windows_unicode� load_libraryr r@ )r/ rh �tmpdir�kwargsr� r� rI r r r �verify� s z FFI.verifyc C s | j j� S )N)r Z get_errno)r/ r r r � _get_errno� s zFFI._get_errnoc C s | j j|� d S )N)r Z set_errno)r/ �errnor r r � _set_errno� s zFFI._set_errnoz(the value of 'errno' from/to the C callsc C s | j j|�S )N)r � getwinerror)r/ �coder r r r� � s zFFI.getwinerrorc C s | j � tj| |�S Q R X d S )N)r r � pointer_cache)r/ �ctyper r r � _pointer_to� s zFFI._pointer_toc G s� y| j j|�}W n8 tk rH dt|�jkrBt|�j|f|�� S � Y nX |rd| j|f|�� \}}n|jdkrvtd��d}| j|�}| j j |||�S )z�Return the address of a <cdata 'struct-or-union'>. If 'fields_or_indexes' are given, returns the address of that field or array item in the structure or array, recursively in case of nested structures. � __addressof__Zpointerzaddressof(pointer)r ) r rX r< rK r r� r` �kindr� Z rawaddressof)r/ rj ra r� �offsetZctypeptrr r r � addressof� s z FFI.addressofc G sD | j j||�\}}x(|D ] }| j j||d�\}}||7 }qW ||fS )Nr )r Z typeoffsetof)r/ r� Zfield_or_indexra r� Zfield1Zoffset1r r r r` � s zFFI._typeoffsetofc C s� t |t�s tdt|�jf ��|| kr.td��|j�X | j�F | jj|j� | j j d� | j j |j � | j j d� | j j |� W dQ R X W dQ R X dS )a� Includes the typedefs, structs, unions and enums defined in another FFI instance. Usage is similar to a #include in C, where a part of the program might include types defined in another part for its own usage. Note that the include() method has no effect on functions, constants and global variables, which must anyway be accessed directly from the lib object returned by the original FFI instance. zGffi.include() expects an argument that is also of type cffi.FFI, not %rzself.include(self)�[�]N) r r r< rK �__name__� ValueErrorr r �includer r@ �extendr )r/ Zffi_to_includer r r r� � s z FFI.includec C s | j j| j|�S )N)r Z newp_handler* )r/ r r r r � new_handle s zFFI.new_handlec C s | j j|�S )N)r � from_handle)r/ r r r r r� s zFFI.from_handlec C s> | j dk rtd��t|�}|r*| jd� n | jd� || _ dS )ac Windows: if 'enabled_flag' is True, enable the UNICODE and _UNICODE defines in C, and declare the types like TCHAR and LPTCSTR to be (pointers to) wchar_t. If 'enabled_flag' is False, declare these types to be (pointers to) plain 8-bit characters. This is mostly for backward compatibility; you usually want True. Nz%set_unicode() can only be called oncez�typedef wchar_t TBYTE;typedef wchar_t TCHAR;typedef const wchar_t *LPCTSTR;typedef const wchar_t *PCTSTR;typedef wchar_t *LPTSTR;typedef wchar_t *PTSTR;typedef TBYTE *PTBYTE;typedef TCHAR *PTCHAR;z�typedef char TBYTE;typedef char TCHAR;typedef const char *LPCTSTR;typedef const char *PCTSTR;typedef char *LPTSTR;typedef char *PTSTR;typedef TBYTE *PTBYTE;typedef TCHAR *PTCHAR;)r! r� �boolr7 )r/ Z enabled_flagr r r � set_unicode s zFFI.set_unicodec C s> |j df �}t|ttf�s"td��t|�ddg }||d< d S )NZ define_macrosz''define_macros' must be a list or tuple�UNICODE�1�_UNICODE)r� r� )r� r� )�getr r% �tupler< )r/ �kwdsZ defmacrosr r r r� 0 s zFFI._apply_windows_unicodec sj � fdd�}dt jkr�dd l}t jdkrNd}tt d�r�|d|jjt jd �� n4t jd k r^d }nd }tt d�r�|d|jjt jd �� tt d�r�|d|jjt jdd�� n�t jdkr�d}tt d�r�|d7 }nLy dd l }W n t k r� ddl m } Y nX d}|j d��r||j d�7 }|t j d? t j d? d@ f }tt d��rF|t j7 }|d|� t jdk�rf|dd � d S ) Nc s" � j | g �}||kr |j|� d S )N)� setdefaultr@ )rO �valueZlst)r� r r �ensure: s z(FFI._apply_embedding_fix.<locals>.ensureZ__pypy__r �win32Zpython27�prefixZ library_dirsZlibs� zpypy-czpypy3-c�binZpypyZgoalz python%d%d�gettotalrefcountZ_d)� sysconfigz python%d.%dZ DEBUG_EXT� � � �abiflagsZ librariesZextra_link_argsz /MANIFEST)r� )�sys�builtin_module_names�os�platformr �path�joinr� � version_infor� � ImportErrorZ distutils�get_config_var� hexversionr� )r/ r� r� r� Z pythonlib�templater� r )r� r �_apply_embedding_fix8 s@ zFFI._apply_embedding_fix�.cc K sd dd l }t| d�rtd��t|t�s,td��|j|ksF|jrN|j|krNtd��t|�|||f| _ d S )Nr �_assigned_sourcez:set_source() cannot be called several times per ffi objectz 'module_name' must be a stringzY'module_name' must not contain '/': use a dotted name to make a 'package.module' location) r� r r� r r; r< �sep�altsepr: r� )r/ � module_namerh �source_extensionr� r� r r r � set_sourcej s zFFI.set_source�buildc C s� ddl m} ddlm} t| d�s>t| d�r6| jj� S td��| j\}}}}|d kr\t d��||� || ||f|||d d �|��\} } |r�| r�t j j d | j d f � nt j j d | j d f � | S ) Nr )�mkpathr )� recompiler� r� z8set_source() must be called before distutils_extension()zadistutils_extension() is only for C extension modules, not for dlopen()-style pure Python modulesF)r� Zextradirr� �call_c_compilerzregenerated: %r znot modified: %r )Zdistutils.dir_utilr� � recompilerr� r r� Z get_extensionr� r� r< r� �stderr�writeZsources) r/ r� �verboser� r� r� rh r� r� Zext�updatedr r r �distutils_extensionw s& zFFI.distutils_extensionc C sZ ddl m} t| d�s td��| j\}}}}|d kr<td��|| ||f|dd�|�� d S )Nr )r� r� z0set_source() must be called before emit_c_code()zYemit_c_code() is only for C extension modules, not for dlopen()-style pure Python modulesF)�c_filer� )r� r� r r� r� r< )r/ �filenamer� r� rh r� r� r r r � emit_c_code� s zFFI.emit_c_codec C sZ ddl m} t| d�s td��| j\}}}}|d k r<td��|| ||f|dd�|�� d S )Nr )r� r� z0set_source() must be called before emit_c_code()z^emit_python_code() is only for dlopen()-style pure Python modules, not for C extension modulesF)r� r� )r� r� r r� r� r< )r/ r� r� r� rh r� r� r r r �emit_python_code� s zFFI.emit_python_code�.c C sL ddl m} t| d�s td��| j\}}}} || ||f|||||d�| ��S )a� The 'target' argument gives the final file name of the compiled DLL. Use '*' to force distutils' choice, suitable for regular CPython C API modules. Use a file name ending in '.*' to ask for the system's default extension for dynamic libraries (.so/.dll/.dylib). The default is '*' when building a non-embedded C API extension, and (module_name + '.*') when building an embedded library. r )r� r� z,set_source() must be called before compile())r� �targetr� Zcompiler_verbose�debug)r� r� r r� r� ) r/ r� r� r� r� r� r� rh r� r� r r r �compile� s z FFI.compilec C s� y| j | }W n( tk r6 | j j|dt� f�}Y nX |d rH|d S |d �4 | j | }|d rl|d S |� }d|f| j |< W d Q R X |S )NFr r T)r" rT r� r )r/ �func�tagr rR r r r � init_once� s z FFI.init_oncec s� | j rtd��dd l}|jd|�}|r6||j� d � }|j� pBdg}|jd|d �j� }xBtdt|��D ]0� |� }|j � rhx|j |�s�|d d � }q~W qhW t|�� � fdd�|D �}dj |�}t |d d � || _ d S ) Nz-embedding_init_code() can only be called oncer z\s*\nr z\s*r c s g | ]}|� d � d �qS )N� r )�.0�line)�ir r � <listcomp>� s z+FFI.embedding_init_code.<locals>.<listcomp>Z cffi_init�exec���) r$ r� �re�match�end� splitlines�group�range�len�rstripr& r� r� )r/ Zpysourcer� r� �linesr� r� r )r� r �embedding_init_code� s$ zFFI.embedding_init_codec O s t d��d S )Nz:ffi.def_extern() is only available on API-mode FFI objects)r� )r/ �argsr� r r r � def_extern� s zFFI.def_externc C s� g }g }g }xh| j jD ]\}|jd�r8|j|dd� � q|jd�rV|j|dd� � q|jd�r|j|dd� � qW |j� |j� |j� |||fS )z�Returns the user type names known to this FFI instance. This returns a tuple containing three lists of names: (typedef_names, names_of_structs, names_of_unions) ztypedef � Nzstruct � zunion � )r � _declarationsr& r@ �sort)r/ ZtypedefsZstructsZunionsrO r r r � list_types� s zFFI.list_types)N)FF)F)F)r )F)N)NNTr� )r� )F)NNN)r )r )r Nr� )r� )r� )r� T)r� r NN)3r� � __module__� __qualname__�__doc__r2 r7 r8 r5 rJ rM rS rV rX r] r_ rb rd rg r, ri rl rm rn rs r| r~ r) r� r� r� �propertyr� r� r� r� r` r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r sb < 2 r c C s� dd l }|d kr*tjdkr&| jd |�S d}d }d|ksHd|ksH|j|kr|y | j||�S tk rz } z |}W Y d d }~X nX dd l}|jj|�}|d kr�|dkr�tjdkr�tj d kr�td��d|f }|d k r�d ||f }t|��| j||�S ) Nr r� �cr� �/r� zXdlopen(None) cannot work on Windows for Python 3 (see http://bugs.python.org/issue23606)zGctypes.util.find_library() did not manage to locate a library called %rz%s. Additionally, %s)r� ) r� r� r� r� r� �OSErrorZ ctypes.util�utilZ find_libraryr� ) r0 r1 rH r� Z first_error�eZctypesr� �msgr r r �_load_backend_lib s, r� c s � j }t|||�� � � � fdd��� � � fdd���� � fdd��dd� �� � fd d ��i �d g�i �������� � fd d �� � �� � � fdd�� G � ��� � � � � fdd�dt�� |d k r�y"t|t�s�|jd�}d| � _W n tk r� Y nX � � � � � jfS )Nc s< d| }�j j| \}}�j|�}� j|| �}|�j| < d S )Nz function )r r� r) � load_functionr )r1 rO rE �_r^ r� )� backendlib�ffi�libraryr r �accessor_function% s z,_make_ffi_library.<locals>.accessor_functionc s\ d� }�j j| \}}�j|�� �j��j�t��t� ��fdd�� ��fdd��� d S )Nz variable c s �� ��S )Nr )r/ )r^ r1 � read_variabler r r 3 s z>_make_ffi_library.<locals>.accessor_variable.<locals>.<lambda>c s �� �|�S )Nr )r/ r� )r^ r1 �write_variabler r r 4 s )r r� r) r r r' r� )r1 rO rE r� )� FFILibraryr� r )r^ r1 r r r �accessor_variable, s z,_make_ffi_library.<locals>.accessor_variablec s� y� | S t k r� �j�Z | � krtd| }�jj| \}}�j|�}|jdkr`tj�|�}�j|| �}|� | < W d Q R X � | S X d S )Nz variable Zarray) rT r r r� r) r� r r� r� )r1 rO rE r� r^ �p)�addr_variablesr� r r r � addressof_var6 s z(_make_ffi_library.<locals>.addressof_varc S s t d| f ��d S )NzDnon-integer constant '%s' cannot be accessed from a dlopen() library)�NotImplementedError)r1 r r r �accessor_constantE s z,_make_ffi_library.<locals>.accessor_constantc s � j j| �j| < d S )N)r �_int_constantsr )r1 )r r r r �accessor_int_constantI s z0_make_ffi_library.<locals>.accessor_int_constantFc s� �d �j krd S x��jjj� D ]�\} \}}t|tj�s~| jdd�\}}|dkrZ��|< q�|dkrl��|< q�|dkr�� �|< q x0t|j �D ]"\}}||f�fdd� }|�|< q�W q W x �jj D ]}�j |�� q�W �j �d< d S ) Nr rz r ZfunctionZvariableZconstantc s |j � |j| � j| < d S )N)Zcheck_not_partialZ enumvaluesr )r1 rE r� )r r r � accessor_enum_ s zB_make_ffi_library.<locals>.update_accessors.<locals>.accessor_enum) r# r r� �itemsr r ZEnumType�split� enumerateZ enumeratorsr r� )rO rE r� r� r1 r� Zenumnamer )r r r r � accessors�accessors_versionr r r r �update_accessorsP s" z+_make_ffi_library.<locals>.update_accessorsc sX �j �H | �jks | � jkr d S | �kr>�� | �kr>t| ���| | � W d Q R X d S )N)r r �AttributeError)r1 )r r r r r r r � make_accessorg s z(_make_ffi_library.<locals>.make_accessorc sR e Zd Z�fdd�Z�fdd�Z���fdd�Z� ���fdd�Z�fd d �Zd S ) z%_make_ffi_library.<locals>.FFILibraryc s � |� t | |�S )N)r( )r/ r1 )r r r � __getattr__r s z1_make_ffi_library.<locals>.FFILibrary.__getattr__c sJ yt | j|�}W n( tk r8 � |� t| ||� Y nX |j| |� d S )N)r( � __class__r r' �__set__)r/ r1 r� r� )r r r � __setattr__u s z1_make_ffi_library.<locals>.FFILibrary.__setattr__c s �j � �� � j� S Q R X d S )N)r �keys)r/ )r r r r r �__dir__} s z-_make_ffi_library.<locals>.FFILibrary.__dir__c sf |�j kr�j | S |� j kr&�|�S �|� |�j krB�j | S |� j krT�|�S td|f ��d S )Nz:cffi library has no function or global variable named '%s')r r )r/ r1 )r r r r r r r� � s z3_make_ffi_library.<locals>.FFILibrary.__addressof__c s � j � | jj� d S )N)Z close_libr rA )r/ )r� r r rL � s z4_make_ffi_library.<locals>.FFILibrary.__cffi_close__N)r� r� r� r r r r� rL r )r r r r� r r r r r r r q s r zutf-8z FFILibrary_%s) r r� r> r r: r= r� � UnicodeErrorr )r ZlibnamerH r0 r )r r r r r r r r r r� r r r r r rG ! s, " rG c C sd dd l }y$|j| j }|j}|j}|| }W n tttfk rF d S X |j� |j |�S Q R X d S )Nr ) r� �modulesr� Z_cffi_original_ffiZ _cffi_types_of_builtin_funcsrT r r< r r) )r� r� �moduler Ztypes_of_builtin_funcsrE r r r rZ � s rZ )r� r �lockr ru r r r rr � NameError� collectionsr r; r: r> r r� rG rZ r r r r �<module> s* wzPK %�\M��Rl� l� ) __pycache__/backend_ctypes.cpython-36.pycnu �[��� 3 M��Zf� � @ s� d dl Z d dlZ d dlZd dlZddlmZ ejdk r<eZne Z e Z e Zdd� ZG dd� de�ZG d d � d e�ZG d d � d e�ZG d d� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZdS )� N� )�model� c C s t | g�S )N)�bytes)�num� r �&/usr/lib64/python3.6/backend_ctypes.py�<lambda> s r c @ s e Zd ZdS )� CTypesTypeN)�__name__� __module__� __qualname__r r r r r s r c @ s e Zd ZeZdgZdZ dd� Zedd� �Ze dd� �Z ed d � �Z ed d � �Z e d d� �Z ed5dd��Zedd� �Zdd� Zdd� Zd6dd�Zdd � Zed d � �Zd d � Zed!d"� �Zd#d$� Zed%d&� �Zd'd(� Zd)d*� Zed+�Zed,�Z ed-�Z ed.�Z ed/�Z ed0�Z d1d2� Z!d3d4� Z"dS )7� CTypesData� __weakref__z<cdata>c G s t d| jf ��d S )Nzcannot instantiate %r)� TypeError� __class__)�self�argsr r r �__init__ s zCTypesData.__init__c C s t d| j� f ��d S )Nz+expected a pointer or array ctype, got '%s')r � _get_c_name)�cls�initr r r �_newp s zCTypesData._newpc C s t �d S )N)r )�valuer r r � _to_ctypes s zCTypesData._to_ctypesc G s^ y | j }W n" tk r, td| f ��Y nX |rR| j|� }t||�sZ| j |�}n| j � }|S )Nz cannot create an instance of %r)�_ctype�AttributeErrorr r � isinstance)r r �ctype�resr r r �_arg_to_ctypes s zCTypesData._arg_to_ctypesc C s |d kr| j � S | j |�S d S )N)r )r r r r r �_create_ctype_obj. s z CTypesData._create_ctype_objc C s t �d S )N)r )Z ctypes_valuer r r � _from_ctypes5 s zCTypesData._from_ctypes� c C s | j jd|�S )Nz &)� _reftypename�replace)r � replace_withr r r r 9 s zCTypesData._get_c_namec C s* d| j � f | _d| j � f | _d| _d S )Nz CData<%s>�ffi)r r r r )r r r r � _fix_class= s zCTypesData._fix_classc C s t �d S )N)�NotImplementedError)r r r r � _get_own_reprC s zCTypesData._get_own_reprc C s8 |dkr dS |dk r,|ddt jt j� > 7 }d| S d S )Nr ZNULLr � z0x%x)�ctypes�sizeof�c_void_p)r �addressr r r � _addr_reprF s zCTypesData._addr_reprNc C s | j � }d|p| j� |f S )Nz <cdata %r %s>)r* r )r �c_nameZownr r r �__repr__N s zCTypesData.__repr__c C s8 |d kr t d| j� f ��nt d| j� |j� f ��d S )Nz cannot convert %r to an addresszcannot convert %r to %r)r r )r �BClassr r r �_convert_to_addressR s z CTypesData._convert_to_addressc C s t j| j�S )N)r, r- r )r r r r � _get_sizeZ s zCTypesData._get_sizec C s t j| j�S )N)r, r- r )r r r r �_get_size_of_instance^ s z CTypesData._get_size_of_instancec C s t d| j� f ��d S )Nzcannot cast to %r)r r )r �sourcer r r � _cast_froma s zCTypesData._cast_fromc C s | j d �S )N)r4 )r r r r �_cast_to_integere s zCTypesData._cast_to_integerc C s t j| j�S )N)r, Z alignmentr )r r r r � _alignmenth s zCTypesData._alignmentc C s t d| j� ��d S )Nz#cdata %r does not support iteration)r r )r r r r �__iter__l s zCTypesData.__iter__c s t t| �� � fdd�}| |_|S )Nc sz t | t� }t |t�o t |t� }|r@|r@� | jd �|jd ��S |sH|rLtS t | t�r\| j} t |t�rl|j}� | |�S d S )N)r �CTypesGenericPrimitiver r4 �NotImplemented�_value)r �otherZv_is_ptrZw_is_ptr)�cmpfuncr r �cmpr s z!CTypesData._make_cmp.<locals>.cmp)�getattr�operatorZ func_name)�namerA r )r@ r � _make_cmpp s zCTypesData._make_cmp�__eq__�__ne__�__lt__�__le__�__gt__�__ge__c C s t | jd ��S )N)�hashr4 )r r r r �__hash__� s zCTypesData.__hash__c C s t d| f ��d S )Nz string(): %r)r )r �maxlenr r r � _to_string� s zCTypesData._to_string)r# )N)#r r r r Z __metaclass__� __slots__r � classmethodr � staticmethodr r r! r" r r( r* r0 r2 r4 r5 r6 r8 r9 r: r; rE rF rG rH rI rJ rK rM rO r r r r r s> r c @ s e Zd Zg Zdd� Zdd� ZdS )r< c C s t | j�S )N)rL r> )r r r r rM � s z CTypesGenericPrimitive.__hash__c C s t | j| j��S )N)�reprr" r> )r r r r r* � s z$CTypesGenericPrimitive._get_own_reprN)r r r rP rM r* r r r r r< � s r< c @ s, e Zd Zg Zedd� �Zdd� Zdd� ZdS )�CTypesGenericArrayc C s | |�S )Nr )r r r r r r � s zCTypesGenericArray._newpc c s$ x t t| ��D ]}| | V qW d S )N)�xrange�len)r �ir r r r; � s zCTypesGenericArray.__iter__c C s | j tj| j��S )N)r0 r, � addressof�_blob)r r r r r* � s z CTypesGenericArray._get_own_reprN)r r r rP rQ r r; r* r r r r rT � s rT c @ s� e Zd ZddgZdZdZedd� �Zedd� �Zed d � �Z d d � Z d d� Z dd� Z e Z edd� �Zedd� �Zedd� �Zdd� ZdS )�CTypesGenericPtr�_address� _as_ctype_ptrF�pointerc C s | |�S )Nr )r r r r r r � s zCTypesGenericPtr._newpc C sV |d krd}n>t |t�r"|j� }n*t |ttf�r6|}ntd| t|�jf ��| j|�S )Nr zbad type for cast to %r: %r) r r r9 �int�longr �typer �_new_pointer_at)r r7 r/ r r r r8 � s zCTypesGenericPtr._cast_fromc C s$ | j | �}||_tj|| j�|_|S )N)�__new__r[ r, �castr r\ )r r/ r r r r ra � s z CTypesGenericPtr._new_pointer_atc C s& y | j | j�S tk r dS X d S )Nz???)r0 r[ r )r r r r r* � s z CTypesGenericPtr._get_own_reprc C s | j S )N)r[ )r r r r r9 � s z!CTypesGenericPtr._cast_to_integerc C s t | j�S )N)�boolr[ )r r r r � __nonzero__� s z CTypesGenericPtr.__nonzero__c C s4 t |t�s tdt|�j ��|j| �}tj|| j�S )Nzunexpected %s object) r r r r` r r4 r, rc r )r r r/ r r r r � s zCTypesGenericPtr._to_ctypesc C s t j|t j�jpd}| j|�S )Nr )r, rc r. r ra )r � ctypes_ptrr/ r r r r" � s z CTypesGenericPtr._from_ctypesc C s |r| j |�j|_d S )N)r �contents)r rf r r r r � _initialize� s z CTypesGenericPtr._initializec C s0 || j d fks|js| jr | jS tj| |�S d S )N)r �_automatic_castsr[ r r4 )r r3 r r r r4 � s z$CTypesGenericPtr._convert_to_addressN)r r r rP ri �kindrQ r r8 ra r* r9 re �__bool__r r" rh r4 r r r r rZ � s rZ c @ s\ e Zd ZdgZedd� �Zdd� Zedd� �Zdd � Zed d � �Z ed d � �Z ddd�Z dS )�CTypesBaseStructOrUnionrY c C s t d| f ��d S )Nz!cannot instantiate opaque type %s)r )r r r r r r! � s z)CTypesBaseStructOrUnion._create_ctype_objc C s | j tj| j��S )N)r0 r, rX rY )r r r r r* � s z%CTypesBaseStructOrUnion._get_own_reprc C s t | j|�jS )N)rB r �offset)r � fieldnamer r r � _offsetof� s z!CTypesBaseStructOrUnion._offsetofc C s. t |dd �| jkr tj| j�S tj| |�S d S )N�_BItem)rB r r, rX rY r r4 )r r3 r r r r4 � s z+CTypesBaseStructOrUnion._convert_to_addressc C s | j | �}||_|S )N)rb rY )r Zctypes_struct_or_unionr r r r r" s z$CTypesBaseStructOrUnion._from_ctypesc C s |j S )N)rY )r r r r r r s z"CTypesBaseStructOrUnion._to_ctypesNc C s t j| |p| jd��S )Nz &)r r2 r )r r1 r r r r2 s z CTypesBaseStructOrUnion.__repr__)N) r r r rP rQ r! r* ro r4 r" r r2 r r r r rl � s rl c @ s e Zd Zejejejejejej ej ej ej ej ejejejejd�ZxfdMD ]^Zejee �Zee edde < eejej�kr�ee ed < eejej�krLee ed < qLW xtdND ]lZejee �Zee edde < eejej�k�ree ed< ee ed< eejej�kr�ee ed< q�W dd� Zdd� Zdd� ZdOdd �Zd d � Z d d � Z d!d"� Z d#d$� Z d%d&� Z d'd(� Z!d)d*� Z"dRd,d-�Z#d.d/� Z$d0d1� Z%d2d3� Z&d4d5� Z'dTd6d7�Z(dVd8d9�Z)d:d;� Zd<d=� Z*d>d?� Z+d@dA� Z,dBdC� Z-dDZ.dWdEdF�Z/e0Z1dGdH� Z2dXdIdJ�Z3dYdKdL�Z4dDS )Z� CTypesBackend)�char�shortr^ r_ z long longz signed charz unsigned charzunsigned shortz unsigned intz unsigned longzunsigned long long�float�double�_Bool�unsigned long long� unsigned long� unsigned int�unsigned short� unsigned charzuint%d_tr+ Z uintptr_tZsize_t� long longr_ r^ rs � signed charzint%d_tZintptr_tZ ptrdiff_tZssize_tc C s d| _ d| _tj| _tj| _d S )Nr )� RTLD_LAZY�RTLD_NOWr, � RTLD_GLOBAL� RTLD_LOCAL)r r r r r 7 s zCTypesBackend.__init__c C s || _ d S )N)r' )r r' r r r �set_ffi= s zCTypesBackend.set_ffic C s t tfS )N)r r )r r r r � _get_types@ s zCTypesBackend._get_typesr c C s t j||�}t| |�S )N)r, ZCDLL� CTypesLibrary)r �path�flags�cdllr r r � load_libraryC s zCTypesBackend.load_libraryc C s G dd� dt �}|j� |S )Nc @ s, e Zd Zg ZdZedd� �Zedd� �ZdS )z/CTypesBackend.new_void_type.<locals>.CTypesVoidzvoid &c S s d S )Nr )�novaluer r r r" K s z<CTypesBackend.new_void_type.<locals>.CTypesVoid._from_ctypesc S s | d k r t dt| �jf ��d S )Nz None expected, got %s object)r r` r )r� r r r r N s z:CTypesBackend.new_void_type.<locals>.CTypesVoid._to_ctypesN)r r r rP r$ rR r" r r r r r � CTypesVoidH s r� )r r( )r r� r r r � new_void_typeG s zCTypesBackend.new_void_typec s� �dkrt ���| j� ��dkr(d}n<�dkr6d}n.�dkrDd}n�dkrRd }nd }�d�jdk�� fd d ��|�G � �����fdd�dt�� � j� � S )NZwchar_trr rt ru � signed char� unsigned char�byterv rd r^ r c sj t | tttf�rt| �} nLt | t�r.| j� } n8t | t�rBt| �} n$| d krPd} ntd� t | �j f ��| S )Nr zbad type for cast to %r: %r) r r^ r_ rt r r9 r �ordr r` r )r7 )�CTypesPrimitiver r �_cast_source_to_inth s z=CTypesBackend.new_primitive_type.<locals>._cast_source_to_intc s� e Zd ZdgZ�Zd� Z�Zdd� Ze� �fdd��Z edksHedkrbe ��fd d ��Z d d � Z ed kr�e �fdd ��Z dd � Z edkr�e �fdd ��Z dd � Z edkr�e ��fdd ��Z dd � Z dd� Z e Zedks�edks�ed kr�e���fdd��Zedk�r e� fdd��Zdd � Znd d � ZeZedk�rFe�fd d��Zed d � �Ze� fd!d"��Zedk�rtd#d$� Zedk�r�d%d$� Zd&S )'z9CTypesBackend.new_primitive_type.<locals>.CTypesPrimitiver> z%s &c S s || _ d S )N)r> )r r r r r r } s zBCTypesBackend.new_primitive_type.<locals>.CTypesPrimitive.__init__c s | d kr�� S �� j | ��S )N)r )r )r� r r r r! � s zKCTypesBackend.new_primitive_type.<locals>.CTypesPrimitive._create_ctype_objr^ r� c s � |�}�|�j }| |�S )N)r )r r7 )r� r r r r8 � s zDCTypesBackend.new_primitive_type.<locals>.CTypesPrimitive._cast_fromc S s | j S )N)r> )r r r r �__int__� s zACTypesBackend.new_primitive_type.<locals>.CTypesPrimitive.__int__rd c s$ t |tttf�s� |�}| t|��S )N)r r^ r_ rt rd )r r7 )r� r r r8 � s c S s | j S )N)r> )r r r r r� � s rr c s � |�}t |d@ �}| |�S )N� )�bytechr)r r7 )r� r r r8 � s c S s t | j�S )N)r� r> )r r r r r� � s rt c sN t |t�r n0t |t�r4t|d�r*t|�}q<t|�}n� |�}�|�j}| |�S )N� __float__)r rt r< �hasattrr^ r )r r7 )r� r r r r8 � s c S s t | j�S )N)r^ r> )r r r r r� � s c S s | j S )N)r> )r r r r r� � s zCCTypesBackend.new_primitive_type.<locals>.CTypesPrimitive.__float__c sn t | ttf�s4t | t�r"t| �} ntdt| �j ��� | �j| krj� r^| dk r^td� ��n td� ��| S )Nzinteger expected, got %sr z%s: negative integerz%s: integer out of bounds) r r^ r_ r r r` r r � OverflowError)�x)r � is_signedrD r r r � s zDCTypesBackend.new_primitive_type.<locals>.CTypesPrimitive._to_ctypesc s@ t | t�rt| �dkr| S t | � �r*| jS tdt| �j ��d S )Nr zcharacter expected, got %s)r r rV r> r r` r )r� )r� r r r � s c S s t | j�dkS )Nr )r� r> )r r r r re � s zECTypesBackend.new_primitive_type.<locals>.CTypesPrimitive.__nonzero__c S s | j dkS )Nr )r> )r r r r re � s c s. t | ttttf�s$tdt| �j ��� | �jS )Nzfloat expected, got %s) r r^ r_ rt r r r` r r )r� )r r r r � s c S s t | d| �S )Nr )rB )r r r r r" � s zFCTypesBackend.new_primitive_type.<locals>.CTypesPrimitive._from_ctypesc s � j |�| _d S )N)r r )�blobr )r� r r rh � s zECTypesBackend.new_primitive_type.<locals>.CTypesPrimitive._initializec S s | j S )N)r> )r rN r r r rO � s zDCTypesBackend.new_primitive_type.<locals>.CTypesPrimitive._to_stringc S s t | jd@ �S )Nr� )�chrr> )r rN r r r rO � s N)r r r rP r r$ rj r rR r! rQ r8 r� r� r9 r re rk r" rh rO r )r� r� r r� �kind1rD r r r� w sF r� )rt ru )r� r� ���r� )r) �PRIMITIVE_TYPESr r< r( )r rD rj r )r� r� r r� r� rD r �new_primitive_typeW s$ wz CTypesBackend.new_primitive_typec s� | j j}� |tjd��kr d�n>� |tjd��|tjd��fkrFd�n� |tj�krZd�nd�G � ��fdd �d t��� | j jtj�ks�� | j jtjd��kr�d �_�j� �S ) Nrr �charpz signed charz unsigned char�bytep�voidp�genericc s� e Zd ZdgZ�dkr edg7 Z�Ze�d�rHej�j�Zej �j�Z nej Ze �e �rd�jd�Zn �jd�Z��fdd�Zd d � Zd d � Z�fd d�Z�fdd�Z�dks��dkr�e�� fdd��Z�dks֔dkr�dd� Z�� fdd�Z� ZS )z1CTypesBackend.new_pointer_type.<locals>.CTypesPtr�_ownr� Z __as_strbufr z(* &)z * &c sb � j |�}�dkr8tj|jd �| _tj| j| j�| _n tj|�| _tj| jtj �j| _ d| _ d S )Nr� � T) r! r, Zcreate_string_bufferr Z_CTypesPtr__as_strbufrc r r\ r] r. r[ r� )r r Zctypeobj)�BItemrj r r r s z:CTypesBackend.new_pointer_type.<locals>.CTypesPtr.__init__c S s, t |ttf�r$| j| j|| j �S tS d S )N)r r^ r_ ra r[ � _bitem_sizer= )r r? r r r �__add__ s z9CTypesBackend.new_pointer_type.<locals>.CTypesPtr.__add__c S sN t |ttf�r$| j| j|| j �S t| �t|�krF| j|j | j S tS d S )N)r r^ r_ ra r[ r� r` r= )r r? r r r �__sub__ s z9CTypesBackend.new_pointer_type.<locals>.CTypesPtr.__sub__c s( t | dd�r|dkrt�� j| j| �S )Nr� Fr )rB � IndexErrorr" r\ )r �index)r� r r � __getitem__) s z=CTypesBackend.new_pointer_type.<locals>.CTypesPtr.__getitem__c s � j |�| j|< d S )N)r r\ )r r� r )r� r r � __setitem__. s z=CTypesBackend.new_pointer_type.<locals>.CTypesPtr.__setitem__r� c s4 |r t |d t�r tj|d �S t� | �j|� S d S )Nr )r r r, Zc_char_p�superr )r r )� CTypesPtrr r r r 2 s z@CTypesBackend.new_pointer_type.<locals>.CTypesPtr._arg_to_ctypesr� c sf |dk rt j}tj| jtjtj��� d}x ||k rH� | dkrH|d7 }q*W dj� fdd�t|�D ��S )Nr r� r � c s g | ] }� | �qS r r )�.0rW )�pr r � <listcomp>B s zPCTypesBackend.new_pointer_type.<locals>.CTypesPtr._to_string.<locals>.<listcomp>) �sys�maxsizer, rc r\ �POINTER�c_char�join�range)r rN �nr )r� r rO : s z<CTypesBackend.new_pointer_type.<locals>.CTypesPtr._to_stringc s. t | dd�r dtj| jj�f S t� | �j� S )Nr� Fzowning %d bytes)rB r, r- r\ rg r� r* )r )r� r r r r* D s z?CTypesBackend.new_pointer_type.<locals>.CTypesPtr._get_own_repr)r r r rP rp r� r, r� r r- r� r. � issubclassrT r r$ r r� r� r� r� rQ r rO r* � __classcell__r )r� r� rj )r r r� � s* r� T)r' �_get_cached_btyper � PrimitiveTypeZ void_typerZ ri r( )r r� �getbtyper )r� r� rj r �new_pointer_type� s Mz CTypesBackend.new_pointer_typec s� �d krd�nd� ��j � | jj}� |tjd��kr<d�n*� |tjd��|tjd��fkrbd�nd�G � �����fdd �d t���j� �S ) Nz &[]z &[%d]rr z signed charz unsigned charr� r� c s� e Zd ZddgZ�dk r$�j� Zn ejd� �j��Z�Z�Z ���fdd�Z e �fdd��Z d d � Z �fd d �Z�fd d�Z�dks��dkr�dd� Z�� fdd�Z�fdd�Ze �fdd��Ze �fdd��Z��fdd �Zed d � �Z� ZS ) z1CTypesBackend.new_array_type.<locals>.CTypesArrayrY r� Nr c s� �d kr\t |ttf�r |}d }n0�dkr@t |t�r@t|�d }nt|�}t|�}� j| | _| j� | _d| _|d k r�| j | j|� d S )Nrr r T) r r^ r_ r rV �tupler rY r� rh )r r Zlen1)r� rj �lengthr r r j s z:CTypesBackend.new_array_type.<locals>.CTypesArray.__init__c s� t � t�r&� fdd�tt� ��D �� nt� �� t� �t| �krFtd��tj| tj�j }tj �j �}tj �j �}x6t � �D ]*\}}tj||| |�}�j|j|� qxW d S )Nc s g | ]}� ||d � �qS )r r )r� rW )r r r r� } s zQCTypesBackend.new_array_type.<locals>.CTypesArray._initialize.<locals>.<listcomp>ztoo many initializers)r r r� rV r� r� r, rc r. r r� r r- � enumeraterh rg )r� r �addr�PTR�itemsizerW r r� )r� )r r rh z s z=CTypesBackend.new_array_type.<locals>.CTypesArray._initializec S s t | j�S )N)rV rY )r r r r �__len__� s z9CTypesBackend.new_array_type.<locals>.CTypesArray.__len__c s2 d| kot | j�k n s"t�� j| j| �S )Nr )rV rY r� r" )r r� )r� r r r� � s z=CTypesBackend.new_array_type.<locals>.CTypesArray.__getitem__c s6 d| kot | j�k n s"t�� j|�| j|< d S )Nr )rV rY r� r )r r� r )r� r r r� � s z=CTypesBackend.new_array_type.<locals>.CTypesArray.__setitem__rr r� c sj |dk rt | j�}tj| jtjtj��� d}x ||k rL� | dkrL|d7 }q.W dj� fdd�t|�D ��S )Nr r� r r� c s g | ] }� | �qS r r )r� rW )r� r r r� � s zPCTypesBackend.new_array_type.<locals>.CTypesArray._to_string.<locals>.<listcomp>)rV rY r, rc r� r� r� r� )r rN r� r )r� r rO � s z<CTypesBackend.new_array_type.<locals>.CTypesArray._to_stringc s, t | dd�r dtj| j�f S t� | �j� S )Nr� Fzowning %d bytes)rB r, r- rY r� r* )r )� CTypesArrayr r r r* � s z?CTypesBackend.new_array_type.<locals>.CTypesArray._get_own_reprc s. |� d fks|j r tj| j�S tj| |�S d S )N)ri r, rX rY r r4 )r r3 )r� r r r4 � s zECTypesBackend.new_array_type.<locals>.CTypesArray._convert_to_addressc s � j � �}| |_|S )N)rb rY )Z ctypes_arrayr )r� r r r" � s z>CTypesBackend.new_array_type.<locals>.CTypesArray._from_ctypesc s � j | �S )N)r )r )r� r r r � s z@CTypesBackend.new_array_type.<locals>.CTypesArray._arg_to_ctypesc s8 t |ttf�r0�jtj| j�|tj� j� �S t S d S )N) r r^ r_ ra r, rX rY r- r r= )r r? )r� r� r r r� � s z9CTypesBackend.new_array_type.<locals>.CTypesArray.__add__c S s t d| j� f ��d S )Nz casting to %r)r) r )r r7 r r r r8 � s z<CTypesBackend.new_array_type.<locals>.CTypesArray._cast_from)r r r rP r �appendr r$ �_declared_length�_CTPtrr rR rh r� r� r� rO r* r4 r" r r� rQ r8 r� r )r� r� r� �bracketsrj r� )r r r� ` s( r� )rp r' r� r r� rT r( )r r� r� r� r )r� r� r� r� rj r� r �new_array_typeQ s cz CTypesBackend.new_array_typec sF G dd� d|��d|�f �_ |� G � ��fdd�dt�}|j� |S )Nc @ s e Zd ZdS )z;CTypesBackend._new_struct_or_union.<locals>.struct_or_unionN)r r r r r r r �struct_or_union� s r� z%s_%sc s( e Zd ZdgZ�Zd�f Z� ZZdS )z?CTypesBackend._new_struct_or_union.<locals>.CTypesStructOrUnionrY z%s &N)r r r rP r r$ �_kindrj r )r� rD r� r r �CTypesStructOrUnion� s r� )r rl r( )r rj rD Zbase_ctypes_classr� r )r� rD r� r �_new_struct_or_union� s z"CTypesBackend._new_struct_or_unionc C s | j d|tj�S )N�struct)r� r, Z Structure)r rD r r r �new_struct_type� s z CTypesBackend.new_struct_typec C s | j d|tj�S )N�union)r� r, ZUnion)r rD r r r �new_union_type� s z CTypesBackend.new_union_typer c sP |dks|dkrt d��� j�dd� |D ��dd� |D �}dd� |D �}i } g } xN|D ]F\} } } | dk r�| j| | jf� | | | < qV| j| | j| f� t| | < qVW |d@ r�d�_| �_| � _t��fd d ��}|� _� ���fd d ��� j d k�t t �t ||����x�|D ]�\} } } | dk�r$t d��t � | ��r<t d| ��| dk �r�| | � j| �tj| j�fdd�}| | fdd�}t| t��r�d }| jdk�r�| | j� j| �tj| j�fdd�}n | | fdd�}| | fdd�}t� | t||�� �qW | jjtj|��}xP�D ]H} t || ��r t d| ��| fdd�}| fdd�}t|| t||�� �q W d S )Nr z�the ctypes backend of CFFI does not support structures completed by verify(); please compile and install the _cffi_backend module.c S s g | ]\}}}|�qS r r )r� �fname�BField�bitsizer r r r� � s z:CTypesBackend.complete_struct_or_union.<locals>.<listcomp>c S s g | ]\}}}|�qS r r )r� r� r� r� r r r r� � s c S s g | ]\}}}|�qS r r )r� r� r� r� r r r r� � s r+ r c s �� }| d k r� || � |S )Nr )r �result)� initializer� r r r! � s zACTypesBackend.complete_struct_or_union.<locals>._create_ctype_objc s� �r"t |�dkr"tdt |�f ��t|t�sxt|ttf�rBtd��t|�}t |�t ��krjtd� j� ��tt �|��}t j | �}xd|j � D ]X\}}�| \}}|dk s�t d��� j|�}t j|j�}t j|| |�} |j| j|� q�W d S )Nr zPunion initializer: %d items given, but only one supported (use a dict if needed)z union initializer: got a strz"too many values for %s initializerr z,not implemented: initializer with bit fields)rV � ValueErrorr �dictr �unicoder r� r �zipr, rX �items�AssertionErrorro r� r rc rh rg ) r� r r� r� r r� r� rm r� r� )r� �fnames�is_union�name2fieldtyper r r� � s* z:CTypesBackend.complete_struct_or_union.<locals>.initializer� r# z nested anonymous structs/unionsz1the field name %r conflicts in the ctypes backendc S s( t j| j�}t j|| |�}|j|j�S )N)r, rX rY rc r" rg )r r� r� rm r� r� r� r r r �getter s z6CTypesBackend.complete_struct_or_union.<locals>.getterc S s t | j||j|�� d S )N)�setattrrY r )r r r� r� r r r �setter$ s z6CTypesBackend.complete_struct_or_union.<locals>.setterc S s& t j| j�}t j|| |�}|j|�S )N)r, rX rY rc r" )r r� Z BFieldPtrrm r� r� r� r r r r� * s c S s |j t| j|��S )N)r" rB rY )r r� r� r r r r� 2 s c S sN |j |�}t| j|�}t| j||� |t| j|�krJt| j||� td��d S )Nz value too large for bitfield)r rB rY r� r� )r r r� r� Zoldvaluer r r r� 4 s c S s t | d |�S )Nr )rB )r r� r r r r� C s c S s t | d ||� d S )Nr )r� )r r r� r r r r� E s )r) r r� �EllipsisZ_pack_Z_fields_� _bfield_typesrR r! r� r� r� r� r� ro r, r� r� rT r� r� r� �propertyr' r� r Z PointerType)r r� Zfields�tpZ totalsizeZtotalalignmentZsflagsZbtypesZ bitfieldsZ bfield_typesZcfieldsr� r� r� r! r� r� r� r )r� r� r� r� r� r� r �complete_struct_or_union� sf z&CTypesBackend.complete_struct_or_unionc sN dd� � D ���r �j d� dj���G � ����fdd�dt���j� �S )Nc S s g | ] }|j � �qS r )r )r� �BArgr r r r� J s z3CTypesBackend.new_function_type.<locals>.<listcomp>z...z, c s� e Zd ZddgZeje�dd�fdd� �D ��ddi�Z�jd �f �Z d����fd d � Z e d d � �Z dd� Z �� fdd�Z���fdd�Z� ZS )z:CTypesBackend.new_function_type.<locals>.CTypesFunctionPtr� _own_callback�_namer Nc S s g | ] }|j �qS r )r )r� r� r r r r� R s zECTypesBackend.new_function_type.<locals>.CTypesFunctionPtr.<listcomp>� use_errnoTz (* &)(%s)c s� dd l �� std��t�dd �d k r8�j�j� ��� nd � ��� ��fdd�}t�t�r~tjtj fdd� �D ��dd i�}n�j }||�| _ tj | j tj �j | _�| _d S ) Nr z#varargs not supported for callbacksr c s� g }x&t | � �D ]\}}|j|j|�� qW y�|� }�j|�}W n �j� �}Y nX t�t�r�|r|tj|tj �j }nd }|S )N) r� r� r" r � print_excr� rZ r, rc r. r )r Zargs2�argr� Zres2)�BArgs�BResult�errorr � tracebackr r �callback_ s zUCTypesBackend.new_function_type.<locals>.CTypesFunctionPtr.__init__.<locals>.callbackc S s g | ] }|j �qS r )r )r� r� r r r r� v s zWCTypesBackend.new_function_type.<locals>.CTypesFunctionPtr.__init__.<locals>.<listcomp>r� T)r� r� rB r" r! r� rZ r, � CFUNCTYPEr. r r\ rc r r[ r� )r r r� r� Zcallback_ctype)r� r� �CTypesFunctionPtr� has_varargs)r� r r� r r V s" zCCTypesBackend.new_function_type.<locals>.CTypesFunctionPtr.__init__c S s |r t d��d S )NzActypes backend: not supported: initializers for function pointers)r) )rf r r r r rh s zFCTypesBackend.new_function_type.<locals>.CTypesFunctionPtr._initializec S sP t | dd �}|rD| jjd�}| j|d dkr6d| }| jjd|�}tj| |�S )Nr� z(* &)r z )*� )rB r$ r� r% r r2 )r r1 rW r r r r2 � s zCCTypesBackend.new_function_type.<locals>.CTypesFunctionPtr.__repr__c s* t | dd �d k r d| jf S t� | �j� S )Nr� z calling %r)rB r� r� r* )r )r� r r r r* � s zHCTypesBackend.new_function_type.<locals>.CTypesFunctionPtr._get_own_reprc s� �r:t |�t � �kst�|t � �d � }|d t � �� }nt |�t � �ksNt�g }x&t|� �D ]\}}|j|j|�� q^W �r�xjt|�D ]^\}}|d kr�|jtjd�� q�t|t �s�t ddt � � | t |�j f ��|j|j|�� q�W | j |� }�j|�S )Nr zKargument %d passed in the variadic part needs to be a cdata object (got %s)r )rV r� r� r� r r� r, r. r r r r` r r\ r" )r r Z extraargsZ ctypes_argsr� r� rW r� )r� r� r� r r �__call__� s( zCCTypesBackend.new_function_type.<locals>.CTypesFunctionPtr.__call__)N)r r r rP r, r� rB r r r$ r rR rh r2 r* r� r� r )r� r� r� r� �nameargs)r r r� O s ) r� )r� r� rZ r( )r r� r� r� r )r� r� r� r� r� r �new_function_typeI s \z CTypesBackend.new_function_typec sF t � t�st�ttt|�t|����G � �fdd�d|�}|j� |S )Nc s0 e Zd Zg Zd� Z�fdd�Z�fdd�ZdS )z/CTypesBackend.new_enum_type.<locals>.CTypesEnumz%s &c s4 | j }yd|� | f S tk r. t|�S X d S )Nz%d: %s)r> �KeyError�str)r r )�reverse_mappingr r r* � s z=CTypesBackend.new_enum_type.<locals>.CTypesEnum._get_own_reprc s, | j }y� | S tk r& t|�S X d S )N)r> r� r� )r rN r )r r r rO � s z:CTypesBackend.new_enum_type.<locals>.CTypesEnum._to_stringN)r r r rP r$ r* rO r )rD r r r � CTypesEnum� s r )r r� r� r� r� �reversedr( )r rD Z enumeratorsZ enumvaluesZ CTypesIntr r )rD r r � new_enum_type� s zCTypesBackend.new_enum_typec C s t j� S )N)r, � get_errno)r r r r r � s zCTypesBackend.get_errnoc C s t j|� d S )N)r, � set_errno)r r r r r r � s zCTypesBackend.set_errnoc C s |j |�S )N)rO )r �brN r r r �string� s zCTypesBackend.stringc C s t d��d S )Nz buffer() with ctypes backend)r) )r Zbptr�sizer r r �buffer� s zCTypesBackend.bufferc C s, t |t�r|j� S t|t�s t�|j� S d S )N)r r r6 r� r� r5 )r Zcdata_or_BTyper r r r- � s zCTypesBackend.sizeofc C s t |t�st�|j� S )N)r� r r� r: )r �BTyper r r �alignof� s zCTypesBackend.alignofc C s t |t�st�|j|�S )N)r� r r r )r r r7 r r r �newp� s zCTypesBackend.newpc C s |j |�S )N)r8 )r r r7 r r r rc � s zCTypesBackend.castc C s |d ks t �|||�S )N)r� )r r r7 r� �onerrorr r r r� � s zCTypesBackend.callbackNc s� | j d kr.dd l}G dd� d|j�}i |f| _ | j \� }|d krpy� ||�= W n tk rj td��Y nX d S � fdd�}| j| j|�|�}||k s�t�||f� |||�< |S )Nr c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )z CTypesBackend.gcp.<locals>.MyRefc S s | � }| |kp |d k o ||� kS )Nr )r r? Zmyrefr r r rF � s z'CTypesBackend.gcp.<locals>.MyRef.__eq__c S s | |k S )Nr )r r? r r r rG � s z'CTypesBackend.gcp.<locals>.MyRef.__ne__c S s. y| j S tk r( t| � �| _ | j S X d S )N)�_hashr rL )r r r r rM � s z)CTypesBackend.gcp.<locals>.MyRef.__hash__N)r r r rF rG rM r r r r �MyRef� s r zFCan remove destructor only on a object previously returned by ffi.gc()c s$ � j | d�\}}|d k r ||� d S )N)NN)�pop)�k�cdata� destructor)� weak_cacher r �remove s z!CTypesBackend.gcp.<locals>.remove)�_weakref_cache_ref�weakref�refr� r rc �typeofr� )r r r r r r r Z new_cdatar )r r �gcp� s zCTypesBackend.gcpc C s |j |�S )N)r )r r r& r r r �getcname s zCTypesBackend.getcnamec C s� t |t�r\|dkr"t|t�r"|j}t|t�s4td��|j| }|tkrNtd��||j |�fS t |t t f�r�t|t �rz|j }t|t�s�td��|j}|j� | }|tjkr�t�||fS tt|���d S )Nr z expected a struct or union ctypeznot supported for bitfieldsz expected an array or ptr ctype)r r� r� rZ rp rl r r� r� ro r^ r_ rT r� r5 r� r� r� r` )r r rn r r� r� rm r r r � typeoffsetof s( zCTypesBackend.typeoffsetofc C s� t |t�r tjt|�j|��}n^t |t�r\|d ksDtt|�jt� rLt d��t|�j|�}n"t |t �rvt|�j|�}nt d��|r�tj tj tj |tj �j | �t|��}|j|�S )Nzunexpected cdata typez$expected a <cdata 'struct-or-union'>)r rl r, r] r` r rZ r� rp r rT rc r. r r" )r ZBTypePtrr rm Zptrr r r � rawaddressof. s zCTypesBackend.rawaddressof)rw rx ry rz r{ )r| r_ r^ rs r} )r r� r� )r� r� r r� )r� r� )r� )r )r )N)5r r r r, r� Zc_shortZc_intZc_longZ c_longlongZc_byteZc_ubyteZc_ushortZc_uintZc_ulongZ c_ulonglongZc_floatZc_doubleZc_boolr� r� r- Z_sizer. Zc_size_tr r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r rc r� r r r` r r r r r r r r rq sx `u le % rq c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) r� c C s || _ || _d S )N)�backendr� )r r r� r r r r D s zCTypesLibrary.__init__c C s t | j|�}|j|�}||_|S )N)rB r� r" r� )r r rD Zc_func�funcobjr r r � load_functionH s zCTypesLibrary.load_functionc C sJ y|j j| j|�}W n* tk r> } zt|��W Y d d }~X nX |j|�S )N)r �in_dllr� r r) r" )r r rD � ctypes_obj�er r r � read_variableN s zCTypesLibrary.read_variablec C s@ |j |�}|jj| j|�}tjtj|�tj|�tj|j�� d S )N)r r r! r� r, ZmemmoverX r- )r r rD r Znew_ctypes_objr" r r r �write_variableU s z CTypesLibrary.write_variableN)r r r r r r$ r% r r r r r� B s r� )r )r, Z ctypes.utilrC r� r# r � version_infor� r� r� r� r^ r_ r� rU r` r �objectr r< rT rZ rl rq r� r r r r �<module> s, C# 7PK %�\T*�� ) __pycache__/setuptools_ext.cpython-36.pycnu �[��� 3 M��Z � @ sn d dl Z d dlZye W n ek r0 eZY nX dd� Zdd� Zdd� Zdd � Zd d � Z d d � Z dd� Z dS )� Nc C s ddl m} || ��d S )Nr )�DistutilsSetupError)Zdistutils.errorsr )�msgr � r �&/usr/lib64/python3.6/setuptools_ext.py�error s r c C s@ t | ��}|j� }W d Q R X |d7 }t|| d�}t|||� d S )N� �exec)�open�read�compiler )�filenameZglob�f�src�coder r r �execfile s r c C s� ddl m} t|t�s*tdt|�jf � t|�}y|jd�\}}W n" t k rf td|f � Y nX t j j |�s�d}|j dd�d }t j j |�r�d |d | f }td ||f � d |d �}t||� y || }W n$ tk r� td||f � Y nX t||��s|� }t||��s0td|t|�jf � t|d��sJtd|f � |j\} } } } |j�rr| j� } |j| � | d k�r�t| || � nt| || | | | � d S )Nr )�FFIzEargument to 'cffi_modules=...' must be a str or a list of str, not %r�:z3%r must be of the form 'path/build.py:ffi_variable'� �.�/z.pyz (rewrite cffi_modules to [%r])z#%r does not name an existing file%sZ__cffi__)�__name__�__file__z!%r: object %r not found in modulez"%r is not an FFI instance (got %r)�_assigned_sourcez*%r: the set_source() method was not called)Zcffi.apir � isinstance� basestringr �typer �str�split� ValueError�os�path�exists�replacer �KeyError�hasattrr Z_windows_unicode�copyZ_apply_windows_unicode�_add_py_module� _add_c_module) �distZmod_specr Zbuild_file_nameZ ffi_var_name�extZ rewrittenZmod_vars�ffi� module_name�source�source_extension�kwdsr r r �add_cffi_module sL r/ c C sp d|krlt td� rltjdkrlddl}y(t|jjd�d �}|dkrLd|d< W n tk rj d|d< Y nX |S ) a� Add py_limited_api to kwds if setuptools >= 26 is in use. Do not alter the setting if it already exists. Setuptools takes care of ignoring the flag on Python 2 and PyPy. CPython itself should ignore the flag in a debugging version (by not listing .abi3.so in the extensions it supports), but it doesn't so far, creating troubles. That's why we check for "not hasattr(sys, 'gettotalrefcount')" (the 2.7 compatible equivalent of 'd' not in sys.abiflags). (http://bugs.python.org/issue28401) On Windows, it's better not to use py_limited_api until issue #355 can be resolved (by having virtualenv copy PYTHON3.DLL). See also the start of _cffi_include.h. Zpy_limited_api�gettotalrefcountZwin32r Nr � T)r$ �sys�platform� setuptools�int� __version__� partitionr )� Extensionr. r4 Zsetuptools_major_versionr r r �_set_py_limited_apiI s r9 c s� ddl m} ddlm} ddlm� ddlm� ddlm � dg}|j |j dg �� t ||�}|f �|d �|���d�������� fd d � �| j d kr�g | _ | j j�� | jjd |�� G � ��fd d�d� �} | | jd < d S )Nr )r8 )� build_ext)�mkpath)�log)� recompilerz $PLACEHOLDER�sources)�namer> c s\ t jj| �� �}�jd| � �| � |d k r:|� �� �j���|�}|sX�jd� |S )Nzgenerating cffi module %rzalready up-to-date)r r �join�infoZ make_c_source)Ztmpdir�pre_runZc_file�updated)r) r* r< r; r+ r= r, r- r r �make_modt s z _add_c_module.<locals>.make_modr: c s e Zd Z� ��fdd�ZdS )z)_add_c_module.<locals>.build_ext_make_modc s: �j d dkr,t| dd �}�| j|��j d< � j| � d S )Nr z $PLACEHOLDERrB )r> �getattrZ build_temp�run)�selfrB )� base_classr) rD r r rF � s z-_add_c_module.<locals>.build_ext_make_mod.runN)r � __module__� __qualname__rF r )rH r) rD r r �build_ext_make_mod� s rK )N)Zdistutils.corer8 � setuptools.command.build_extr: �distutils.dir_utilr; � distutilsr< �cffir= �extend�popr9 Z ext_modules�append�cmdclass�get) r( r* r+ r, r- r. r8 r: Z allsourcesrK r ) rH r) r* r< rD r; r+ r= r, r- r r' g s r' c s� ddl m� ddlm} ddlm} ddlm� ddlm � �����fdd��| j j d |�� G � ��fd d �d � �}|| j d < | j d kr�g | _ | j j �� | j j d |��G ���fd d�d��}|| j d < d S )Nr )r; )�build_py)r: )r< )r= c s> �j d| � �tjj| �� �j� �| �}|s:�j d� d S )Nzgenerating cffi module %rzalready up-to-date)rA r r �dirnameZmake_py_source)Zpy_filerC )r* r< r; r+ r= r r � generate_mod� s z$_add_py_module.<locals>.generate_modrU c s e Zd Z� ��fdd�ZdS )z)_add_py_module.<locals>.build_py_make_modc s@ � j | � �jd�}|d d7 < �tjj| jf|�� � d S )Nr � z.py���)rF r r r r@ Z build_lib)rG � module_path)rH rW r+ r r rF � s z-_add_py_module.<locals>.build_py_make_mod.runN)r rI rJ rF r )rH rW r+ r r �build_py_make_mod� s r[ r: c s e Zd Z� ��fdd�ZdS )z*_add_py_module.<locals>.build_ext_make_modc sb � j | � | jr^�jd�}dj|d d� �}| jd�}|j|�}|d d }�tjj||�� d S )Nr rX rU z.pyrY rY )rF Zinplacer r@ Zget_finalized_commandZget_package_dirr r )rG rZ �packagerU Z package_dir� file_name)� base_class_2rW r+ r r rF � s z._add_py_module.<locals>.build_ext_make_mod.runN)r rI rJ rF r )r^ rW r+ r r rK � s rK )rM r; Zsetuptools.command.build_pyrU rL r: rN r< rO r= rS rT Z py_modulesrR )r( r* r+ rU r: r[ rK r )rH r^ r* rW r< r; r+ r= r r& � s r& c C s8 |dks t �t|t�r |g}x|D ]}t| |� q"W d S )N� cffi_modules)�AssertionErrorr r r/ )r( �attr�valueZ cffi_moduler r r r_ � s r_ ) r r2 r � NameErrorr r r r/ r9 r' r& r_ r r r r �<module> s - .1PK %�\kRC3� 3� , __pycache__/vengine_cpy.cpython-36.opt-1.pycnu �[��� 3 M��Z�� � @ s@ d dl Z d dlZddlmZ ddlmZ G dd� de�ZdZdS )� N� )�model)�VerificationErrorc @ s e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zdnd d �Z dd� Z dd� Z dd� Z dodd�Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� ZeZeZeZeZeZd)d*� Z d+d,� Z d-d.� Z eZ d/d0� Z eZ!d1d2� Z"d3d4� Z#d5d6� Z$d7d8� Z%eZ&d9d:� Z'd;d<� Z(d=d>� Z)d?d@� Z*dAdB� Z+dCdD� Z,dEdF� Z-dGdH� Z.eZ/dIdJ� Z0dKdL� Z1dMdN� Z2dOdP� Z3dpdSdT�Z4dUdV� Z5dWdX� Z6eZ7eZ8eZ9dqdYdZ�Z:d[d\� Z;drd^d_�Z<eZ=eZ>d`da� Z?dbdc� Z@ddde� ZAeZBeZCeZDeZEdfdg� ZFdhdi� ZGeZHeZIdjdk� ZJdldm� ZKdS )s�VCPythonEngine�xTc C s || _ |j| _i | _i | _d S )N)�verifier�ffi� _struct_pending_verification�_types_of_builtin_functions)�selfr � r �#/usr/lib64/python3.6/vengine_cpy.py�__init__ s zVCPythonEngine.__init__c C s d S )Nr )r �kwdsr r r �patch_extension_kwds s z#VCPythonEngine.patch_extension_kwdsc C sP yt j||�\}}}W n tk r* d S X |d k r<|j� |d |krLd S |S )Nr )�imp� find_module� ImportError�close)r Z module_name�pathZ so_suffixes�f�filenameZdescrr r r r s zVCPythonEngine.find_modulec C s i | _ | jd� d S )NZ collecttype)� _typesdict� _generate)r r r r � collect_types$ s z VCPythonEngine.collect_types� c C s | j j|d � d S )N� )Z_f�write)r Zwhatr r r �_prnt( s zVCPythonEngine._prntc C s | j | S )N)r )r �typer r r � _gettypenum+ s zVCPythonEngine._gettypenumc C s: t |tj� s|jdkr6|| jkr6t| j�}|| j|< d S )Nz long double)� isinstancer � PrimitiveType�namer �len)r �tpZnumr r r �_do_collect_type/ s z VCPythonEngine._do_collect_typec C s� | j � ddg| _| j}|t� |� || jj� |� | jd� | j� |� |d� | jd� |d� |d� |d� |� | jj� }| jd }|d � |� |d � |d � |d | � |d � |d� |d� |d� |d� |� |d� |d| � |d� |d� |d� |d� |d� |d|f � |d� |d� |d� |d� |d � |� |d � |� |d� |d | � |d� |d� |d | � |d� |d � |d!|f � |d � |d"� |d � |� |d#� d S )$Nz ((void)lib,0)�declz&static PyMethodDef _cffi_methods[] = {�methodz3 {"_cffi_setup", _cffi_setup, METH_VARARGS, NULL},z) {NULL, NULL, 0, NULL} /* Sentinel */z};Fz#if PY_MAJOR_VERSION >= 3z.static struct PyModuleDef _cffi_module_def = {z PyModuleDef_HEAD_INIT,z "%s",z NULL,z -1,z _cffi_methods,z NULL, NULL, NULL, NULLZPyMODINIT_FUNCzPyInit_%s(void)�{z PyObject *lib;z+ lib = PyModule_Create(&_cffi_module_def);z if (lib == NULL)z return NULL;z# if (%s < 0 || _cffi_init() < 0) {z Py_DECREF(lib);z }z return lib;�}z#elsez init%s(void)z+ lib = Py_InitModule("%s", _cffi_methods);z return;z! if (%s < 0 || _cffi_init() < 0)z return;z#endif) r �_chained_list_constantsr �cffimod_headerr Zpreambler �_generate_setup_custom�get_module_name)r �prnt�modnameZ constantsr r r �write_source_to_f6 st z VCPythonEngine.write_source_to_fNc sv t j� z�ttd�r tj� }zvy6ttd�r<|d k r<tj|� t j�jj� �jj ��W n: t k r� } z d�jj |f }t |��W Y d d }~X nX W d ttd�r�tj|� X W d t j � X �j �d� tdd� �jj� D ����fdd�tt���D �}tt�jj|��}G � ��fdd �d t�� � � }�j|t |��rRd d l}|jd �jj� � �j �d |d � �j�_�j �_ |S )N�getdlopenflags�setdlopenflagszimporting %r: %sZloadingc S s g | ]\}}||f�qS r r )�.0�key�valuer r r � <listcomp>� s z/VCPythonEngine.load_library.<locals>.<listcomp>c s g | ] }� | �qS r r )r4 �i)� revmappingr r r7 � s c s& e Zd Z�Z�jZg Z� fdd�ZdS )z/VCPythonEngine.load_library.<locals>.FFILibraryc s � j t| j� S )N)� _cffi_dir�list�__dict__)r )� FFILibraryr r �__dir__� s z7VCPythonEngine.load_library.<locals>.FFILibrary.__dir__N)�__name__� __module__� __qualname__Z_cffi_python_moduler Z _cffi_ffir: r> r )r= �moduler r r r= � s r= r z0reimporting %r might overwrite older definitionsZloaded)�library) r � acquire_lock�hasattr�sysr2 r3 Z load_dynamicr r. Zmodulefilenamer r � release_lock�_load�dictr �items�ranger$ r; �mapr �_get_cached_btype�objectZ _cffi_setup�warnings�warnZ_cffi_original_ffir Z _cffi_types_of_builtin_funcs)r �flagsZprevious_flags�e�error�lstrC rO r )r= rB r9 r r � load_library� s< zVCPythonEngine.load_libraryc C s$ dd� | j jjj� D �}|j� |S )Nc S s g | ]\}\}}||f�qS r r )r4 r5 r% Zqualr r r r7 � s z4VCPythonEngine._get_declarations.<locals>.<listcomp>)r Z_parserZ _declarationsrJ �sort)r rT r r r �_get_declarations� s z VCPythonEngine._get_declarationsc C s� x�| j � D ]�\}}|jdd�\}}yt| d||f �}W n tk rX td| ��Y nX y|||� W q tk r� } ztj||� � W Y d d }~X q X q W d S )N� r z_generate_cpy_%s_%sz not implemented in verify(): %r)rW �split�getattr�AttributeErrorr � Exceptionr �attach_exception_info)r � step_namer# r% �kind�realnamer( rR r r r r � s zVCPythonEngine._generatec K s� x|| j � D ]p\}}|jdd�\}}t| d||f �}y||||f|� W q tk rx } ztj| |� � W Y d d } ~ X q X q W d S )NrX r z _%s_cpy_%s)rW rY rZ r\ r r] ) r rB r^ r r# r% r_ r` r( rR r r r rH � s zVCPythonEngine._loadc C s d S )Nr )r r% r# r r r �_generate_nothing� s z VCPythonEngine._generate_nothingc K s d S )Nr )r r% r# rB r r r r � _loaded_noop� s zVCPythonEngine._loaded_noopc C s* d}t |tj�rT|j� r2|jdkr2d}d|j }n d|jd�|jjdd�f }d}n�t |tj�rt| j||||� d S t |tj tj f�r�| j d || j |�|f � | j d | � d S t |tj �r�d |jd� }d | j |� }d }nt|��| j d||||f � | j d||jd�|f � | j d | � d S )Nr �_BoolZ_cffi_to_c_intz, %sz(%s)_cffi_to_c_%srX �_z-1z6 if (_cffi_to_c((char *)&%s, _cffi_type(%d), %s) < 0)z %s;z(%s)_cffi_to_c_pointerz, _cffi_type(%d)ZNULLz %s = %s(%s%s);z' if (%s == (%s)%s && PyErr_Occurred()))r! r r" �is_integer_typer# � get_c_name�replace� PointerType�"_convert_funcarg_to_c_ptr_or_array� StructOrUnion�EnumTyper r �FunctionPtrType�NotImplementedError)r r% �fromvar�tovar�errcodeZextraargZ converterZerrvaluer r r �_convert_funcarg_to_c� s4 z$VCPythonEngine._convert_funcarg_to_cc C s t |tj�r|jd� d S )NzPy_ssize_t datasize)r! r rh �add)r r% � localvarsr r r �_extra_local_variables s z%VCPythonEngine._extra_local_variablesc C s� | j d� | j d| j|�||f � | j d� | j d� | j d| � | j d|f � | j d|f � | j d|| j|�|f � | j d| � | j d � d S ) Nz1 datasize = _cffi_prepare_pointer_call_argument(z( _cffi_type(%d), %s, (char **)&%s);z if (datasize != 0) {z if (datasize < 0)z %s;z" %s = alloca((size_t)datasize);z, memset((void *)%s, 0, (size_t)datasize);zL if (_cffi_convert_array_from_object((char *)%s, _cffi_type(%d), %s) < 0)z })r r )r r% rn ro rp r r r ri s z1VCPythonEngine._convert_funcarg_to_c_ptr_or_arrayc C s t |tj�r`|j� r,|jdkr,d||jf S |jdkrLd|jjdd�|f S d|| j|�f S n�t |tjtjf�r�d|| j|�f S t |tj �r�d|| jtj|j ��f S t |tj �r�|j d kr�t d |j� |f ��d || j|�f S t |tj��rd|| j|�f S t|��d S ) Nrc z_cffi_from_c_int(%s, %s)z long doublez_cffi_from_c_%s(%s)rX rd z/_cffi_from_c_deref((char *)&%s, _cffi_type(%d))z0_cffi_from_c_pointer((char *)%s, _cffi_type(%d))z!'%s' is used as %s, but is opaquez0_cffi_from_c_struct((char *)&%s, _cffi_type(%d)))r! r r" re r# rg r rh rl � ArrayType�itemrj �fldnames� TypeError� _get_c_namerk rm )r r% �var�contextr r r �_convert_expr_from_c) s. z#VCPythonEngine._convert_expr_from_cc C s< |j r| j|� n&x|jD ]}| j|� qW | j|j� d S )N)�ellipsisr& �args�result)r r% r# r r r r �"_generate_cpy_function_collecttypeP s z1VCPythonEngine._generate_cpy_function_collecttypec C sp |j r| jd||� d S | j}t|j�}|dkr6d}n|dkrDd}nd}|d� |d||f � |d � d | }x.t|j�D ] \}}|d |jd | |� � q|W t� } x|jD ]}| j|| � q�W x| D ]} |d | f � q�W t |j t j ��sd } d| }|d |j jd|� � nd} t|j�dk�r�t t|j��} x| D ]}|d| � �q:W |� |dd| |djdd� | D ��f � |d� |� x6t|j�D ](\}}| j|d| d| d� |� �q�W |d� |d � |d | |djd d� t t|j��D ��f � |d � |d � |� |d!� |dk�r.|d"� | �rN|d#| j|j d$d%� � n|d&� |d'� |d(� |� d S ))NFr Znoargr Zarg0r~ zstatic PyObject *z(_cffi_f_%s(PyObject *self, PyObject *%s)r) zargument of %sz %s;z x%dz result = z result of %sz resultr z PyObject *arg%d;z+ if (!PyArg_ParseTuple(args, "%s:%s", %s))�Oz, c S s g | ] }d | �qS )z&arg%dr )r4 r8 r r r r7 � s z>VCPythonEngine._generate_cpy_function_decl.<locals>.<listcomp>z return NULL;zarg%dzx%dz return NULLz Py_BEGIN_ALLOW_THREADSz _cffi_restore_errno();z { %s%s(%s); }c S s g | ] }d | �qS )zx%dr )r4 r8 r r r r7 � s z _cffi_save_errno();z Py_END_ALLOW_THREADSz (void)self; /* unused */z (void)noarg; /* unused */z return %s;r z result typez Py_INCREF(Py_None);z return Py_None;r* )r} �_generate_cpy_constr r$ r~ � enumeraterf �setrt r! r r ZVoidTyperK �joinrq r| ) r r% r# r/ �numargsZargnamer{ r8 r rs r' Z result_code�rngr r r �_generate_cpy_function_decl[ sr " $ z*VCPythonEngine._generate_cpy_function_declc C sL |j r d S t|j�}|dkr"d}n|dkr0d}nd}| jd|||f � d S )Nr Z METH_NOARGSr ZMETH_OZ METH_VARARGSz {"%s", _cffi_f_%s, %s, NULL},)r} r$ r~ r )r r% r# r� �methr r r � _generate_cpy_function_method� s z,VCPythonEngine._generate_cpy_function_methodc C s. |j r d S t||�}t|||� || j|< d S )N)r} rZ �setattrr )r r% r# rB rC �funcr r r �_loaded_cpy_function� s z#VCPythonEngine._loaded_cpy_functionc C s | j |d|� d S )N�struct)� _generate_struct_or_union_decl)r r% r# r r r �_generate_cpy_struct_decl� s z(VCPythonEngine._generate_cpy_struct_declc C s | j |d|� d S )Nr� )� _generate_struct_or_union_method)r r% r# r r r �_generate_cpy_struct_method� s z*VCPythonEngine._generate_cpy_struct_methodc C s | j |d||� d S )Nr� )�_loading_struct_or_union)r r% r# rB r r r �_loading_cpy_struct� s z"VCPythonEngine._loading_cpy_structc K s | j |� d S )N)�_loaded_struct_or_union)r r% r# rB r r r r �_loaded_cpy_struct� s z!VCPythonEngine._loaded_cpy_structc C s | j |d|� d S )N�union)r� )r r% r# r r r �_generate_cpy_union_decl� s z'VCPythonEngine._generate_cpy_union_declc C s | j |d|� d S )Nr� )r� )r r% r# r r r �_generate_cpy_union_method� s z)VCPythonEngine._generate_cpy_union_methodc C s | j |d||� d S )Nr� )r� )r r% r# rB r r r �_loading_cpy_union� s z!VCPythonEngine._loading_cpy_unionc K s | j |� d S )N)r� )r r% r# rB r r r r �_loaded_cpy_union� s z VCPythonEngine._loaded_cpy_unionc C s |j d krd S d||f }d||f }d||f j� }| j}|d||f � |d� |d� |d� x�|j� D ]�\}} } } t| tj�r�| j� s�| dkr�|d | � qny$|d | jd d | | d �|f � W qn t k r� } z|dt | � � W Y d d } ~ X qnX qnW |d� |d� |d|f � |d� |d| � |d� |d| � |d� xt|j� D ]h\}} } } | dk�rr�qX|d||f � t| tj ��r�| j d k�r�|d| j � � n|d||f � �qXW |d� |d� |d� |d � |d � |d � |d |f � |d� |� d S ) Nz_cffi_check_%s_%sz_cffi_layout_%s_%sz%s %szstatic void %s(%s *p)r) z8 /* only to generate compile-time warnings or errors */z (void)p;r z (void)((p->%s) << 1);z { %s = &p->%s; (void)tmp; }z*tmpzfield %r)Zqualsz /* %s */r* zstatic PyObject *z#%s(PyObject *self, PyObject *noarg)z, struct _cffi_aligncheck { char x; %s y; };z static Py_ssize_t nums[] = {z sizeof(%s),z) offsetof(struct _cffi_aligncheck, y),z offsetof(%s, %s),z 0, /* %s */z sizeof(((%s *)0)->%s),z -1z };z (void)self; /* unused */z (void)noarg; /* unused */z' return _cffi_get_struct_layout(nums);z3 /* the next line is not executed, but compiled */z %s(0);)rw �stripr � enumfieldsr! r r" re rf r �strru �lengthry ) r r% �prefixr# Z checkfuncname�layoutfuncname�cnamer/ �fname�ftype�fbitsize�fqualrR r r r r� � sX & z-VCPythonEngine._generate_struct_or_union_declc C s0 |j d krd S d||f }| jd||f � d S )Nz_cffi_layout_%s_%sz {"%s", %s, METH_NOARGS, NULL},)rw r )r r% r� r# r� r r r r� s z/VCPythonEngine._generate_struct_or_union_methodc C s� |j d krd S d||f }t||�}|� }t|tj�r�|jr�|d }|d } |dd d� } |dd d� } |j� | | || f|_n d||f j� } || f| j |< d S )Nz_cffi_layout_%s_%sr r � � z%s %s) rw rZ r! r rj �partialZ force_flattenZ fixedlayoutr� r ) r r% r� r# rB r� Zfunction�layoutZ totalsizeZtotalalignmentZfieldofsZ fieldsizer� r r r r� s z'VCPythonEngine._loading_struct_or_unionc C s |j d krd S | jj|� || jk�rdd� }| j}|j|�}| jj|�\}}||d |j|�d� ||d |j|�d� d}x�|j� D ]v\}} } } | dkr�q�||| |j||�d|f � ||d dkr�|j| �} |||d |j| �d |f � |d7 }q�W d S ) Nc S s | |krt d||| f ��d S )Nz'%s (we have %d, but C compiler says %d))r )Z realvalueZ expectedvalue�msgr r r �check( s z5VCPythonEngine._loaded_struct_or_union.<locals>.checkr zwrong total sizer zwrong total alignmentr� zwrong offset for field %rzwrong size for field %r) rw r rM r �pop�sizeofZalignofr� Zoffsetof) r r% r� r ZBStructr� r� r8 r� r� r� r� ZBFieldr r r r� ! s, z&VCPythonEngine._loaded_struct_or_unionc C s. t |tj�r | j||d� n| j|d|� d S )Nr )r! r rk �_generate_cpy_enum_declr� )r r% r# r r r � _generate_cpy_anonymous_declE s z+VCPythonEngine._generate_cpy_anonymous_declc C s t |tj�s| j|d|� d S )Nr )r! r rk r� )r r% r# r r r � _generate_cpy_anonymous_methodK s z-VCPythonEngine._generate_cpy_anonymous_methodc C s0 t |tj�r | j|||� n| j|d||� d S )Nr )r! r rk �_loading_cpy_enumr� )r r% r# rB r r r �_loading_cpy_anonymousO s z%VCPythonEngine._loading_cpy_anonymousc K s. t |tj�r | j|||f|� n | j|� d S )N)r! r rk �_loaded_cpy_enumr� )r r% r# rB r r r r �_loaded_cpy_anonymousU s z$VCPythonEngine._loaded_cpy_anonymous�constFc C s` | j } d||f } | d| � | d� | d� | d� |sT| d|pD|jd|� � n |d k rh| j||� |s�|dkr~d | } n|} | d | f � | d | j|d d �f � n | d| � | d� | d� |�r | d� | d� | d|f � | d� | d� | d� | d� | d| � | d� | d� | d� | d| j| � | d | j|< | d � | � d S ) Nz _cffi_%s_%sz static int %s(PyObject *lib)r) z PyObject *o;z int res;z %s;z irz �&z i = (%s);z o = %s;r8 z variable typez! o = _cffi_from_c_int_const(%s);z if (o == NULL)z return -1;z {z PyObject *o1 = o;z8 o = Py_BuildValue("On", o1, (Py_ssize_t)sizeof(%s));z Py_DECREF(o1);z if (o == NULL)z return -1;z }z- res = PyObject_SetAttrString(lib, "%s", o);z Py_DECREF(o);z if (res < 0)z return %s;z(lib)r* )r rf �_check_int_constant_valuer| r+ ) r �is_intr# r% �category�vartp�delayed�size_too� check_valuer/ �funcnameZrealexprr r r r� ^ sL z"VCPythonEngine._generate_cpy_constc C s& t |tj�o|j� }|s"| j|� d S )N)r! r r" re r& )r r% r# r� r r r �"_generate_cpy_constant_collecttype� s z1VCPythonEngine._generate_cpy_constant_collecttypec C s& t |tj�o|j� }| j|||� d S )N)r! r r" re r� )r r% r# r� r r r �_generate_cpy_constant_decl� s z*VCPythonEngine._generate_cpy_constant_declc C s� | j }|dkr"|d|||f � n|d|||f � |d� |d| � |d| � |d� |d| � |d � |d � |d |||f � |d � |d � d S )Nr z& if ((%s) > 0 || (long)(%s) != %dL) {z1 if ((%s) <= 0 || (unsigned long)(%s) != %dUL) {z char buf[64];z if ((%s) <= 0)z. snprintf(buf, 63, "%%ld", (long)(%s));z elsez7 snprintf(buf, 63, "%%lu", (unsigned long)(%s));z) PyErr_Format(_cffi_VerificationError,z6 "%s%s has the real value %s, not %s",z( "%s", "%s", buf, "%d");z return -1;z })r )r r# r6 Z err_prefixr/ r r r r� � s$ z(VCPythonEngine._check_int_constant_valuec C s |j dd�}d||f S )N�$Z___D_z _cffi_e_%s_%s)rg )r r� r# r r r �_enum_funcname� s z VCPythonEngine._enum_funcname�enumc C s� |j r*x |jD ]}| jd|dd� qW d S | j||�}| j}|d| � |d� x,t|j|j�D ]\}}| j||d| � q`W |d| jd � |d | jd< |d � |� d S ) NTF)r� z static int %s(PyObject *lib)r) z enum %s: z return %s;z(lib)r* ) r� � enumeratorsr� r� r �zip� enumvaluesr� r+ )r r% r# r� � enumeratorr� r/ � enumvaluer r r r� � s z&VCPythonEngine._generate_cpy_enum_declc s. |j r*� fdd�|jD �}t|�|_d|_d S )Nc s g | ]}t � |��qS r )rZ )r4 r� )rB r r r7 � s z4VCPythonEngine._loading_cpy_enum.<locals>.<listcomp>T)r� r� �tupler� Zpartial_resolved)r r% r# rB r� r )rB r r� � s z VCPythonEngine._loading_cpy_enumc C s, x&t |j|j�D ]\}}t|||� qW d S )N)r� r� r� r� )r r% r# rB rC r� r� r r r r� � s z VCPythonEngine._loaded_cpy_enumc C s& |dkrd }n|}| j d||d� d S )Nz...T)r� )r� )r r% r# r� r r r �_generate_cpy_macro_decl� s z'VCPythonEngine._generate_cpy_macro_declc C s2 t |tj�rtj|j�}n tj|�}| j|� d S )N)r! r ru rh rv r& )r r% r# �tp_ptrr r r �"_generate_cpy_variable_collecttype� s z1VCPythonEngine._generate_cpy_variable_collecttypec C sT t |tj�r4tj|j�}| jd||||jdkd� n tj|�}| jd||dd� d S )NFz...)r� r� rz )r� )r! r ru rh rv r� r� )r r% r# r� r r r �_generate_cpy_variable_decl� s z*VCPythonEngine._generate_cpy_variable_declc s� t ||�}t|tj�r�|jdkrp|\}}| jj|j�}t|| jj |��\}} | dkrft d||jf ��|j |�}|jd k r�| jj|�} | jj | |�}t |||� d S |� t||� � fdd�} � fdd�} t t|�|t| | �� t|�jj|� d S )Nz...r z/bad size: %r does not seem to be an array of %sc s � d S )Nr r )rC )�ptrr r �getter s z3VCPythonEngine._loaded_cpy_variable.<locals>.getterc s |� d< d S )Nr r )rC r6 )r� r r �setter s z3VCPythonEngine._loaded_cpy_variable.<locals>.setter)rZ r! r ru r� r rM rv �divmodr� r Zresolve_length�castr� �delattrr �propertyr: �append) r r% r# rB rC r6 �sizeZ BItemTyper� �restZBArrayr� r� r )r� r �_loaded_cpy_variable� s, z#VCPythonEngine._loaded_cpy_variablec C s4 | j }|d� |d� |d| jd � |d� d S )Nz,static int _cffi_setup_custom(PyObject *lib)r) z return %s;Tr* )r r+ )r r/ r r r r- s z%VCPythonEngine._generate_setup_custom)r )N)Nr� NTFN)r )r� )Lr? r@ rA Z _class_keyZ_gen_python_moduler r r r r r r& r1 rU rW r rH ra rb rq rt ri r| Z!_generate_cpy_typedef_collecttypeZ_generate_cpy_typedef_declZ _generate_cpy_typedef_methodZ_loading_cpy_typedefZ_loaded_cpy_typedefr� r� r� Z_loading_cpy_functionr� Z _generate_cpy_struct_collecttyper� r� r� r� Z _generate_cpy_union_collecttyper� r� r� r� r� r� r� r� Z#_generate_cpy_anonymous_collecttyper� r� r� r� r� r� r� Z _generate_cpy_constant_methodZ_loading_cpy_constantZ_loaded_cpy_constantr� r� r� Z _generate_cpy_enum_collecttypeZ_generate_cpy_enum_methodr� r� r� Z _generate_cpy_macro_collecttypeZ_generate_cpy_macro_methodZ_loading_cpy_macroZ_loaded_cpy_macror� r� Z _generate_cpy_variable_methodZ_loading_cpy_variabler� r- r r r r r s� [ : $ I 3" . "r at# #include <Python.h> #include <stddef.h> /* this block of #ifs should be kept exactly identical between c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py and cffi/_cffi_include.h */ #if defined(_MSC_VER) # include <malloc.h> /* for alloca() */ # if _MSC_VER < 1600 /* MSVC < 2010 */ typedef __int8 int8_t; typedef __int16 int16_t; typedef __int32 int32_t; typedef __int64 int64_t; typedef unsigned __int8 uint8_t; typedef unsigned __int16 uint16_t; typedef unsigned __int32 uint32_t; typedef unsigned __int64 uint64_t; typedef __int8 int_least8_t; typedef __int16 int_least16_t; typedef __int32 int_least32_t; typedef __int64 int_least64_t; typedef unsigned __int8 uint_least8_t; typedef unsigned __int16 uint_least16_t; typedef unsigned __int32 uint_least32_t; typedef unsigned __int64 uint_least64_t; typedef __int8 int_fast8_t; typedef __int16 int_fast16_t; typedef __int32 int_fast32_t; typedef __int64 int_fast64_t; typedef unsigned __int8 uint_fast8_t; typedef unsigned __int16 uint_fast16_t; typedef unsigned __int32 uint_fast32_t; typedef unsigned __int64 uint_fast64_t; typedef __int64 intmax_t; typedef unsigned __int64 uintmax_t; # else # include <stdint.h> # endif # if _MSC_VER < 1800 /* MSVC < 2013 */ # ifndef __cplusplus typedef unsigned char _Bool; # endif # endif #else # include <stdint.h> # if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) # include <alloca.h> # endif #endif #if PY_MAJOR_VERSION < 3 # undef PyCapsule_CheckExact # undef PyCapsule_GetPointer # define PyCapsule_CheckExact(capsule) (PyCObject_Check(capsule)) # define PyCapsule_GetPointer(capsule, name) \ (PyCObject_AsVoidPtr(capsule)) #endif #if PY_MAJOR_VERSION >= 3 # define PyInt_FromLong PyLong_FromLong #endif #define _cffi_from_c_double PyFloat_FromDouble #define _cffi_from_c_float PyFloat_FromDouble #define _cffi_from_c_long PyInt_FromLong #define _cffi_from_c_ulong PyLong_FromUnsignedLong #define _cffi_from_c_longlong PyLong_FromLongLong #define _cffi_from_c_ulonglong PyLong_FromUnsignedLongLong #define _cffi_from_c__Bool PyBool_FromLong #define _cffi_to_c_double PyFloat_AsDouble #define _cffi_to_c_float PyFloat_AsDouble #define _cffi_from_c_int_const(x) \ (((x) > 0) ? \ ((unsigned long long)(x) <= (unsigned long long)LONG_MAX) ? \ PyInt_FromLong((long)(x)) : \ PyLong_FromUnsignedLongLong((unsigned long long)(x)) : \ ((long long)(x) >= (long long)LONG_MIN) ? \ PyInt_FromLong((long)(x)) : \ PyLong_FromLongLong((long long)(x))) #define _cffi_from_c_int(x, type) \ (((type)-1) > 0 ? /* unsigned */ \ (sizeof(type) < sizeof(long) ? \ PyInt_FromLong((long)x) : \ sizeof(type) == sizeof(long) ? \ PyLong_FromUnsignedLong((unsigned long)x) : \ PyLong_FromUnsignedLongLong((unsigned long long)x)) : \ (sizeof(type) <= sizeof(long) ? \ PyInt_FromLong((long)x) : \ PyLong_FromLongLong((long long)x))) #define _cffi_to_c_int(o, type) \ ((type)( \ sizeof(type) == 1 ? (((type)-1) > 0 ? (type)_cffi_to_c_u8(o) \ : (type)_cffi_to_c_i8(o)) : \ sizeof(type) == 2 ? (((type)-1) > 0 ? (type)_cffi_to_c_u16(o) \ : (type)_cffi_to_c_i16(o)) : \ sizeof(type) == 4 ? (((type)-1) > 0 ? (type)_cffi_to_c_u32(o) \ : (type)_cffi_to_c_i32(o)) : \ sizeof(type) == 8 ? (((type)-1) > 0 ? (type)_cffi_to_c_u64(o) \ : (type)_cffi_to_c_i64(o)) : \ (Py_FatalError("unsupported size for type " #type), (type)0))) #define _cffi_to_c_i8 \ ((int(*)(PyObject *))_cffi_exports[1]) #define _cffi_to_c_u8 \ ((int(*)(PyObject *))_cffi_exports[2]) #define _cffi_to_c_i16 \ ((int(*)(PyObject *))_cffi_exports[3]) #define _cffi_to_c_u16 \ ((int(*)(PyObject *))_cffi_exports[4]) #define _cffi_to_c_i32 \ ((int(*)(PyObject *))_cffi_exports[5]) #define _cffi_to_c_u32 \ ((unsigned int(*)(PyObject *))_cffi_exports[6]) #define _cffi_to_c_i64 \ ((long long(*)(PyObject *))_cffi_exports[7]) #define _cffi_to_c_u64 \ ((unsigned long long(*)(PyObject *))_cffi_exports[8]) #define _cffi_to_c_char \ ((int(*)(PyObject *))_cffi_exports[9]) #define _cffi_from_c_pointer \ ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[10]) #define _cffi_to_c_pointer \ ((char *(*)(PyObject *, CTypeDescrObject *))_cffi_exports[11]) #define _cffi_get_struct_layout \ ((PyObject *(*)(Py_ssize_t[]))_cffi_exports[12]) #define _cffi_restore_errno \ ((void(*)(void))_cffi_exports[13]) #define _cffi_save_errno \ ((void(*)(void))_cffi_exports[14]) #define _cffi_from_c_char \ ((PyObject *(*)(char))_cffi_exports[15]) #define _cffi_from_c_deref \ ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[16]) #define _cffi_to_c \ ((int(*)(char *, CTypeDescrObject *, PyObject *))_cffi_exports[17]) #define _cffi_from_c_struct \ ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[18]) #define _cffi_to_c_wchar_t \ ((wchar_t(*)(PyObject *))_cffi_exports[19]) #define _cffi_from_c_wchar_t \ ((PyObject *(*)(wchar_t))_cffi_exports[20]) #define _cffi_to_c_long_double \ ((long double(*)(PyObject *))_cffi_exports[21]) #define _cffi_to_c__Bool \ ((_Bool(*)(PyObject *))_cffi_exports[22]) #define _cffi_prepare_pointer_call_argument \ ((Py_ssize_t(*)(CTypeDescrObject *, PyObject *, char **))_cffi_exports[23]) #define _cffi_convert_array_from_object \ ((int(*)(char *, CTypeDescrObject *, PyObject *))_cffi_exports[24]) #define _CFFI_NUM_EXPORTS 25 typedef struct _ctypedescr CTypeDescrObject; static void *_cffi_exports[_CFFI_NUM_EXPORTS]; static PyObject *_cffi_types, *_cffi_VerificationError; static int _cffi_setup_custom(PyObject *lib); /* forward */ static PyObject *_cffi_setup(PyObject *self, PyObject *args) { PyObject *library; int was_alive = (_cffi_types != NULL); (void)self; /* unused */ if (!PyArg_ParseTuple(args, "OOO", &_cffi_types, &_cffi_VerificationError, &library)) return NULL; Py_INCREF(_cffi_types); Py_INCREF(_cffi_VerificationError); if (_cffi_setup_custom(library) < 0) return NULL; return PyBool_FromLong(was_alive); } static int _cffi_init(void) { PyObject *module, *c_api_object = NULL; module = PyImport_ImportModule("_cffi_backend"); if (module == NULL) goto failure; c_api_object = PyObject_GetAttrString(module, "_C_API"); if (c_api_object == NULL) goto failure; if (!PyCapsule_CheckExact(c_api_object)) { PyErr_SetNone(PyExc_ImportError); goto failure; } memcpy(_cffi_exports, PyCapsule_GetPointer(c_api_object, "cffi"), _CFFI_NUM_EXPORTS * sizeof(void *)); Py_DECREF(module); Py_DECREF(c_api_object); return 0; failure: Py_XDECREF(module); Py_XDECREF(c_api_object); return -1; } #define _cffi_type(num) ((CTypeDescrObject *)PyList_GET_ITEM(_cffi_types, num)) /**********/ ) rF r r r rS r rN r r, r r r r �<module> s uPK %�\]XAn n & __pycache__/ffiplatform.cpython-36.pycnu �[��� 3 M��Z� � @ s� d dl Z d dlZddlmZ dddddgZf fd d �Zdd d �Zdd d�Zyd dlm Z W n e k rv dd� Z Y nX dd� Z ye e fZd dlZW n ek r� e Zd dlZY nX dd� Zdd� Zdd� ZdS ) � N� )�VerificationError�sourcesZ include_dirsZ library_dirsZ extra_objectsZdependsc K sL t � ddlm} | g}x |D ]}|jtjj|�� q W |f ||d�|��S )Nr )� Extension)�namer )�_hack_at_distutils�distutils.corer �append�os�path�normpath)Z srcfilename�modnamer �kwdsr Z allsources�src� r �#/usr/lib64/python3.6/ffiplatform.py� get_extension s r c C sf t � tjj� }z t| |||�}tjj|�}W dx.|j� D ]"\}}tjj|�|kr:|tj|< q:W X |S )z-Compile a C extension module using distutils.N) r r �environ�copy�_buildr �abspath�items�get)�tmpdir�ext�compiler_verbose�debugZ saved_environZoutputfilename�key�valuer r r �compile s r c C s ddl m} dd l}dd l}|d|gi�}|j� |jd�}|d krLtjj}d|f|d< d |d< d| f|d < d| f|d < yR|j j d�p�d}z.|j j |� |j d� |j d�} | j� \} W d |j j |� X W nD |jj|jjfk �r } ztd | jj| f ��W Y d d } ~ X nX | S ) Nr )� DistributionZ ext_modulesZ build_ext� ffiplatformr T�forceZ build_libZ build_tempz%s: %s)r! T)r r Zdistutils.errorsZ distutils.logZparse_config_filesZget_option_dict�sys�flagsr �logZ set_thresholdZ set_verbosityZ run_commandZget_command_objZ get_outputs�errorsZ CompileErrorZ LinkErrorr � __class__�__name__) r r r r r Z distutilsZdistZoptionsZ old_levelZcmd_objZsoname�er r r r s. &r )�samefilec C s t jj| �t jj|�kS )N)r r r )�f1�f2r r r r* A s r* c C s� t jj| �s| S | }g }xn|}t jj|�\}}||ks<| r@| S |j|� y$t|t j�rl|j� t jj|� S W q t k r� Y qX qW d S )N) r r �isabs�splitr r* �curdir�reverse�join�OSError)r �dir�namesZprevdirr r r r �maybe_relative_pathD s r5 c C s� t | t�r"|jdt| �| f � n�t | t�rrt| j� �}|jdt|� � x�|D ] }t||� t| | |� qPW ndt | tt f�r�|jdt| � � xB| D ]}t||� q�W n*t | t �r�|jd| f � nt d| f ��d S )Nz%ds%sz%ddz%dlz%diz7the keywords to verify() contains unsupported object %r) � isinstance�str�write�len�dict�sorted�keys�_flatten�list�tuple� int_or_long� TypeError)�x�fr< r r r r r r= _ s r= c C s t j� }t| |� |j� S )N)� cStringIO�StringIOr= �getvalue)rB rC r r r �flattenr s rG c C s0 t jdkr,y dd l} W n tk r* Y nX d S )NZwin32r )r# �platform� setuptools� ImportError)rI r r r r w s r )r N)r N)r# r �errorr ZLIST_OF_FILE_NAMESr r r Zos.pathr* rJ r5 �intZlongr@ rD � NameError�ior= rG r r r r r �<module> s( PK %�\�Z�2� � $ __pycache__/api.cpython-36.opt-1.pycnu �[��� 3 '+e� � @ s� d dl Z d dlZddlmZ ddlmZ ddlmZ ye W n( e k rd d dl m Z dd� ZY nX ye W n e k r� e Z Y nX G d d � d e�Zd d � Zd d� Zdd� ZdS )� N� )� allocate_lock)� CDefError)�model)�Callablec C s t | t�S )N)� isinstancer )�x� r �/usr/lib64/python3.6/api.py�<lambda> s r c @ s� e Zd ZdZdfdd�Zdgdd�Zdhdd �Zdid d �Zdjd d�Zdd� Z dd� Z dkdd�Z dd� Z dd� Z dd� Zdd � Zdld d �Zdmd d!�Zd"d#� Zdod%d&�Zd'd(� Zdpd)d*�Zd+d,� Zdqd-d.�Zdrd0d1�Zdsd2d3�Zd4d5� Zdtd6d7�Zd8d9� Z d:d;� Z e e e dd<�Z dvd=d>�Z d?d@� Z!dAdB� Z"dCdD� Z#dEdF� Z$dGdH� Z%dIdJ� Z&dKdL� Z'dMdN� Z(dOdP� Z)dwdRdS�Z*dxdUdV�Z+dWdX� Z,dYdZ� Z-dyd\d]�Z.d^d_� Z/d`da� Z0dbdc� Z1ddde� Z2dS )z�FFIa� The main top-level class that you instantiate once, or once per module. Example usage: ffi = FFI() ffi.cdef(""" int printf(const char *, ...); """) C = ffi.dlopen(None) # standard library -or- C = ffi.verify() # use a C compiler: verify the decl above is right C.printf("hello, %s!\n", ffi.new("char[]", "world")) Nc C s� |dkr^ddl }ddlm} |j|kr^t|d�rJtd|t|j|jf ��ntd|t|jf ��ddlm} || _t� | _ |j � | _ i | _ t jd �j| _t jd �j| _g | _g | _g | _g | _d| _i | _d| _d| _tj|�| _ t|d �r�|j | � x2t |j�D ]$}|j d ��r t | |t!||�� �q W | j �" | j"tj#�| _$| j"tj%�| _&W dQ R X t'|t j��r�tt(d ��s�| j)| j$d�t(_*|j+� \t(_,t(_-n | j)| j$d�| _*|j+� \| _,| _-|j.| _.dS )z{Create an FFI instance. The 'backend' argument is used to select a non-default backend, mostly for tests. Nr r )� __version__�__file__z�Version mismatch: this is the 'cffi' package version %s, located in %r. When we import the top-level '_cffi_backend' extension module, we get version %s, located in %r. The two versions should be equal; check your installation.z�Version mismatch: this is the 'cffi' package version %s, located in %r. This interpreter comes with a built-in '_cffi_backend' module, which is version %s. The two versions should be equal; check your installation.)�cparserZ parsed_typesZ new_types�set_ffiZRTLD_�NULL)/Z _cffi_backend� r �hasattr� Exceptionr r �_backendr �_lockZParser�_parser�_cached_btypes�types� ModuleType�__dict__� _parsed_typesZ _new_types�_function_caches� _libraries� _cdefsources�_included_ffis�_windows_unicode�_init_once_cache� _cdef_version� _embeddingr Z get_typecacheZ _typecacher �list� startswith�setattr�getattr�_get_cached_btypeZ voidp_type�BVoidPZchar_array_type�BCharAr r �castr Z _get_types�CDataZCType�buffer)�self�backendr r �namer r r �__init__' sR z FFI.__init__Fc C s | j |||d� dS )a� Parse the given C source. This registers all declared functions, types, and global variables. The functions and global variables can then be accessed via either 'ffi.dlopen()' or 'ffi.verify()'. The types can be used in 'ffi.new()' and other functions. If 'packed' is specified as True, all structs declared inside this cdef are packed, i.e. laid out without any field alignment at all. )�override�packedN)�_cdef)r/ �csourcer3 r4 r r r �cdefc s zFFI.cdefc C s$ | j ||dd� | jd kr d| _d S )NT)r4 Z dllexportr )r5 r$ )r/ r6 r4 r r r � embedding_apim s zFFI.embedding_apic K s� t |t�s&t |t�s td��|jd�}| j�| t� | _| jj |fd|i|�� | j j |� |rvx| j D ] }|j � qfW | jj}|r�g | j_x|D ]}|j| |� q�W W d Q R X d S )Nz cdef() argument must be a string�asciir3 )r �str� basestring� TypeError�encoder �objectr# r �parser �appendr �clearZ _recomplete�finish_backend_type)r/ r6 r3 Zoptions�cache� finishlist�tpr r r r5 r s z FFI._cdefr c C s> | j �. t| ||�\}}| jj|� | jj|� W dQ R X |S )aH Load and return a dynamic library identified by 'name'. The standard C library can be loaded by passing None. Note that functions and types declared by 'ffi.cdef()' are not linked to a particular library, just like C headers; in the library we only look for the actual (untyped) symbols. N)r �_make_ffi_libraryr r@ r )r/ r1 �flags�libZfunction_cacher r r �dlopen� s z FFI.dlopenc C s t |�j|� dS )z�Close a library obtained with ffi.dlopen(). After this call, access to functions or variables from the library will fail (possibly with a segmentation fault). N)�type�__cffi_close__)r/ rH r r r �dlclose� s z FFI.dlclosec C sj |}|| j kr| j | S t|t�s,|jd�}| jj|�}|j}|rJ|j� }| j|�}||f}|| j |< |S )Nr9 ) r r r: r= r Z parse_typeZis_raw_functionZas_function_pointerr) )r/ �cdecl�keyrJ �really_a_function_type�btype�resultr r r �_typeof_locked� s zFFI._typeof_lockedc C sd y| j | }W n0 tk r> | j� | j|�}W d Q R X Y nX |\}}|r`| r`td|f ��|S )Nz>the type %r is a function type, not a pointer-to-function type)r �KeyErrorr rR r )r/ rM � consider_function_as_funcptrrQ rP rO r r r �_typeof� s z FFI._typeofc C s� t |t�r| j|�S t || j�r,| jj|�S t |tj�rLt|�}|dk rL|S t |tj �r|t |d�r|| j � | j |j �S Q R X tt|���dS )z�Parse the C type given as a string and return the corresponding <ctype> object. It can also be used on 'cdata' instance to get its C type. N�_cffi_base_type)r r; rU r- r �typeofr �BuiltinFunctionType�_builtin_function_type� FunctionTyper r r) rV r< rJ )r/ rM �resr r r rW � s z FFI.typeofc C s0 t |t�r | j|�}| jj|�S | jj|�S dS )zvReturn the size in bytes of the argument. It can be a string naming a C type, or a 'cdata' instance. N)r r; rU r �sizeof)r/ rM �BTyper r r r\ � s z FFI.sizeofc C s t |t�r| j|�}| jj|�S )z\Return the natural alignment size in bytes of the C type given as a string. )r r; rU r �alignof)r/ rM r r r r^ � s z FFI.alignofc G s( t |t�r| j|�}| j|f|�� d S )a3 Return the offset of the named field inside the given structure or array, which must be given as a C type name. You can give several field names in case of nested structures. You can also give numeric values which correspond to array items, in case of an array type. r )r r; rU � _typeoffsetof)r/ rM �fields_or_indexesr r r �offsetof� s z FFI.offsetofc C s" t |t�r| j|�}| jj||�S )a� Allocate an instance according to the specified C type and return a pointer to it. The specified C type must be either a pointer or an array: ``new('X *')`` allocates an X and returns a pointer to it, whereas ``new('X[n]')`` allocates an array of n X'es and returns an array referencing it (which works mostly like a pointer, like in C). You can also use ``new('X[]', n)`` to allocate an array of a non-constant length n. The memory is initialized following the rules of declaring a global variable in C: by default it is zero-initialized, but an explicit initializer can be given which can be used to fill all or part of the memory. When the returned <cdata> object goes out of scope, the memory is freed. In other words the returned <cdata> object has ownership of the value of type 'cdecl' that it points to. This means that the raw data can be used as long as this object is kept alive, but must not be used for a longer time. Be careful about that when copying the pointer to the memory somewhere else, e.g. into another structure. )r r; rU r Znewp)r/ rM �initr r r �new� s zFFI.newTc s, �j j� }|j|||�� d� �fdd� }|S )a� Return a new allocator, i.e. a function that behaves like ffi.new() but uses the provided low-level 'alloc' and 'free' functions. 'alloc' is called with the size as argument. If it returns NULL, a MemoryError is raised. 'free' is called with the result of 'alloc' as argument. Both can be either Python function or directly C functions. If 'free' is None, then no free function is called. If both 'alloc' and 'free' are None, the default is used. If 'should_clear_after_alloc' is set to False, then the memory returned by 'alloc' is assumed to be already cleared (or you are fine with garbage); otherwise CFFI will clear it. Nc s t | t�r�j| �} � | |�S )N)r r; rU )rM rb )� allocatorr/ r r �allocate s z#FFI.new_allocator.<locals>.allocate)N)r r � new_allocator)r/ ZallocZfreeZshould_clear_after_allocZ compiled_ffire r )rd r/ r rf s zFFI.new_allocatorc C s" t |t�r| j|�}| jj||�S )z�Similar to a C cast: returns an instance of the named C type initialized with the given 'source'. The source is casted between integers or pointers of any type. )r r; rU r r, )r/ rM �sourcer r r r, s zFFI.castr c C s | j j||�S )a� Return a Python string (or unicode string) from the 'cdata'. If 'cdata' is a pointer or array of characters or bytes, returns the null-terminated string. The returned string extends until the first null character, or at most 'maxlen' characters. If 'cdata' is an array then 'maxlen' defaults to its length. If 'cdata' is a pointer or array of wchar_t, returns a unicode string following the same rules. If 'cdata' is a single character or byte or a wchar_t, returns it as a string or unicode string. If 'cdata' is an enum, returns the value of the enumerator as a string, or 'NUMBER' if the value is out of range. )r �string)r/ �cdata�maxlenr r r rh % s z FFI.stringc C s | j j||�S )aL Unpack an array of C data of the given length, returning a Python string/unicode/list. If 'cdata' is a pointer to 'char', returns a byte string. It does not stop at the first null. This is equivalent to: ffi.buffer(cdata, length)[:] If 'cdata' is a pointer to 'wchar_t', returns a unicode string. 'length' is measured in wchar_t's; it is not the size in bytes. If 'cdata' is a pointer to anything else, returns a list of 'length' items. This is a faster equivalent to: [cdata[i] for i in range(length)] )r �unpack)r/ ri Zlengthr r r rk 7 s z FFI.unpackc C s | j j| j||�S )a� Return a <cdata 'char[]'> that points to the data of the given Python object, which must support the buffer interface. Note that this is not meant to be used on the built-in types str or unicode (you can build 'char[]' arrays explicitly) but only on objects containing large quantities of raw data in some other format, like 'array.array' or numpy arrays. )r � from_bufferr+ )r/ Z python_bufferZrequire_writabler r r rl U s zFFI.from_bufferc C s | j j|||�S )a_ ffi.memmove(dest, src, n) copies n bytes of memory from src to dest. Like the C function memmove(), the memory areas may overlap; apart from that it behaves like the C function memcpy(). 'src' can be any cdata ptr or array, or any Python buffer object. 'dest' can be any cdata ptr or array, or a writable Python buffer object. The size to copy, 'n', is always measured in bytes. Unlike other methods, this one supports all Python buffer including byte strings and bytearrays---but it still does not support non-contiguous buffers. )r �memmove)r/ �dest�src�nr r r rm ` s z FFI.memmovec sB � ���fdd�}t � t�r*�j� dd�� |dkr6|S ||�S dS )a� Return a callback object or a decorator making such a callback object. 'cdecl' must name a C function pointer type. The callback invokes the specified 'python_callable' (which may be provided either directly or via a decorator). Important: the callback object must be manually kept alive for as long as the callback may be invoked from the C level. c s" t | �std���jj� | ���S )Nz.the 'python_callable' argument is not callable)�callabler< r �callback)�python_callable)rM �error�onerrorr/ r r �callback_decorator_wrapx s z-FFI.callback.<locals>.callback_decorator_wrapT)rT N)r r; rU )r/ rM rs rt ru rv r )rM rt ru r/ r rr p s z FFI.callbackr c C sh t |t�r| j|�}|j� }|jd�rBd| jj|d�krBd| }n|rZ|d dkrZd| }| jj||�S )a. Return a string giving the C type 'cdecl', which may be itself a string or a <ctype> object. If 'replace_with' is given, it gives extra text to append (or insert for more complicated C types), like a variable name, or '*' to get actually the C type 'pointer-to-cdecl'. �*z&[�&z(%s)r z[(� )r r; rU �stripr& r Zgetcname)r/ rM Z replace_withr r r �getctype� s z FFI.getctypec C s | j j|||�S )a� Return a new cdata object that points to the same data. Later, when this new cdata object is garbage-collected, 'destructor(old_cdata_object)' will be called. The optional 'size' gives an estimate of the size, used to trigger the garbage collection more eagerly. So far only used on PyPy. It tells the GC that the returned object keeps alive roughly 'size' bytes of external memory. )r Zgcp)r/ ri Z destructor�sizer r r �gc� s zFFI.gcc C sR y| j | }W n> tk rL g }|j| |�}x|D ]}|j| |� q4W Y nX |S )N)r rS Zget_cached_btyperB )r/ rJ r] rD r r r r) � s zFFI._get_cached_btypec K sV ddl m}m} | jr | j|� |p(|� }|| ||f|�| _ | j j� }| jj|� |S )a� Verify that the current ffi signatures compile on this machine, and return a dynamic library object. The dynamic library can be used to call functions and access global variables declared in this 'ffi'. The library is compiled by the C compiler: it gives you C-level API compatibility (including calling macros). This is unlike 'ffi.dlopen()', which requires binary compatibility in the signatures. r )�Verifier�_caller_dir_pycache)�verifierr~ r r! �_apply_windows_unicode� load_libraryr r@ )r/ rg �tmpdir�kwargsr~ r rH r r r �verify� s z FFI.verifyc C s | j j� S )N)r Z get_errno)r/ r r r � _get_errno� s zFFI._get_errnoc C s | j j|� d S )N)r Z set_errno)r/ �errnor r r � _set_errno� s zFFI._set_errnoz(the value of 'errno' from/to the C callsc C s | j j|�S )N)r � getwinerror)r/ �coder r r r� � s zFFI.getwinerrorc C s | j � tj| |�S Q R X d S )N)r r � pointer_cache)r/ �ctyper r r � _pointer_to� s zFFI._pointer_toc G s� y| j j|�}W n8 tk rH dt|�jkrBt|�j|f|�� S � Y nX |rd| j|f|�� \}}n|jdkrvtd��d}| j|�}| j j |||�S )z�Return the address of a <cdata 'struct-or-union'>. If 'fields_or_indexes' are given, returns the address of that field or array item in the structure or array, recursively in case of nested structures. � __addressof__Zpointerzaddressof(pointer)r ) r rW r< rJ r r� r_ �kindr� Z rawaddressof)r/ ri r` r� �offsetZctypeptrr r r � addressof� s z FFI.addressofc G sD | j j||�\}}x(|D ] }| j j||d�\}}||7 }qW ||fS )Nr )r Z typeoffsetof)r/ r� Zfield_or_indexr` r� Zfield1Zoffset1r r r r_ � s zFFI._typeoffsetofc C s� t |t�s tdt|�jf ��|| kr.td��|j�X | j�F | jj|j� | j j d� | j j |j � | j j d� | j j |� W dQ R X W dQ R X dS )a� Includes the typedefs, structs, unions and enums defined in another FFI instance. Usage is similar to a #include in C, where a part of the program might include types defined in another part for its own usage. Note that the include() method has no effect on functions, constants and global variables, which must anyway be accessed directly from the lib object returned by the original FFI instance. zGffi.include() expects an argument that is also of type cffi.FFI, not %rzself.include(self)�[�]N) r r r< rJ �__name__� ValueErrorr r �includer r@ �extendr )r/ Zffi_to_includer r r r� � s z FFI.includec C s | j j| j|�S )N)r Z newp_handler* )r/ r r r r � new_handle s zFFI.new_handlec C s | j j|�S )N)r � from_handle)r/ r r r r r� s zFFI.from_handlec C s> | j dk rtd��t|�}|r*| jd� n | jd� || _ dS )ac Windows: if 'enabled_flag' is True, enable the UNICODE and _UNICODE defines in C, and declare the types like TCHAR and LPTCSTR to be (pointers to) wchar_t. If 'enabled_flag' is False, declare these types to be (pointers to) plain 8-bit characters. This is mostly for backward compatibility; you usually want True. Nz%set_unicode() can only be called oncez�typedef wchar_t TBYTE;typedef wchar_t TCHAR;typedef const wchar_t *LPCTSTR;typedef const wchar_t *PCTSTR;typedef wchar_t *LPTSTR;typedef wchar_t *PTSTR;typedef TBYTE *PTBYTE;typedef TCHAR *PTCHAR;z�typedef char TBYTE;typedef char TCHAR;typedef const char *LPCTSTR;typedef const char *PCTSTR;typedef char *LPTSTR;typedef char *PTSTR;typedef TBYTE *PTBYTE;typedef TCHAR *PTCHAR;)r! r� �boolr7 )r/ Z enabled_flagr r r � set_unicode s zFFI.set_unicodec C s> |j df �}t|ttf�s"td��t|�ddg }||d< d S )NZ define_macrosz''define_macros' must be a list or tuple�UNICODE�1�_UNICODE)r� r� )r� r� )�getr r% �tupler< )r/ �kwdsZ defmacrosr r r r� 0 s zFFI._apply_windows_unicodec sj � fdd�}dt jkr�dd l}t jdkrNd}tt d�r�|d|jjt jd �� n4t jd k r^d }nd }tt d�r�|d|jjt jd �� tt d�r�|d|jjt jdd�� n�t jdkr�d}tt d�r�|d7 }nLy dd l }W n t k r� ddl m } Y nX d}|j d��r||j d�7 }|t j d? t j d? d@ f }tt d��rF|t j7 }|d|� t jdk�rf|dd � d S ) Nc s" � j | g �}||kr |j|� d S )N)� setdefaultr@ )rN �valueZlst)r� r r �ensure: s z(FFI._apply_embedding_fix.<locals>.ensureZ__pypy__r �win32Zpython27�prefixZ library_dirsZlibs� zpypy-czpypy3-c�binZpypyZgoalz python%d%d�gettotalrefcountZ_d)� sysconfigz python%d.%dZ DEBUG_EXT� � � �abiflagsZ librariesZextra_link_argsz /MANIFEST)r� )�sys�builtin_module_names�os�platformr �path�joinr� � version_infor� � ImportErrorZ distutils�get_config_var� hexversionr� )r/ r� r� r� Z pythonlib�templater� r )r� r �_apply_embedding_fix8 s@ zFFI._apply_embedding_fix�.cc K sd dd l }t| d�rtd��t|t�s,td��|j|ksF|jrN|j|krNtd��t|�|||f| _ d S )Nr �_assigned_sourcez:set_source() cannot be called several times per ffi objectz 'module_name' must be a stringzY'module_name' must not contain '/': use a dotted name to make a 'package.module' location) r� r r� r r; r< �sep�altsepr: r� )r/ � module_namerg �source_extensionr� r� r r r � set_sourcej s zFFI.set_source�buildc C s� ddl m} ddlm} t| d�s>t| d�r6| jj� S td��| j\}}}}|d kr\t d��||� || ||f|||d d �|��\} } |r�| r�t j j d | j d f � nt j j d | j d f � | S ) Nr )�mkpathr )� recompiler� r� z8set_source() must be called before distutils_extension()zadistutils_extension() is only for C extension modules, not for dlopen()-style pure Python modulesF)r� Zextradirr� �call_c_compilerzregenerated: %r znot modified: %r )Zdistutils.dir_utilr� � recompilerr� r r� Z get_extensionr� r� r< r� �stderr�writeZsources) r/ r� �verboser� r� r� rg r� r� Zext�updatedr r r �distutils_extensionw s& zFFI.distutils_extensionc C sZ ddl m} t| d�s td��| j\}}}}|d kr<td��|| ||f|dd�|�� d S )Nr )r� r� z0set_source() must be called before emit_c_code()zYemit_c_code() is only for C extension modules, not for dlopen()-style pure Python modulesF)�c_filer� )r� r� r r� r� r< )r/ �filenamer� r� rg r� r� r r r � emit_c_code� s zFFI.emit_c_codec C sZ ddl m} t| d�s td��| j\}}}}|d k r<td��|| ||f|dd�|�� d S )Nr )r� r� z0set_source() must be called before emit_c_code()z^emit_python_code() is only for dlopen()-style pure Python modules, not for C extension modulesF)r� r� )r� r� r r� r� r< )r/ r� r� r� rg r� r� r r r �emit_python_code� s zFFI.emit_python_code�.c C sL ddl m} t| d�s td��| j\}}}} || ||f|||||d�| ��S )a� The 'target' argument gives the final file name of the compiled DLL. Use '*' to force distutils' choice, suitable for regular CPython C API modules. Use a file name ending in '.*' to ask for the system's default extension for dynamic libraries (.so/.dll/.dylib). The default is '*' when building a non-embedded C API extension, and (module_name + '.*') when building an embedded library. r )r� r� z,set_source() must be called before compile())r� �targetr� Zcompiler_verbose�debug)r� r� r r� r� ) r/ r� r� r� r� r� r� rg r� r� r r r �compile� s z FFI.compilec C s� y| j | }W n( tk r6 | j j|dt� f�}Y nX |d rH|d S |d �4 | j | }|d rl|d S |� }d|f| j |< W d Q R X |S )NFr r T)r" rS r� r )r/ �func�tagr rQ r r r � init_once� s z FFI.init_oncec s� | j rtd��dd l}|jd|�}|r6||j� d � }|j� pBdg}|jd|d �j� }xBtdt|��D ]0� |� }|j � rhx|j |�s�|d d � }q~W qhW t|�� � fdd�|D �}dj |�}t |d d � || _ d S ) Nz-embedding_init_code() can only be called oncer z\s*\nr z\s*r c s g | ]}|� d � d �qS )N� r )�.0�line)�ir r � <listcomp>� s z+FFI.embedding_init_code.<locals>.<listcomp>Z cffi_init�exec���) r$ r� �re�match�end� splitlines�group�range�len�rstripr& r� r� )r/ Zpysourcer� r� �linesr� r� r )r� r �embedding_init_code� s$ zFFI.embedding_init_codec O s t d��d S )Nz:ffi.def_extern() is only available on API-mode FFI objects)r� )r/ �argsr� r r r � def_extern� s zFFI.def_externc C s� g }g }g }xh| j jD ]\}|jd�r8|j|dd� � q|jd�rV|j|dd� � q|jd�r|j|dd� � qW |j� |j� |j� |||fS )z�Returns the user type names known to this FFI instance. This returns a tuple containing three lists of names: (typedef_names, names_of_structs, names_of_unions) ztypedef � Nzstruct � zunion � )r � _declarationsr& r@ �sort)r/ ZtypedefsZstructsZunionsrN r r r � list_types� s zFFI.list_types)N)FF)F)F)r )F)N)NNTr� )r� )F)NNN)r )r )r Nr� )r� )r� )r� T)r� r NN)3r� � __module__� __qualname__�__doc__r2 r7 r8 r5 rI rL rR rU rW r\ r^ ra rc rf r, rh rk rl rm rr r{ r} r) r� r� r� �propertyr� r� r� r� r_ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r sb < 2 r c C s� dd l }|d kr*tjdkr&| jd |�S d}d }d|ksHd|ksH|j|kr|y | j||�S tk rz } z |}W Y d d }~X nX dd l}|jj|�}|d kr�|dkr�tjdkr�tj d kr�td��d|f }|d k r�d ||f }t|��| j||�S ) Nr r� �cr� �/r� zXdlopen(None) cannot work on Windows for Python 3 (see http://bugs.python.org/issue23606)zGctypes.util.find_library() did not manage to locate a library called %rz%s. Additionally, %s)r� ) r� r� r� r� r� �OSErrorZ ctypes.util�utilZ find_libraryr� ) r0 r1 rG r� Z first_error�eZctypesr� �msgr r r �_load_backend_lib s, r� c s � j }t|||�� � � � fdd��� � � fdd���� � fdd��dd� �� � fd d ��i �d g�i �������� � fd d �� � �� � � fdd�� G � ��� � � � � fdd�dt�� |d k r�y"t|t�s�|jd�}d| � _W n tk r� Y nX � � � � � jfS )Nc s< d| }�j j| \}}�j|�}� j|| �}|�j| < d S )Nz function )r r� r) � load_functionr )r1 rN rE �_r] r� )� backendlib�ffi�libraryr r �accessor_function% s z,_make_ffi_library.<locals>.accessor_functionc s\ d� }�j j| \}}�j|�� �j��j�t��t� ��fdd�� ��fdd��� d S )Nz variable c s �� ��S )Nr )r/ )r] r1 � read_variabler r r 3 s z>_make_ffi_library.<locals>.accessor_variable.<locals>.<lambda>c s �� �|�S )Nr )r/ r� )r] r1 �write_variabler r r 4 s )r r� r) r r r' r� )r1 rN rE r� )� FFILibraryr� r� )r] r1 r r r �accessor_variable, s z,_make_ffi_library.<locals>.accessor_variablec s� y� | S t k r� �j�Z | � krtd| }�jj| \}}�j|�}|jdkr`tj�|�}�j|| �}|� | < W d Q R X � | S X d S )Nz variable Zarray) rS r r r� r) r� r r� r� )r1 rN rE r� r] �p)�addr_variablesr� r� r r � addressof_var6 s z(_make_ffi_library.<locals>.addressof_varc S s t d| f ��d S )NzDnon-integer constant '%s' cannot be accessed from a dlopen() library)�NotImplementedError)r1 r r r �accessor_constantE s z,_make_ffi_library.<locals>.accessor_constantc s � j j| �j| < d S )N)r �_int_constantsr )r1 )r� r� r r �accessor_int_constantI s z0_make_ffi_library.<locals>.accessor_int_constantFc s� �d �j krd S x��jjj� D ]�\} \}}t|tj�s~| jdd�\}}|dkrZ��|< q�|dkrl��|< q�|dkr�� �|< q x0t|j �D ]"\}}||f�fdd� }|�|< q�W q W x �jj D ]}�j |�� q�W �j �d< d S ) Nr ry r ZfunctionZvariableZconstantc s |j � |j| � j| < d S )N)Zcheck_not_partialZ enumvaluesr )r1 rE r� )r� r r � accessor_enum_ s zB_make_ffi_library.<locals>.update_accessors.<locals>.accessor_enum) r# r r� �itemsr r ZEnumType�split� enumerateZ enumeratorsr r� )rN rE r� r� r1 r� Zenumnamer )r r r r � accessors�accessors_versionr� r� r r �update_accessorsP s" z+_make_ffi_library.<locals>.update_accessorsc sX �j �H | �jks | � jkr d S | �kr>�� | �kr>t| ���| | � W d Q R X d S )N)r r �AttributeError)r1 )r r r� r� r r r � make_accessorg s z(_make_ffi_library.<locals>.make_accessorc sR e Zd Z�fdd�Z�fdd�Z���fdd�Z� ���fdd�Z�fd d �Zd S ) z%_make_ffi_library.<locals>.FFILibraryc s � |� t | |�S )N)r( )r/ r1 )r r r � __getattr__r s z1_make_ffi_library.<locals>.FFILibrary.__getattr__c sJ yt | j|�}W n( tk r8 � |� t| ||� Y nX |j| |� d S )N)r( � __class__r r' �__set__)r/ r1 r� r� )r r r � __setattr__u s z1_make_ffi_library.<locals>.FFILibrary.__setattr__c s �j � �� � j� S Q R X d S )N)r �keys)r/ )r r� r r r �__dir__} s z-_make_ffi_library.<locals>.FFILibrary.__dir__c sf |�j kr�j | S |� j kr&�|�S �|� |�j krB�j | S |� j krT�|�S td|f ��d S )Nz:cffi library has no function or global variable named '%s')r r )r/ r1 )r r r� r r r r� � s z3_make_ffi_library.<locals>.FFILibrary.__addressof__c s � j � | jj� d S )N)Z close_libr rA )r/ )r� r r rK � s z4_make_ffi_library.<locals>.FFILibrary.__cffi_close__N)r� r� r� r r r r� rK r )r r r r� r� r� r r r r r q s r zutf-8z FFILibrary_%s) r r� r> r r: r= r� � UnicodeErrorr )r� ZlibnamerG r0 r )r r r r r r r r r r� r� r� r r r rF ! s, " rF c C sd dd l }y$|j| j }|j}|j}|| }W n tttfk rF d S X |j� |j |�S Q R X d S )Nr ) r� �modulesr� Z_cffi_original_ffiZ _cffi_types_of_builtin_funcsrS r r< r r) )r� r� �moduler� Ztypes_of_builtin_funcsrE r r r rY � s rY )r� r �lockr rt r r r rq � NameError� collectionsr r; r: r> r r� rF rY r r r r �<module> s* wzPK %�\�H��L L __pycache__/model.cpython-36.pycnu �[��� 3 M��Z0T � @ s� d dl Z d dlZddlmZ ddlmZmZmZ dZdZ dZ dd� Z G d d � d e �Z G d d � d e �ZG d d� de�Ze� ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd � d e�ZG d d � d e�Zee�Zd d � Zee�ZG d!d"� d"e�Z G d#d$� d$e�Z e ed%�d�Z G d&d'� d'e �Z G d(d)� d)e �Z G d*d+� d+e �Z!G d,d-� d-e �Z"G d.d/� d/e �Z#d<d0d1�Z$d=d2d3�Z%e� Z&ej'� Z(d4d5� Z)d6d7� Z*d8d9� Z+d:d;� Z,dS )>� N� )� allocate_lock)� CDefError�VerificationError�VerificationMissing� � c C s@ | t @ rd|j� }| t@ r(d|j� }| t@ r<d|j� }|S )Nz const z volatile z __restrict )�Q_CONST�lstrip� Q_VOLATILE� Q_RESTRICT)�quals� replace_with� r � /usr/lib64/python3.6/model.py�qualify s r c @ sP e Zd ZdZdZddd�Zdd� Zd d � Zd d � Zdd d�Z dd� Z dd� Z dS )�BaseTypeByIdentityF� �a C filer c C s� | j }|jd�dkst�|j� }|rT|jd�r@d|kr@d| }n|d dkrTd| }t||�}|jd|�}d |kr�td | j� |f ��|S ) N�&r �*z&[z(%s)r z[(� �$z-cannot generate '%s' in %s: unknown type name) �c_name_with_marker�count�AssertionError�strip� startswithr �replacer � _get_c_name)�selfr �contextr �resultr r r � get_c_name s z BaseTypeByIdentity.get_c_namec C s | j jdd�S )Nr r )r r )r r r r r / s z BaseTypeByIdentity._get_c_namec C s d| j � kS )Nr )r )r r r r � has_c_name2 s z BaseTypeByIdentity.has_c_namec C s dS )NFr )r r r r �is_integer_type5 s z"BaseTypeByIdentity.is_integer_typec C sN y|j | }W n: tk rH | j||�}|j j| |�}||ksDt�Y nX |S )N)�_cached_btypes�KeyError�build_backend_type� setdefaultr )r �ffi� finishlist� can_delay�BTypeZBType2r r r �get_cached_btype8 s z#BaseTypeByIdentity.get_cached_btypec C s d| j � f S )Nz<%s>)r )r r r r �__repr__A s zBaseTypeByIdentity.__repr__c s � fdd�� j D �S )Nc s g | ]}|t � |�f�qS r )�getattr)�.0�name)r r r � <listcomp>E s z1BaseTypeByIdentity._get_items.<locals>.<listcomp>)�_attrs_)r r )r r � _get_itemsD s z BaseTypeByIdentity._get_itemsN)r r r )F) �__name__� __module__� __qualname__� is_array_type�is_raw_functionr# r r$ r% r. r/ r5 r r r r r s r c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�BaseTypec C s | j |j ko| j� |j� kS )N)� __class__r5 )r �otherr r r �__eq__J s zBaseType.__eq__c C s | |k S )Nr )r r= r r r �__ne__N s zBaseType.__ne__c C s t | jt| j� �f�S )N)�hashr< �tupler5 )r r r r �__hash__Q s zBaseType.__hash__N)r6 r7 r8 r> r? rB r r r r r; H s r; c @ s e Zd Zf Zdd� Zdd� ZdS )�VoidTypec C s d| _ d S )Nzvoid&)r )r r r r �__init__X s zVoidType.__init__c C s t | |d�S )NZ new_void_type)� global_cache)r r* r+ r r r r( [ s zVoidType.build_backend_typeN)r6 r7 r8 r4 rD r( r r r r rC U s rC c @ s e Zd Zdd� ZdS )�BasePrimitiveTypec C s dS )NFr )r r r r �is_complex_typeb s z!BasePrimitiveType.is_complex_typeN)r6 r7 r8 rG r r r r rF a s rF c 4 @ s� e Zd ZdZdddddddddddddddddddddddddddddddddddddddddddddddddddd�3Zdd� Zd d � Zd d � Zd d� Zdd� Z dd� Z dS )� PrimitiveTyper2 �c�i�f�j)3�charZshort�int�longz long longz signed charz unsigned charzunsigned shortz unsigned intz unsigned longzunsigned long long�floatZdoublez long doublezfloat _Complexzdouble _ComplexZ_BoolZwchar_tZchar16_tZchar32_tZint8_tZuint8_tZint16_tZuint16_tZint32_tZuint32_tZint64_tZuint64_tZ int_least8_tZ uint_least8_tZ int_least16_tZuint_least16_tZ int_least32_tZuint_least32_tZ int_least64_tZuint_least64_tZ int_fast8_tZ uint_fast8_tZ int_fast16_tZ uint_fast16_tZ int_fast32_tZ uint_fast32_tZ int_fast64_tZ uint_fast64_tZintptr_tZ uintptr_tZintmax_tZ uintmax_tZ ptrdiff_tZsize_tZssize_tc C s" || j kst�|| _|d | _d S )Nr )�ALL_PRIMITIVE_TYPESr r2 r )r r2 r r r rD � s zPrimitiveType.__init__c C s | j | j dkS )NrI )rQ r2 )r r r r � is_char_type� s zPrimitiveType.is_char_typec C s | j | j dkS )NrJ )rQ r2 )r r r r r% � s z PrimitiveType.is_integer_typec C s | j | j dkS )NrK )rQ r2 )r r r r � is_float_type� s zPrimitiveType.is_float_typec C s | j | j dkS )NrL )rQ r2 )r r r r rG � s z PrimitiveType.is_complex_typec C s t | |d| j�S )NZnew_primitive_type)rE r2 )r r* r+ r r r r( � s z PrimitiveType.build_backend_typeN)r2 ) r6 r7 r8 r4 rQ rD rR r% rS rG r( r r r r rH f st rH c @ s( e Zd Zd Zdd� Zdd� Zdd� ZdS ) �UnknownIntegerTyper2 c C s || _ |d | _d S )Nr )r2 r )r r2 r r r rD � s zUnknownIntegerType.__init__c C s dS )NTr )r r r r r% � s z"UnknownIntegerType.is_integer_typec C s t d| j ��d S )Nz4integer type '%s' can only be used after compilation)�NotImplementedErrorr2 )r r* r+ r r r r( � s z%UnknownIntegerType.build_backend_typeN)r2 )r6 r7 r8 r4 rD r% r( r r r r rT � s rT c @ s e Zd ZdZdd� Zdd� ZdS )�UnknownFloatTyper2 c C s || _ |d | _d S )Nr )r2 r )r r2 r r r rD � s zUnknownFloatType.__init__c C s t d| j ��d S )Nz2float type '%s' can only be used after compilation)rU r2 )r r* r+ r r r r( � s z#UnknownFloatType.build_backend_typeN)r2 )r6 r7 r8 r4 rD r( r r r r rV � s rV c @ s e Zd ZdZd dd�ZdS ) �BaseFunctionType�argsr" �ellipsis�abiNc C s� || _ || _|| _|| _dd� | j D �}| jr8|jd� |p@dg}| jdj|�f }|d k r||d d� | d |dd � }| jjjd|�| _d S ) Nc S s g | ] }|j � �qS r )r )r1 �argr r r r3 � s z-BaseFunctionType.__init__.<locals>.<listcomp>z...�voidz, r r r ) rX r" rY rZ �append� _base_pattern�joinr r )r rX r" rY rZ Zreprargsr r r r rD � s zBaseFunctionType.__init__)rX r" rY rZ )N)r6 r7 r8 r4 rD r r r r rW � s rW c @ s$ e Zd ZdZdZdd� Zdd� ZdS )�RawFunctionTypez(&)(%s)Tc C s t d| f ��d S )NzPcannot render the type %r: it is a function type, not a pointer-to-function type)r )r r* r+ r r r r( � s z"RawFunctionType.build_backend_typec C s t | j| j| j| j�S )N)�FunctionPtrTyperX r" rY rZ )r r r r �as_function_pointer� s z#RawFunctionType.as_function_pointerN)r6 r7 r8 r^ r: r( rb r r r r r` � s r` c @ s e Zd ZdZdd� Zdd� ZdS )ra z(*&)(%s)c C s� | j j||�}g }x | jD ]}|j|j||�� qW f }| jdkrl| jsly|jjf}W n tk rj Y nX t | |dt |�|| jf|�� S )NZ __stdcallZnew_function_type) r" r. rX r] rZ rY �_backendZ FFI_STDCALL�AttributeErrorrE rA )r r* r+ r" rX �tpZabi_argsr r r r( � s z"FunctionPtrType.build_backend_typec C s t | j| j| j| j�S )N)r` rX r" rY rZ )r r r r �as_raw_function s z FunctionPtrType.as_raw_functionN)r6 r7 r8 r^ r( rf r r r r ra � s ra c @ s" e Zd Zd Zd dd�Zdd� ZdS ) � PointerType�totyper r c C s> || _ || _t|d�}|jr*d|j� f }|jjd|�| _d S )Nz *&z(%s)r )rh r r r9 r r r )r rh r Zextrar r r rD s zPointerType.__init__c C s | j j||dd�}t| |d|�S )NT)r, �new_pointer_type)rh r. rE )r r* r+ ZBItemr r r r( s z PointerType.build_backend_typeN)rh r )r )r6 r7 r8 r4 rD r( r r r r rg s rg c C s t | t�S )N)rg r )rh r r r �ConstPointerType s rj c @ s e Zd ZdZddd�ZdS ) �NamedPointerTyperh r2 r c C s" t j| ||� || _|d | _d S )Nr )rg rD r2 r )r rh r2 r r r r rD s zNamedPointerType.__init__N)rh r2 )r )r6 r7 r8 r4 rD r r r r rk s rk c @ s, e Zd Zd ZdZdd� Zdd� Zdd � Zd S ) � ArrayType�item�lengthTc C sF || _ || _|d krd}n|dkr(d}nd| }| j jjd|�| _d S )Nz&[]z...z &[/*...*/]z&[%s]r )rm rn r r )r rm rn Zbracketsr r r rD ) s zArrayType.__init__c C s t | j|�S )N)rl rm )r Z newlengthr r r �resolve_length6 s zArrayType.resolve_lengthc C sJ | j dkrtd| f ��| jj||� t| j�j||�}t| |d|| j �S )Nz...z)cannot render the type %r: unknown lengthZnew_array_type)rn r rm r. rg rE )r r* r+ ZBPtrItemr r r r( 9 s z ArrayType.build_backend_typeN)rm rn )r6 r7 r8 r4 r9 rD ro r( r r r r rl % s rl rM c @ s, e Zd Zd ZdZdd� Zdd� Zdd� ZdS ) �StructOrUnionOrEnumr2 Nc C s$ | j pd| j| jf }|d | _d S )Nz%s %sr )� forcename�kindr2 r )r r2 r r r �build_c_name_with_markerH s z,StructOrUnionOrEnum.build_c_name_with_markerc C s || _ | j� d S )N)rq rs )r rq r r r �force_the_nameL s z"StructOrUnionOrEnum.force_the_namec C s | j jd�st�| j d d� S )Nr r ���)r �endswithr )r r r r �get_official_nameP s z%StructOrUnionOrEnum.get_official_name)r2 )r6 r7 r8 r4 rq rs rt rw r r r r rp D s rp c @ sj e Zd ZdZdZdZdZddd�Zdd� Zdd d �Z d d � Z dd d�Z dd� Z dd� Z dd� Zdd� ZdS )� StructOrUnionNr Fc C s* || _ || _|| _|| _|| _| j� d S )N)r2 �fldnames�fldtypes� fldbitsize�fldqualsrs )r r2 ry rz r{ r| r r r rD [ s zStructOrUnion.__init__c c sB | j d k r>x2t| j| j �D ] \}}|dkrt|t�r|V qW d S )Nr )rz �zipry � isinstancerx )r r2 �typer r r �anonymous_struct_fieldsc s z%StructOrUnion.anonymous_struct_fieldsTc c s� | j }|d kr dt| j� }xbt| j| j| j|�D ]J\}}}}|dkrnt|t�rn|rnx&|j� D ] }|V q^W q2||||fV q2W d S )Nr r )r ) r| �lenry r} rz r{ r~ rx � enumfields)r Z expand_anonymous_struct_unionr| r2 r �bitsizer r" r r r r� i s zStructOrUnion.enumfieldsc C s~ g }g }g }g }x@| j � D ]4\}}}}|j|� |j|� |j|� |j|� qW t|�| _t|�| _t|�| _t|�| _d S )N)r� r] rA ry rz r{ r| ) r �names�typesZbitsizesr| r2 r r� r r r r � force_flattenw s zStructOrUnion.force_flattenc C s$ t j| |||�}|s | j||� |S )N)rp r. �finish_backend_type)r r* r+ r, r- r r r r. � s z StructOrUnion.get_cached_btypec s | j r$| j dkr td| jf ��d S � j| }d| _ | jd krB�n�| jd kr�� �fdd�| jD �}tt| j|| j ��}d}| j r�d}� j j ||| d d |� �ntg }| j\}}} } �x4t t| j��D �] } || } | j| } t| t�o�| jdk�rn| jj� ��}t| � j|��\}}|dk�r<| jd | j| j| �p4d f � | j|�} | jd | � | f | j| d d � | _| j� ��}t| t��r�| jd k�r�| dk�s�t�n8� j|�}|| k�r�| jd | j| j| �p�d || f � |j|� q�W tt| j|| j |��}� j j ||| | | � d| _ d S )Nr z(recursive structure declaration for '%s'r c s g | ]}|j � ���qS r )r. )r1 re )r* r+ r r r3 � s z5StructOrUnion.finish_backend_type.<locals>.<listcomp>r � z...z field '%s.%s' has a bogus size?z{}z=field '%s.%s' is declared as %d bytes, but is really %d bytesru ru )� completedrU r2 r& rz � fixedlayout�listr} ry r{ �packedrc Zcomplete_struct_or_union�ranger� r~ rl rn rm r. �divmod�sizeof�_verification_errorro r r] )r r* r+ r- rz ZlstZsflagsZfieldofsZ fieldsizeZ totalsizeZtotalalignmentrJ ZfsizeZftypeZ BItemTypeZnlenZnrestZ BFieldTypeZ bitemsizer )r* r+ r r� � s` z!StructOrUnion.finish_backend_typec C s t |��d S )N)r )r �msgr r r r� � s z!StructOrUnion._verification_errorc C s | j r | jd kr t| j� ��d S )N)�partialr� r r )r r r r �check_not_partial� s z StructOrUnion.check_not_partialc C s. | j � |j| � t| |d| j | j� | d�S )Nz new_%s_type)�key)r� r] rE rr rw )r r* r+ r r r r( � s z StructOrUnion.build_backend_type)N)T)F)r6 r7 r8 r� r� r� r� rD r� r� r� r. r� r� r� r( r r r r rx U s <rx c @ s e Zd ZdZdS )� StructType�structN)r6 r7 r8 rr r r r r r� � s r� c @ s e Zd ZdZdS )� UnionType�unionN)r6 r7 r8 rr r r r r r� � s r� c @ sB e Zd ZdZdZdZddd�Zdd� Zdd � Zd d � Z d d � Z dS )�EnumType�enumFNc C s$ || _ || _|| _|| _| j� d S )N)r2 � enumerators� enumvalues� baseinttypers )r r2 r� r� r� r r r rD � s zEnumType.__init__c C s4 t j| |� | jd kr0| j� }d|jdd� | _d S )Nr r �_)rp rt rq rw r )r rq r2 r r r rt � s zEnumType.force_the_namec C s | j r| j rt| j� ��d S )N)r� �partial_resolvedr r )r r r r r� � s zEnumType.check_not_partialc C s4 | j � | j||�}t| |d| j� | j| j|| d�S )NZ new_enum_type)r� )r� �build_baseinttyperE rw r� r� )r r* r+ Z base_btyper r r r( � s zEnumType.build_backend_typec C sH | j d k r| j j||�S | jr4t| j�}t| j�}nDdd l}y tj� W n tk r\ Y nX |j d| j � � d }}|dk r�d}t d�}t d�}nd}t d�}t d�}|j||�} |j||�} |j | �} |j | �} |d d| d > ko�|dd| | > k �r| S |d d| d > k�r4|dd| | > k �r4| S t d | j � ��d S ) Nr zU%r has no values explicitly defined; guessing that it is equivalent to 'unsigned int'r rN rO z unsigned intz unsigned longr� z=%s values don't all fit into either 'long' or 'unsigned long'ru ru )r� r. r� �min�max�warningsZ__warningregistry__�clear� NameError�warnr rH r� r ) r r* r+ Zsmallest_valueZ largest_valuer� ZsignZ candidate1Z candidate2Zbtype1Zbtype2Zsize1Zsize2r r r r� s@ zEnumType.build_baseinttype)N) r6 r7 r8 rr r� r� rD rt r� r( r� r r r r r� � s r� c C s2 |d krd| }t |d d d �}|j| � d|_|S )Nz$%s� unknown_type)r� rt �origin)r2 � structnamere r r r r� * s r� c C s( |d krd| }t |d d d �}t|| �S )Nz$$%s)r� rk )r2 r� re r r r �unknown_ptr_type2 s r� c C sF t | tj�rtS t�( tt| �d�s2tj� t| �_ t| �j S Q R X d S )N� __typecache) r~ r� � ModuleType�_typecache_cffi_backend� global_lock�hasattrr �weakref�WeakValueDictionaryr� )Zbackendr r r � get_typecache< s r� c O s� |j d||f�}| st�y |j| S tk r8 Y nX yt|j|�|� }W n4 tk r� } ztd|| |f ��W Y d d }~X nX |j}t�( |j|�} | d kr�|||< |S | S W d Q R X d S )Nr� z %s: %r: %s) �popr Z _typecacher' r0 rc rU r� �get) Zsrctyper* �funcnamerX �kwdsr� �res�e�cacheZres1r r r rE G s" $ rE c C s t d| d|�S )N�?ri )rE )r* r- r r r � pointer_cache^ s r� c C s@ | j r<t| j d �tkr<d|| j d f f| j dd � | _ d S )Nr z%s: %sr )rX r �str)r� r2 r r r �attach_exception_infoa s r� )N)N)-r� r� �lockr �errorr r r r r r r �objectr r; rC Z void_typerF rH rT rV rW r` ra rg Z voidp_typerj Zconst_voidp_typerk rl Zchar_array_typerp rx r� r� r� r� r� r� r� r� r� rE r� r� r r r r �<module> sN / L G PK %�\��OC C & __pycache__/commontypes.cpython-36.pycnu �[��� 3 M��Z� � @ s� d dl Z ddlmZ ddlmZ i Zyd dlmZ ee� W n ek rP Y nX ej dd�ed< ded < x"ej j D ]Z e j d �rte ee < qtW [ i Zd d � Zd d� Ze jdkr�eje� � dS )� N� )�model)�FFIError)�_get_common_types�FILEZ_IO_FILEZ_Bool�boolZ_tc C s� yt | S tk r� tj||�}t|t�s:|d }}nZ|tjjkrXtj|�d }}n<|dkrpt d|f ��n$||kr�t d|f ��| j |�\}}t|tj �s�t �||ft |< ||fS X d S )Nr zset-unicode-neededzFThe Windows type %r is only available after you call ffi.set_unicode()z�Unsupported type: %r. Please look at http://cffi.readthedocs.io/en/latest/cdef.html#ffi-cdef-limitations and file an issue if you think this type should really be supported.) �_CACHE�KeyError� COMMON_TYPES�get� isinstance�strr � PrimitiveType�ALL_PRIMITIVE_TYPESr Zparse_type_and_qualsZBaseTypeByIdentity�AssertionError)�parserZ commontypeZcdecl�resultZquals� r �#/usr/lib64/python3.6/commontypes.py�resolve_common_type s& r c C sR t jddddgt jd�t jd�t jt jd��gd d dg�dd d d d d d d d d d � S )NZ_UNICODE_STRINGZLengthZ MaximumLengthZBufferzunsigned shortZwchar_tr zUNICODE_STRING *zconst UNICODE_STRING *zset-unicode-needed) ZUNICODE_STRINGZPUNICODE_STRINGZPCUNICODE_STRINGZTBYTEZTCHARZLPCTSTRZPCTSTRZLPTSTRZPTSTRZPTBYTEZPTCHAR���r r )r Z StructTyper Z PointerTyper r r r �win_common_types7 s& r Zwin32)�sys� r �errorr r Z _cffi_backendr � ImportErrorZ unknown_typer r Z_type�endswithr r r �platform�updater r r r �<module> s& PK %�\����s s & __pycache__/cffi_opcode.cpython-36.pycnu �[��� 3 M��Z\ � 4 @ s< d dl mZ G dd� de�Zdd� Zd ZdZdZdZd Z d Z d Z d Z d Z dZdZdZdZdZdZdZdZdZdZdZdZdZd ZdZ dZ d Z dZ d Z dZ!d Z"d Z#d Z$d Z%d Z&d Z'd!Z(d Z)d"Z*d Z+d#Z,dZ-d$Z.dZ/d%Z0dZ1d&Z2dZ3d'Z4dZ5d(Z6dZ7d)Z8dZ9d*Z:dZ;d+Z<dZ=d,Z>dZ?d-Z@dZAd.ZBdZCd/ZDd0ZEd1ZFd2ZGd3ZHd4ZId5ZJd6ZKd7ZLd8ZMd9ZNdDZOdEZPdFZQdGZRe e e!e#e%e e e e"e$e&e'e(e)eJeKee*eLeMe+e,e-e.e/e0e1e2e3e4e5e6e7e8e9e:e;e<e=e>e?e@eAeBeCeDeEeFeGeHeId:�3ZSd ZTdZUd ZVd ZWd"ZXeYd;d<� dHD ��ZZi Z[xDe\e]� j^� �D ]2\Z_Z`e_jadB��rebe`ec��re_ddC� e[e`< �qW dCS )I� )�VerificationErrorc @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �CffiOpc C s || _ || _d S )N)�op�arg)�selfr r � r �#/usr/lib64/python3.6/cffi_opcode.py�__init__ s zCffiOp.__init__c C s> | j d kr&t| jt�st�d| jf S t| j }d|| jf S )Nz(_cffi_opcode_t)(%s)z_CFFI_OP(_CFFI_OP_%s, %s))r � isinstancer �str�AssertionError� CLASS_NAME)r � classnamer r r � as_c_expr s zCffiOp.as_c_exprc C sn | j d kr>| jj� r>t| j�}|dkr6td| jf ��t|�S t| jt�rZtd| jf ��t| jd> | j B �S )N� � z"cannot emit %r: limited to 2**31-1zcannot emit to Python: %r� l ) r r �isdigit�int� OverflowError�format_four_bytesr r r )r �valuer r r �as_python_bytes s zCffiOp.as_python_bytesc C s t j| j| j�}d|| jf S )Nz(%s %s))r �getr r )r r r r r �__str__ s zCffiOp.__str__N)�__name__� __module__� __qualname__r r r r r r r r r s r c C s, d| d? d@ | d? d@ | d? d@ | d@ f S )Nz\x%02X\x%02X\x%02X\x%02X� � � r r )Znumr r r r s r � � � � � � � � � � � � � � r �! �# �% �' �) � r � � r � � � r � � � r � � � � �" �$ �& �( �* �+ �, �- �. �/ �0 �1 �2 �3 �4 )3�charZshortr Zlongz long longz signed charz unsigned charzunsigned shortz unsigned intz unsigned longzunsigned long long�floatZdoublez long doublezfloat _Complexzdouble _ComplexZ_BoolZwchar_tZchar16_tZchar32_tZint8_tZuint8_tZint16_tZuint16_tZint32_tZuint32_tZint64_tZuint64_tZintptr_tZ uintptr_tZ ptrdiff_tZsize_tZssize_tZ int_least8_tZ uint_least8_tZ int_least16_tZuint_least16_tZ int_least32_tZuint_least32_tZ int_least64_tZuint_least64_tZ int_fast8_tZ uint_fast8_tZ int_fast16_tZ uint_fast16_tZ int_fast32_tZ uint_fast32_tZ int_fast64_tZ uint_fast64_tZintmax_tZ uintmax_tc C s g | ]}d | t � | f�qS )Z_CFFI_)�globals)�.0Z_keyr r r � <listcomp>� s rT �F_UNION�F_CHECK_FIELDS�F_PACKED� F_EXTERNAL�F_OPAQUEZOP_N���������rZ )rU rV rW rX rY )d�errorr �objectr r Z OP_PRIMITIVEZ OP_POINTERZOP_ARRAYZ OP_OPEN_ARRAYZOP_STRUCT_UNIONZOP_ENUMZ OP_FUNCTIONZOP_FUNCTION_ENDZOP_NOOPZ OP_BITFIELDZ OP_TYPENAMEZOP_CPYTHON_BLTN_VZOP_CPYTHON_BLTN_NZOP_CPYTHON_BLTN_OZ OP_CONSTANTZOP_CONSTANT_INTZ OP_GLOBAL_VARZOP_DLOPEN_FUNCZOP_DLOPEN_CONSTZOP_GLOBAL_VAR_FZOP_EXTERN_PYTHONZ PRIM_VOIDZ PRIM_BOOLZ PRIM_CHARZ PRIM_SCHARZ PRIM_UCHARZ PRIM_SHORTZ PRIM_USHORTZPRIM_INTZ PRIM_UINTZ PRIM_LONGZ PRIM_ULONGZ PRIM_LONGLONGZPRIM_ULONGLONGZ PRIM_FLOATZ PRIM_DOUBLEZPRIM_LONGDOUBLEZ PRIM_WCHARZ PRIM_INT8Z PRIM_UINT8Z PRIM_INT16Z PRIM_UINT16Z PRIM_INT32Z PRIM_UINT32Z PRIM_INT64Z PRIM_UINT64Z PRIM_INTPTRZ PRIM_UINTPTRZ PRIM_PTRDIFFZ PRIM_SIZEZ PRIM_SSIZEZPRIM_INT_LEAST8ZPRIM_UINT_LEAST8ZPRIM_INT_LEAST16ZPRIM_UINT_LEAST16ZPRIM_INT_LEAST32ZPRIM_UINT_LEAST32ZPRIM_INT_LEAST64ZPRIM_UINT_LEAST64ZPRIM_INT_FAST8ZPRIM_UINT_FAST8ZPRIM_INT_FAST16ZPRIM_UINT_FAST16ZPRIM_INT_FAST32ZPRIM_UINT_FAST32ZPRIM_INT_FAST64ZPRIM_UINT_FAST64Z PRIM_INTMAXZ PRIM_UINTMAXZPRIM_FLOATCOMPLEXZPRIM_DOUBLECOMPLEXZ PRIM_CHAR16Z PRIM_CHAR32Z _NUM_PRIMZ _UNKNOWN_PRIMZ_UNKNOWN_FLOAT_PRIMZ_UNKNOWN_LONG_DOUBLEZ_IO_FILE_STRUCTZPRIMITIVE_TO_INDEXrU rV rW rX rY �dictZG_FLAGSr �listrR �items�_nameZ_value� startswithr r r r r r �<module> s PK %�\NH�k k __pycache__/lock.cpython-36.pycnu �[��� 3 M��Z� � @ s| d dl Z e jdk rFyd dlmZ W qx ek rB d dlmZ Y qxX n2yd dlmZ W n ek rv d dlmZ Y nX dS )� N� )� allocate_lock)r )�sys� version_infoZthreadr � ImportErrorZ dummy_thread�_threadZ _dummy_thread� r r � /usr/lib64/python3.6/lock.py�<module> s PK %�\��� , __pycache__/commontypes.cpython-36.opt-1.pycnu �[��� 3 M��Z� � @ s� d dl Z ddlmZ ddlmZ i Zyd dlmZ ee� W n ek rP Y nX ej dd�ed< ded < x"ej j D ]Z e j d �rte ee < qtW [ i Zd d � Zd d� Ze jdkr�eje� � dS )� N� )�model)�FFIError)�_get_common_types�FILEZ_IO_FILEZ_Bool�boolZ_tc C s� yt | S tk r� tj||�}t|t�s:|d }}nZ|tjjkrXtj|�d }}n<|dkrpt d|f ��n$||kr�t d|f ��| j |�\}}||ft |< ||fS X d S )Nr zset-unicode-neededzFThe Windows type %r is only available after you call ffi.set_unicode()z�Unsupported type: %r. Please look at http://cffi.readthedocs.io/en/latest/cdef.html#ffi-cdef-limitations and file an issue if you think this type should really be supported.) �_CACHE�KeyError� COMMON_TYPES�get� isinstance�strr � PrimitiveType�ALL_PRIMITIVE_TYPESr Zparse_type_and_quals)�parserZ commontypeZcdecl�resultZquals� r �#/usr/lib64/python3.6/commontypes.py�resolve_common_type s$ r c C sR t jddddgt jd�t jd�t jt jd��gd d dg�dd d d d d d d d d d � S )NZ_UNICODE_STRINGZLengthZ MaximumLengthZBufferzunsigned shortZwchar_tr zUNICODE_STRING *zconst UNICODE_STRING *zset-unicode-needed) ZUNICODE_STRINGZPUNICODE_STRINGZPCUNICODE_STRINGZTBYTEZTCHARZLPCTSTRZPCTSTRZLPTSTRZPTSTRZPTBYTEZPTCHAR���r r )r Z StructTyper Z PointerTyper r r r �win_common_types7 s& r Zwin32)�sys� r �errorr r Z _cffi_backendr � ImportErrorZ unknown_typer r Z_type�endswithr r r �platform�updater r r r �<module> s& PK %�\�v�!� � __pycache__/error.cpython-36.pycnu �[��� 3 M��Z� � @ sD G d d� de �ZG dd� de �ZG dd� de �ZG dd� de �ZdS ) c @ s e Zd ZdS )�FFIErrorN)�__name__� __module__� __qualname__� r r � /usr/lib64/python3.6/error.pyr s r c @ s e Zd Zdd� ZdS )� CDefErrorc C s\ y*| j d }|jj}|jj}d||f }W n tttfk rH d}Y nX d|| j d f S )N� z%s:%d: � z%s%s� )�argsZcoord�file�line�AttributeError� TypeError� IndexError)�selfZ current_decl�filenameZlinenum�prefixr r r �__str__ s zCDefError.__str__N)r r r r r r r r r s r c @ s e Zd ZdZdS )�VerificationErrorz- An error raised when verification fails N)r r r �__doc__r r r r r s r c @ s e Zd ZdZdS )�VerificationMissingzl An error raised when incomplete structures are passed into cdef, but no verification has been done N)r r r r r r r r r s r N)� Exceptionr r r r r r r r �<module> s PK %�\d��,M� M� + __pycache__/recompiler.cpython-36.opt-1.pycnu �[��� 3 M��Z�� � @ s d dl Z d dlZd dlZddlmZmZ ddlmZ ddlT dZ dZ dZ G d d � d �Z G d d � d �Z G d d� d�ZG dd� d�ZG dd� d�ZG dd� d�Zejd0kr�ejZnG dd� dej�Zdd� Zd1dd �Zd2d d �Zd d � Zd!d"� Zd#d$� Zd%d&� Z d'd(� Z d3d,d-�Z d.d/� Z dS )4� N� )� ffiplatform�model)�VerificationError)�*i& i' i( c @ s& e Zd Zd dd�Zdd� Zdd� ZdS ) � GlobalExprr c C s" || _ || _|| _|| _|| _d S )N)�name�address�type_op�size� check_value)�selfr r r r r � r �"/usr/lib64/python3.6/recompiler.py�__init__ s zGlobalExpr.__init__c C s d| j | j| jj� | jf S )Nz' { "%s", (void *)%s, %s, (void *)%s },)r r r � as_c_exprr )r r r r r s zGlobalExpr.as_c_exprc C s d| j j� | j| jf S )Nz b'%s%s',%d)r �as_python_bytesr r )r r r r �as_python_expr s zGlobalExpr.as_python_exprN)r r )�__name__� __module__� __qualname__r r r r r r r r s r c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) � FieldExprc C s" || _ || _|| _|| _|| _d S )N)r � field_offset� field_size�fbitsize� field_type_op)r r r r r r r r r r s zFieldExpr.__init__c C s> dt | j� }d| j| jf d|| jf d|| jj� f S )N� z { "%s", %s, z %s %s, z %s %s },)�lenr r r r r )r Zspacesr r r r # s zFieldExpr.as_c_exprc C s t �d S )N)�NotImplementedError)r r r r r ) s zFieldExpr.as_python_exprc C sD | j jtkrd}n | j jtkr*t| j�}nt�d| j j� || jf S )N� z b'%s%s%s') r �op�OP_NOOP� OP_BITFIELD�format_four_bytesr r r r )r Z size_exprr r r �as_field_python_expr, s z FieldExpr.as_field_python_exprN)r r r r r r r$ r r r r r s r c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�StructUnionExprc C s4 || _ || _|| _|| _|| _|| _|| _|| _d S )N)r � type_index�flagsr � alignment�comment�first_field_index�c_fields) r r r& r' r r( r) r* r+ r r r r 8 s zStructUnionExpr.__init__c C sP d| j | j| jf d| j| jf d| jt| j�f | jrFd| j nd d S )Nz { "%s", %d, %s,z %s, %s, z%d, %d z /* %s */ r z},) r r& r' r r( r* r r+ r) )r r r r r C s zStructUnionExpr.as_c_exprc C s> t | jt�}dd� | jD �}dt| j�t|�| jdj|�f S )Nc S s g | ] }|j � �qS r )r$ )�.0Zc_fieldr r r � <listcomp>L s z2StructUnionExpr.as_python_expr.<locals>.<listcomp>z(b'%s%s%s',%s)�,)�evalr' ZG_FLAGSr+ r# r& r �join)r r' Z fields_exprr r r r J s z StructUnionExpr.as_python_exprN)r r r r r r r r r r r% 7 s r% c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�EnumExprc C s" || _ || _|| _|| _|| _d S )N)r r& r �signed�allenums)r r r& r r2 r3 r r r r U s zEnumExpr.__init__c C s d| j | j| j| j| jf S )Nz1 { "%s", %d, _cffi_prim_int(%s, %s), "%s" },)r r& r r2 r3 )r r r r r \ s zEnumExpr.as_c_exprc C sN dt dtd td td td td tdti| j| j f }dt | j �t |�| j | j f S )Nr r � � � zb'%s%s%s\x00%s')r r )r r )r4 r )r4 r )r5 r )r5 r )r6 r )r6 r )Z PRIM_UINT8Z PRIM_INT8Z PRIM_UINT16Z PRIM_INT16Z PRIM_UINT32Z PRIM_INT32Z PRIM_UINT64Z PRIM_INT64r r2 r# r& r r3 )r � prim_indexr r r r a s zEnumExpr.as_python_exprN)r r r r r r r r r r r1 T s r1 c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )� TypenameExprc C s || _ || _d S )N)r r& )r r r& r r r r m s zTypenameExpr.__init__c C s d| j | jf S )Nz { "%s", %d },)r r& )r r r r r q s zTypenameExpr.as_c_exprc C s dt | j�| jf S )Nzb'%s%s')r# r& r )r r r r r t s zTypenameExpr.as_python_exprN)r r r r r r r r r r r8 l s r8 c @ s� e Zd ZdZd�dd�Zdd� Zdd� Zd d � Zd d � Zd ddddgZ dd� Z d�dd�Z dd� Z dd� Z dd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Zd5d6� Zd7d8� Z d9d:� Z d;d<� Z d=d>� Z d?d@� Z d�dBdC�Z!dDdE� Z"dFdG� Z#dHdI� Z$e$Z%dJdK� Z&dLdM� Z'e'Z(dNdO� Z)e)Z*dPdQ� Z+dRdS� Z,dTdU� Z-d�dWdX�Z.dYdZ� Z/d[d\� Z0d]d^� Z1d_d`� Z2d�dadb�Z3dcdd� Z4dedf� Z5dgdh� Z6didj� Z7dkdl� Z8dmdn� Z9dodp� Z:dqdr� Z;dsdt� Z<dudv� Z=e= Z>Z?dwdx� Z@dydz� ZAd{d|� ZBd}d~� ZCdd�� ZDeD ZEZFd�d�� ZGd�d�� ZHd�d�� ZId�d�� ZJd�d�� ZKd�d�� ZLd�d�� ZMeMZNeMZOd�d�� ZPd�d�� ZQd�d�� ZReRZSd�d�� ZTdAS )�� Recompilerr Fc C s || _ || _|| _t| _d S )N)�ffi� module_name�target_is_python� VERSION_BASE�_version)r r: r; r< r r r r ~ s zRecompiler.__init__c C s t | j|�| _d S )N)�maxr> )r Zverr r r � needs_version� s zRecompiler.needs_versionc C s� i | _ | jd� t| j td�}g | _xt|D ]l}|jr*t| j�| j |< | jj|� x8|jD ].}| j | d krzt| j�| j |< | jj|� qXW | jjd� q*W xZ|D ]R}|j r�| j | d kr�t| j�| j |< | jj|� |j r�|j d k r�| jjd� q�W i | _ i | _ x@|D ]8}t |tj��r&d | j |< nt |tj��rd | j |< �qW x.tt| j dd� d��D ]\}}|| j |< �q\W x.tt| j dd� d��D ]\}}|| j |< �q�W x0|D ](}t| d|jj �}||| j | � �q�W x| jD ]}�q�W t| j�| _d S ) NZ collecttype)�keyZENDZLENc S s | j S )N)r )�tpr r r �<lambda>� s z/Recompiler.collect_type_table.<locals>.<lambda>c S s | j S )N)r )rB r r r rC � s Z_emit_bytecode_)� _typesdict� _generate�sorted�str� cffi_typesZis_raw_functionr �append�argsZ is_array_type�length�_struct_unions�_enums� isinstancer � StructOrUnion�EnumType� enumerate�getattr� __class__r �tuple)r Z all_declsrB �tp1�i�methodr r r r �collect_type_table� sL z Recompiler.collect_type_tablec C s� t |tj�s2t |t�r.x|D ]}| j|� q W d S || jkr�d | j|< t |tj�rb| j|j� � ntt |tj�r�|j d k r�|| j j j kr�xN|j � D ] \}}}}| j| j|||�� q�W n x |j� D ]\}}| j|� q�W d S )N)rN r ZBaseTypeByIdentityrT �_do_collect_typerD �FunctionPtrType�as_raw_functionrO �fldtypesr: �_parser�_included_declarations� enumfields� _field_typeZ _get_items)r rB �xZname1rU �_r r r rY � s zRecompiler._do_collect_typec C s� | j jjj� }x�t|�D ]�\}\}}|jdd�\}}yt| d||f �}W n tk rj td| ��Y nX y|| _ |||� W q t k r� } zt j | |� � W Y d d } ~ X qX qW d S )Nr r z_generate_cpy_%s_%sz"not implemented in recompile(): %r) r: r] Z _declarations�itemsrF �splitrR �AttributeErrorr �_current_quals� Exceptionr Zattach_exception_info) r � step_name�lstr rB �qualsZkindZrealnamerW �er r r rE � s zRecompiler._generate�global�field� struct_union�enum�typenamec C s� i | _ x| jD ]}g | j |< qW t� | _| jd� | j� x>| jD ]4}| j | }|dkrh|jdd� d� t|�| j |< qBW | j d }x| jj � D ]\}}q�W | j d }x| j j � D ]\}}q�W d S )NZctxrm c S s | j S )N)r )�entryr r r rC � s z0Recompiler.collect_step_tables.<locals>.<lambda>)rA rn ro ) �_lsts� ALL_STEPS�set�_seen_struct_unionsrE �_add_missing_struct_unions�sortrT rL rc rM )r rh ri rB rV r r r �collect_step_tables� s$ z Recompiler.collect_step_tablesr c C s | j j|d � d S )N� )�_f�write)r Zwhatr r r �_prnt s zRecompiler._prntc C s" | j r| j|� n | j||� d S )N)r< �write_py_source_to_f�write_c_source_to_f)r �f�preambler r r �write_source_to_f s z Recompiler.write_source_to_fc C s0 t tjjtjjt�|�d�}|j� }|j� |S )N�r)�open�os�pathr0 �dirname�__file__� readlines�close)r �filename�g�linesr r r �_rel_readlines s zRecompiler._rel_readlinesc C sz || _ | j}| jjd k r |d� | jd�}|jd�}| jd�|||d �< |dj|�� | jjd�dI }| jjd k �r0|d| jf � |d � | j | jj� |d � |d � |d |f � |d � |d|f � |d� |d|f � |d� | jd�}|jd�}| jd�|||d �< |dj|�� | j t � |d� |� ||� |� |d� |� |d� t dd� | j j� D ��}xLt| j�D ]>\}}d} ||k�r�d|| j� } |d||j� | f � �q�W | j�s�|d� |d � |� t� | _| jd � i } xn| jD ]d} | j| } t| �| | < | | d k�r|d | | f � x| D ]} || j� � �qBW |d � |� �qW | jj�r|d � xr| jjD ]f}y|jd d!� \}}W n( tk �r� t d"| j|f ��Y nX |d k�r�t d#��|d$|f � �q�W |d%� |d � |� |d&� |d'� x8| jD ].} | | d k�r@|d(| � n |d)| � �q W x.| jD ]$} | d*k�rZ|d+| | | f � �qZW | jj�r�|d,� n|d-� |d.t| j�f � d }| j �r�|dO }|d/| � |d � |� |d0� |d1� |d� |� |d � |d2� |d3|f � |d4� | j �rD|d5� |d6� |d7� |d8| j � |d9� |d:� |d;� |d� |d<� |d=� |d>� |d?� |d@|f � |dA� |dB|f � |dC� |dC� |d � |d2� |dD|f � |d4� |dE| j| j f � |d<� |d� |d2� |dF|f � |d4� |dG| j| j f � |d<� |d� |� |d0� |dH� |d� d | _ d S )JNz#define _CFFI_USE_EMBEDDINGz_cffi_include.hz#include "parse_c_type.h" zparse_c_type.hr r �.z #define _CFFI_MODULE_NAME "%s"z1static const char _CFFI_PYTHON_STARTUP_CODE[] = {z0 };z#ifdef PYPY_VERSIONz5# define _CFFI_PYTHON_STARTUP_FUNC _cffi_pypyinit_%sz#elif PY_MAJOR_VERSION >= 3z-# define _CFFI_PYTHON_STARTUP_FUNC PyInit_%sz#elsez*# define _CFFI_PYTHON_STARTUP_FUNC init%sz#endifz _embedding.hz#include "_cffi_errors.h" z_cffi_errors.hz>/************************************************************/z static void *_cffi_types[] = {c S s g | ]\}}||f�qS r r )r, rB rV r r r r- G s z2Recompiler.write_c_source_to_f.<locals>.<listcomp>z // z/* %2d */ %s,%sz 0z};�declr z.static const struct _cffi_%s_s _cffi_%ss[] = {z.static const char * const _cffi_includes[] = {r4 zQffi object %r includes %r, but the latter has not been prepared with set_source()zMnot implemented yet: ffi.include() of a Python-based ffi inside a C-based ffiz "%s",z NULLz?static const struct _cffi_type_context_s _cffi_type_context = {z _cffi_types,z _cffi_%ss,z NULL, /* no %ss */rm z %d, /* num_%ss */z _cffi_includes,z NULL, /* no includes */z %d, /* num_types */z %d, /* flags */z#ifdef __GNUC__z?# pragma GCC visibility push(default) /* for -fvisibility= */ZPyMODINIT_FUNCz"_cffi_pypyinit_%s(const void *p[])�{z% if (((intptr_t)p[0]) >= 0x0A03) {zQ _cffi_call_python_org = (void(*)(struct _cffi_externpy_s *, char *))p[1];z }z p[0] = (const void *)0x%x;z p[1] = &_cffi_type_context;z#if PY_MAJOR_VERSION >= 3z return NULL;�}z# ifdef _MSC_VERz PyMODINIT_FUNCz# if PY_MAJOR_VERSION >= 3z% PyInit_%s(void) { return NULL; }z# elsez init%s(void) { }z# endifzPyInit_%s(void)z5 return _cffi_init("%s", 0x%x, &_cffi_type_context);z init%s(void)z. _cffi_init("%s", 0x%x, &_cffi_type_context);z # pragma GCC visibility pop���) rz r| r: � _embeddingr� �indexr0 r; rd � _print_string_literal_in_arrayr@ �VERSION_EMBEDDED�dictrD rc rQ rH � _get_c_namer rt �_seen_constantsrE rs rr r �_included_ffis�_assigned_sourcere r � _num_externpyr> )r r r� �prntr� rV Zbase_module_name�typeindex2typer r) Znumsrh ri rq �ffi_to_include�included_module_name�included_sourcer' r r r r~ s z Recompiler.write_c_source_to_fc sb t |t�rd|f S t |ttf�rZ� fdd�|D �}t|�dkrJ|jd� ddj|�f S |j� S )Nzb'%s'c s g | ]}� j |��qS r )�_to_py)r, �item)r r r r- � s z%Recompiler._to_py.<locals>.<listcomp>r r z(%s)r. )rN rG �listrT r rI r0 r )r ra Zrepr )r r r� � s zRecompiler._to_pyc C s� || _ | j}|d� |d� t| jjp(f �}xzt|�D ]n}| jj| }y|jd d� \}}W n& tk r� td| j|f ��Y nX |d k r�td��|d||f � q6W |� |d| j f � |d| j f � d | _ t | j �| _ d d � | j D �}|d | j d j|��f � td d � | jj� D ��} xH| jD ]>} | j| } t| �dk�r*| dk�r*|d| | j | �f � �q*W |dk�r�|ddjdd � t|�D ��f � |d� d S )Nz# auto-generated filezimport _cffi_backendr4 zQffi object %r includes %r, but the latter has not been prepared with set_source()zMnot implemented yet: ffi.include() of a C-based ffi inside a Python-based ffiz from %s import ffi as _ffi%dz ffi = _cffi_backend.FFI('%s',z _version = 0x%x,c S s g | ] }|j � �qS r )r )r, r r r r r- � s z3Recompiler.write_py_source_to_f.<locals>.<listcomp>z _types = %s,r c S s g | ]\}}||f�qS r r )r, rB rV r r r r- � s r rm z _%ss = %s,z _includes = (%s,),z, c S s g | ] }d | �qS )z_ffi%dr )r, rV r r r r- � s �))rz r| r r: r� �ranger� re r r; r> rT rH r� r0 r� rD rc rs rr ) r r r� Z num_includesrV r� r� r� Z types_lstr� rh ri r r r r} � sB z Recompiler.write_py_source_to_fc C s | j | S )N)rD )r �typer r r � _gettypenum s zRecompiler._gettypenumc C sp d}t |tj�r�|j� r�|j� r<|jdkr<d}d|j }nPt |tj�rZd|jd�f }n2|jd�}d||jjdd�f }|dkr�| j t � d }n�t |tj �r�| j ||||� d S t |tj �s�t |tj�r�| jd || j|�|f � | jd | � d S t |tj��r&d|jd� }d| j|� }d}nt|��| jd||||f � | jd||jd�|f � | jd | � d S )Nr �_BoolZ_cffi_to_c_intz, %sz(%s)_cffi_to_c_doublez(%s)_cffi_to_c_%sr rb �char16_t�char32_tz-1z6 if (_cffi_to_c((char *)&%s, _cffi_type(%d), %s) < 0)z %s;z(%s)_cffi_to_c_pointerz, _cffi_type(%d)ZNULLz %s = %s(%s%s);z' if (%s == (%s)%s && PyErr_Occurred()))r� r� )rN r �BasePrimitiveType�is_complex_type�is_integer_typer �UnknownFloatType� get_c_name�replacer@ �VERSION_CHAR16CHAR32� PointerType�"_convert_funcarg_to_c_ptr_or_arrayZStructOrUnionOrEnumr| r� rZ r ) r rB �fromvar�tovar�errcodeZextraargZ converter�cnameZerrvaluer r r �_convert_funcarg_to_c s@ z Recompiler._convert_funcarg_to_cc C s t |tj�r|jd� d S )NzPy_ssize_t datasize)rN r r� �add)r rB � localvarsr r r �_extra_local_variables3 s z!Recompiler._extra_local_variablesc C s� | j d� | j d| j|�||f � | j d� | j d� | j d| � | j d||jd�f � | j d|f � | j d || j|�|f � | j d| � | j d � d S ) Nz1 datasize = _cffi_prepare_pointer_call_argument(z( _cffi_type(%d), %s, (char **)&%s);z if (datasize != 0) {z if (datasize < 0)z %s;z& %s = (%s)alloca((size_t)datasize);r z, memset((void *)%s, 0, (size_t)datasize);zL if (_cffi_convert_array_from_object((char *)%s, _cffi_type(%d), %s) < 0)z })r| r� r� )r rB r� r� r� r r r r� 7 s z-Recompiler._convert_funcarg_to_c_ptr_or_arrayc C sL t |tj�r�|j� r,|jdkr,d||jf S t |tj�rBd|f S |jdkr�|j� r�|jjdd�}|dkrv| jt � d ||f S d || j |�f S n�t |tj tj f�r�d || j |�f S t |tj �r�d || j tj |j��f S t |tj��r |jd k�rtd |j� |f ��d || j |�f S t |tj��r@d || j |�f S t|��d S )Nr� z_cffi_from_c_int(%s, %s)z_cffi_from_c_double(%s)z long doubler rb r� r� z_cffi_from_c_%s(%s)z/_cffi_from_c_deref((char *)&%s, _cffi_type(%d))z0_cffi_from_c_pointer((char *)%s, _cffi_type(%d))z!'%s' is used as %s, but is opaquez0_cffi_from_c_struct((char *)&%s, _cffi_type(%d)))r� r� )rN r r� r� r r� r� r� r@ r� r� r� rZ � ArrayTyper� rO Zfldnames� TypeErrorr� rP r )r rB �var�contextr� r r r �_convert_expr_from_cG s8 z Recompiler._convert_expr_from_cc C s | j |d|f �S )Nz (*(%s *)0))� _global_type)r rB r r r r � _typedef_typej s zRecompiler._typedef_typec C s | j | j||�� d S )N)rY r� )r rB r r r r �!_generate_cpy_typedef_collecttypem s z,Recompiler._generate_cpy_typedef_collecttypec C s d S )Nr )r rB r r r r �_generate_cpy_typedef_declp s z%Recompiler._generate_cpy_typedef_declc C s$ | j | }| jd jt||�� d S )Nrp )rD rr rI r8 )r rB r r& r r r � _typedef_ctxs s zRecompiler._typedef_ctxc C sf | j ||�}| j||� t|dd �dkr<| j||jd d� n&t|tj�rb| j|j|jj|j|d� d S )N�originZ unknown_type)� approxname)r� � named_ptr) r� r� rR � _struct_ctxr rN r ZNamedPointerType�totype)r rB r r r r �_generate_cpy_typedef_ctxw s z$Recompiler._generate_cpy_typedef_ctxc C s* | j |j� � |jr&| j r&| j |� d S )N)rY r[ �ellipsisr< )r rB r r r r �"_generate_cpy_function_collecttype� s z-Recompiler._generate_cpy_function_collecttypec C s� |j r| j||� d S | j}t|j�}|dkr4d}n|dkrBd}nd}g }g }d| }x:t|j�D ],\} } |j| jd| |�� |jd| � qbW d j|�} | p�d } |j r�|j d } nd } d | || f } |d|j j| �f � |d� d j|�}d}t |j t j ��rd }|d|||f � |d� |d� |d� |d||f � |d� d| }x4t|j�D ]&\} } | jd| |�}|d| � �q^W t� }x |jD ]} | j| |� �q�W x |D ]}|d|f � �q�W t |j t j ��sd}d| }d|j jd|� }||� nd }d }t|j�dk�r~tt|j��}x|D ]} |d| � �q.W |� |d|t|�t|�d jd d � |D ��f � |d � |� x6t|j�D ](\} } | j| d | d| d � |� �q�W |d!� |d"� d#d � tt|j��D �}d j|�}|d$|||f � |d%� |d&� |� |d'� |dk�r0|d(� |�rP|d)| j|j d*d+� � n|d,� |d-� |d� |d.� d/d0� }d1}g }g }d| }x^t|j�D ]P\} } d }|| ��r�d2}d3}| jd4|| f |�}|j|� |jd5|| f � �q�W |j }||��r.d| }|jd6|�}|jd|� t j}d }d7}d3}|�r�d j|�} | �pFd } d8| || f } |d|j| �f � |d� |�r�||� d j|�}|d$|||f � |�r�|d9� |d� n|d:||f � |d;� |� d S )<Nr Znoargr Zarg0rJ zargument of %sz x%dzx%dz, �voidr r z%s_cffi_d_%s(%s)z static %sr� zreturn z %s%s(%s);r� z#ifndef PYPY_VERSIONzstatic PyObject *z(_cffi_f_%s(PyObject *self, PyObject *%s)z %s;z result = z result of %sz resultz PyObject *arg%d;z1 if (!PyArg_UnpackTuple(args, "%s", %d, %d, %s))c S s g | ] }d | �qS )z&arg%dr )r, rV r r r r- � s z:Recompiler._generate_cpy_function_decl.<locals>.<listcomp>z return NULL;zarg%dz return NULLz Py_BEGIN_ALLOW_THREADSz _cffi_restore_errno();c S s g | ] }d | �qS )zx%dr )r, rV r r r r- � s z { %s%s(%s); }z _cffi_save_errno();z Py_END_ALLOW_THREADSz (void)self; /* unused */z (void)noarg; /* unused */z return %s;�resultz result typez Py_INCREF(Py_None);z return Py_None;z#elsec S s t | tj�p t | tj�o | j� S )N)rN r rO � PrimitiveTyper� )r� r r r �need_indirection� s z@Recompiler._generate_cpy_function_decl.<locals>.need_indirectionFr Tz %sx%dz%sx%dz *resultz *result = z%s_cffi_f_%s(%s)z return result;z # define _cffi_f_%s _cffi_d_%sz#endif)r� �_generate_cpy_constant_declr| r rJ rQ rI r� r0 �abir� rN r �VoidTypert r� r� r� r� �insertZ void_type)r rB r r� �numargsZargname� argumentsZcall_argumentsr� rV r� �repr_argumentsr� �name_and_argumentsZ result_code�argr� r� Z result_decl�rngr� � differenceZ indirectionZ tp_resultr r r �_generate_cpy_function_decl� s� z&Recompiler._generate_cpy_function_declc C s� |j r | j r | j||� d S | j|j� }t|j�}| jrBt}n |dkrPt}n|dkr^t }nt }| j d j t |d| t||�d| d�� d S )Nr r rl z _cffi_f_%sz _cffi_d_%s)r )r� r< �_generate_cpy_constant_ctxrD r[ r rJ ZOP_DLOPEN_FUNCZOP_CPYTHON_BLTN_NZOP_CPYTHON_BLTN_OZOP_CPYTHON_BLTN_Vrr rI r �CffiOp)r rB r r& r� Z meth_kindr r r �_generate_cpy_function_ctx# s z%Recompiler._generate_cpy_function_ctxc C sT t |tj�rP|j}|dkr0|jd�}d||f }| j|d| |j�}tj||�}|S )Nz...r z _cffi_array_len(((%s)0)->%s)z%s[0])rN r r� rK r� r` r� )r Z tp_structZ field_nameZtp_field� actual_lengthZptr_struct_name�tp_itemr r r r` 9 s zRecompiler._field_typec C s0 | j |� | jr,x|j� D ]}| j|� qW d S )N)rY r< �anonymous_struct_fields�_struct_collecttype)r rB �fldtyper r r r� E s z Recompiler._struct_collecttypec C s< |j d krd S | j}d|f }|d� |d||f � |d� |d� |d� x�|j� D ]�\}}}} y||j� sv|dkr�|d|||f � wXx2t|tj�r�|jd ks�|jd kr�|j}|d }q�W |d |j d d | | d�|f � W qX t k �r } z|dt | � � W Y d d } ~ X qXX qXW |d� |d||f � |� d S )Nz_cffi_checkfld_%sZ_CFFI_UNUSED_FNzstatic void %s(%s *p)r� z8 /* only to generate compile-time warnings or errors */z (void)p;r z> (void)((p->%s) | 0); /* check that '%s.%s' is an integer */z...z[0]z { %s = &p->%s; (void)tmp; }z*tmpzfield %r)rj z /* %s */r� z(struct _cffi_align_%s { char x; %s y; };) r\ r| r_ r� rN r r� rK r� r� r rG ) r rB r� r� r� Z checkfuncnameZfnameZftyper �fqualrk r r r � _struct_declL s6 &zRecompiler._struct_declNc C s� | j | }d }g }t|tj�r(|jd� |jd kr@|jd� d}|| jjjkr�|d ksd|| jjjkr�|jd krpn |j s�t |j � �r�n |jd� |j r�|jd� n|jd� d}dj |�p�d }g }|d k�rZ| j } t|j| ��} �x | D �] \} } } }| j|| | �} | j| d |j| f � t}| d k�r6t}d | }nL|d k�sZt| tj��r`| jd k�r`d }n"d|d k�rv|jd�n|j| f }|d k�s�| d k�r�d }n,|d k �r�d|j| f }nd|jd�| f }|jt| ||| t|| j | ��� q�W t| j d �}| j d j |� |d k�r$d}d }d}n4|d k �r@d|jf }d}nd|f }d|f }d }nd }d }d }|}| j d jt |j|||||||�� | j j |� d S ) NZ _CFFI_F_UNIONZ_CFFI_F_OPAQUEZopaqueZ_CFFI_F_CHECK_FIELDSZ_CFFI_F_PACKEDZ_CFFI_F_EXTERNALZexternal�|�0z field '%s.%s'r z %d /* bits */z (size_t)-1zsizeof(((%s)0)->%s)r z"((char *)&((%s)0)->%s) - (char *)0zoffsetof(%s, %s)r rm z (size_t)-2r4 Zunnamedzsizeof(*(%s)0)z-1 /* unknown alignment */z sizeof(%s)z"offsetof(struct _cffi_align_%s, y)r rn ���r� r� )!rD rN r Z UnionTyperI r\ r: r] r^ �partial�anyr� Zpackedr0 r< r� r_ r` �_check_not_opaquer r! r" r� rK r� r r� r rr �extendr% ru r� )r rB r� r� r� r& Zreason_for_not_expandingr' r+ Z expand_anonymous_struct_unionr_ Zfldnamer� r r� r r �offsetr* Zalignr) r r r r� m s� zRecompiler._struct_ctxc C s> xt |tj�r|j}qW t |tj�r:|jd kr:td| ��d S )Nz0%s is of an opaque type (not declared in cdef()))rN r r� r� rO r\ r� )r rB �locationr r r r� � s z Recompiler._check_not_opaquec C s� t | jj� �}|jdd� d� x�|D ]�\}}|| jkr$|jrJtd|f ��|jjd�rx|jdd � j � rx|jdd � }n4|jdkr�|j dkr�d}| j |d� ntd |f ��| j |d |� q$W d S ) Nc S s | d S )Nr r )Ztp_orderr r r rC � s z7Recompiler._add_missing_struct_unions.<locals>.<lambda>)rA zDinternal inconsistency: %r is partial but was not seen at this point�$r Z_IO_FILE�FILEzinternal inconsistency: %r) r� rL rc rw ru r� r r � startswith�isdigitZ forcenamer� r� )r ri rB �orderr� r r r rv � s z%Recompiler._add_missing_struct_unionsc C s | j |� d S )N)r� )r rB r r r r � _generate_cpy_struct_collecttype� s z+Recompiler._generate_cpy_struct_collecttypec C s2 |j d�}d|kr"||jdd�fS |d| fS d S )Nr r rb )r� r� )r rB r� r r r � _struct_names� s zRecompiler._struct_namesc C s | j |f| j|��� d S )N)r� r� )r rB r r r r �_generate_cpy_struct_decl� s z$Recompiler._generate_cpy_struct_declc C s | j |f| j|��� d S )N)r� r� )r rB r r r r �_generate_cpy_struct_ctx� s z#Recompiler._generate_cpy_struct_ctxc C s( t |tj�r| j||� n | j|� d S )N)rN r rP � _generate_cpy_enum_collecttyper� )r rB r r r r �#_generate_cpy_anonymous_collecttype� s z.Recompiler._generate_cpy_anonymous_collecttypec C s. t |tj�r| j|� n| j||d| � d S )N�typedef_)rN r rP �_generate_cpy_enum_declr� )r rB r r r r � _generate_cpy_anonymous_decl� s z'Recompiler._generate_cpy_anonymous_declc C s0 t |tj�r| j||� n| j||d| � d S )Nr� )rN r rP � _enum_ctxr� )r rB r r r r �_generate_cpy_anonymous_ctx� s z&Recompiler._generate_cpy_anonymous_ctx�constc C s� ||f| j kr td||f ��| j j||f� | j}d||f }|r�|d| � |d� |d|f � |d||f � |d k r�|dkr�d|f }|d |f � |d � |d � |d � n2|d | � |d� |d|jd�|f � |d � |� d S )Nz duplicate declaration of %s '%s'z _cffi_%s_%sz$static int %s(unsigned long long *o)r� z int n = (%s) <= 0;zI *o = (unsigned long long)((%s) | 0); /* check that %s is an integer */r z%dUz" if (!_cffi_check_int(*o, n, %s))z n |= 2;z return n;r� zstatic void %s(char *o)z *(%s)o = %s;r )r� r r� r| r� )r �is_intr rB �categoryr r� �funcnamer r r �_generate_cpy_const s0 z Recompiler._generate_cpy_constc C s" |j � }| s| jr | j|� d S )N)r� r< rY )r rB r r r r r �"_generate_cpy_constant_collecttype& s z-Recompiler._generate_cpy_constant_collecttypec C s |j � }| j|||� d S )N)r� r )r rB r r r r r r� + s z&Recompiler._generate_cpy_constant_declc C s` | j r |j� r ttd�}n$| j r(t}nt}| j| }t||�}| jd jt |d| |�� d S )Nr rl z_cffi_const_%sr� ) r< r� r� �OP_CONSTANT_INTZOP_DLOPEN_CONSTZ OP_CONSTANTrD rr rI r )r rB r r Z const_kindr& r r r r� / s z%Recompiler._generate_cpy_constant_ctxc C s | j |� d S )N)rY )r rB r r r r r� ? s z)Recompiler._generate_cpy_enum_collecttypec C s x|j D ]}| jd|� qW d S )NT)� enumeratorsr )r rB r � enumeratorr r r r� B s z"Recompiler._generate_cpy_enum_declc C s� | j | }ttd �}| jr"|j� x:t|j|j�D ](\}}| jd j t |d| ||d�� q2W |d k r�d|kr�| j r�d| }d| }n4|j | j g �} | j j | �}tt| j j| d ��dk �}d j|j�} | jd j t|j|||| �� d S ) Nr rl z_cffi_const_%s)r r� z sizeof(%s)z ((%s)-1) <= 0r r. ro r� r� )rD r� �OP_ENUMr< Zcheck_not_partial�zipr Z enumvaluesrr rI r Zbuild_baseinttyper: Zsizeof�int�castr0 r1 r ) r rB r� r& r r Z enumvaluer r2 Zbasetpr3 r r r r F s" zRecompiler._enum_ctxc C s | j ||j� � d S )N)r r� )r rB r r r r �_generate_cpy_enum_ctx[ s z!Recompiler._generate_cpy_enum_ctxc C s d S )Nr )r rB r r r r � _generate_cpy_macro_collecttypea s z*Recompiler._generate_cpy_macro_collecttypec C s& |dkrd }n|}| j d||d� d S )Nz...T)r )r )r rB r r r r r �_generate_cpy_macro_decld s z#Recompiler._generate_cpy_macro_declc C sT |dkr"| j r td|f ��d }n|}ttd�}| jd jt|d| ||d�� d S )Nz...zGcannot use the syntax '...' in '#define %s ...' when using the ABI moder rl z_cffi_const_%s)r r� )r< r r� r rr rI r )r rB r r r r r r �_generate_cpy_macro_ctxk s z"Recompiler._generate_cpy_macro_ctxc C sF t |tj�rB|j}|dkr$d|f }| j|jd| �}tj||�}|S )Nz...z_cffi_array_len(%s)z%s[0])rN r r� rK r� r� )r rB Z global_namer� r� r r r r� | s zRecompiler._global_typec C s | j | j||�� d S )N)rY r� )r rB r r r r �"_generate_cpy_variable_collecttype� s z-Recompiler._generate_cpy_variable_collecttypec C s� | j }| j||�}t|tj�r4|jd kr4|j}d}nd}d|f }|d|j|| jd� � |d� |d||f � |d� |� d S ) Nr �&z*_cffi_var_%s(void)zstatic )rj r� z return %s(%s);r� ) r| r� rN r r� rK r� r� rf )r rB r r� Z ampersandr� r r r �_generate_cpy_variable_decl� s z&Recompiler._generate_cpy_variable_declc C sL | j ||�}| j| }| jr"t}nt}| jd jt|d| t||��� d S )Nrl z _cffi_var_%s) r� rD r< Z OP_GLOBAL_VARZOP_GLOBAL_VAR_Frr rI r r� )r rB r r& r r r r �_generate_cpy_variable_ctx� s z%Recompiler._generate_cpy_variable_ctxc C s | j |� d S )N)rY )r rB r r r r �'_generate_cpy_extern_python_collecttype� s z2Recompiler._generate_cpy_extern_python_collecttypec C s | j }t|jtj�rd}n d| }d|jjd|�f }|d| � |d| j||f � |� g }d| }x0t|j�D ]"\}} | jd| |�} |j | � qtW d j |�} | p�d } d || f } |j d kr�d | } dd� } t t |j�d d�}| |j�r�t |d�}t|jtj��r*d|jjd�||jjd�|f }|d||jj| �f � |d� |d| � |d� xft|j�D ]X\}} d| } t| tj��s�| | ��r�d| } tj| �} |d| jd�|d | f � �qjW |d| � t|jtj��s�|d |jjd�f � |d � |� | jd 7 _d S ) Nr� z result of %sz(int)sizeof(%s)r z3static struct _cffi_externpy_s _cffi_externpy__%s =z { "%s.%s", %s };zargument of %sz a%dz, r� z%s(%s)� __stdcallz_cffi_stdcall c S s t | tj�o| jdkS )Nz long double)rN r r� r )rB r r r �may_need_128_bits� s z9Recompiler._extern_python_decl.<locals>.may_need_128_bitsr6 � z!sizeof(%s) > %d ? sizeof(%s) : %dz%s%sr� z char a[%s];z char *p = a;za%dr z *(%s)(p + %d) = %s;r z, _cffi_call_python(&_cffi_externpy__%s, p);z return *(%s)p;r� r )r| rN r� r r� r� r; rQ rJ rI r0 r� r? r rO r� r� )r rB r Z tag_and_spacer� Zsize_of_resultr� r� rV r� r� r� r� r Z size_of_ar r r �_extern_python_decl� sX " z Recompiler._extern_python_declc C s | j ||d� d S )Nzstatic )r )r rB r r r r � _generate_cpy_extern_python_decl� s z+Recompiler._generate_cpy_extern_python_declc C s | j ||d� d S )NzCFFI_DLLEXPORT )r )r rB r r r r �#_generate_cpy_dllexport_python_decl� s z.Recompiler._generate_cpy_dllexport_python_declc C s | j ||d� d S )Nr )r )r rB r r r r �'_generate_cpy_extern_python_plus_c_decl� s z2Recompiler._generate_cpy_extern_python_plus_c_declc C sR | j rtd��|jr td��| j| }tt|�}| jd jt |d| ||�� d S )Nz,cannot use 'extern "Python"' in the ABI modez$a vararg function is extern "Python"rl z&_cffi_externpy__%s) r< r r� r rD r� ZOP_EXTERN_PYTHONrr rI r )r rB r r& r r r r � _generate_cpy_extern_python_ctx� s z*Recompiler._generate_cpy_extern_python_ctxc C sz | j }|d� xf|jd�D ]X}|d| j� � d}x6|D ].}t|�dkrT||� d}|dt|�f 7 }q8W ||� qW d S )Nz=// # NB. this is not a string because of a size limit in MSVCTz// r �L z%d,)r| � splitlines�rstripr �ord)r �sr� �lineZ printed_line�cr r r r� s z)Recompiler._print_string_literal_in_arrayc C s t tt�| j|< d S )N)r� � OP_PRIMITIVEZ PRIM_VOIDrH )r rB r� r r r �_emit_bytecode_VoidType s z"Recompiler._emit_bytecode_VoidTypec C s t |j }tt|�| j|< d S )N)ZPRIMITIVE_TO_INDEXr r� r' rH )r rB r� r7 r r r � _emit_bytecode_PrimitiveType s z'Recompiler._emit_bytecode_PrimitiveTypec C s( d|j |j |j f }tt|�| j|< d S )Nzl_cffi_prim_int(sizeof(%s), ( ((%s)-1) | 0 /* check that %s is an integer type */ ) <= 0))r r� r' rH )r rB r� r$ r r r �!_emit_bytecode_UnknownIntegerType s z,Recompiler._emit_bytecode_UnknownIntegerTypec C s$ d|j |j f }tt|�| j|< d S )Nzd_cffi_prim_float(sizeof(%s) * (((%s)1) / 2) * 2 /* integer => 0, float => 1 */ ))r r� r' rH )r rB r� r$ r r r � _emit_bytecode_UnknownFloatType s z*Recompiler._emit_bytecode_UnknownFloatTypec C s� t t| j|j �| j|< |d7 }xR|jD ]H}| j| }||krht|tj�rX| j ||� nt t |�| j|< |d7 }q(W t |j �}|j d k r�|j dkr�|dO }ntd|j f ��t t|�| j|< d S )Nr r r4 zabi=%r)r� Z OP_FUNCTIONrD r� rH rJ rN r r� r) r! r r� r� r ZOP_FUNCTION_END)r rB r� rU Z realindexr' r r r � _emit_bytecode_RawFunctionType# s z)Recompiler._emit_bytecode_RawFunctionTypec C s t t| j|j �| j|< d S )N)r� � OP_POINTERrD r� rH )r rB r� r r r �_emit_bytecode_PointerType6 s z%Recompiler._emit_bytecode_PointerTypec C s" |j � }tt| j| �| j|< d S )N)r[ r� r- rD rH )r rB r� �rawr r r � _emit_bytecode_FunctionPtrType< s z)Recompiler._emit_bytecode_FunctionPtrTypec C s| | j |j }|jd kr(tt|�| j|< nP|jdkrNtdt|�jdd�f ��n*tt |�| j|< td t|j��| j|d < d S )Nz...zitype %s badly placed: the '...' array length can only be used on global arrays or on fields of structuresz/*...*/r ) rD r� rK r� Z OP_OPEN_ARRAYrH r rG r� ZOP_ARRAY)r rB r� Z item_indexr r r �_emit_bytecode_ArrayType@ s z#Recompiler._emit_bytecode_ArrayTypec C s | j | }tt|�| j|< d S )N)rL r� ZOP_STRUCT_UNIONrH )r rB r� Z struct_indexr r r �_emit_bytecode_StructTypeN s z$Recompiler._emit_bytecode_StructTypec C s | j | }tt|�| j|< d S )N)rM r� r rH )r rB r� Z enum_indexr r r �_emit_bytecode_EnumTypeS s z"Recompiler._emit_bytecode_EnumType)F)r )N)Nr N)N)Ur r r r� r r@ rX rY rE rs rx r| r� r� r~ r� r} r� r� r� r� r� r� r� r� r� r� r� r� r� r` r� r� r� r� rv r� Z _generate_cpy_union_collecttyper� r� Z_generate_cpy_union_declr� Z_generate_cpy_union_ctxr� r� r r r r� r� r� r� r r r r r r� r r r r Z*_generate_cpy_dllexport_python_collecttypeZ._generate_cpy_extern_python_plus_c_collecttyper r r r r Z"_generate_cpy_dllexport_python_ctxZ&_generate_cpy_extern_python_plus_c_ctxr� r( r) r* r+ r, r. Z _emit_bytecode_ConstPointerTypeZ _emit_bytecode_NamedPointerTyper0 r1 r2 Z_emit_bytecode_UnionTyper3 r r r r r9 { s� : , 4-# ! Q 5 r9 � c s e Zd Z� fdd�Z� ZS )�NativeIOc s( t |t�r|jd�}tt| �j|� d S )N�ascii)rN Zunicode�encode�superr5 r{ )r r$ )rS r r r{ \ s zNativeIO.write)r r r r{ � __classcell__r r )rS r r5 [ s r5 c C s |rt d|f � t| ||d kd�}|j� |j� t� }|j||� |j� }y@t|d�� }|jt |�d �|krvt �W d Q R X |r�t d� dS t k �r d|t j � f } t| d��}|j |� W d Q R X yt j| |� W n, tk �r t j|� t j| |� Y nX d S X d S ) Nz generating %s)r< r� r z(already up-to-date)Fz%s.~%d�wT)�printr9 rX rx r5 r� �getvaluer� �readr �IOErrorr� �getpidr{ �rename�OSError�unlink) r: r; r� Z target_file�verboseZ recompilerr �output�f1Ztmp_filer r r �_make_c_or_py_sourcea s4 rF Fc C s t | ||||�S )N)rF )r: r; r� Z target_c_filerC r r r � make_c_source} s rG c C s t | |d ||�S )N)rF )r: r; Ztarget_py_filerC r r r �make_py_source� s rH c C sj |j d�}y$tjtjj| f|d d� �� � W n tk rB Y nX |d |7 < tjj| f|�� |fS )Nr� r r� r� )rd r� �makedirsr� r0 rA )Z outputdir�modname� extension�partsr r r �_modname_to_file� s $rM c C s* t ||�}| j|||f� t|||� |S )N)rR rI �setattr)� patchlist�clsr Znew_meth�oldr r r � _patch_meth� s rR c C s( x"t | �D ]\}}}t|||� q W d S )N)�reversedrN )rO rP r Zold_methr r r �_unpatch_meths� s rT c s\ t jdkr(ddlm} t| |ddd� � t jdkrXddlm} � fd d �}t| |d |�� d S ) N�win32r )� MSVCCompilerZ_remove_visual_c_refc S s |S )Nr )r Z manifest_filer r r rC � s z&_patch_for_embedding.<locals>.<lambda>�darwin)� CCompilerc s< d| j kr,t| j �| _ | j jd�}d| j |< � | f|�|�S )Nz-bundlez -dynamiclib)Z linker_sor� r� )r rJ �kwdsrV )�old_link_shared_objectr r �my_link_shared_object� s z3_patch_for_embedding.<locals>.my_link_shared_objectZlink_shared_object)�sys�platformZdistutils.msvc9compilerrV rR Zdistutils.ccompilerrX )rO rV rX r[ r )rZ r �_patch_for_embedding� s r^ c sl ddl m} � jd�rR� d d � � tjdkr6� d7 � n tjdkrJ� d7 � n� d 7 � t| |d � fd d �� d S )Nr )� build_extz.*r4 rU z.dllrW z.dylibz.soZget_ext_filenamec s � S )Nr )r Zext_name)�targetr r rC � s z#_patch_for_target.<locals>.<lambda>r� )Zdistutils.command.build_extr_ �endswithr\ r] rR )rO r` r_ r )r` r �_patch_for_target� s rb r� T�.cc K s� t |t�s|jd�}| jr$| j| � |d k �r^| jd k } | rF| j| � |d krzt|||�\}} |rl|g| } tj j | � }n|}| d kr�| r�d| } nd} t j ||f| �}t | ||||d�}|�rTg }tj� }zn| r�t|� | dkr�t|| � |�r |dk�rd}nd}td|tj j|�f � tj|� t jd||| �}W d tj|� t|� X |S ||fS n<|d k�rxt||d �\}}t| |||d�}|�r�|S d |fS d S ) Nr6 z%s.*r )rC r� zthe current directory isz setting the current directory toz%s %rz.py)rN rG r7 Z_windows_unicodeZ_apply_windows_unicoder� Z_apply_embedding_fixrM r� r� r0 r Z get_extensionrG �getcwdr^ rb r; �abspath�chdir�compilerT rH )r: r; r� �tmpdirZcall_c_compilerZc_fileZsource_extensionZextradirZcompiler_verboser` �debugrY Z embeddingrL Z ext_c_fileZext�updatedrO �cwd�msg�outputfilenamerb r r r � recompile� sb rn c O s� ddl m} dd l}|jdt|�� t| ||f|�|�}|j||�}xFt|j�D ]8} | j d�sPt |j| �} | t | | t � �k rPt | | | � qPW dd� } | | _ x6t| �D ]*} | j d� r�t|j| � r�t | | t� q�W |jS )Nr )�udirrh rb c _ s t �d S )N)r )rJ rY r r r �typeof_disabled s z _verify.<locals>.typeof_disabled)Z testing.udirro �imp� setdefaultrG rn Z load_dynamic�dirr: r� rR �objectrN Z_typeof�hasattr�NotImplemented�lib) r: r; r� rJ rY ro rq rm �moduler �attrrp r r r �_verify s rz )r4 )F)F)r� TNrc Nr NN) r� r\ �ior r r �errorr Z cffi_opcoder= r� r� r r r% r1 r8 r9 � version_info�StringIOr5 �BytesIOrF rG rH rM rR rT r^ rb rn rz r r r r �<module> sH f <PK %�\�x���O �O ( __pycache__/cparser.cpython-36.opt-1.pycnu �[��� 3 M��ZR� � @ s� d dl mZ d dlmZmZ d dlmZmZ yd dl mZ W n e k rX ddl Z Y nX ddl Z ddl Z ddl Z y(e jd#k r�ddlZnddlZej� ZW n e k r� dZY nX dZe jd e je jB �Ze jd e je jB �Ze jd �Ze jd �Ze jd �Ze jd�Z da e jde j �Z e jd�Z e jd�Z!e jd�Z"e jd�Z#e jd�Z$e jd�Z%e jd�Z&dd� Z'dd� Z(dd � Z)d d � Z*d d � Z+G d!d"� d"e,�Z-dS )$� )�model)� COMMON_TYPES�resolve_common_type)�FFIError� CDefError)� _pycparser� N� z<cdef source string>z /\*.*?\*/|//([^\n\\]|\\.)*?$z?^\s*#\s*define\s+([A-Za-z_][A-Za-z_0-9]*)\b((?:[^\n\\]|\\.)*?)$z =\s*\.\.\.\s*[,}]|\.\.\.\s*\}z__dotdotdot\d+__$z\[\s*\.\.\.\s*\]z\w+|\Sz-?0?x?[0-9a-f]+[lu]*$z\b(__stdcall|WINAPI)\bz[(]\s*(__stdcall|WINAPI)\bz \b__cdecl\bz9\bextern\s*"(Python|Python\s*\+\s*C|C\s*\+\s*Python)"\s*.z'[*]\s*((const|volatile|restrict)\b\s*)+z3(\b(int|long|short|signed|unsigned|char)\s*)+\.\.\.z\b(double|float)\s*\.\.\.c C s t d krtj� a t S )N)� _parser_cache� pycparserZCParser� r r � /usr/lib64/python3.6/cparser.py� _get_parser* s r c C s g }x�t j| �}|sP |j| d |j� � � |jd� d}|j|j� � |j� }| jd|�rn|jd� |d7 }d}|}x`|t| �k r�| | }|dkr�|d7 }n.|dkr�|dkr�P |d8 }n|dkr�|dkr�P |d7 }qxW | ||� | | |d � } qW |j| � dj|�S )N�(�)�*r r z,;=� ) �_r_star_const_space�search�append�start�group�end� startswith�len�join)�csource�parts�match�closing�endpos�level�i�cr r r � _workaround_for_old_pycparser0 s< r$ c C s0 g }�xt j| �}|sP |j� d }|j| d |j� � � d|jd�krT|jd� n |jd� | | dkr�| jd|�}|dk r�td��| jd|d |�dkr�td ��|j| |d |� � | |d d � } nB| jd |�}|dk r�td ��|j| ||d � � | |d d � } |jd � qW |j| � d j |�S )Nr �Cz(void __cffi_extern_python_plus_c_start; z!void __cffi_extern_python_start; �{�}r z!'extern "Python" {': no '}' foundz7cannot use { } inside a block 'extern "Python" { ... }'�;z 'extern "Python": no ';' foundz void __cffi_extern_python_stop;r ) �_r_extern_pythonr r r r r �findr �NotImplementedErrorr )r r r r r Z semicolonr r r �_preprocess_extern_pythonZ s4 r, c C s\ t jd| �} i }x6tj| �D ](}|j� \}}|jdd�j� }|||< q W tjd| �} tjdk rft | �} t jd| �} t jd| �} t jd| �} t | �} tjd| �} ttj| ��}x�tt|��D ]v\}}|j� }| | dk�r| jd ||j� �}d | d |� || |d d � f } q�d | d |� || |d d � f } q�W tjd | �} tjd| �} | jd d�|fS )N� z\ r z2.14z volatile volatile const(z volatile volatile const z[__dotdotdotarray__]�=z...z%s,__dotdotdot%d__ %sr z%s __dotdotdot%d__ %sz __dotdotdotint__ z __dotdotdotfloat__ z __dotdotdot__ )� _r_comment�sub� _r_define�finditer�groups�replace�stripr � __version__r$ � _r_stdcall2� _r_stdcall1�_r_cdeclr, �_r_partial_array�list�_r_partial_enum� enumerate�reversedr r* r �_r_int_dotdotdot�_r_float_dotdotdot) r �macrosr Z macronameZ macrovalueZmatchesZnumber�pZp2r r r � _preprocess� s4 rC c C s t t�}|jd� |jd� |jd� |jd� |jd� t � }d}d}d}x�tj| �D ]�}||kr�|dkr�|r�|j|� |j|� d}nj|dkr�d }d}nX|dkr�|d 7 }nF|dkr�|d 8 }n4|dkr�|r�|dkr�|j|� |j|� n |j|� |}qXW |S ) Nr( �,r r �typedefFr r Tr )�setr �add�_r_words�findall�discard)r Zlook_for_wordsZ words_usedZ is_typedefZparenZ previous_wordZwordr r r �_common_type_names� s> rK c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd8d d �Zd d � Zdd� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zd9d d �Zd d � Zd:d"d#�Zd;d$d%�Zd<d&d'�Zd(d)� Zd=d*d+�Zd,d-� Zd>d.d/�Zd0d1� Zd2d3� Zd4d5� Zd6d7� Z d!S )?�Parserc C s: i | _ t� | _d| _tj� | _i | _i | _g | _ d | _ d S )Nr ) � _declarationsrF �_included_declarations�_anonymous_counter�weakref�WeakKeyDictionary�_structnode2type�_options�_int_constants� _recomplete�_uses_new_feature)�selfr r r �__init__� s zParser.__init__c C s4 t |�\}}t|�}g }x<t| j�D ].}|jd�r$|dd � }|j|� |j|� q$W |t|�7 }g }|jd� x|D ]}|jd| � qvW |jd� |jdtf � |j|� dj|�}t d k r�t j � zJyt � j |�} W n4 t jjk �r } z| j| |� W Y d d } ~ X nX W d t d k �r(t j� X | ||fS )Nztypedef � z*# 1 "<cdef automatic initialization code>"ztypedef int %s;z@typedef int __dotdotdotint__, __dotdotdotfloat__, __dotdotdot__;z# 1 "%s"� )rC rK �sortedrM r r rJ �CDEF_SOURCE_STRINGr �lock�acquirer �parser Zc_parserZ ParseError�convert_pycparser_error�release) rW r rA Zctn� typenames�name� csourcelines�typenameZ fullcsource�ast�er r r �_parse� s4 " z Parser._parsec C sf d }t |�}tjdtf |�}|rbt|jd�d�}|j� }d| koPt|�kn rb||d }|S )Nz %s:(\d+):r � )�str�rer r\ �intr � splitlinesr )rW rg r �line�msgr Zlinenumrd r r r �_convert_pycparser_error s z Parser._convert_pycparser_errorc C s@ | j ||�}t|�}|r*d|j� |f }n d|f }t|��d S )Nzcannot parse "%s" %szparse error %s)rp rj r5 r )rW rg r rn ro r r r r` + s z Parser.convert_pycparser_errorFc C s0 | j }z |||d�| _ | j|� W d || _ X d S )N)�override�packed� dllexport)rS �_internal_parse)rW r rq rr rs Z prev_optionsr r r r_ 5 s z Parser.parsec C s | j |�\}}}| j|� t|j�}x|D ]}|jdkr*P q*W d }�yBd| _�x4|D �]*}|}t|tjj �rx| j |� qTt|tjj ��r^|js�t d|��d}t|j j tjj�r�|j j jd jd�r�| j|�}nxt|j tjj��r.t|j j tjj��r.t|j j j tjj��r.|j j j jd jd��r.| j|�}n| j|j |jdd�\}}| jd |j ||d � qT|jjd k�rnqTt d |jj |��qTW W n� t k �r� } z&t| j�dk�r�| j|f | _� W Y d d } ~ X nN tk �r } z0| j | |�} | �r| jd d | f| _� W Y d d } ~ X nX d S )N� __dotdotdot__�__cffi_extern_python_stopz!typedef does not declare any namer r Z __dotdotdotT)rc �partial_length_okztypedef )�qualsZPragmazBunexpected <%s>: this construct is valid C but not valid in cdef()z *** Err: %s���ry ) rh �_process_macros�iter�extrc �_inside_extern_python� isinstancer �c_astZDecl� _parse_declZTypedefr �type�IdentifierType�namesr �_get_unknown_type�PtrDecl�TypeDecl�_get_unknown_ptr_type�_get_type_and_quals�_declare� __class__�__name__r �argsr rp ) rW r rf rA �iterator�declZ current_declrx Zrealtyperg ro r r r rt ? sV zParser._internal_parsec C s8 || j kr*| j | |kr d S td|f ��|| j |< d S )Nz%multiple declarations of constant: %s)rT r )rW �key�valr r r �_add_constantsu s zParser._add_constantsc C s� |j � jd�}|jd�}|r(|dd � }|jd�rV|dkrV|jd� rVd|dd � }t|d�}|rj| }| j||� | jd| |� d S ) NZul�-r �0�0xZ0or zmacro )�lower�rstripr rl r� r� )rW rc Zint_str�negZpyvaluer r r �_add_integer_constant} s z Parser._add_integer_constantc C sh xb|j � D ]V\}}|j� }tj|�r2| j||� q |dkrL| jd| |� q td||||f ��q W d S )Nz...zmacro z�only supports one of the following syntax: #define %s ... (literally dot-dot-dot) #define %s NUMBER (with NUMBER an integer constant, decimal/hex/octal) got: #define %s %s)�itemsr5 �_r_int_literalr r� r� r )rW rA r� �valuer r r rz � s zParser._process_macrosc C sX | j ||�}| jjd�r d}n$| jdkr.d}n| jdkr>d}nd}| j||j |� d S )Nrs zdllexport_python Z__cffi_extern_python_startzextern_python Z!__cffi_extern_python_plus_c_startzextern_python_plus_c z function )�_get_type_pointerrS �getr} r� rc )rW �tprx r� �tagr r r �_declare_function� s zParser._declare_functionc C s� |j }t|tjj�r:| j||jd�\}}| j|||� �n�t|tjj�rV| j d|� nHt|tjj �rr| j d|� n,t|tjj �r�| j d|� n|js�t d|��|j�r�| j|dd�\}}|j r�| j|||� �n$|j� o�t|d�o�t|jd �o�tj|jj��r| j|j|jj� n�|j� �rxt|jtjj��rx|jjd k�rxt|jjd ��rxtj|jjj��rx| j|jd |jjj � n||tjk�r�|jjd ��r�|j| _nX| jd k�r�t d ��|tj @ �r�|j �r�| j d|j ||d� n| j d|j ||d� d S )N)rc �struct�union�enumz'construct does not declare any variableT)rw �initr� r� Z__cffi_extern_python_rv z<cannot declare constants or variables with 'extern "Python"'z constant )rx z variable ) r� r~ r r �FuncDeclr� rc r� �Struct�_get_struct_union_enum_type�Union�Enumr Zis_raw_functionZis_integer_type�hasattrr� r� r r� r� �UnaryOp�op�exprr � void_typer r} �Q_CONSTZ is_array_typer� )rW r� Znoder� rx r r r r� � sN zParser._parse_declc C s | j |�d S )Nr )�parse_type_and_quals)rW �cdeclr r r � parse_type� s zParser.parse_typec C sX | j d| �d d� \}}|jd jjjd }t|tjj�rLt d|j f ��| j |j�S )Nzvoid __dummy( %s );� r r zunknown identifier '%s'ry ) rh r| r� r� �paramsr~ r r �IDr rc r� )rW r� rf rA �exprnoder r r r� � s zParser.parse_type_and_qualsr c C sh || j krF| j | \}}||kr,||kr,d S | jjd�sFtd|f ��||f| j |< |rd| jj|� d S )Nrq zPmultiple declarations of %s (for interactive usage, try cdef(xx, override=True)))rM rS r� r rN rG )rW rc �obj�includedrx ZprevobjZ prevqualsr r r r� � s zParser._declarec C sZ d}t |tjjtjjf�rVd|jkr.|tjO }d|jkrB|tjO }d|jkrV|tj O }|S )Nr �const�volatileZrestrict) r~ r r r� r� rx r r� Z Q_VOLATILEZ Q_RESTRICT)rW r� rx r r r �_extract_quals� s zParser._extract_qualsNc C sj t |tj�r|j� S t |tj�r^|jjd�r^|jdd � j� r^|jd kr^|d k r^tj |||�S tj ||�S )N�$r ) r~ r �RawFunctionType�as_function_pointerZStructOrUnionOrEnumrc r �isdigit� forcenameZNamedPointerType� PointerType)rW r� rx �declnamer r r r� s zParser._get_type_pointerc C sH t |tjj�rtt |jtjj�rtt|jj�dkrtd|jjd | jkrt| jd|jjd \}}|| j |�O }||fS t |tjj �r�|j d kr�d }n| j |j |d�}| j |j|d�\}}tj||�|fS t |tjj��r| j |j�\}}| j|||d�}| j |�}||fS t |tjj��r�| j |�}|j} t | tjj��rVt| j�} | ddgk�ri } x<| �r�| d }|dk�r�| j|d�d | |< | d= nP �qVW g } x4dD ],} x$t| j| d��D ]}| j| � �q�W �q�W | �s�d g} | d gk�r�d| k�s�d | k�r�g } | | } d j| �}|d k�r"tj|fS |dk�r<td|jj ��t| |�\}}|||B fS t | tjj ��r|| j d| |�}||fS t | tjj ��r�| j d| |�}||fS t | tjj ��r�| j d| |�}||fS t |tjj ��r�| j!||�dfS t |tjj ��r| j d||dd�dfS t |tjj ��r4| j d||dd�dfS td|jj ��d S )Nr ztypedef r )rw )r� �signed�char�short�long�unsignedrl r- �voidru z:%d: bad usage of "..."r� r� r� T)�nestedz(:%d: bad or unsupported type declaration)r� r� r� r� )r� r� r� )"r~ r r r� r� r� r r� rM r� Z ArrayDeclZdim�_parse_constantr� r � ArrayTyper� r� r; r� �ranger r r� r �coordrn r r� r� r� r� r� �_parse_function_type)rW �typenoderc rw r� rx ZlengthZitemtypeZ itemqualsr� r� �prefixesZnewnames�prefixr" ZidentZtp0Zquals0r r r r� s� zParser._get_type_and_qualsc s< t t|jdg ��}x@t|�D ]4\}}t|d�s td|p8d|d t|dd�f ��q W t|�dko�t|d jt j j �o�t|d jjt j j �o�|d jjj d gk}|r�|j� |s�td |p�d ��� fd d �|D �}| r�|tjgkr�g }� j|j�\}} d } t|jd ��r(|jjdd � dddgk�r(d} tjt|�||| �S )Nr� r� zt%s arg %d: unknown type '%s' (if you meant to use the old C syntax of giving untyped arguments, it is not supported)z in expressionr rc �?r ru z=%s: a function with only '(...)' as argument is not correct Cc s g | ]}� j � j|j�� �qS r )� _as_func_argr� r� )�.0Z argdeclnode)rW r r � <listcomp>| s z/Parser._parse_function_type.<locals>.<listcomp>rx r r� r� Z __stdcallry ry ry ���)r; �getattrr� r= r� r r r~ r� r r r� r� r� �popr r� r� rx r� �tuple) rW r� �funcnamer� r" �argZellipsisr� �resultrx �abir )rW r r� g s6 zParser._parse_function_typec C s6 t |tj�rtj|j|�S t |tj�r.|j� S |S d S )N)r~ r r� r� �itemr� r� )rW r� rx r r r r� � s zParser._as_func_argc C s, y | j | S tk r Y nX |}|j}|d krb|d k rDd| }n| jd7 _d| j }d }n"|}d||f }| jj|d�\}} |d k�r|dkr�tj|d d d �}nP|dkr�tj|d d d �}n6|dkr�|dkr�t d ��| j ||j �}nt d |f ��|d k �r2| j ||� n"|dk�r2|j d k �r2td | ��|j�sD|j|� |j�rjd |jk�rj| j d |j |� || j |< |dk�r�|S |jd k�r�|S |jd k �r�t d| ��g } g } g } g } x�|jD ]�}t|jtjj��r�dj|jj�dk�r�| j||� �q�|jd k�rd}n | j |j�}d| _ | j |jdd�\}}| j �rH| j||� t|tj��rj|j �rj| j||� | j |j�pxd� | j |� | j |� | j |� �q�W t!| �|_t!| �|_"t!| �|_#t!| �|_$| dgt%| � k�r t|tj��r |j �r td|f ��| j&jd�|_'|j(�r(d|_(| j)j |� |S )Nz$%sr z$%dz%s %sr� r� r� ru z!Enums cannot be declared with ...z kind = %rz^enum %s: the '{}' declaration should appear on the first time the enum is mentioned, not laterr� z anonymous %sz"duplicate declaration of struct %sr FT)rw z#%s: using both bitfields and '...;'rr r )NNry ry )*rR �KeyErrorrc rO rM r� r Z StructTypeZ UnionTyper �_build_enum_type�values�AssertionErrorr� r+ r� Zforce_the_name�decls�fldnamesr~ r� r r r� r r� � _make_partial�bitsizer� �_partial_lengthr� �partialr r� �fldtypes� fldbitsize�fldqualsr rS rr Z completedrU )rW �kindr� rc r� Z force_name� explicit_namer� r� �_r� r� r� r� r� r� Zfqualr r r r� � s� z"Parser._get_struct_union_enum_typec C sB t |tj�std|f ��|j� r8| r8td|f ��d|_d S )Nz%s cannot be partialz %s is partial but has no C nameT)r~ r Z StructOrUnionr Z has_c_namer+ r� )rW r� r� r r r r� s zParser._make_partialc C s� t |tjj�r�|j}|jd�rF|jd�s2|jd�r<t|d�S t|d�S d|d ko\dkn rlt|d �S |d d kr�|d d kr�t|�d ks�t|�d kr�|d dkr�t|d �S t d|f ��t |tjj �r�|j dkr�| j |j �S t |tjj ��r|j dk�r| j |j � S t |tjj��r:|j| jk�r:| j|j S t |tjj��rv|jdk�rv|�rfd| _dS td|jj ��t |tjj��r�|j dk�r�| j |j�| j |j� S t |tjj��r�|j dk�r�| j |j�| j |j� S td|jj ��d S )Nr� r� Z0X� rY �1r �9ri �'r r � �\r� zinvalid constant %r�+r� Z__dotdotdotarray__Tz...zT:%d: unsupported '[...]' here, cannot derive the actual array length in this contextz?:%d: unsupported expression: expected a simple numeric constantry ���)r~ r r ZConstantr� r rl r �ordr r� r� r� r� r� rc rT r� r r� rn ZBinaryOp�left�right)rW r� rw �sr r r r� sL $ zParser._parse_constantc C s� |d k r�d}g }g }d}xb|j D ]X}tj|j�r6d}q |jd k rL| j|j�}|j|j� |j|� | j|j|� |d7 }q W t|�}t|�}t j |||�}||_ nt j |f f �}|S )NFr Tr ) � enumerators�_r_enum_dotdotdotr rc r� r� r r� r� r ZEnumTyper� ) rW r� r� r� r� Z enumvaluesZ nextenumvaluer� r� r r r r� B s* zParser._build_enum_typec C sz xP|j j� D ]B\}\}}|jd�r$q |jdd�d }|d kr | j||d |d � q W x"|jj� D ]\}}| j||� q^W d S ) Nzanonymous $enum_$r- r r r� r� r� � anonymousrE T)r� rx )r� r� r� r� rE )rM r� r �splitr� rT r� )rW �otherrc r� rx r� �k�vr r r �includeZ s zParser.includec C s� |j j j}|dgkr tj|j�S |dgkrL| jd kr@d|j | _tj|j�S |dgkrx| jd krld|j | _tj|j�S td|j j ��d S )Nru Z__dotdotdotint__z'typedef int... %s'Z__dotdotdotfloat__z'typedef float... %s'z*:%d: unsupported usage of "..." in typedef) r� r� r Z unknown_typerc rV ZUnknownIntegerTypeZUnknownFloatTyper r� rn )rW r� rb r r r r� d s zParser._get_unknown_typec C s2 |j j j jdgkr tj|j�S td|jj ��d S )Nru z*:%d: unsupported usage of "..." in typedef)r� r� r Zunknown_ptr_typerc r r� rn )rW r� r r r r� w s z Parser._get_unknown_ptr_type)FFF)Fr )N)NF)N)NF)F) r� � __module__� __qualname__rX rh rp r` r_ rt r� r� rz r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r� r� r r r r rL � s4 & 6 2 ^ # v 3 rL )r ).r r Z commontypesr r �errorr r r r � ImportErrorrP rk �sys� version_infoZthread�_thread� allocate_lockr] r\ �compile�DOTALL� MULTILINEr/ r1 r< r� r: rH r � IGNORECASEr� r8 r7 r9 r) r r? r@ r r$ r, rC rK �objectrL r r r r �<module> sN *27(PK %�\- W�G G , __pycache__/cffi_opcode.cpython-36.opt-1.pycnu �[��� 3 M��Z\ � 4 @ s< d dl mZ G dd� de�Zdd� Zd ZdZdZdZd Z d Z d Z d Z d Z dZdZdZdZdZdZdZdZdZdZdZdZdZd ZdZ dZ d Z dZ d Z dZ!d Z"d Z#d Z$d Z%d Z&d Z'd!Z(d Z)d"Z*d Z+d#Z,dZ-d$Z.dZ/d%Z0dZ1d&Z2dZ3d'Z4dZ5d(Z6dZ7d)Z8dZ9d*Z:dZ;d+Z<dZ=d,Z>dZ?d-Z@dZAd.ZBdZCd/ZDd0ZEd1ZFd2ZGd3ZHd4ZId5ZJd6ZKd7ZLd8ZMd9ZNdDZOdEZPdFZQdGZRe e e!e#e%e e e e"e$e&e'e(e)eJeKee*eLeMe+e,e-e.e/e0e1e2e3e4e5e6e7e8e9e:e;e<e=e>e?e@eAeBeCeDeEeFeGeHeId:�3ZSd ZTdZUd ZVd ZWd"ZXeYd;d<� dHD ��ZZi Z[xDe\e]� j^� �D ]2\Z_Z`e_jadB��rebe`ec��re_ddC� e[e`< �qW dCS )I� )�VerificationErrorc @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �CffiOpc C s || _ || _d S )N)�op�arg)�selfr r � r �#/usr/lib64/python3.6/cffi_opcode.py�__init__ s zCffiOp.__init__c C s. | j d krd| jf S t| j }d|| jf S )Nz(_cffi_opcode_t)(%s)z_CFFI_OP(_CFFI_OP_%s, %s))r r � CLASS_NAME)r � classnamer r r � as_c_expr s zCffiOp.as_c_exprc C sn | j d kr>| jj� r>t| j�}|dkr6td| jf ��t|�S t| jt�rZtd| jf ��t| jd> | j B �S )N� � z"cannot emit %r: limited to 2**31-1zcannot emit to Python: %r� l ) r r �isdigit�int� OverflowError�format_four_bytes� isinstance�strr )r �valuer r r �as_python_bytes s zCffiOp.as_python_bytesc C s t j| j| j�}d|| jf S )Nz(%s %s))r �getr r )r r r r r �__str__ s zCffiOp.__str__N)�__name__� __module__� __qualname__r r r r r r r r r s r c C s, d| d? d@ | d? d@ | d? d@ | d@ f S )Nz\x%02X\x%02X\x%02X\x%02X� � � r r )Znumr r r r s r � � � � � � � � � � � � � � r �! �# �% �' �) � r � � r � � � r � � � r � � � � �" �$ �& �( �* �+ �, �- �. �/ �0 �1 �2 �3 �4 )3�charZshortr Zlongz long longz signed charz unsigned charzunsigned shortz unsigned intz unsigned longzunsigned long long�floatZdoublez long doublezfloat _Complexzdouble _ComplexZ_BoolZwchar_tZchar16_tZchar32_tZint8_tZuint8_tZint16_tZuint16_tZint32_tZuint32_tZint64_tZuint64_tZintptr_tZ uintptr_tZ ptrdiff_tZsize_tZssize_tZ int_least8_tZ uint_least8_tZ int_least16_tZuint_least16_tZ int_least32_tZuint_least32_tZ int_least64_tZuint_least64_tZ int_fast8_tZ uint_fast8_tZ int_fast16_tZ uint_fast16_tZ int_fast32_tZ uint_fast32_tZ int_fast64_tZ uint_fast64_tZintmax_tZ uintmax_tc C s g | ]}d | t � | f�qS )Z_CFFI_)�globals)�.0Z_keyr r r � <listcomp>� s rS �F_UNION�F_CHECK_FIELDS�F_PACKED� F_EXTERNAL�F_OPAQUEZOP_N���������rY )rT rU rV rW rX )d�errorr �objectr r Z OP_PRIMITIVEZ OP_POINTERZOP_ARRAYZ OP_OPEN_ARRAYZOP_STRUCT_UNIONZOP_ENUMZ OP_FUNCTIONZOP_FUNCTION_ENDZOP_NOOPZ OP_BITFIELDZ OP_TYPENAMEZOP_CPYTHON_BLTN_VZOP_CPYTHON_BLTN_NZOP_CPYTHON_BLTN_OZ OP_CONSTANTZOP_CONSTANT_INTZ OP_GLOBAL_VARZOP_DLOPEN_FUNCZOP_DLOPEN_CONSTZOP_GLOBAL_VAR_FZOP_EXTERN_PYTHONZ PRIM_VOIDZ PRIM_BOOLZ PRIM_CHARZ PRIM_SCHARZ PRIM_UCHARZ PRIM_SHORTZ PRIM_USHORTZPRIM_INTZ PRIM_UINTZ PRIM_LONGZ PRIM_ULONGZ PRIM_LONGLONGZPRIM_ULONGLONGZ PRIM_FLOATZ PRIM_DOUBLEZPRIM_LONGDOUBLEZ PRIM_WCHARZ PRIM_INT8Z PRIM_UINT8Z PRIM_INT16Z PRIM_UINT16Z PRIM_INT32Z PRIM_UINT32Z PRIM_INT64Z PRIM_UINT64Z PRIM_INTPTRZ PRIM_UINTPTRZ PRIM_PTRDIFFZ PRIM_SIZEZ PRIM_SSIZEZPRIM_INT_LEAST8ZPRIM_UINT_LEAST8ZPRIM_INT_LEAST16ZPRIM_UINT_LEAST16ZPRIM_INT_LEAST32ZPRIM_UINT_LEAST32ZPRIM_INT_LEAST64ZPRIM_UINT_LEAST64ZPRIM_INT_FAST8ZPRIM_UINT_FAST8ZPRIM_INT_FAST16ZPRIM_UINT_FAST16ZPRIM_INT_FAST32ZPRIM_UINT_FAST32ZPRIM_INT_FAST64ZPRIM_UINT_FAST64Z PRIM_INTMAXZ PRIM_UINTMAXZPRIM_FLOATCOMPLEXZPRIM_DOUBLECOMPLEXZ PRIM_CHAR16Z PRIM_CHAR32Z _NUM_PRIMZ _UNKNOWN_PRIMZ_UNKNOWN_FLOAT_PRIMZ_UNKNOWN_LONG_DOUBLEZ_IO_FILE_STRUCTZPRIMITIVE_TO_INDEXrT rU rV rW rX �dictZG_FLAGSr �listrQ �items�_nameZ_value� startswithr r r r r r �<module> s PK %�\NH�k k % __pycache__/lock.cpython-36.opt-1.pycnu �[��� 3 M��Z� � @ s| d dl Z e jdk rFyd dlmZ W qx ek rB d dlmZ Y qxX n2yd dlmZ W n ek rv d dlmZ Y nX dS )� N� )� allocate_lock)r )�sys� version_infoZthreadr � ImportErrorZ dummy_thread�_threadZ _dummy_thread� r r � /usr/lib64/python3.6/lock.py�<module> s PK %�\ - v}� }� % __pycache__/recompiler.cpython-36.pycnu �[��� 3 M��Z�� � @ s d dl Z d dlZd dlZddlmZmZ ddlmZ ddlT dZ dZ dZ G d d � d �Z G d d � d �Z G d d� d�ZG dd� d�ZG dd� d�ZG dd� d�Zejd0kr�ejZnG dd� dej�Zdd� Zd1dd �Zd2d d �Zd d � Zd!d"� Zd#d$� Zd%d&� Z d'd(� Z d3d,d-�Z d.d/� Z dS )4� N� )� ffiplatform�model)�VerificationError)�*i& i' i( c @ s& e Zd Zd dd�Zdd� Zdd� ZdS ) � GlobalExprr c C s" || _ || _|| _|| _|| _d S )N)�name�address�type_op�size� check_value)�selfr r r r r � r �"/usr/lib64/python3.6/recompiler.py�__init__ s zGlobalExpr.__init__c C s d| j | j| jj� | jf S )Nz' { "%s", (void *)%s, %s, (void *)%s },)r r r � as_c_exprr )r r r r r s zGlobalExpr.as_c_exprc C s d| j j� | j| jf S )Nz b'%s%s',%d)r �as_python_bytesr r )r r r r �as_python_expr s zGlobalExpr.as_python_exprN)r r )�__name__� __module__� __qualname__r r r r r r r r s r c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) � FieldExprc C s" || _ || _|| _|| _|| _d S )N)r � field_offset� field_size�fbitsize� field_type_op)r r r r r r r r r r s zFieldExpr.__init__c C s> dt | j� }d| j| jf d|| jf d|| jj� f S )N� z { "%s", %s, z %s %s, z %s %s },)�lenr r r r r )r Zspacesr r r r # s zFieldExpr.as_c_exprc C s t �d S )N)�NotImplementedError)r r r r r ) s zFieldExpr.as_python_exprc C sD | j jtkrd}n | j jtkr*t| j�}nt�d| j j� || jf S )N� z b'%s%s%s') r �op�OP_NOOP� OP_BITFIELD�format_four_bytesr r r r )r Z size_exprr r r �as_field_python_expr, s z FieldExpr.as_field_python_exprN)r r r r r r r$ r r r r r s r c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�StructUnionExprc C s4 || _ || _|| _|| _|| _|| _|| _|| _d S )N)r � type_index�flagsr � alignment�comment�first_field_index�c_fields) r r r& r' r r( r) r* r+ r r r r 8 s zStructUnionExpr.__init__c C sP d| j | j| jf d| j| jf d| jt| j�f | jrFd| j nd d S )Nz { "%s", %d, %s,z %s, %s, z%d, %d z /* %s */ r z},) r r& r' r r( r* r r+ r) )r r r r r C s zStructUnionExpr.as_c_exprc C s> t | jt�}dd� | jD �}dt| j�t|�| jdj|�f S )Nc S s g | ] }|j � �qS r )r$ )�.0Zc_fieldr r r � <listcomp>L s z2StructUnionExpr.as_python_expr.<locals>.<listcomp>z(b'%s%s%s',%s)�,)�evalr' ZG_FLAGSr+ r# r& r �join)r r' Z fields_exprr r r r J s z StructUnionExpr.as_python_exprN)r r r r r r r r r r r% 7 s r% c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�EnumExprc C s" || _ || _|| _|| _|| _d S )N)r r& r �signed�allenums)r r r& r r2 r3 r r r r U s zEnumExpr.__init__c C s d| j | j| j| j| jf S )Nz1 { "%s", %d, _cffi_prim_int(%s, %s), "%s" },)r r& r r2 r3 )r r r r r \ s zEnumExpr.as_c_exprc C sN dt dtd td td td td tdti| j| j f }dt | j �t |�| j | j f S )Nr r � � � zb'%s%s%s\x00%s')r r )r r )r4 r )r4 r )r5 r )r5 r )r6 r )r6 r )Z PRIM_UINT8Z PRIM_INT8Z PRIM_UINT16Z PRIM_INT16Z PRIM_UINT32Z PRIM_INT32Z PRIM_UINT64Z PRIM_INT64r r2 r# r& r r3 )r � prim_indexr r r r a s zEnumExpr.as_python_exprN)r r r r r r r r r r r1 T s r1 c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )� TypenameExprc C s || _ || _d S )N)r r& )r r r& r r r r m s zTypenameExpr.__init__c C s d| j | jf S )Nz { "%s", %d },)r r& )r r r r r q s zTypenameExpr.as_c_exprc C s dt | j�| jf S )Nzb'%s%s')r# r& r )r r r r r t s zTypenameExpr.as_python_exprN)r r r r r r r r r r r8 l s r8 c @ s� e Zd ZdZd�dd�Zdd� Zdd� Zd d � Zd d � Zd ddddgZ dd� Z d�dd�Z dd� Z dd� Z dd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Zd5d6� Zd7d8� Z d9d:� Z d;d<� Z d=d>� Z d?d@� Z d�dBdC�Z!dDdE� Z"dFdG� Z#dHdI� Z$e$Z%dJdK� Z&dLdM� Z'e'Z(dNdO� Z)e)Z*dPdQ� Z+dRdS� Z,dTdU� Z-d�dWdX�Z.dYdZ� Z/d[d\� Z0d]d^� Z1d_d`� Z2d�dadb�Z3dcdd� Z4dedf� Z5dgdh� Z6didj� Z7dkdl� Z8dmdn� Z9dodp� Z:dqdr� Z;dsdt� Z<dudv� Z=e= Z>Z?dwdx� Z@dydz� ZAd{d|� ZBd}d~� ZCdd�� ZDeD ZEZFd�d�� ZGd�d�� ZHd�d�� ZId�d�� ZJd�d�� ZKd�d�� ZLd�d�� ZMeMZNeMZOd�d�� ZPd�d�� ZQd�d�� ZReRZSd�d�� ZTdAS )�� Recompilerr Fc C s || _ || _|| _t| _d S )N)�ffi� module_name�target_is_python� VERSION_BASE�_version)r r: r; r< r r r r ~ s zRecompiler.__init__c C s t | j|�| _d S )N)�maxr> )r Zverr r r � needs_version� s zRecompiler.needs_versionc C sP i | _ | jd� t| j td�}g | _x�|D ]�}|jr*| j | d ksFt�t| j�| j |< | jj|� xZ|j D ]P}t |t j t j t jt jt jf�s�t�| j | d kr�t| j�| j |< | jj|� qjW | jjd� q*W xZ|D ]R}|j o�| j | d kr�t| j�| j |< | jj|� |jr�|jd k r�| jjd� q�W d | j j� k�s>t�i | _i | _x@|D ]8}t |t j��rnd | j|< nt |t j��rPd | j|< �qPW x.tt| jdd� d��D ]\}}|| j|< �q�W x.tt| jdd� d��D ]\}}|| j|< �q�W x0|D ](}t| d|jj �}||| j | � �q�W x | jD ]}t |t ��s&t��q&W t | j�| _d S ) NZ collecttype)�keyZEND�LENc S s | j S )N)r )�tpr r r �<lambda>� s z/Recompiler.collect_type_table.<locals>.<lambda>c S s | j S )N)r )rC r r r rD � s Z_emit_bytecode_) � _typesdict� _generate�sorted�str� cffi_typesZis_raw_function�AssertionErrorr �append�args� isinstancer �VoidType�BasePrimitiveType� PointerType�StructOrUnionOrEnum�FunctionPtrTypeZ is_array_type�length�values�_struct_unions�_enums� StructOrUnion�EnumType� enumerate�getattr� __class__r �CffiOp�tuple)r Z all_declsrC �tp1�i�methodr r r r �collect_type_table� sZ z Recompiler.collect_type_tablec C s� t |tj�s2t |t�r.x|D ]}| j|� q W d S || jkr�d | j|< t |tj�rb| j|j� � ntt |tj�r�|j d k r�|| j j j kr�xN|j � D ] \}}}}| j| j|||�� q�W n x |j� D ]\}}| j|� q�W d S )N)rM r ZBaseTypeByIdentityr] �_do_collect_typerE rR �as_raw_functionrW �fldtypesr: �_parser�_included_declarations� enumfields� _field_typeZ _get_items)r rC �xZname1r^ �_r r r rb � s zRecompiler._do_collect_typec C s� | j jjj� }x�t|�D ]�\}\}}|jdd�\}}yt| d||f �}W n tk rj td| ��Y nX y|| _ |||� W q t k r� } zt j | |� � W Y d d } ~ X qX qW d S )Nr r z_generate_cpy_%s_%sz"not implemented in recompile(): %r) r: re Z _declarations�itemsrG �splitrZ �AttributeErrorr �_current_quals� Exceptionr Zattach_exception_info) r � step_name�lstr rC �qualsZkindZrealnamer` �er r r rF � s zRecompiler._generate�global�field� struct_union�enum�typenamec C s: i | _ x| jD ]}g | j |< qW t� | _| jd� | j� x>| jD ]4}| j | }|dkrh|jdd� d� t|�| j |< qBW | j d }x:| jj � D ],\}}|t |�k s�t �|| j |j ks�t �q�W t |�t | j�ks�t �| j d }x<| j j � D ].\}}|t |�k �st �|| j |j ks�t �q�W t |�t | j �k�s6t �d S )NZctxru c S s | j S )N)r )�entryr r r rD � s z0Recompiler.collect_step_tables.<locals>.<lambda>)rA rv rw )�_lsts� ALL_STEPS�set�_seen_struct_unionsrF �_add_missing_struct_unions�sortr] rU rk r rJ r rV )r rp rq rC r_ r r r �collect_step_tables� s* z Recompiler.collect_step_tablesr c C s | j j|d � d S )N� )�_f�write)r Zwhatr r r �_prnt s zRecompiler._prntc C s: | j r |d kst�| j|� n|d k s*t�| j||� d S )N)r< rJ �write_py_source_to_f�write_c_source_to_f)r �f�preambler r r �write_source_to_f s z Recompiler.write_source_to_fc C s0 t tjjtjjt�|�d�}|j� }|j� |S )N�r)�open�os�pathr0 �dirname�__file__� readlines�close)r �filename�g�linesr r r �_rel_readlines s zRecompiler._rel_readlinesc C sz || _ | j}| jjd k r |d� | jd�}|jd�}| jd�|||d �< |dj|�� | jjd�dI }| jjd k �r0|d| jf � |d � | j | jj� |d � |d � |d |f � |d � |d|f � |d� |d|f � |d� | jd�}|jd�}| jd�|||d �< |dj|�� | j t � |d� |� ||� |� |d� |� |d� t dd� | j j� D ��}xLt| j�D ]>\}}d} ||k�r�d|| j� } |d||j� | f � �q�W | j�s�|d� |d � |� t� | _| jd � i } xn| jD ]d} | j| } t| �| | < | | d k�r|d | | f � x| D ]} || j� � �qBW |d � |� �qW | jj�r|d � xr| jjD ]f}y|jd d!� \}}W n( tk �r� t d"| j|f ��Y nX |d k�r�t d#��|d$|f � �q�W |d%� |d � |� |d&� |d'� x8| jD ].} | | d k�r@|d(| � n |d)| � �q W x.| jD ]$} | d*k�rZ|d+| | | f � �qZW | jj�r�|d,� n|d-� |d.t| j�f � d }| j �r�|dO }|d/| � |d � |� |d0� |d1� |d� |� |d � |d2� |d3|f � |d4� | j �rD|d5� |d6� |d7� |d8| j � |d9� |d:� |d;� |d� |d<� |d=� |d>� |d?� |d@|f � |dA� |dB|f � |dC� |dC� |d � |d2� |dD|f � |d4� |dE| j| j f � |d<� |d� |d2� |dF|f � |d4� |dG| j| j f � |d<� |d� |� |d0� |dH� |d� d | _ d S )JNz#define _CFFI_USE_EMBEDDINGz_cffi_include.hz#include "parse_c_type.h" zparse_c_type.hr r �.z #define _CFFI_MODULE_NAME "%s"z1static const char _CFFI_PYTHON_STARTUP_CODE[] = {z0 };z#ifdef PYPY_VERSIONz5# define _CFFI_PYTHON_STARTUP_FUNC _cffi_pypyinit_%sz#elif PY_MAJOR_VERSION >= 3z-# define _CFFI_PYTHON_STARTUP_FUNC PyInit_%sz#elsez*# define _CFFI_PYTHON_STARTUP_FUNC init%sz#endifz _embedding.hz#include "_cffi_errors.h" z_cffi_errors.hz>/************************************************************/z static void *_cffi_types[] = {c S s g | ]\}}||f�qS r r )r, rC r_ r r r r- G s z2Recompiler.write_c_source_to_f.<locals>.<listcomp>z // z/* %2d */ %s,%sz 0z};�declr z.static const struct _cffi_%s_s _cffi_%ss[] = {z.static const char * const _cffi_includes[] = {r4 zQffi object %r includes %r, but the latter has not been prepared with set_source()zMnot implemented yet: ffi.include() of a Python-based ffi inside a C-based ffiz "%s",z NULLz?static const struct _cffi_type_context_s _cffi_type_context = {z _cffi_types,z _cffi_%ss,z NULL, /* no %ss */ru z %d, /* num_%ss */z _cffi_includes,z NULL, /* no includes */z %d, /* num_types */z %d, /* flags */z#ifdef __GNUC__z?# pragma GCC visibility push(default) /* for -fvisibility= */ZPyMODINIT_FUNCz"_cffi_pypyinit_%s(const void *p[])�{z% if (((intptr_t)p[0]) >= 0x0A03) {zQ _cffi_call_python_org = (void(*)(struct _cffi_externpy_s *, char *))p[1];z }z p[0] = (const void *)0x%x;z p[1] = &_cffi_type_context;z#if PY_MAJOR_VERSION >= 3z return NULL;�}z# ifdef _MSC_VERz PyMODINIT_FUNCz# if PY_MAJOR_VERSION >= 3z% PyInit_%s(void) { return NULL; }z# elsez init%s(void) { }z# endifzPyInit_%s(void)z5 return _cffi_init("%s", 0x%x, &_cffi_type_context);z init%s(void)z. _cffi_init("%s", 0x%x, &_cffi_type_context);z # pragma GCC visibility pop���) r� r� r: � _embeddingr� �indexr0 r; rl � _print_string_literal_in_arrayr@ �VERSION_EMBEDDED�dictrE rk rY rI � _get_c_namer r| �_seen_constantsrF r{ rz r �_included_ffis�_assigned_sourcerm r � _num_externpyr> )r r� r� �prntr� r_ Zbase_module_name�typeindex2typer r) Znumsrp rq ry �ffi_to_include�included_module_name�included_sourcer' r r r r� s z Recompiler.write_c_source_to_fc sb t |t�rd|f S t |ttf�rZ� fdd�|D �}t|�dkrJ|jd� ddj|�f S |j� S )Nzb'%s'c s g | ]}� j |��qS r )�_to_py)r, �item)r r r r- � s z%Recompiler._to_py.<locals>.<listcomp>r r z(%s)r. )rM rH �listr] r rK r0 r )r ri Zrepr )r r r� � s zRecompiler._to_pyc C s� || _ | j}|d� |d� t| jjp(f �}xzt|�D ]n}| jj| }y|jd d� \}}W n& tk r� td| j|f ��Y nX |d k r�td��|d||f � q6W |� |d| j f � |d| j f � d | _ t | j �| _ d d � | j D �}|d | j d j|��f � td d � | jj� D ��} xH| jD ]>} | j| } t| �dk�r*| dk�r*|d| | j | �f � �q*W |dk�r�|ddjdd � t|�D ��f � |d� d S )Nz# auto-generated filezimport _cffi_backendr4 zQffi object %r includes %r, but the latter has not been prepared with set_source()zMnot implemented yet: ffi.include() of a C-based ffi inside a Python-based ffiz from %s import ffi as _ffi%dz ffi = _cffi_backend.FFI('%s',z _version = 0x%x,c S s g | ] }|j � �qS r )r )r, r r r r r- � s z3Recompiler.write_py_source_to_f.<locals>.<listcomp>z _types = %s,r c S s g | ]\}}||f�qS r r )r, rC r_ r r r r- � s r ru z _%ss = %s,z _includes = (%s,),z, c S s g | ] }d | �qS )z_ffi%dr )r, r_ r r r r- � s �))r� r� r r: r� �ranger� rm r r; r> r] rI r� r0 r� rE rk r{ rz ) r r� r� Z num_includesr_ r� r� r� Z types_lstr� rp rq r r r r� � sB z Recompiler.write_py_source_to_fc C s | j | S )N)rE )r �typer r r � _gettypenum s zRecompiler._gettypenumc C sp d}t |tj�r�|j� r�|j� r<|jdkr<d}d|j }nPt |tj�rZd|jd�f }n2|jd�}d||jjdd�f }|dkr�| j t � d }n�t |tj �r�| j ||||� d S t |tj �s�t |tj�r�| jd || j|�|f � | jd | � d S t |tj��r&d|jd� }d| j|� }d}nt|��| jd||||f � | jd||jd�|f � | jd | � d S )Nr �_BoolZ_cffi_to_c_intz, %sz(%s)_cffi_to_c_doublez(%s)_cffi_to_c_%sr rj �char16_t�char32_tz-1z6 if (_cffi_to_c((char *)&%s, _cffi_type(%d), %s) < 0)z %s;z(%s)_cffi_to_c_pointerz, _cffi_type(%d)ZNULLz %s = %s(%s%s);z' if (%s == (%s)%s && PyErr_Occurred()))r� r� )rM r rO �is_complex_type�is_integer_typer �UnknownFloatType� get_c_name�replacer@ �VERSION_CHAR16CHAR32rP �"_convert_funcarg_to_c_ptr_or_arrayrQ r� r� rR r ) r rC �fromvar�tovar�errcodeZextraargZ converter�cnameZerrvaluer r r �_convert_funcarg_to_c s@ z Recompiler._convert_funcarg_to_cc C s t |tj�r|jd� d S )NzPy_ssize_t datasize)rM r rP �add)r rC � localvarsr r r �_extra_local_variables3 s z!Recompiler._extra_local_variablesc C s� | j d� | j d| j|�||f � | j d� | j d� | j d| � | j d||jd�f � | j d|f � | j d || j|�|f � | j d| � | j d � d S ) Nz1 datasize = _cffi_prepare_pointer_call_argument(z( _cffi_type(%d), %s, (char **)&%s);z if (datasize != 0) {z if (datasize < 0)z %s;z& %s = (%s)alloca((size_t)datasize);r z, memset((void *)%s, 0, (size_t)datasize);zL if (_cffi_convert_array_from_object((char *)%s, _cffi_type(%d), %s) < 0)z })r� r� r� )r rC r� r� r� r r r r� 7 s z-Recompiler._convert_funcarg_to_c_ptr_or_arrayc C sL t |tj�r�|j� r,|jdkr,d||jf S t |tj�rBd|f S |jdkr�|j� r�|jjdd�}|dkrv| jt � d ||f S d || j |�f S n�t |tj tj f�r�d || j |�f S t |tj �r�d || j tj |j��f S t |tj��r |jd k�rtd |j� |f ��d || j |�f S t |tj��r@d || j |�f S t|��d S )Nr� z_cffi_from_c_int(%s, %s)z_cffi_from_c_double(%s)z long doubler rj r� r� z_cffi_from_c_%s(%s)z/_cffi_from_c_deref((char *)&%s, _cffi_type(%d))z0_cffi_from_c_pointer((char *)%s, _cffi_type(%d))z!'%s' is used as %s, but is opaquez0_cffi_from_c_struct((char *)&%s, _cffi_type(%d)))r� r� )rM r rO r� r r� r� r� r@ r� r� rP rR � ArrayTyper� rW Zfldnames� TypeErrorr� rX r )r rC �var�contextr� r r r �_convert_expr_from_cG s8 z Recompiler._convert_expr_from_cc C s | j |d|f �S )Nz (*(%s *)0))� _global_type)r rC r r r r � _typedef_typej s zRecompiler._typedef_typec C s | j | j||�� d S )N)rb r� )r rC r r r r �!_generate_cpy_typedef_collecttypem s z,Recompiler._generate_cpy_typedef_collecttypec C s d S )Nr )r rC r r r r �_generate_cpy_typedef_declp s z%Recompiler._generate_cpy_typedef_declc C s$ | j | }| jd jt||�� d S )Nrx )rE rz rK r8 )r rC r r& r r r � _typedef_ctxs s zRecompiler._typedef_ctxc C sf | j ||�}| j||� t|dd �dkr<| j||jd d� n&t|tj�rb| j|j|jj|j|d� d S )N�originZ unknown_type)� approxname)r� � named_ptr) r� r� rZ � _struct_ctxr rM r ZNamedPointerType�totype)r rC r r r r �_generate_cpy_typedef_ctxw s z$Recompiler._generate_cpy_typedef_ctxc C s* | j |j� � |jr&| j r&| j |� d S )N)rb rc �ellipsisr< )r rC r r r r �"_generate_cpy_function_collecttype� s z-Recompiler._generate_cpy_function_collecttypec C s� | j s t�t|tj�s t�|jr2| j||� d S | j}t|j �}|dkrPd}n|dkr^d}nd}g }g }d| }x:t |j �D ],\} } |j | j d| |�� |j d| � q~W d j |�} | p�d } |jr�|jd } nd } d | || f } |d|jj | �f � |d� d j |�}d}t|jtj��r$d }|d|||f � |d� |d� |d� |d||f � |d� d| }x4t |j �D ]&\} } | j d| |�}|d| � �qzW t� }x |j D ]} | j| |� �q�W x |D ]}|d|f � �q�W t|jtj��s d}d| }d|jj d|� }||� nd }d }t|j �dk�r�tt|j ��}x|D ]} |d| � �qJW |� |d|t|�t|�d j d d � |D ��f � |d � |� x6t |j �D ](\} } | j| d | d| d � |� �q�W |d!� |d"� d#d � tt|j ��D �}d j |�}|d$|||f � |d%� |d&� |� |d'� |dk�rL|d(� |�rl|d)| j|jd*d+� � n|d,� |d-� |d� |d.� d/d0� }d1}g }g }d| }x^t |j �D ]P\} } d }|| ��r�d2}d3}| j d4|| f |�}|j |� |j d5|| f � �q�W |j}||��rJd| }|j d6|�}|jd|� tj}d }d7}d3}|�r�d j |�} | �pbd } d8| || f } |d|j | �f � |d� |�r�||� d j |�}|d$|||f � |�r�|d9� |d� n|d:||f � |d;� |� d S )<Nr Znoargr Zarg0rL zargument of %sz x%dzx%dz, �voidr r z%s_cffi_d_%s(%s)z static %sr� zreturn z %s%s(%s);r� z#ifndef PYPY_VERSIONzstatic PyObject *z(_cffi_f_%s(PyObject *self, PyObject *%s)z %s;z result = z result of %sz resultz PyObject *arg%d;z1 if (!PyArg_UnpackTuple(args, "%s", %d, %d, %s))c S s g | ] }d | �qS )z&arg%dr )r, r_ r r r r- � s z:Recompiler._generate_cpy_function_decl.<locals>.<listcomp>z return NULL;zarg%dz return NULLz Py_BEGIN_ALLOW_THREADSz _cffi_restore_errno();c S s g | ] }d | �qS )zx%dr )r, r_ r r r r- � s z { %s%s(%s); }z _cffi_save_errno();z Py_END_ALLOW_THREADSz (void)self; /* unused */z (void)noarg; /* unused */z return %s;�resultz result typez Py_INCREF(Py_None);z return Py_None;z#elsec S s t | tj�p t | tj�o | j� S )N)rM r rW � PrimitiveTyper� )r� r r r �need_indirection� s z@Recompiler._generate_cpy_function_decl.<locals>.need_indirectionFr Tz %sx%dz%sx%dz *resultz *result = z%s_cffi_f_%s(%s)z return result;z # define _cffi_f_%s _cffi_d_%sz#endif)r< rJ rM r rR r� �_generate_cpy_constant_declr� r rL rY rK r� r0 �abir� rN r| r� r� r� r� �insertZ void_type)r rC r r� �numargsZargname� argumentsZcall_argumentsr� r_ r� �repr_argumentsr� �name_and_argumentsZ result_code�argr� r� Z result_decl�rngr� � differenceZ indirectionZ tp_resultr r r �_generate_cpy_function_decl� s� z&Recompiler._generate_cpy_function_declc C s� |j r | j r | j||� d S | j|j� }t|j�}| jrBt}n |dkrPt}n|dkr^t }nt }| j d j t |d| t||�d| d�� d S )Nr r rt z _cffi_f_%sz _cffi_d_%s)r )r� r< �_generate_cpy_constant_ctxrE rc r rL ZOP_DLOPEN_FUNCZOP_CPYTHON_BLTN_NZOP_CPYTHON_BLTN_OZOP_CPYTHON_BLTN_Vrz rK r r\ )r rC r r& r� Z meth_kindr r r �_generate_cpy_function_ctx# s z%Recompiler._generate_cpy_function_ctxc C sT t |tj�rP|j}|dkr0|jd�}d||f }| j|d| |j�}tj||�}|S )Nz...r z _cffi_array_len(((%s)0)->%s)z%s[0])rM r r� rS r� rh r� )r Z tp_structZ field_nameZtp_field� actual_lengthZptr_struct_name�tp_itemr r r rh 9 s zRecompiler._field_typec C s0 | j |� | jr,x|j� D ]}| j|� qW d S )N)rb r< �anonymous_struct_fields�_struct_collecttype)r rC �fldtyper r r r� E s z Recompiler._struct_collecttypec C s< |j d krd S | j}d|f }|d� |d||f � |d� |d� |d� x�|j� D ]�\}}}} y||j� sv|dkr�|d|||f � wXx2t|tj�r�|jd ks�|jd kr�|j}|d }q�W |d |j d d | | d�|f � W qX t k �r } z|dt | � � W Y d d } ~ X qXX qXW |d� |d||f � |� d S )Nz_cffi_checkfld_%sZ_CFFI_UNUSED_FNzstatic void %s(%s *p)r� z8 /* only to generate compile-time warnings or errors */z (void)p;r z> (void)((p->%s) | 0); /* check that '%s.%s' is an integer */z...z[0]z { %s = &p->%s; (void)tmp; }z*tmpzfield %r)rr z /* %s */r� z(struct _cffi_align_%s { char x; %s y; };) rd r� rg r� rM r r� rS r� r� r rH ) r rC r� r� r� Z checkfuncnameZfnameZftyper �fqualrs r r r � _struct_declL s6 &zRecompiler._struct_declNc C s� | j | }d }g }t|tj�r(|jd� |jd kr@|jd� d}|| jjjkr�|d ksd|| jjjkr�|jd krpn |j s�t |j � �r�n |jd� |j r�|jd� n|jd� d}dj |�p�d }g }|d k�rZ| j } t|j| ��} �x | D �] \} } } }| j|| | �} | j| d |j| f � t}| d k�r6t}d | }nL|d k�sZt| tj��r`| jd k�r`d }n"d|d k�rv|jd�n|j| f }|d k�s�| d k�r�d }n,|d k �r�d|j| f }nd|jd�| f }|jt| ||| t|| j | ��� q�W t| j d �}| j d j |� |d k�r$d}d }d}n4|d k �r@d|jf }d}nd|f }d|f }d }nd }d }d }|}| j d jt |j|||||||�� | j j |� d S ) NZ _CFFI_F_UNIONZ_CFFI_F_OPAQUEZopaqueZ_CFFI_F_CHECK_FIELDSZ_CFFI_F_PACKEDZ_CFFI_F_EXTERNALZexternal�|�0z field '%s.%s'r z %d /* bits */z (size_t)-1zsizeof(((%s)0)->%s)r z"((char *)&((%s)0)->%s) - (char *)0zoffsetof(%s, %s)r ru z (size_t)-2r4 Zunnamedzsizeof(*(%s)0)z-1 /* unknown alignment */z sizeof(%s)z"offsetof(struct _cffi_align_%s, y)r rv ���r� r� )!rE rM r Z UnionTyperK rd r: re rf �partial�anyr� Zpackedr0 r< r� rg rh �_check_not_opaquer r! r" r� rS r� r r\ r rz �extendr% r} r� )r rC r� r� r� r& Zreason_for_not_expandingr' r+ Z expand_anonymous_struct_unionrg Zfldnamer� r r� r r �offsetr* Zalignr) r r r r� m s� zRecompiler._struct_ctxc C s> xt |tj�r|j}qW t |tj�r:|jd kr:td| ��d S )Nz0%s is of an opaque type (not declared in cdef()))rM r r� r� rW rd r� )r rC �locationr r r r� � s z Recompiler._check_not_opaquec C s� t | jj� �}|jdd� d� x�|D ]�\}}|| jkr$|jrJtd|f ��|jjd�rx|jdd � j � rx|jdd � }n4|jdkr�|j dkr�d}| j |d� ntd |f ��| j |d |� q$W d S ) Nc S s | d S )Nr r )Ztp_orderr r r rD � s z7Recompiler._add_missing_struct_unions.<locals>.<lambda>)rA zDinternal inconsistency: %r is partial but was not seen at this point�$r Z_IO_FILE�FILEzinternal inconsistency: %r) r� rU rk r r} r� r r � startswith�isdigitZ forcenamer� r� )r rq rC �orderr� r r r r~ � s z%Recompiler._add_missing_struct_unionsc C s | j |� d S )N)r� )r rC r r r r � _generate_cpy_struct_collecttype� s z+Recompiler._generate_cpy_struct_collecttypec C s2 |j d�}d|kr"||jdd�fS |d| fS d S )Nr r rj )r� r� )r rC r� r r r � _struct_names� s zRecompiler._struct_namesc C s | j |f| j|��� d S )N)r� r� )r rC r r r r �_generate_cpy_struct_decl� s z$Recompiler._generate_cpy_struct_declc C s | j |f| j|��� d S )N)r� r� )r rC r r r r �_generate_cpy_struct_ctx� s z#Recompiler._generate_cpy_struct_ctxc C s( t |tj�r| j||� n | j|� d S )N)rM r rX � _generate_cpy_enum_collecttyper� )r rC r r r r �#_generate_cpy_anonymous_collecttype� s z.Recompiler._generate_cpy_anonymous_collecttypec C s. t |tj�r| j|� n| j||d| � d S )N�typedef_)rM r rX �_generate_cpy_enum_declr� )r rC r r r r � _generate_cpy_anonymous_decl� s z'Recompiler._generate_cpy_anonymous_declc C s0 t |tj�r| j||� n| j||d| � d S )Nr )rM r rX � _enum_ctxr� )r rC r r r r �_generate_cpy_anonymous_ctx� s z&Recompiler._generate_cpy_anonymous_ctx�constc C s ||f| j kr td||f ��| j j||f� | j}d||f }|r�|d| � |d� |d|f � |d||f � |d k r�|dkr�d|f }|d |f � |d � |d � |d � n>|d ks�t�|d | � |d� |d|jd�|f � |d � |� d S )Nz duplicate declaration of %s '%s'z _cffi_%s_%sz$static int %s(unsigned long long *o)r� z int n = (%s) <= 0;zI *o = (unsigned long long)((%s) | 0); /* check that %s is an integer */r z%dUz" if (!_cffi_check_int(*o, n, %s))z n |= 2;z return n;r� zstatic void %s(char *o)z *(%s)o = %s;r )r� r r� r� rJ r� )r �is_intr rC �categoryr r� �funcnamer r r �_generate_cpy_const s2 z Recompiler._generate_cpy_constc C s" |j � }| s| jr | j|� d S )N)r� r< rb )r rC r r r r r �"_generate_cpy_constant_collecttype& s z-Recompiler._generate_cpy_constant_collecttypec C s |j � }| j|||� d S )N)r� r )r rC r r r r r r� + s z&Recompiler._generate_cpy_constant_declc C s` | j r |j� r ttd�}n$| j r(t}nt}| j| }t||�}| jd jt |d| |�� d S )Nr rt z_cffi_const_%sr� ) r< r� r\ �OP_CONSTANT_INTZOP_DLOPEN_CONSTZ OP_CONSTANTrE rz rK r )r rC r r Z const_kindr& r r r r� / s z%Recompiler._generate_cpy_constant_ctxc C s | j |� d S )N)rb )r rC r r r r r� ? s z)Recompiler._generate_cpy_enum_collecttypec C s x|j D ]}| jd|� qW d S )NT)� enumeratorsr )r rC r � enumeratorr r r r B s z"Recompiler._generate_cpy_enum_declc C s� | j | }ttd �}| jr"|j� x:t|j|j�D ](\}}| jd j t |d| ||d�� q2W |d k r�d|kr�| j r�d| }d| }n4|j | j g �} | j j | �}tt| j j| d ��dk �}d j|j�} | jd j t|j|||| �� d S ) Nr rt z_cffi_const_%s)r r� z sizeof(%s)z ((%s)-1) <= 0r r. rw r� r� )rE r\ �OP_ENUMr< Zcheck_not_partial�zipr Z enumvaluesrz rK r Zbuild_baseinttyper: Zsizeof�int�castr0 r1 r ) r rC r� r& r r Z enumvaluer r2 Zbasetpr3 r r r r F s" zRecompiler._enum_ctxc C s | j ||j� � d S )N)r r� )r rC r r r r �_generate_cpy_enum_ctx[ s z!Recompiler._generate_cpy_enum_ctxc C s d S )Nr )r rC r r r r � _generate_cpy_macro_collecttypea s z*Recompiler._generate_cpy_macro_collecttypec C s& |dkrd }n|}| j d||d� d S )Nz...T)r )r )r rC r r r r r �_generate_cpy_macro_decld s z#Recompiler._generate_cpy_macro_declc C sT |dkr"| j r td|f ��d }n|}ttd�}| jd jt|d| ||d�� d S )Nz...zGcannot use the syntax '...' in '#define %s ...' when using the ABI moder rt z_cffi_const_%s)r r� )r< r r\ r rz rK r )r rC r r r r r r �_generate_cpy_macro_ctxk s z"Recompiler._generate_cpy_macro_ctxc C sF t |tj�rB|j}|dkr$d|f }| j|jd| �}tj||�}|S )Nz...z_cffi_array_len(%s)z%s[0])rM r r� rS r� r� )r rC Z global_namer� r� r r r r� | s zRecompiler._global_typec C s | j | j||�� d S )N)rb r� )r rC r r r r �"_generate_cpy_variable_collecttype� s z-Recompiler._generate_cpy_variable_collecttypec C s� | j }| j||�}t|tj�r4|jd kr4|j}d}nd}d|f }|d|j|| jd� � |d� |d||f � |d� |� d S ) Nr �&z*_cffi_var_%s(void)zstatic )rr r� z return %s(%s);r� ) r� r� rM r r� rS r� r� rn )r rC r r� Z ampersandr� r r r �_generate_cpy_variable_decl� s z&Recompiler._generate_cpy_variable_declc C sL | j ||�}| j| }| jr"t}nt}| jd jt|d| t||��� d S )Nrt z _cffi_var_%s) r� rE r< Z OP_GLOBAL_VARZOP_GLOBAL_VAR_Frz rK r r\ )r rC r r& r r r r �_generate_cpy_variable_ctx� s z%Recompiler._generate_cpy_variable_ctxc C s t |tj�st�| j|� d S )N)rM r rR rJ rb )r rC r r r r �'_generate_cpy_extern_python_collecttype� s z2Recompiler._generate_cpy_extern_python_collecttypec C s | j }t|jtj�rd}n d| }d|jjd|�f }|d| � |d| j||f � |� g }d| }x0t|j�D ]"\}} | jd| |�} |j | � qtW d j |�} | p�d } d || f } |j d kr�d | } dd� } t t |j�d d�}| |j�r�t |d�}t|jtj��r*d|jjd�||jjd�|f }|d||jj| �f � |d� |d| � |d� xft|j�D ]X\}} d| } t| tj��s�| | ��r�d| } tj| �} |d| jd�|d | f � �qjW |d| � t|jtj��s�|d |jjd�f � |d � |� | jd 7 _d S ) Nr� z result of %sz(int)sizeof(%s)r z3static struct _cffi_externpy_s _cffi_externpy__%s =z { "%s.%s", %s };zargument of %sz a%dz, r� z%s(%s)� __stdcallz_cffi_stdcall c S s t | tj�o| jdkS )Nz long double)rM r r� r )rC r r r �may_need_128_bits� s z9Recompiler._extern_python_decl.<locals>.may_need_128_bitsr6 � z!sizeof(%s) > %d ? sizeof(%s) : %dz%s%sr� z char a[%s];z char *p = a;za%dr z *(%s)(p + %d) = %s;r z, _cffi_call_python(&_cffi_externpy__%s, p);z return *(%s)p;r� r )r� rM r� r rN r� r; rY rL rK r0 r� r? r rW rP r� )r rC r Z tag_and_spacer� Zsize_of_resultr� r� r_ r� r� r� r� r Z size_of_ar r r �_extern_python_decl� sX " z Recompiler._extern_python_declc C s | j ||d� d S )Nzstatic )r )r rC r r r r � _generate_cpy_extern_python_decl� s z+Recompiler._generate_cpy_extern_python_declc C s | j ||d� d S )NzCFFI_DLLEXPORT )r )r rC r r r r �#_generate_cpy_dllexport_python_decl� s z.Recompiler._generate_cpy_dllexport_python_declc C s | j ||d� d S )Nr )r )r rC r r r r �'_generate_cpy_extern_python_plus_c_decl� s z2Recompiler._generate_cpy_extern_python_plus_c_declc C sR | j rtd��|jr td��| j| }tt|�}| jd jt |d| ||�� d S )Nz,cannot use 'extern "Python"' in the ABI modez$a vararg function is extern "Python"rt z&_cffi_externpy__%s) r< r r� r rE r\ ZOP_EXTERN_PYTHONrz rK r )r rC r r& r r r r � _generate_cpy_extern_python_ctx� s z*Recompiler._generate_cpy_extern_python_ctxc C sz | j }|d� xf|jd�D ]X}|d| j� � d}x6|D ].}t|�dkrT||� d}|dt|�f 7 }q8W ||� qW d S )Nz=// # NB. this is not a string because of a size limit in MSVCTz// r �L z%d,)r� � splitlines�rstripr �ord)r �sr� �lineZ printed_line�cr r r r� s z)Recompiler._print_string_literal_in_arrayc C s t tt�| j|< d S )N)r\ � OP_PRIMITIVEZ PRIM_VOIDrI )r rC r� r r r �_emit_bytecode_VoidType s z"Recompiler._emit_bytecode_VoidTypec C s t |j }tt|�| j|< d S )N)ZPRIMITIVE_TO_INDEXr r\ r+ rI )r rC r� r7 r r r � _emit_bytecode_PrimitiveType s z'Recompiler._emit_bytecode_PrimitiveTypec C s( d|j |j |j f }tt|�| j|< d S )Nzl_cffi_prim_int(sizeof(%s), ( ((%s)-1) | 0 /* check that %s is an integer type */ ) <= 0))r r\ r+ rI )r rC r� r( r r r �!_emit_bytecode_UnknownIntegerType s z,Recompiler._emit_bytecode_UnknownIntegerTypec C s$ d|j |j f }tt|�| j|< d S )Nzd_cffi_prim_float(sizeof(%s) * (((%s)1) / 2) * 2 /* integer => 0, float => 1 */ ))r r\ r+ rI )r rC r� r( r r r � _emit_bytecode_UnknownFloatType s z*Recompiler._emit_bytecode_UnknownFloatTypec C s� t t| j|j �| j|< |d7 }xR|jD ]H}| j| }||krht|tj�rX| j ||� nt t |�| j|< |d7 }q(W t |j �}|j d k r�|j dkr�|dO }ntd|j f ��t t|�| j|< d S )Nr r r4 zabi=%r)r\ Z OP_FUNCTIONrE r� rI rL rM r r� r- r! r r� r� r ZOP_FUNCTION_END)r rC r� r^ Z realindexr' r r r � _emit_bytecode_RawFunctionType# s z)Recompiler._emit_bytecode_RawFunctionTypec C s t t| j|j �| j|< d S )N)r\ � OP_POINTERrE r� rI )r rC r� r r r �_emit_bytecode_PointerType6 s z%Recompiler._emit_bytecode_PointerTypec C s" |j � }tt| j| �| j|< d S )N)rc r\ r1 rE rI )r rC r� �rawr r r � _emit_bytecode_FunctionPtrType< s z)Recompiler._emit_bytecode_FunctionPtrTypec C s� | j |j }|jd kr(tt|�| j|< nf|jdkrNtdt|�jdd�f ��n@| j|d dksdt �tt |�| j|< td t|j��| j|d < d S )Nz...zitype %s badly placed: the '...' array length can only be used on global arrays or on fields of structuresz/*...*/r rB ) rE r� rS r\ Z OP_OPEN_ARRAYrI r rH r� rJ ZOP_ARRAY)r rC r� Z item_indexr r r �_emit_bytecode_ArrayType@ s z#Recompiler._emit_bytecode_ArrayTypec C s | j | }tt|�| j|< d S )N)rU r\ ZOP_STRUCT_UNIONrI )r rC r� Z struct_indexr r r �_emit_bytecode_StructTypeN s z$Recompiler._emit_bytecode_StructTypec C s | j | }tt|�| j|< d S )N)rV r\ r rI )r rC r� Z enum_indexr r r �_emit_bytecode_EnumTypeS s z"Recompiler._emit_bytecode_EnumType)F)r )N)Nr N)N)Ur r r r� r r@ ra rb rF r{ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rh r� r� r� r� r~ r� Z _generate_cpy_union_collecttyper� r� Z_generate_cpy_union_declr� Z_generate_cpy_union_ctxr r r r r r� r� r� r r r r r r r� r r r r Z*_generate_cpy_dllexport_python_collecttypeZ._generate_cpy_extern_python_plus_c_collecttyper r r! r" r# Z"_generate_cpy_dllexport_python_ctxZ&_generate_cpy_extern_python_plus_c_ctxr� r, r- r. r/ r0 r2 Z _emit_bytecode_ConstPointerTypeZ _emit_bytecode_NamedPointerTyper4 r5 r6 Z_emit_bytecode_UnionTyper7 r r r r r9 { s� : , 4-# ! Q 5 r9 � c s e Zd Z� fdd�Z� ZS )�NativeIOc s( t |t�r|jd�}tt| �j|� d S )N�ascii)rM Zunicode�encode�superr9 r� )r r( )r[ r r r� \ s zNativeIO.write)r r r r� � __classcell__r r )r[ r r9 [ s r9 c C s |rt d|f � t| ||d kd�}|j� |j� t� }|j||� |j� }y@t|d�� }|jt |�d �|krvt �W d Q R X |r�t d� dS t k �r d|t j � f } t| d��}|j |� W d Q R X yt j| |� W n, tk �r t j|� t j| |� Y nX d S X d S ) Nz generating %s)r< r� r z(already up-to-date)Fz%s.~%d�wT)�printr9 ra r� r9 r� �getvaluer� �readr �IOErrorr� �getpidr� �rename�OSError�unlink) r: r; r� Z target_file�verboseZ recompilerr� �output�f1Ztmp_filer r r �_make_c_or_py_sourcea s4 rJ Fc C s |d k s t �t| ||||�S )N)rJ rJ )r: r; r� Z target_c_filerG r r r � make_c_source} s rK c C s t | |d ||�S )N)rJ )r: r; Ztarget_py_filerG r r r �make_py_source� s rL c C sj |j d�}y$tjtjj| f|d d� �� � W n tk rB Y nX |d |7 < tjj| f|�� |fS )Nr� r r� r� )rl r� �makedirsr� r0 rE )Z outputdir�modname� extension�partsr r r �_modname_to_file� s $rQ c C s* t ||�}| j|||f� t|||� |S )N)rZ rK �setattr)� patchlist�clsr Znew_meth�oldr r r � _patch_meth� s rV c C s( x"t | �D ]\}}}t|||� q W d S )N)�reversedrR )rS rT r Zold_methr r r �_unpatch_meths� s rX c s\ t jdkr(ddlm} t| |ddd� � t jdkrXddlm} � fd d �}t| |d |�� d S ) N�win32r )� MSVCCompilerZ_remove_visual_c_refc S s |S )Nr )r Z manifest_filer r r rD � s z&_patch_for_embedding.<locals>.<lambda>�darwin)� CCompilerc s< d| j kr,t| j �| _ | j jd�}d| j |< � | f|�|�S )Nz-bundlez -dynamiclib)Z linker_sor� r� )r rL �kwdsr_ )�old_link_shared_objectr r �my_link_shared_object� s z3_patch_for_embedding.<locals>.my_link_shared_objectZlink_shared_object)�sys�platformZdistutils.msvc9compilerrZ rV Zdistutils.ccompilerr\ )rS rZ r\ r_ r )r^ r �_patch_for_embedding� s rb c sl ddl m} � jd�rR� d d � � tjdkr6� d7 � n tjdkrJ� d7 � n� d 7 � t| |d � fd d �� d S )Nr )� build_extz.*r4 rY z.dllr[ z.dylibz.soZget_ext_filenamec s � S )Nr )r Zext_name)�targetr r rD � s z#_patch_for_target.<locals>.<lambda>r� )Zdistutils.command.build_extrc �endswithr` ra rV )rS rd rc r )rd r �_patch_for_target� s rf r� T�.cc K s� t |t�s|jd�}| jr$| j| � |d k �r^| jd k } | rF| j| � |d krzt|||�\}} |rl|g| } tj j | � }n|}| d kr�| r�d| } nd} t j ||f| �}t | ||||d�}|�rTg }tj� }zn| r�t|� | dkr�t|| � |�r |dk�rd}nd}td|tj j|�f � tj|� t jd||| �}W d tj|� t|� X |S ||fS n<|d k�rxt||d �\}}t| |||d�}|�r�|S d |fS d S ) Nr: z%s.*r )rG r� zthe current directory isz setting the current directory toz%s %rz.py)rM rH r; Z_windows_unicodeZ_apply_windows_unicoder� Z_apply_embedding_fixrQ r� r� r0 r Z get_extensionrK �getcwdrb rf r? �abspath�chdir�compilerX rL )r: r; r� �tmpdirZcall_c_compilerZc_fileZsource_extensionZextradirZcompiler_verboserd �debugr] Z embeddingrP Z ext_c_fileZext�updatedrS �cwd�msg�outputfilenamerj r r r � recompile� sb rr c O s� ddl m} dd l}|tjks,td|f ��|jdt|�� t| ||f|�|�}|j ||�}xFt |j �D ]8} | j d�sht |j | �} | t | | t� �k rht| | | � qhW dd� } | | _x6t | �D ]*} | j d� r�t|j | � r�t| | t� q�W |jS )Nr )�udirzmodule name conflict: %rrl rj c _ s t �d S )N)r )rL r] r r r �typeof_disabled s z _verify.<locals>.typeof_disabled)Z testing.udirrs �impr` �modulesrJ � setdefaultrH rr Z load_dynamic�dirr: r� rZ �objectrR Z_typeof�hasattr�NotImplemented�lib) r: r; r� rL r] rs ru rq �moduler �attrrt r r r �_verify s$ r )r8 )F)F)r� TNrg Nr NN) r� r` �ior r r �errorr Z cffi_opcoder= r� r� r r r% r1 r8 r9 � version_info�StringIOr9 �BytesIOrJ rK rL rQ rV rX rb rf rr r r r r r �<module> sH f <PK %�\B�S�Q Q , __pycache__/vengine_gen.cpython-36.opt-1.pycnu �[��� 3 M��Z4h � @ sH d dl Z d dlZd dlZddlmZ ddlmZ G dd� de�ZdZ dS )� N� )�model)�VerificationErrorc @ s� e Zd ZdZdZdd� Zdd� Zdd� Zd d � ZdZd d �Z dd� Z d[dd�Z dd� Z dd� Z dd� Zdd� Zdd � ZeZeZeZd d � ZeZd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Z d-d.� Z d/d0� Z d1d2� Z d3d4� Z d5d6� Z!d7d8� Z"d9d:� Z#d\d=d>�Z$d?d@� Z%eZ&d]dAdB�Z'dCdD� Z(dEdF� Z)dGdH� Z*dIdJ� Z+d^dLdM�Z,d_dNdO�Z-dPdQ� Z.dRdS� Z/eZ0dTdU� Z1dVdW� Z2eZ3dXdY� Z4d;S )`�VGenericEngine�gFc C s || _ |j| _g | _i | _d S )N)�verifier�ffi�export_symbols� _struct_pending_verification)�selfr � r �#/usr/lib64/python3.6/vengine_gen.py�__init__ s zVGenericEngine.__init__c C s |j d| j� d S )Nr )� setdefaultr )r �kwdsr r r �patch_extension_kwds s z#VGenericEngine.patch_extension_kwdsc C sT xN|D ]F}|| }|d kr t j}x*|D ]"}tjj||�}tjj|�r&|S q&W qW d S )N)�sys�path�os�join�isfile)r Z module_namer Z so_suffixesZ so_suffix�basename�dirname�filenamer r r � find_module s zVGenericEngine.find_modulec C s d S )Nr )r r r r � collect_types% s z VGenericEngine.collect_types� c C s | j j|d � d S )N� )Z_f�write)r Zwhatr r r �_prnt( s zVGenericEngine._prntc C s` | j }|t� || jj� | jd� tjdkr\tjdkr>d}nd}| jj� }|d||f � d S )NZdeclZwin32� ZPyInit_Zinitzvoid %s%s(void) { } )r ) r �cffimod_headerr Zpreamble� _generater �platform� version_infoZget_module_name)r �prnt�prefix�modnamer r r �write_source_to_f+ s z VGenericEngine.write_source_to_fr c sj �j j}tjjtj�jj�}|j||���j �d� G � ��fdd�dt j �� � d�}�j �d|d� |S )NZloadingc s& e Zd Z�Z�jZg Z� fdd�ZdS )z/VGenericEngine.load_library.<locals>.FFILibraryc s � j S )N)� _cffi_dir)r )� FFILibraryr r �__dir__T s z7VGenericEngine.load_library.<locals>.FFILibrary.__dir__N)�__name__� __module__� __qualname__Z_cffi_generic_moduler Z _cffi_ffir) r+ r )r* �moduler r r r* P s r* r Zloaded)�library) r �_backendr r r �curdirr Zmodulefilename� load_library�_load�types� ModuleType)r �flags�backendr r0 r )r* r/ r r r3 A s zVGenericEngine.load_libraryc C s$ dd� | j jjj� D �}|j� |S )Nc S s g | ]\}\}}||f�qS r r )�.0�key�tpZqualr r r � <listcomp>^ s z4VGenericEngine._get_declarations.<locals>.<listcomp>)r Z_parserZ _declarations�items�sort)r Zlstr r r �_get_declarations] s z VGenericEngine._get_declarationsc C s� x�| j � D ]�\}}|jdd�\}}yt| d||f �}W n tk rX td| ��Y nX y|||� W q tk r� } ztj||� � W Y d d }~X q X q W d S )N� r z_generate_gen_%s_%sz not implemented in verify(): %r)r? �split�getattr�AttributeErrorr � Exceptionr �attach_exception_info)r � step_name�namer; �kind�realname�method�er r r r" c s zVGenericEngine._generatec K s� x|| j � D ]p\}}|jdd�\}}t| d||f �}y||||f|� W q tk rx } ztj| |� � W Y d d } ~ X q X q W d S )Nr@ r z _%s_gen_%s)r? rA rB rD r rE ) r r/ rF r rG r; rH rI rJ rK r r r r4 r s zVGenericEngine._loadc C s d S )Nr )r r; rG r r r �_generate_nothing| s z VGenericEngine._generate_nothingc K s d S )Nr )r r; rG r/ r r r r � _loaded_noop s zVGenericEngine._loaded_noopc sx |j r| jd||� d S | j}t|j�}g }x<t|j�D ].\}}d}t|tj�rTd}|j d||f � q8W d| � � fdd�t |j|�D �} |j } t| tj�r�| j d| j d � �� tj} d j| �p�d } d | } | jj | � |jr�|jd } nd} d| | | f } d| � || j | � �� |d� t|j tj��r4d}nt|j tj��sJd}nd}|d||d j|�f � |d� |� d S )NFr �*z%sx%dzargument of %sc s g | ]\}}|j d | � ��qS )z %s)� get_c_name)r9 �type�arg)�contextr r r< � s z>VGenericEngine._generate_gen_function_decl.<locals>.<listcomp>r z *rz, �voidz _cffi_f_%sr@ z %s%s(%s)z result of %s�{z*r = zreturn z %s%s(%s);�})�ellipsis�_generate_gen_constr �len�args� enumerate� isinstancer � StructOrUnion�append�zip�result�insertrO � void_typer r �abiZVoidType)r r; rG r% ZnumargsZargnames�irP Z indirectionZarglistZtpresult� wrappernamerb ZfuncdeclZ result_coder )rR r �_generate_gen_function_decl� sH z*VGenericEngine._generate_gen_function_declc C s` |j r| jd|||�}�n&g }|}tdd� |jD ��sDt|jtj�r�g }xDt|j�D ]6\} } t| tj�r�tj | �} |j | | f� |j | � qTW |j} t| tj�r�| j d kr�t d| j � f ��tj | �} |jd| � |jdd| f� tj} tjt|�| |j �}| jj|�} d| } |j| | �}x"|D ]\} } | j|| | |�}�q"W t|||� t|�jj |� d S )NFc s s | ]}t |tj�V qd S )N)r[ r r\ )r9 �typr r r � <genexpr>� s z6VGenericEngine._loaded_gen_function.<locals>.<genexpr>z*'%s' is used as result type, but is opaquer r_ z _cffi_f_%s)rV �_load_constant�anyrY r[ r_ r r\ rZ � PointerTyper] Zfldtypes� TypeError� _get_c_namer` ra ZFunctionPtrType�tupler �_get_cached_btype� load_function�_make_struct_wrapper�setattrrP r) )r r; rG r/ r0 Z newfunctionZ indirections�base_tpZ indirect_argsrc rf Zindirect_result�BFuncrd r r r �_loaded_gen_function� s> z#VGenericEngine._loaded_gen_functionc sP | j j�| j j|�� �dkr4| j �� ��fdd�}n� ���fdd�}||_|S )Nr_ c s �j � �}�|f| �� |d S )Nr )�new)rY �res)�BTyper �oldfuncr r �newfunc� s z4VGenericEngine._make_struct_wrapper.<locals>.newfuncc s6 | d �� �j � | � �f | �d d � } �| � S )Nr )Znewp)rY )rw r8 rc rx r r ry � s .)r r1 rn Z_cffi_base_type)r rx rc r; rr ry r )rw r8 r rc rx r rp � s z#VGenericEngine._make_struct_wrapperc C s | j |d|� d S )N�struct)� _generate_struct_or_union_decl)r r; rG r r r �_generate_gen_struct_decl� s z(VGenericEngine._generate_gen_struct_declc C s | j |d||� d S )Nrz )�_loading_struct_or_union)r r; rG r/ r r r �_loading_gen_struct� s z"VGenericEngine._loading_gen_structc K s | j |� d S )N)�_loaded_struct_or_union)r r; rG r/ r r r r �_loaded_gen_struct� s z!VGenericEngine._loaded_gen_structc C s | j |d|� d S )N�union)r{ )r r; rG r r r �_generate_gen_union_decl� s z'VGenericEngine._generate_gen_union_declc C s | j |d||� d S )Nr� )r} )r r; rG r/ r r r �_loading_gen_union s z!VGenericEngine._loading_gen_unionc K s | j |� d S )N)r )r r; rG r/ r r r r �_loaded_gen_union s z VGenericEngine._loaded_gen_unionc C s |j d krd S d||f }d||f }d||f j� }| j}|d||f � |d� |d� |d� x�|j� D ]�\}} } } t| tj�r�| j� s�| dkr�|d | � qny$|d | jd d | | d �|f � W qn t k r� } z|dt | � � W Y d d } ~ X qnX qnW |d� | j j |� |d|f � |d� |d| � |d� |d| � |d� xt|j� D ]h\}} } } | dk�rv�q\|d||f � t| tj ��r�| jd k�r�|d| j� � n|d||f � �q\W |d� |d� |d� |d� |d |f � |d� |� d S ) Nz_cffi_check_%s_%sz_cffi_layout_%s_%sz%s %szstatic void %s(%s *p)rT z8 /* only to generate compile-time warnings or errors */z (void)p;r z (void)((p->%s) << 1);z { %s = &p->%s; (void)tmp; }z*tmpzfield %r)Zqualsz /* %s */rU zintptr_t %s(intptr_t i)z, struct _cffi_aligncheck { char x; %s y; };z static intptr_t nums[] = {z sizeof(%s),z) offsetof(struct _cffi_aligncheck, y),z offsetof(%s, %s),z 0, /* %s */z sizeof(((%s *)0)->%s),z -1z };z return nums[i];z3 /* the next line is not executed, but compiled */z %s(0);)�fldnames�stripr � enumfieldsr[ r � PrimitiveType�is_integer_typerO r �strr r] � ArrayType�lengthrl ) r r; r& rG Z checkfuncname�layoutfuncname�cnamer% �fname�ftype�fbitsize�fqualrK r r r r{ sT & z-VGenericEngine._generate_struct_or_union_declc C s� |j d krd S d||f }| jjd�d }|j||�}g }d} x(|| �} | dk rRP |j| � | d7 } q@W t|tj�r�|jr�|d } |d } |dd d� } |dd d� }|j � | || | f|_ n d||f j � }||f| j |< d S )Nz_cffi_layout_%s_%szintptr_t(*)(intptr_t)r r � r z%s %s) r� r �_typeof_lockedro r] r[ r r\ �partialZ force_flattenZ fixedlayoutr� r )r r; r& rG r/ r� rs �function�layoutZnum�xZ totalsizeZtotalalignmentZfieldofsZ fieldsizer� r r r r} 7 s, z'VGenericEngine._loading_struct_or_unionc C s |j d krd S | jj|� || jk�rdd� }| j}|j|�}| jj|�\}}||d |j|�d� ||d |j|�d� d}x�|j� D ]v\}} } } | dkr�q�||| |j||�d|f � ||d dkr�|j| �} |||d |j| �d |f � |d7 }q�W d S ) Nc S s | |krt d||| f ��d S )Nz'%s (we have %d, but C compiler says %d))r )Z realvalueZ expectedvalue�msgr r r �checkZ s z5VGenericEngine._loaded_struct_or_union.<locals>.checkr zwrong total sizer zwrong total alignmentr� zwrong offset for field %rzwrong size for field %r) r� r rn r �pop�sizeofZalignofr� Zoffsetof) r r; r� r ZBStructr� r� rc r� r� r� r� ZBFieldr r r r S s, z&VGenericEngine._loaded_struct_or_unionc C s. t |tj�r | j||d� n| j|d|� d S )Nr )r[ r �EnumType�_generate_gen_enum_declr{ )r r; rG r r r � _generate_gen_anonymous_declu s z+VGenericEngine._generate_gen_anonymous_declc C s2 t |tj�r | j|||d� n| j|d||� d S )Nr )r[ r r� �_loading_gen_enumr} )r r; rG r/ r r r �_loading_gen_anonymous{ s z%VGenericEngine._loading_gen_anonymousc K s. t |tj�r | j|||f|� n | j|� d S )N)r[ r r� �_loaded_gen_enumr )r r; rG r/ r r r r �_loaded_gen_anonymous� s z$VGenericEngine._loaded_gen_anonymousN�constc C s | j }d||f }| jj|� |d k rX|d| � |d� | j||� |d� |d� n�|r�|d| � |d� |d|f � |d|f � |d� nj|d kr�d }nd }d } |d kr�t|tj�r�d } d }||jd| |f |�� |d� |d||f � |d� |� d S )Nz _cffi_%s_%szint %s(char *out_error)rT z return 0;rU z int %s(long long *out_value)z *out_value = (long long)(%s);z return (%s) <= 0;�var�&r r� zconst *z %s%s(void)z return (%s%s);)r r r] �_check_int_constant_valuer[ r r\ rO ) r �is_intrG r; �category� check_valuer% �funcnameZ ampersandZextrar r r rW � s6 z"VGenericEngine._generate_gen_constc C s& t |tj�o|j� }| j|||� d S )N)r[ r r� r� rW )r r; rG r� r r r �_generate_gen_constant_decl� s z*VGenericEngine._generate_gen_constant_declc C s d| }|d k r"| j ||� |}n�|r�| jjd�d }| jjd�d } |j| |�} | jj|�} | | �} t| d �}|dk r�| r�| jjd�d } |dd| jj| � > 7 }nXd}t|tj �r�d | }| jj|j ||��d } |j| |�} | � }t|tj ��r|d }|S ) Nz_cffi_const_%sz long long*r zint(*)(long long*)z long longr � z (*)(void)rN ) �_load_known_int_constantr r� ro ru �intr� r[ r r\ rO )r r� r; rG r/ r� r� �valuerw rs r� �p�negativeZ BLongLongZ fntypeextrar r r rh � s. z VGenericEngine._load_constantc C sD t |tj�o|j� }| j||||�}t|||� t|�jj|� d S )N) r[ r r� r� rh rq rP r) r] )r r; rG r/ r0 r� r� r r r �_loaded_gen_constant� s z#VGenericEngine._loaded_gen_constantc C s� | j }|dkr"|d|||f � n|d|||f � |d� |d| � |d| � |d� |d| � |d � |d |d d � |f � |d � |d � d S )Nr z& if ((%s) > 0 || (long)(%s) != %dL) {z1 if ((%s) <= 0 || (unsigned long)(%s) != %dUL) {z char buf[64];z if ((%s) <= 0)z) sprintf(buf, "%%ld", (long)(%s));z elsez2 sprintf(buf, "%%lu", (unsigned long)(%s));z: sprintf(out_error, "%s has the real value %s, not %s",z "%s", buf, "%d");�d z return -1;z })r )r rG r� r% r r r r� � s z(VGenericEngine._check_int_constant_valuec C sr | j jd�d }| j jd�d }|j||�}| j j|d�}||�dk rn| j j|�}tjdkrft|d�}t|��d S )Nzchar[]r z int(*)(char*)� r zutf-8)r ) r r� ro ru �stringr r$ r� r )r r/ r� rw rs r� r� �errorr r r r� � s z'VGenericEngine._load_known_int_constantc C s |j dd�}d||f S )N�$Z___D_z _cffi_e_%s_%s)�replace)r r& rG r r r �_enum_funcname� s z VGenericEngine._enum_funcname�enumc C s� |j r&x|jD ]}| jd|� qW d S | j||�}| jj|� | j}|d| � |d� x&t|j|j�D ]\}}| j ||� qhW |d� |d� |� d S )NTzint %s(char *out_error)rT z return 0;rU ) r� � enumeratorsrW r� r r] r r^ � enumvaluesr� )r r; rG r& � enumeratorr� r% � enumvaluer r r r� � s z&VGenericEngine._generate_gen_enum_declc sL �j r0� ��fdd��jD �}t|��_d�_n�j||�}�j� |� d S )Nc s g | ]}�j d �|� ��qS )T)rh )r9 r� )r/ r r; r r r< s z4VGenericEngine._loading_gen_enum.<locals>.<listcomp>T)r� r� rm r� Zpartial_resolvedr� r� )r r; rG r/ r& r� r� r )r/ r r; r r� s z VGenericEngine._loading_gen_enumc C s< x6t |j|j�D ]$\}}t|||� t|�jj|� qW d S )N)r^ r� r� rq rP r) r] )r r; rG r/ r0 r� r� r r r r� s z VGenericEngine._loaded_gen_enumc C s& |dkrd }n|}| j d||d� d S )Nz...T)r� )rW )r r; rG r� r r r �_generate_gen_macro_decl s z'VGenericEngine._generate_gen_macro_declc C sF |dkrd }n|}| j d||||d�}t|||� t|�jj|� d S )Nz...T)r� )rh rq rP r) r] )r r; rG r/ r0 r� r� r r r �_loaded_gen_macro) s z VGenericEngine._loaded_gen_macroc C s� t |tj�rx|jdkr\| j}d|f }| jj|� |d| � |d� |d|f � |d� tj|j�}| j d||� n tj|�}| j d||dd � d S ) Nz...z_cffi_sizeof_%szsize_t %s(void)rT z return sizeof(%s);rU Fr� )r� ) r[ r r� r� r r r] rj �itemrW )r r; rG r% r� �tp_ptrr r r �_generate_gen_variable_decl6 s z*VGenericEngine._generate_gen_variable_declc s^ t |tj�r�|jdkr�d|f }| jjd�d }|j||�}|� }| jj|j�} t || jj | ��\} } | dkr�t d||jf ��|j | �}tj |j�} | jd| ||�} |jd k r�| jj|�}| jj|| �} t||| � t|�jj|� d S d| }| jj|jd|��d }|j||�}|� � � fd d �}� fd d �}tt|�|t||�� t|�jj|� d S ) Nz...z_cffi_sizeof_%szsize_t(*)(void)r z/bad size: %r does not seem to be an array of %sFz _cffi_var_%sz *(*)(void)c s � d S )Nr r )r0 )�ptrr r �getterg s z3VGenericEngine._loaded_gen_variable.<locals>.getterc s |� d< d S )Nr r )r0 r� )r� r r �setteri s z3VGenericEngine._loaded_gen_variable.<locals>.setter)r[ r r� r� r r� ro rn r� �divmodr� r Zresolve_lengthrj rh �castrq rP r) r] rO �property)r r; rG r/ r0 r� rs r� �sizeZ BItemTyper� �restr� r� ZBArrayr� r� r )r� r �_loaded_gen_variableH s: z#VGenericEngine._loaded_gen_variable)r )r )Nr� N)N)r� )r� )5r, r- r. Z _class_keyZ_gen_python_moduler r r r r r( r3 r? r" r4 rL rM Z_generate_gen_typedef_declZ_loading_gen_typedefZ_loaded_gen_typedefre Z_loading_gen_functionrt rp r| r~ r� r� r� r� r{ r} r r� r� r� rW r� Z_loading_gen_constantrh r� r� r� r� r� r� r� r� Z_loading_gen_macror� r� Z_loading_gen_variabler� r r r r r sf -$1 " $ r ad #include <stdio.h> #include <stddef.h> #include <stdarg.h> #include <errno.h> #include <sys/types.h> /* XXX for ssize_t on some platforms */ /* this block of #ifs should be kept exactly identical between c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py and cffi/_cffi_include.h */ #if defined(_MSC_VER) # include <malloc.h> /* for alloca() */ # if _MSC_VER < 1600 /* MSVC < 2010 */ typedef __int8 int8_t; typedef __int16 int16_t; typedef __int32 int32_t; typedef __int64 int64_t; typedef unsigned __int8 uint8_t; typedef unsigned __int16 uint16_t; typedef unsigned __int32 uint32_t; typedef unsigned __int64 uint64_t; typedef __int8 int_least8_t; typedef __int16 int_least16_t; typedef __int32 int_least32_t; typedef __int64 int_least64_t; typedef unsigned __int8 uint_least8_t; typedef unsigned __int16 uint_least16_t; typedef unsigned __int32 uint_least32_t; typedef unsigned __int64 uint_least64_t; typedef __int8 int_fast8_t; typedef __int16 int_fast16_t; typedef __int32 int_fast32_t; typedef __int64 int_fast64_t; typedef unsigned __int8 uint_fast8_t; typedef unsigned __int16 uint_fast16_t; typedef unsigned __int32 uint_fast32_t; typedef unsigned __int64 uint_fast64_t; typedef __int64 intmax_t; typedef unsigned __int64 uintmax_t; # else # include <stdint.h> # endif # if _MSC_VER < 1800 /* MSVC < 2013 */ # ifndef __cplusplus typedef unsigned char _Bool; # endif # endif #else # include <stdint.h> # if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) # include <alloca.h> # endif #endif ) r r r5 r r r� r �objectr r! r r r r �<module> s PK %�\]XAn n , __pycache__/ffiplatform.cpython-36.opt-1.pycnu �[��� 3 M��Z� � @ s� d dl Z d dlZddlmZ dddddgZf fd d �Zdd d �Zdd d�Zyd dlm Z W n e k rv dd� Z Y nX dd� Z ye e fZd dlZW n ek r� e Zd dlZY nX dd� Zdd� Zdd� ZdS ) � N� )�VerificationError�sourcesZ include_dirsZ library_dirsZ extra_objectsZdependsc K sL t � ddlm} | g}x |D ]}|jtjj|�� q W |f ||d�|��S )Nr )� Extension)�namer )�_hack_at_distutils�distutils.corer �append�os�path�normpath)Z srcfilename�modnamer �kwdsr Z allsources�src� r �#/usr/lib64/python3.6/ffiplatform.py� get_extension s r c C sf t � tjj� }z t| |||�}tjj|�}W dx.|j� D ]"\}}tjj|�|kr:|tj|< q:W X |S )z-Compile a C extension module using distutils.N) r r �environ�copy�_buildr �abspath�items�get)�tmpdir�ext�compiler_verbose�debugZ saved_environZoutputfilename�key�valuer r r �compile s r c C s ddl m} dd l}dd l}|d|gi�}|j� |jd�}|d krLtjj}d|f|d< d |d< d| f|d < d| f|d < yR|j j d�p�d}z.|j j |� |j d� |j d�} | j� \} W d |j j |� X W nD |jj|jjfk �r } ztd | jj| f ��W Y d d } ~ X nX | S ) Nr )� DistributionZ ext_modulesZ build_ext� ffiplatformr T�forceZ build_libZ build_tempz%s: %s)r! T)r r Zdistutils.errorsZ distutils.logZparse_config_filesZget_option_dict�sys�flagsr �logZ set_thresholdZ set_verbosityZ run_commandZget_command_objZ get_outputs�errorsZ CompileErrorZ LinkErrorr � __class__�__name__) r r r r r Z distutilsZdistZoptionsZ old_levelZcmd_objZsoname�er r r r s. &r )�samefilec C s t jj| �t jj|�kS )N)r r r )�f1�f2r r r r* A s r* c C s� t jj| �s| S | }g }xn|}t jj|�\}}||ks<| r@| S |j|� y$t|t j�rl|j� t jj|� S W q t k r� Y qX qW d S )N) r r �isabs�splitr r* �curdir�reverse�join�OSError)r �dir�namesZprevdirr r r r �maybe_relative_pathD s r5 c C s� t | t�r"|jdt| �| f � n�t | t�rrt| j� �}|jdt|� � x�|D ] }t||� t| | |� qPW ndt | tt f�r�|jdt| � � xB| D ]}t||� q�W n*t | t �r�|jd| f � nt d| f ��d S )Nz%ds%sz%ddz%dlz%diz7the keywords to verify() contains unsupported object %r) � isinstance�str�write�len�dict�sorted�keys�_flatten�list�tuple� int_or_long� TypeError)�x�fr< r r r r r r= _ s r= c C s t j� }t| |� |j� S )N)� cStringIO�StringIOr= �getvalue)rB rC r r r �flattenr s rG c C s0 t jdkr,y dd l} W n tk r* Y nX d S )NZwin32r )r# �platform� setuptools� ImportError)rI r r r r w s r )r N)r N)r# r �errorr ZLIST_OF_FILE_NAMESr r r Zos.pathr* rJ r5 �intZlongr@ rD � NameError�ior= rG r r r r r �<module> s( PK %�\��*N� � / __pycache__/setuptools_ext.cpython-36.opt-1.pycnu �[��� 3 M��Z � @ sn d dl Z d dlZye W n ek r0 eZY nX dd� Zdd� Zdd� Zdd � Zd d � Z d d � Z dd� Z dS )� Nc C s ddl m} || ��d S )Nr )�DistutilsSetupError)Zdistutils.errorsr )�msgr � r �&/usr/lib64/python3.6/setuptools_ext.py�error s r c C s@ t | ��}|j� }W d Q R X |d7 }t|| d�}t|||� d S )N� �exec)�open�read�compiler )�filenameZglob�f�src�coder r r �execfile s r c C s� ddl m} t|t�s*tdt|�jf � t|�}y|jd�\}}W n" t k rf td|f � Y nX t j j |�s�d}|j dd�d }t j j |�r�d |d | f }td ||f � d |d �}t||� y || }W n$ tk r� td||f � Y nX t||��s|� }t||��s0td|t|�jf � t|d��sJtd|f � |j\} } } } |j�rr| j� } |j| � | d k�r�t| || � nt| || | | | � d S )Nr )�FFIzEargument to 'cffi_modules=...' must be a str or a list of str, not %r�:z3%r must be of the form 'path/build.py:ffi_variable'� �.�/z.pyz (rewrite cffi_modules to [%r])z#%r does not name an existing file%sZ__cffi__)�__name__�__file__z!%r: object %r not found in modulez"%r is not an FFI instance (got %r)�_assigned_sourcez*%r: the set_source() method was not called)Zcffi.apir � isinstance� basestringr �typer �str�split� ValueError�os�path�exists�replacer �KeyError�hasattrr Z_windows_unicode�copyZ_apply_windows_unicode�_add_py_module� _add_c_module) �distZmod_specr Zbuild_file_nameZ ffi_var_name�extZ rewrittenZmod_vars�ffi� module_name�source�source_extension�kwdsr r r �add_cffi_module sL r/ c C sp d|krlt td� rltjdkrlddl}y(t|jjd�d �}|dkrLd|d< W n tk rj d|d< Y nX |S ) a� Add py_limited_api to kwds if setuptools >= 26 is in use. Do not alter the setting if it already exists. Setuptools takes care of ignoring the flag on Python 2 and PyPy. CPython itself should ignore the flag in a debugging version (by not listing .abi3.so in the extensions it supports), but it doesn't so far, creating troubles. That's why we check for "not hasattr(sys, 'gettotalrefcount')" (the 2.7 compatible equivalent of 'd' not in sys.abiflags). (http://bugs.python.org/issue28401) On Windows, it's better not to use py_limited_api until issue #355 can be resolved (by having virtualenv copy PYTHON3.DLL). See also the start of _cffi_include.h. Zpy_limited_api�gettotalrefcountZwin32r Nr � T)r$ �sys�platform� setuptools�int� __version__� partitionr )� Extensionr. r4 Zsetuptools_major_versionr r r �_set_py_limited_apiI s r9 c s� ddl m} ddlm} ddlm� ddlm� ddlm � dg}|j |j dg �� t ||�}|f �|d �|���d�������� fd d � �| j d kr�g | _ | j j�� | jjd |�� G � ��fd d�d� �} | | jd < d S )Nr )r8 )� build_ext)�mkpath)�log)� recompilerz $PLACEHOLDER�sources)�namer> c s\ t jj| �� �}�jd| � �| � |d k r:|� �� �j���|�}|sX�jd� |S )Nzgenerating cffi module %rzalready up-to-date)r r �join�infoZ make_c_source)Ztmpdir�pre_runZc_file�updated)r) r* r< r; r+ r= r, r- r r �make_modt s z _add_c_module.<locals>.make_modr: c s e Zd Z� ��fdd�ZdS )z)_add_c_module.<locals>.build_ext_make_modc s: �j d dkr,t| dd �}�| j|��j d< � j| � d S )Nr z $PLACEHOLDERrB )r> �getattrZ build_temp�run)�selfrB )� base_classr) rD r r rF � s z-_add_c_module.<locals>.build_ext_make_mod.runN)r � __module__� __qualname__rF r )rH r) rD r r �build_ext_make_mod� s rK )N)Zdistutils.corer8 � setuptools.command.build_extr: �distutils.dir_utilr; � distutilsr< �cffir= �extend�popr9 Z ext_modules�append�cmdclass�get) r( r* r+ r, r- r. r8 r: Z allsourcesrK r ) rH r) r* r< rD r; r+ r= r, r- r r' g s r' c s� ddl m� ddlm} ddlm} ddlm� ddlm � �����fdd��| j j d |�� G � ��fd d �d � �}|| j d < | j d kr�g | _ | j j �� | j j d |��G ���fd d�d��}|| j d < d S )Nr )r; )�build_py)r: )r< )r= c s> �j d| � �tjj| �� �j� �| �}|s:�j d� d S )Nzgenerating cffi module %rzalready up-to-date)rA r r �dirnameZmake_py_source)Zpy_filerC )r* r< r; r+ r= r r � generate_mod� s z$_add_py_module.<locals>.generate_modrU c s e Zd Z� ��fdd�ZdS )z)_add_py_module.<locals>.build_py_make_modc s@ � j | � �jd�}|d d7 < �tjj| jf|�� � d S )Nr � z.py���)rF r r r r@ Z build_lib)rG � module_path)rH rW r+ r r rF � s z-_add_py_module.<locals>.build_py_make_mod.runN)r rI rJ rF r )rH rW r+ r r �build_py_make_mod� s r[ r: c s e Zd Z� ��fdd�ZdS )z*_add_py_module.<locals>.build_ext_make_modc sb � j | � | jr^�jd�}dj|d d� �}| jd�}|j|�}|d d }�tjj||�� d S )Nr rX rU z.pyrY rY )rF Zinplacer r@ Zget_finalized_commandZget_package_dirr r )rG rZ �packagerU Z package_dir� file_name)� base_class_2rW r+ r r rF � s z._add_py_module.<locals>.build_ext_make_mod.runN)r rI rJ rF r )r^ rW r+ r r rK � s rK )rM r; Zsetuptools.command.build_pyrU rL r: rN r< rO r= rS rT Z py_modulesrR )r( r* r+ rU r: r[ rK r )rH r^ r* rW r< r; r+ r= r r& � s r& c C s, t |t�r|g}x|D ]}t| |� qW d S )N)r r r/ )r( �attr�valueZ cffi_moduler r r � cffi_modules� s ra ) r r2 r � NameErrorr r r r/ r9 r' r& ra r r r r �<module> s - .1PK %�\�uU^g# g# # __pycache__/verifier.cpython-36.pycnu �[��� 3 M��Z�+ � @ s� d dl Z d dlZd dlZd dlZd dlZddlmZ ddlmZ ddlm Z e j dkrhd dl Z dd� Z nd dlZd d� Z e j d kr�ejZnG d d � d ej�ZG d d � d e�ZdZdd� Zdadd� Zdd� Zd dd�Zdd� Zdd� ZdS ) � N� )� __version_verifier_modules__)� ffiplatform)�VerificationError� c C s t jjd d � S )N)� importlib� machinery�EXTENSION_SUFFIXES� r r � /usr/lib64/python3.6/verifier.py�_extension_suffixes s r c C s dd� t j� D �S )Nc S s g | ]\}}}|t jkr|�qS r )�impZ C_EXTENSION)�.0�suffix�_�typer r r � <listcomp> s z'_extension_suffixes.<locals>.<listcomp>)r Z get_suffixesr r r r r s c s e Zd Z� fdd�Z� ZS )�NativeIOc s( t |t�r|jd�}tt| �j|� d S )N�ascii)� isinstanceZunicode�encode�superr �write)�self�s)� __class__r r r s zNativeIO.write)�__name__� __module__� __qualname__r � __classcell__r r )r r r s r c @ sz e Zd Zd dd�Zd dd�Zd d � Zd d � Zd d� Zdd� Zdd� Z dd� Z dd� Z dd� Z d!dd�Z dd � Zd d � ZdS )"�VerifierN� F�.cc K sv |j jrtd|j jf ��|| _|| _|s4tj| �} t||�} | | �| _| jj | � | | _ | j | | �| _ |rz|rxt d��n�djtjd d� t|| g|j �}tjdkr�|jd�}ttj|dd d� �d@ �}|jd �jd �}ttj|d d d� �d@ �}|jd �jd �}d || jj||f }t� d }|�p0t � | _ t j j| j || �| _ t j j| j || �| _!|| _"d| _#d| _$d S )NzKfeature not supported with ffi.verify(), but only with ffi.set_source(): %sz)can't specify both 'modulename' and 'tag'� r zutf-8r � l �� Z0x�Lr �0z_cffi_%s_%s%s%sF)r )%Z_parserZ_uses_new_featurer �ffi�preambler Zflatten�_locate_engine_class�_vengineZpatch_extension_kwds�flags�make_relative_to�kwds� TypeError�join�sys�versionr Z _cdefsources� version_infor �hex�binasciiZcrc32�lstrip�rstripZ _class_key�_get_so_suffixes�_caller_dir_pycache�tmpdir�os�path�sourcefilename�modulefilename� ext_package� _has_source� _has_module)r r' r( r9 Z modulenamer> �tag�force_generic_engineZsource_extensionr+ � relative_tor- Zflattened_kwdsZ vengine_class�keyZk1Zk2r r r r �__init__ sD zVerifier.__init__c C s8 | j j�& | jr |dkr td��| j|� W dQ R X dS )zkWrite the C source code. It is produced in 'self.sourcefilename', which can be tweaked beforehand.Nzsource code already written)r' �_lockr? r � _write_source)r �filer r r � write_sourceH s zVerifier.write_sourcec C s< | j j�* | jrtd��| js&| j� | j� W dQ R X dS )z�Write the C source code (if not done already) and compile it. This produces a dynamic link library in 'self.modulefilename'.zmodule already compiledN)r' rF r@ r r? rG �_compile_module)r r r r �compile_moduleQ s zVerifier.compile_modulec C sF | j j�4 | js4| j� | js4| js,| j� | j� | j� S Q R X dS )a" Get a C module from this Verifier instance. Returns an instance of a FFILibrary class that behaves like the objects returned by ffi.dlopen(), but that delegates all operations to the C module. If necessary, the C code is written and compiled first. N)r' rF r@ �_locate_moduler? rG rJ � _load_library)r r r r � load_library[ s zVerifier.load_libraryc C sB t jj| j�}|jdd�d }|jd�r>ttd�r>|d d� }|S )N�.r r Z_d�gettotalrefcountr$ ���)r: r; �basenamer= �split�endswith�hasattrr0 )r rR r r r �get_module_namek s zVerifier.get_module_namec C sV t j� | js0| jj� | js&| j� W d Q R X t j| j�}| j� }t j ||f| j �S )N) r Z_hack_at_distutilsr? r' rF rG Zmaybe_relative_pathr< rV � get_extensionr- )r Z sourcename�modnamer r r rW v s zVerifier.get_extensionc C s | j jS )N)r* Z_gen_python_module)r r r r �generates_python_module� s z Verifier.generates_python_modulec s~ |rzt jj|�rzt jj|�� |j� }xTtjD ]J}||kr,|| }t|ttf�s\t d|f ��� fdd�|D �}|||< q,W |S )Nz&keyword '%s' should be a list or tuplec s g | ]}t jj� |��qS r )r: r; r/ )r �fn)�dirnamer r r � s z-Verifier.make_relative_to.<locals>.<listcomp>) r: r; r[ �copyr ZLIST_OF_FILE_NAMESr �list�tupler. )r r- rC rD Zlstr )r[ r r, � s zVerifier.make_relative_toc C s� t jj| j�st| jrHyt| jd d dg�}W n tk r> d S X |j}nd }| jj | j � |t � �}|d krnd S || _| jj � d| _ d S )N�__doc__T)r: r; �isfiler= r> � __import__� ImportError�__path__r* � find_modulerV r7 Z collect_typesr@ )r Zpkgr; �filenamer r r rL � s zVerifier._locate_modulec C s$ || j _z| j j� W d | j `X d S )N)r* Z_fZwrite_source_to_f)r rH r r r �_write_source_to� s zVerifier._write_source_toc C s� |d k r| j |� n�t� }| j |� |j� }tjj| j�rbt| jd��}|j� |k }W d Q R X nd}|r�t | j� t| jd��}|j |� W d Q R X d| _ d S )N�rT�w) rf r �getvaluer: r; �existsr< �open�read� _ensure_dirr r? )r rH �fZ source_data�fpZ needs_writtenr r r rG � s zVerifier._write_sourcec C sp t jj| j�}tj|| j� �}ytj|| j�}W n t k rH d}Y nX |sft | j� t j || j� d| _ d S )NFT)r: r; r[ r< r �compilerW �samefiler= �OSErrorrm �shutilZmover@ )r r9 ZoutputfilenameZsamer r r rJ � s zVerifier._compile_modulec C s0 | j s t�| jd k r"| jj| j�S | jj� S d S )N)r@ �AssertionErrorr+ r* rN )r r r r rM � s zVerifier._load_library)NNNr! Fr" NN)N)N)r r r rE rI rK rN rV rW rY r, rL rf rG rJ rM r r r r r s & r Fc C s| t rd}|sPdtjkr d}n4y dd l}W n tk r@ d}Y nX | j|k rPd}|rfddlm} |jS ddlm } |j S d S )NTZ__pypy__r �?r )� vengine_gen)� vengine_cpy) �_FORCE_GENERIC_ENGINEr0 �builtin_module_names� _cffi_backendrb Z_backendr! rv ZVGenericEnginerw ZVCPythonEngine)r' rB rz rv rw r r r r) � s r) c C sH t rt S tjjd�} | r | S tjd�jj}tjj tjj tjj |�d��S )NZ CFFI_TMPDIRr$ � __pycache__) �_TMPDIRr: �environ�getr0 � _getframe�f_code� co_filenamer; �abspathr/ r[ )�resultre r r r r8 � s r8 c C s | a dS )z:Set the temporary directory to use instead of __pycache__.N)r| )r[ r r r � set_tmpdir s r� c C s0 | pt � } ytj| �}W n tk r, dS X |r8d}nt� d j� }xd|D ]\}|j� jd�rL|j� j|�sz|j� jd�rLytjtj j | |�� W qL tk r� Y qLX qLW tj j | d�g}xn|D ]f}yJxDtj|�D ]6}tj j ||�}tj j |��r |j |� q�tj|� q�W W q� tk �r& Y q�X q�W dS )z}Clean up the temporary directory by removing all files in it called `_cffi_*.{c,so}` as well as the `build` subdirectory.Nz.cr Z_cffi_Zbuild) r8 r: �listdirrr r7 �lower� startswithrT �unlinkr; r/ �isdir�append)r9 Zkeep_soZfilelistr rZ Z clean_dir�dirr r r �cleanup_tmpdir s2 r� c C s& t � } | s"tjdkr dg} ndg} | S )NZwin32z.pydz.so)r r0 �platform)�suffixesr r r r7 $ s r7 c C s, t jj| �}|r(t jj|� r(t j|� d S )N)r: r; r[ r� �makedirs)re r[ r r r rm / s rm )r r )r )NF) r0 r: r4 rs �ior! r r �errorr r2 Zimportlib.machineryr r r �StringIOr �BytesIO�objectr rx r) r| r8 r� r� r7 rm r r r r �<module> s* ( ? PK %�\( �� � # __pycache__/__init__.cpython-36.pycnu �[��� 3 M��Z� � @ sB d ddddgZ ddlmZ ddlmZmZmZmZ dZd Z d Z d S )�FFI�VerificationError�VerificationMissing� CDefError�FFIError� )r )r r r r z1.11.5� � z0.8.6N)r r r ) �__all__Zapir �errorr r r r � __version__Z__version_info__Z __version_verifier_modules__� r r � /usr/lib64/python3.6/__init__.py�<module> s PK %�\�1��/� /� / __pycache__/backend_ctypes.cpython-36.opt-1.pycnu �[��� 3 M��Zf� � @ s� d dl Z d dlZ d dlZd dlZddlmZ ejdk r<eZne Z e Z e Zdd� ZG dd� de�ZG d d � d e�ZG d d � d e�ZG d d� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZdS )� N� )�model� c C s t | g�S )N)�bytes)�num� r �&/usr/lib64/python3.6/backend_ctypes.py�<lambda> s r c @ s e Zd ZdS )� CTypesTypeN)�__name__� __module__� __qualname__r r r r r s r c @ s e Zd ZeZdgZdZ dd� Zedd� �Ze dd� �Z ed d � �Z ed d � �Z e d d� �Z ed5dd��Zedd� �Zdd� Zdd� Zd6dd�Zdd � Zed d � �Zd d � Zed!d"� �Zd#d$� Zed%d&� �Zd'd(� Zd)d*� Zed+�Zed,�Z ed-�Z ed.�Z ed/�Z ed0�Z d1d2� Z!d3d4� Z"dS )7� CTypesData� __weakref__z<cdata>c G s t d| jf ��d S )Nzcannot instantiate %r)� TypeError� __class__)�self�argsr r r �__init__ s zCTypesData.__init__c C s t d| j� f ��d S )Nz+expected a pointer or array ctype, got '%s')r � _get_c_name)�cls�initr r r �_newp s zCTypesData._newpc C s t �d S )N)r )�valuer r r � _to_ctypes s zCTypesData._to_ctypesc G s^ y | j }W n" tk r, td| f ��Y nX |rR| j|� }t||�sZ| j |�}n| j � }|S )Nz cannot create an instance of %r)�_ctype�AttributeErrorr r � isinstance)r r �ctype�resr r r �_arg_to_ctypes s zCTypesData._arg_to_ctypesc C s |d kr| j � S | j |�S d S )N)r )r r r r r �_create_ctype_obj. s z CTypesData._create_ctype_objc C s t �d S )N)r )Z ctypes_valuer r r � _from_ctypes5 s zCTypesData._from_ctypes� c C s | j jd|�S )Nz &)� _reftypename�replace)r � replace_withr r r r 9 s zCTypesData._get_c_namec C s* d| j � f | _d| j � f | _d| _d S )Nz CData<%s>�ffi)r r r r )r r r r � _fix_class= s zCTypesData._fix_classc C s t �d S )N)�NotImplementedError)r r r r � _get_own_reprC s zCTypesData._get_own_reprc C s8 |dkr dS |dk r,|ddt jt j� > 7 }d| S d S )Nr ZNULLr � z0x%x)�ctypes�sizeof�c_void_p)r �addressr r r � _addr_reprF s zCTypesData._addr_reprNc C s | j � }d|p| j� |f S )Nz <cdata %r %s>)r* r )r �c_nameZownr r r �__repr__N s zCTypesData.__repr__c C s8 |d kr t d| j� f ��nt d| j� |j� f ��d S )Nz cannot convert %r to an addresszcannot convert %r to %r)r r )r �BClassr r r �_convert_to_addressR s z CTypesData._convert_to_addressc C s t j| j�S )N)r, r- r )r r r r � _get_sizeZ s zCTypesData._get_sizec C s t j| j�S )N)r, r- r )r r r r �_get_size_of_instance^ s z CTypesData._get_size_of_instancec C s t d| j� f ��d S )Nzcannot cast to %r)r r )r �sourcer r r � _cast_froma s zCTypesData._cast_fromc C s | j d �S )N)r4 )r r r r �_cast_to_integere s zCTypesData._cast_to_integerc C s t j| j�S )N)r, Z alignmentr )r r r r � _alignmenth s zCTypesData._alignmentc C s t d| j� ��d S )Nz#cdata %r does not support iteration)r r )r r r r �__iter__l s zCTypesData.__iter__c s t t| �� � fdd�}| |_|S )Nc sz t | t� }t |t�o t |t� }|r@|r@� | jd �|jd ��S |sH|rLtS t | t�r\| j} t |t�rl|j}� | |�S d S )N)r �CTypesGenericPrimitiver r4 �NotImplemented�_value)r �otherZv_is_ptrZw_is_ptr)�cmpfuncr r �cmpr s z!CTypesData._make_cmp.<locals>.cmp)�getattr�operatorZ func_name)�namerA r )r@ r � _make_cmpp s zCTypesData._make_cmp�__eq__�__ne__�__lt__�__le__�__gt__�__ge__c C s t | jd ��S )N)�hashr4 )r r r r �__hash__� s zCTypesData.__hash__c C s t d| f ��d S )Nz string(): %r)r )r �maxlenr r r � _to_string� s zCTypesData._to_string)r# )N)#r r r r Z __metaclass__� __slots__r � classmethodr � staticmethodr r r! r" r r( r* r0 r2 r4 r5 r6 r8 r9 r: r; rE rF rG rH rI rJ rK rM rO r r r r r s> r c @ s e Zd Zg Zdd� Zdd� ZdS )r< c C s t | j�S )N)rL r> )r r r r rM � s z CTypesGenericPrimitive.__hash__c C s t | j| j��S )N)�reprr" r> )r r r r r* � s z$CTypesGenericPrimitive._get_own_reprN)r r r rP rM r* r r r r r< � s r< c @ s, e Zd Zg Zedd� �Zdd� Zdd� ZdS )�CTypesGenericArrayc C s | |�S )Nr )r r r r r r � s zCTypesGenericArray._newpc c s$ x t t| ��D ]}| | V qW d S )N)�xrange�len)r �ir r r r; � s zCTypesGenericArray.__iter__c C s | j tj| j��S )N)r0 r, � addressof�_blob)r r r r r* � s z CTypesGenericArray._get_own_reprN)r r r rP rQ r r; r* r r r r rT � s rT c @ s� e Zd ZddgZdZdZedd� �Zedd� �Zed d � �Z d d � Z d d� Z dd� Z e Z edd� �Zedd� �Zedd� �Zdd� ZdS )�CTypesGenericPtr�_address� _as_ctype_ptrF�pointerc C s | |�S )Nr )r r r r r r � s zCTypesGenericPtr._newpc C sV |d krd}n>t |t�r"|j� }n*t |ttf�r6|}ntd| t|�jf ��| j|�S )Nr zbad type for cast to %r: %r) r r r9 �int�longr �typer �_new_pointer_at)r r7 r/ r r r r8 � s zCTypesGenericPtr._cast_fromc C s$ | j | �}||_tj|| j�|_|S )N)�__new__r[ r, �castr r\ )r r/ r r r r ra � s z CTypesGenericPtr._new_pointer_atc C s& y | j | j�S tk r dS X d S )Nz???)r0 r[ r )r r r r r* � s z CTypesGenericPtr._get_own_reprc C s | j S )N)r[ )r r r r r9 � s z!CTypesGenericPtr._cast_to_integerc C s t | j�S )N)�boolr[ )r r r r � __nonzero__� s z CTypesGenericPtr.__nonzero__c C s4 t |t�s tdt|�j ��|j| �}tj|| j�S )Nzunexpected %s object) r r r r` r r4 r, rc r )r r r/ r r r r � s zCTypesGenericPtr._to_ctypesc C s t j|t j�jpd}| j|�S )Nr )r, rc r. r ra )r � ctypes_ptrr/ r r r r" � s z CTypesGenericPtr._from_ctypesc C s |r| j |�j|_d S )N)r �contents)r rf r r r r � _initialize� s z CTypesGenericPtr._initializec C s0 || j d fks|js| jr | jS tj| |�S d S )N)r �_automatic_castsr[ r r4 )r r3 r r r r4 � s z$CTypesGenericPtr._convert_to_addressN)r r r rP ri �kindrQ r r8 ra r* r9 re �__bool__r r" rh r4 r r r r rZ � s rZ c @ s\ e Zd ZdgZedd� �Zdd� Zedd� �Zdd � Zed d � �Z ed d � �Z ddd�Z dS )�CTypesBaseStructOrUnionrY c C s t d| f ��d S )Nz!cannot instantiate opaque type %s)r )r r r r r r! � s z)CTypesBaseStructOrUnion._create_ctype_objc C s | j tj| j��S )N)r0 r, rX rY )r r r r r* � s z%CTypesBaseStructOrUnion._get_own_reprc C s t | j|�jS )N)rB r �offset)r � fieldnamer r r � _offsetof� s z!CTypesBaseStructOrUnion._offsetofc C s. t |dd �| jkr tj| j�S tj| |�S d S )N�_BItem)rB r r, rX rY r r4 )r r3 r r r r4 � s z+CTypesBaseStructOrUnion._convert_to_addressc C s | j | �}||_|S )N)rb rY )r Zctypes_struct_or_unionr r r r r" s z$CTypesBaseStructOrUnion._from_ctypesc C s |j S )N)rY )r r r r r r s z"CTypesBaseStructOrUnion._to_ctypesNc C s t j| |p| jd��S )Nz &)r r2 r )r r1 r r r r2 s z CTypesBaseStructOrUnion.__repr__)N) r r r rP rQ r! r* ro r4 r" r r2 r r r r rl � s rl c @ s e Zd Zejejejejejej ej ej ej ej ejejejejd�ZxfdMD ]^Zejee �Zee edde < eejej�kr�ee ed < eejej�krLee ed < qLW xtdND ]lZejee �Zee edde < eejej�k�ree ed< ee ed< eejej�kr�ee ed< q�W dd� Zdd� Zdd� ZdOdd �Zd d � Z d d � Z d!d"� Z d#d$� Z d%d&� Z d'd(� Z!d)d*� Z"dRd,d-�Z#d.d/� Z$d0d1� Z%d2d3� Z&d4d5� Z'dTd6d7�Z(dVd8d9�Z)d:d;� Zd<d=� Z*d>d?� Z+d@dA� Z,dBdC� Z-dDZ.dWdEdF�Z/e0Z1dGdH� Z2dXdIdJ�Z3dYdKdL�Z4dDS )Z� CTypesBackend)�char�shortr^ r_ z long longz signed charz unsigned charzunsigned shortz unsigned intz unsigned longzunsigned long long�float�double�_Bool�unsigned long long� unsigned long� unsigned int�unsigned short� unsigned charzuint%d_tr+ Z uintptr_tZsize_t� long longr_ r^ rs � signed charzint%d_tZintptr_tZ ptrdiff_tZssize_tc C s d| _ d| _tj| _tj| _d S )Nr )� RTLD_LAZY�RTLD_NOWr, � RTLD_GLOBAL� RTLD_LOCAL)r r r r r 7 s zCTypesBackend.__init__c C s || _ d S )N)r' )r r' r r r �set_ffi= s zCTypesBackend.set_ffic C s t tfS )N)r r )r r r r � _get_types@ s zCTypesBackend._get_typesr c C s t j||�}t| |�S )N)r, ZCDLL� CTypesLibrary)r �path�flags�cdllr r r � load_libraryC s zCTypesBackend.load_libraryc C s G dd� dt �}|j� |S )Nc @ s, e Zd Zg ZdZedd� �Zedd� �ZdS )z/CTypesBackend.new_void_type.<locals>.CTypesVoidzvoid &c S s d S )Nr )�novaluer r r r" K s z<CTypesBackend.new_void_type.<locals>.CTypesVoid._from_ctypesc S s | d k r t dt| �jf ��d S )Nz None expected, got %s object)r r` r )r� r r r r N s z:CTypesBackend.new_void_type.<locals>.CTypesVoid._to_ctypesN)r r r rP r$ rR r" r r r r r � CTypesVoidH s r� )r r( )r r� r r r � new_void_typeG s zCTypesBackend.new_void_typec s� �dkrt ���| j� ��dkr(d}n<�dkr6d}n.�dkrDd}n�dkrRd }nd }�d�jdk�� fd d ��|�G � �����fdd�dt�� � j� � S )NZwchar_trr rt ru � signed char� unsigned char�byterv rd r^ r c sj t | tttf�rt| �} nLt | t�r.| j� } n8t | t�rBt| �} n$| d krPd} ntd� t | �j f ��| S )Nr zbad type for cast to %r: %r) r r^ r_ rt r r9 r �ordr r` r )r7 )�CTypesPrimitiver r �_cast_source_to_inth s z=CTypesBackend.new_primitive_type.<locals>._cast_source_to_intc s� e Zd ZdgZ�Zd� Z�Zdd� Ze� �fdd��Z edksHedkrbe ��fd d ��Z d d � Z ed kr�e �fdd ��Z dd � Z edkr�e �fdd ��Z dd � Z edkr�e ��fdd ��Z dd � Z dd� Z e Zedks�edks�ed kr�e���fdd��Zedk�r e� fdd��Zdd � Znd d � ZeZedk�rFe�fd d��Zed d � �Ze� fd!d"��Zedk�rtd#d$� Zedk�r�d%d$� Zd&S )'z9CTypesBackend.new_primitive_type.<locals>.CTypesPrimitiver> z%s &c S s || _ d S )N)r> )r r r r r r } s zBCTypesBackend.new_primitive_type.<locals>.CTypesPrimitive.__init__c s | d kr�� S �� j | ��S )N)r )r )r� r r r r! � s zKCTypesBackend.new_primitive_type.<locals>.CTypesPrimitive._create_ctype_objr^ r� c s � |�}�|�j }| |�S )N)r )r r7 )r� r r r r8 � s zDCTypesBackend.new_primitive_type.<locals>.CTypesPrimitive._cast_fromc S s | j S )N)r> )r r r r �__int__� s zACTypesBackend.new_primitive_type.<locals>.CTypesPrimitive.__int__rd c s$ t |tttf�s� |�}| t|��S )N)r r^ r_ rt rd )r r7 )r� r r r8 � s c S s | j S )N)r> )r r r r r� � s rr c s � |�}t |d@ �}| |�S )N� )�bytechr)r r7 )r� r r r8 � s c S s t | j�S )N)r� r> )r r r r r� � s rt c sN t |t�r n0t |t�r4t|d�r*t|�}q<t|�}n� |�}�|�j}| |�S )N� __float__)r rt r< �hasattrr^ r )r r7 )r� r r r r8 � s c S s t | j�S )N)r^ r> )r r r r r� � s c S s | j S )N)r> )r r r r r� � s zCCTypesBackend.new_primitive_type.<locals>.CTypesPrimitive.__float__c sn t | ttf�s4t | t�r"t| �} ntdt| �j ��� | �j| krj� r^| dk r^td� ��n td� ��| S )Nzinteger expected, got %sr z%s: negative integerz%s: integer out of bounds) r r^ r_ r r r` r r � OverflowError)�x)r � is_signedrD r r r � s zDCTypesBackend.new_primitive_type.<locals>.CTypesPrimitive._to_ctypesc s@ t | t�rt| �dkr| S t | � �r*| jS tdt| �j ��d S )Nr zcharacter expected, got %s)r r rV r> r r` r )r� )r� r r r � s c S s t | j�dkS )Nr )r� r> )r r r r re � s zECTypesBackend.new_primitive_type.<locals>.CTypesPrimitive.__nonzero__c S s | j dkS )Nr )r> )r r r r re � s c s. t | ttttf�s$tdt| �j ��� | �jS )Nzfloat expected, got %s) r r^ r_ rt r r r` r r )r� )r r r r � s c S s t | d| �S )Nr )rB )r r r r r" � s zFCTypesBackend.new_primitive_type.<locals>.CTypesPrimitive._from_ctypesc s � j |�| _d S )N)r r )�blobr )r� r r rh � s zECTypesBackend.new_primitive_type.<locals>.CTypesPrimitive._initializec S s | j S )N)r> )r rN r r r rO � s zDCTypesBackend.new_primitive_type.<locals>.CTypesPrimitive._to_stringc S s t | jd@ �S )Nr� )�chrr> )r rN r r r rO � s N)r r r rP r r$ rj r rR r! rQ r8 r� r� r9 r re rk r" rh rO r )r� r� r r� �kind1rD r r r� w sF r� )rt ru )r� r� ���r� )r) �PRIMITIVE_TYPESr r< r( )r rD rj r )r� r� r r� r� rD r �new_primitive_typeW s$ wz CTypesBackend.new_primitive_typec s� | j j}� |tjd��kr d�n>� |tjd��|tjd��fkrFd�n� |tj�krZd�nd�G � ��fdd �d t��� | j jtj�ks�� | j jtjd��kr�d �_�j� �S ) Nrr �charpz signed charz unsigned char�bytep�voidp�genericc s� e Zd ZdgZ�dkr edg7 Z�Ze�d�rHej�j�Zej �j�Z nej Ze �e �rd�jd�Zn �jd�Z��fdd�Zd d � Zd d � Z�fd d�Z�fdd�Z�dks��dkr�e�� fdd��Z�dks֔dkr�dd� Z�� fdd�Z� ZS )z1CTypesBackend.new_pointer_type.<locals>.CTypesPtr�_ownr� Z __as_strbufr z(* &)z * &c sb � j |�}�dkr8tj|jd �| _tj| j| j�| _n tj|�| _tj| jtj �j| _ d| _ d S )Nr� � T) r! r, Zcreate_string_bufferr Z_CTypesPtr__as_strbufrc r r\ r] r. r[ r� )r r Zctypeobj)�BItemrj r r r s z:CTypesBackend.new_pointer_type.<locals>.CTypesPtr.__init__c S s, t |ttf�r$| j| j|| j �S tS d S )N)r r^ r_ ra r[ � _bitem_sizer= )r r? r r r �__add__ s z9CTypesBackend.new_pointer_type.<locals>.CTypesPtr.__add__c S sN t |ttf�r$| j| j|| j �S t| �t|�krF| j|j | j S tS d S )N)r r^ r_ ra r[ r� r` r= )r r? r r r �__sub__ s z9CTypesBackend.new_pointer_type.<locals>.CTypesPtr.__sub__c s( t | dd�r|dkrt�� j| j| �S )Nr� Fr )rB � IndexErrorr" r\ )r �index)r� r r � __getitem__) s z=CTypesBackend.new_pointer_type.<locals>.CTypesPtr.__getitem__c s � j |�| j|< d S )N)r r\ )r r� r )r� r r � __setitem__. s z=CTypesBackend.new_pointer_type.<locals>.CTypesPtr.__setitem__r� c s4 |r t |d t�r tj|d �S t� | �j|� S d S )Nr )r r r, Zc_char_p�superr )r r )� CTypesPtrr r r r 2 s z@CTypesBackend.new_pointer_type.<locals>.CTypesPtr._arg_to_ctypesr� c sf |dk rt j}tj| jtjtj��� d}x ||k rH� | dkrH|d7 }q*W dj� fdd�t|�D ��S )Nr r� r � c s g | ] }� | �qS r r )�.0rW )�pr r � <listcomp>B s zPCTypesBackend.new_pointer_type.<locals>.CTypesPtr._to_string.<locals>.<listcomp>) �sys�maxsizer, rc r\ �POINTER�c_char�join�range)r rN �nr )r� r rO : s z<CTypesBackend.new_pointer_type.<locals>.CTypesPtr._to_stringc s. t | dd�r dtj| jj�f S t� | �j� S )Nr� Fzowning %d bytes)rB r, r- r\ rg r� r* )r )r� r r r r* D s z?CTypesBackend.new_pointer_type.<locals>.CTypesPtr._get_own_repr)r r r rP rp r� r, r� r r- r� r. � issubclassrT r r$ r r� r� r� r� rQ r rO r* � __classcell__r )r� r� rj )r r r� � s* r� T)r' �_get_cached_btyper � PrimitiveTypeZ void_typerZ ri r( )r r� �getbtyper )r� r� rj r �new_pointer_type� s Mz CTypesBackend.new_pointer_typec s� �d krd�nd� ��j � | jj}� |tjd��kr<d�n*� |tjd��|tjd��fkrbd�nd�G � �����fdd �d t���j� �S ) Nz &[]z &[%d]rr z signed charz unsigned charr� r� c s� e Zd ZddgZ�dk r$�j� Zn ejd� �j��Z�Z�Z ���fdd�Z e �fdd��Z d d � Z �fd d �Z�fd d�Z�dks��dkr�dd� Z�� fdd�Z�fdd�Ze �fdd��Ze �fdd��Z��fdd �Zed d � �Z� ZS ) z1CTypesBackend.new_array_type.<locals>.CTypesArrayrY r� Nr c s� �d kr\t |ttf�r |}d }n0�dkr@t |t�r@t|�d }nt|�}t|�}� j| | _| j� | _d| _|d k r�| j | j|� d S )Nrr r T) r r^ r_ r rV �tupler rY r� rh )r r Zlen1)r� rj �lengthr r r j s z:CTypesBackend.new_array_type.<locals>.CTypesArray.__init__c s� t � t�r&� fdd�tt� ��D �� nt� �� t� �t| �krFtd��tj| tj�j }tj �j �}tj �j �}x6t � �D ]*\}}tj||| |�}�j|j|� qxW d S )Nc s g | ]}� ||d � �qS )r r )r� rW )r r r r� } s zQCTypesBackend.new_array_type.<locals>.CTypesArray._initialize.<locals>.<listcomp>ztoo many initializers)r r r� rV r� r� r, rc r. r r� r r- � enumeraterh rg )r� r �addr�PTR�itemsizerW r r� )r� )r r rh z s z=CTypesBackend.new_array_type.<locals>.CTypesArray._initializec S s t | j�S )N)rV rY )r r r r �__len__� s z9CTypesBackend.new_array_type.<locals>.CTypesArray.__len__c s2 d| kot | j�k n s"t�� j| j| �S )Nr )rV rY r� r" )r r� )r� r r r� � s z=CTypesBackend.new_array_type.<locals>.CTypesArray.__getitem__c s6 d| kot | j�k n s"t�� j|�| j|< d S )Nr )rV rY r� r )r r� r )r� r r r� � s z=CTypesBackend.new_array_type.<locals>.CTypesArray.__setitem__rr r� c sj |dk rt | j�}tj| jtjtj��� d}x ||k rL� | dkrL|d7 }q.W dj� fdd�t|�D ��S )Nr r� r r� c s g | ] }� | �qS r r )r� rW )r� r r r� � s zPCTypesBackend.new_array_type.<locals>.CTypesArray._to_string.<locals>.<listcomp>)rV rY r, rc r� r� r� r� )r rN r� r )r� r rO � s z<CTypesBackend.new_array_type.<locals>.CTypesArray._to_stringc s, t | dd�r dtj| j�f S t� | �j� S )Nr� Fzowning %d bytes)rB r, r- rY r� r* )r )� CTypesArrayr r r r* � s z?CTypesBackend.new_array_type.<locals>.CTypesArray._get_own_reprc s. |� d fks|j r tj| j�S tj| |�S d S )N)ri r, rX rY r r4 )r r3 )r� r r r4 � s zECTypesBackend.new_array_type.<locals>.CTypesArray._convert_to_addressc s � j � �}| |_|S )N)rb rY )Z ctypes_arrayr )r� r r r" � s z>CTypesBackend.new_array_type.<locals>.CTypesArray._from_ctypesc s � j | �S )N)r )r )r� r r r � s z@CTypesBackend.new_array_type.<locals>.CTypesArray._arg_to_ctypesc s8 t |ttf�r0�jtj| j�|tj� j� �S t S d S )N) r r^ r_ ra r, rX rY r- r r= )r r? )r� r� r r r� � s z9CTypesBackend.new_array_type.<locals>.CTypesArray.__add__c S s t d| j� f ��d S )Nz casting to %r)r) r )r r7 r r r r8 � s z<CTypesBackend.new_array_type.<locals>.CTypesArray._cast_from)r r r rP r �appendr r$ �_declared_length�_CTPtrr rR rh r� r� r� rO r* r4 r" r r� rQ r8 r� r )r� r� r� �bracketsrj r� )r r r� ` s( r� )rp r' r� r r� rT r( )r r� r� r� r )r� r� r� r� rj r� r �new_array_typeQ s cz CTypesBackend.new_array_typec sF G dd� d|��d|�f �_ |� G � ��fdd�dt�}|j� |S )Nc @ s e Zd ZdS )z;CTypesBackend._new_struct_or_union.<locals>.struct_or_unionN)r r r r r r r �struct_or_union� s r� z%s_%sc s( e Zd ZdgZ�Zd�f Z� ZZdS )z?CTypesBackend._new_struct_or_union.<locals>.CTypesStructOrUnionrY z%s &N)r r r rP r r$ �_kindrj r )r� rD r� r r �CTypesStructOrUnion� s r� )r rl r( )r rj rD Zbase_ctypes_classr� r )r� rD r� r �_new_struct_or_union� s z"CTypesBackend._new_struct_or_unionc C s | j d|tj�S )N�struct)r� r, Z Structure)r rD r r r �new_struct_type� s z CTypesBackend.new_struct_typec C s | j d|tj�S )N�union)r� r, ZUnion)r rD r r r �new_union_type� s z CTypesBackend.new_union_typer c sP |dks|dkrt d��� j�dd� |D ��dd� |D �}dd� |D �}i } g } xN|D ]F\} } } | dk r�| j| | jf� | | | < qV| j| | j| f� t| | < qVW |d@ r�d�_| �_| � _t��fd d ��}|� _� ���fd d ��� j d k�t t �t ||����x�|D ]�\} } } | dk�r$t d��t � | ��r<t d| ��| dk �r�| | � j| �tj| j�fdd�}| | fdd�}t| t��r�d }| jdk�r�| | j� j| �tj| j�fdd�}n | | fdd�}| | fdd�}t� | t||�� �qW | jjtj|��}xP�D ]H} t || ��r t d| ��| fdd�}| fdd�}t|| t||�� �q W d S )Nr z�the ctypes backend of CFFI does not support structures completed by verify(); please compile and install the _cffi_backend module.c S s g | ]\}}}|�qS r r )r� �fname�BField�bitsizer r r r� � s z:CTypesBackend.complete_struct_or_union.<locals>.<listcomp>c S s g | ]\}}}|�qS r r )r� r� r� r� r r r r� � s c S s g | ]\}}}|�qS r r )r� r� r� r� r r r r� � s r+ r c s �� }| d k r� || � |S )Nr )r �result)� initializer� r r r! � s zACTypesBackend.complete_struct_or_union.<locals>._create_ctype_objc s� �r"t |�dkr"tdt |�f ��t|t�sxt|ttf�rBtd��t|�}t |�t ��krjtd� j� ��tt �|��}t j | �}xT|j � D ]H\}}�| \}}� j |�}t j|j�}t j|| |�} |j| j|� q�W d S )Nr zPunion initializer: %d items given, but only one supported (use a dict if needed)z union initializer: got a strz"too many values for %s initializer)rV � ValueErrorr �dictr �unicoder r� r �zipr, rX �itemsro r� r rc rh rg ) r� r r� r� r r� r� rm r� r� )r� �fnames�is_union�name2fieldtyper r r� � s& z:CTypesBackend.complete_struct_or_union.<locals>.initializer� r# z nested anonymous structs/unionsz1the field name %r conflicts in the ctypes backendc S s( t j| j�}t j|| |�}|j|j�S )N)r, rX rY rc r" rg )r r� r� rm r� r� r� r r r �getter s z6CTypesBackend.complete_struct_or_union.<locals>.getterc S s t | j||j|�� d S )N)�setattrrY r )r r r� r� r r r �setter$ s z6CTypesBackend.complete_struct_or_union.<locals>.setterc S s& t j| j�}t j|| |�}|j|�S )N)r, rX rY rc r" )r r� Z BFieldPtrrm r� r� r� r r r r� * s c S s |j t| j|��S )N)r" rB rY )r r� r� r r r r� 2 s c S sN |j |�}t| j|�}t| j||� |t| j|�krJt| j||� td��d S )Nz value too large for bitfield)r rB rY r� r� )r r r� r� Zoldvaluer r r r� 4 s c S s t | d |�S )Nr )rB )r r� r r r r� C s c S s t | d ||� d S )Nr )r� )r r r� r r r r� E s )r) r r� �EllipsisZ_pack_Z_fields_� _bfield_typesrR r! r� r� r� r� r� ro r, r� r� rT r� r� r� �propertyr' r� r Z PointerType)r r� Zfields�tpZ totalsizeZtotalalignmentZsflagsZbtypesZ bitfieldsZ bfield_typesZcfieldsr� r� r� r! r� r� r� r )r� r� r� r� r� r� r �complete_struct_or_union� sf z&CTypesBackend.complete_struct_or_unionc sN dd� � D ���r �j d� dj���G � ����fdd�dt���j� �S )Nc S s g | ] }|j � �qS r )r )r� �BArgr r r r� J s z3CTypesBackend.new_function_type.<locals>.<listcomp>z...z, c s� e Zd ZddgZeje�dd�fdd� �D ��ddi�Z�jd �f �Z d����fd d � Z e d d � �Z dd� Z �� fdd�Z���fdd�Z� ZS )z:CTypesBackend.new_function_type.<locals>.CTypesFunctionPtr� _own_callback�_namer Nc S s g | ] }|j �qS r )r )r� r� r r r r� R s zECTypesBackend.new_function_type.<locals>.CTypesFunctionPtr.<listcomp>� use_errnoTz (* &)(%s)c s� dd l �t�dd �d k r*�j�j� ��� nd � ��� ��fdd�}t�t�rptjtjfdd� �D ��ddi�}n�j }||�| _ tj | j tj�j | _ �| _d S ) Nr r c s� g }x&t | � �D ]\}}|j|j|�� qW y�|� }�j|�}W n �j� �}Y nX t�t�r�|r|tj|tj �j }nd }|S )N) r� r� r" r � print_excr� rZ r, rc r. r )r Zargs2�argr� Zres2)�BArgs�BResult�errorr � tracebackr r �callback_ s zUCTypesBackend.new_function_type.<locals>.CTypesFunctionPtr.__init__.<locals>.callbackc S s g | ] }|j �qS r )r )r� r� r r r r� v s zWCTypesBackend.new_function_type.<locals>.CTypesFunctionPtr.__init__.<locals>.<listcomp>r� T)r� rB r" r! r� rZ r, � CFUNCTYPEr. r r\ rc r r[ r� )r r r� r� Zcallback_ctype)r� r� �CTypesFunctionPtr� has_varargs)r� r r� r r V s zCCTypesBackend.new_function_type.<locals>.CTypesFunctionPtr.__init__c S s |r t d��d S )NzActypes backend: not supported: initializers for function pointers)r) )rf r r r r rh s zFCTypesBackend.new_function_type.<locals>.CTypesFunctionPtr._initializec S sP t | dd �}|rD| jjd�}| j|d dkr6d| }| jjd|�}tj| |�S )Nr� z(* &)r z )*� )rB r$ r� r% r r2 )r r1 rW r r r r2 � s zCCTypesBackend.new_function_type.<locals>.CTypesFunctionPtr.__repr__c s* t | dd �d k r d| jf S t� | �j� S )Nr� z calling %r)rB r� r� r* )r )r� r r r r* � s zHCTypesBackend.new_function_type.<locals>.CTypesFunctionPtr._get_own_reprc s� �r&|t � �d � }|d t � �� }n g }x&t|� �D ]\}}|j|j|�� q6W �r�xjt|�D ]^\}}|d kr�|jtjd�� q`t|t�s�t ddt � � | t |�j f ��|j|j|�� q`W | j |� }�j |�S )Nr zKargument %d passed in the variadic part needs to be a cdata object (got %s)r )rV r� r� r r� r, r. r r r r` r r\ r" )r r Z extraargsZ ctypes_argsr� r� rW r� )r� r� r� r r �__call__� s$ zCCTypesBackend.new_function_type.<locals>.CTypesFunctionPtr.__call__)N)r r r rP r, r� rB r r r$ r rR rh r2 r* r� r� r )r� r� r� r� �nameargs)r r r� O s ) r� )r� r� rZ r( )r r� r� r� r )r� r� r� r� r� r �new_function_typeI s \z CTypesBackend.new_function_typec s8 t tt|�t|����G � �fdd�d|�}|j� |S )Nc s0 e Zd Zg Zd� Z�fdd�Z�fdd�ZdS )z/CTypesBackend.new_enum_type.<locals>.CTypesEnumz%s &c s4 | j }yd|� | f S tk r. t|�S X d S )Nz%d: %s)r> �KeyError�str)r r )�reverse_mappingr r r* � s z=CTypesBackend.new_enum_type.<locals>.CTypesEnum._get_own_reprc s, | j }y� | S tk r& t|�S X d S )N)r> r� r� )r rN r )r� r r rO � s z:CTypesBackend.new_enum_type.<locals>.CTypesEnum._to_stringN)r r r rP r$ r* rO r )rD r� r r � CTypesEnum� s r )r� r� �reversedr( )r rD Z enumeratorsZ enumvaluesZ CTypesIntr r )rD r� r � new_enum_type� s zCTypesBackend.new_enum_typec C s t j� S )N)r, � get_errno)r r r r r � s zCTypesBackend.get_errnoc C s t j|� d S )N)r, � set_errno)r r r r r r � s zCTypesBackend.set_errnoc C s |j |�S )N)rO )r �brN r r r �string� s zCTypesBackend.stringc C s t d��d S )Nz buffer() with ctypes backend)r) )r Zbptr�sizer r r �buffer� s zCTypesBackend.bufferc C s t |t�r|j� S |j� S d S )N)r r r6 r5 )r Zcdata_or_BTyper r r r- � s zCTypesBackend.sizeofc C s |j � S )N)r: )r �BTyper r r �alignof� s zCTypesBackend.alignofc C s t |t�st�|j|�S )N)r� r r r )r r r7 r r r �newp� s zCTypesBackend.newpc C s |j |�S )N)r8 )r r r7 r r r rc � s zCTypesBackend.castc C s |||�S )Nr )r r r7 r� �onerrorr r r r� � s zCTypesBackend.callbackNc s� | j d kr.dd l}G dd� d|j�}i |f| _ | j \� }|d krpy� ||�= W n tk rj td��Y nX d S � fdd�}| j| j|�|�}||f� |||�< |S )Nr c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )z CTypesBackend.gcp.<locals>.MyRefc S s | � }| |kp |d k o ||� kS )Nr )r r? Zmyrefr r r rF � s z'CTypesBackend.gcp.<locals>.MyRef.__eq__c S s | |k S )Nr )r r? r r r rG � s z'CTypesBackend.gcp.<locals>.MyRef.__ne__c S s. y| j S tk r( t| � �| _ | j S X d S )N)�_hashr rL )r r r r rM � s z)CTypesBackend.gcp.<locals>.MyRef.__hash__N)r r r rF rG rM r r r r �MyRef� s r zFCan remove destructor only on a object previously returned by ffi.gc()c s$ � j | d�\}}|d k r ||� d S )N)NN)�pop)�k�cdata� destructor)� weak_cacher r �remove s z!CTypesBackend.gcp.<locals>.remove)�_weakref_cache_ref�weakref�refr� r rc �typeof)r r r r r r r Z new_cdatar )r r �gcp� s zCTypesBackend.gcpc C s |j |�S )N)r )r r r& r r r �getcname s zCTypesBackend.getcnamec C s� t |t�r\|dkr"t|t�r"|j}t|t�s4td��|j| }|tkrNtd��||j |�fS t |t t f�r�t|t �rz|j }t|t�s�td��|j}|j� | }|tjkr�t�||fS tt|���d S )Nr z expected a struct or union ctypeznot supported for bitfieldsz expected an array or ptr ctype)r r� r� rZ rp rl r r� r� ro r^ r_ rT r� r5 r� r� r� r` )r r rn r r� r� rm r r r � typeoffsetof s( zCTypesBackend.typeoffsetofc C s� t |t�r tjt|�j|��}n^t |t�r\|d ksDtt|�jt� rLt d��t|�j|�}n"t |t �rvt|�j|�}nt d��|r�tj tj tj |tj �j | �t|��}|j|�S )Nzunexpected cdata typez$expected a <cdata 'struct-or-union'>)r rl r, r] r` r rZ r� rp r rT rc r. r r" )r ZBTypePtrr rm Zptrr r r � rawaddressof. s zCTypesBackend.rawaddressof)rw rx ry rz r{ )r| r_ r^ rs r} )r r� r� )r� r� r r� )r� r� )r� )r )r )N)5r r r r, r� Zc_shortZc_intZc_longZ c_longlongZc_byteZc_ubyteZc_ushortZc_uintZc_ulongZ c_ulonglongZc_floatZc_doubleZc_boolr� r� r- Z_sizer. Zc_size_tr r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r rc r� r r r` r r r r r r r r rq sx `u le % rq c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) r� c C s || _ || _d S )N)�backendr� )r r r� r r r r D s zCTypesLibrary.__init__c C s t | j|�}|j|�}||_|S )N)rB r� r" r� )r r rD Zc_func�funcobjr r r � load_functionH s zCTypesLibrary.load_functionc C sJ y|j j| j|�}W n* tk r> } zt|��W Y d d }~X nX |j|�S )N)r �in_dllr� r r) r" )r r rD � ctypes_obj�er r r � read_variableN s zCTypesLibrary.read_variablec C s@ |j |�}|jj| j|�}tjtj|�tj|�tj|j�� d S )N)r r r r� r, ZmemmoverX r- )r r rD r Znew_ctypes_objr! r r r �write_variableU s z CTypesLibrary.write_variableN)r r r r r r# r$ r r r r r� B s r� )r )r, Z ctypes.utilrC r� r# r � version_infor� r� r� r� r^ r_ r� rU r` r �objectr r< rT rZ rl rq r� r r r r �<module> s, C# 7PK %�\�w�.P .P " __pycache__/cparser.cpython-36.pycnu �[��� 3 M��ZR� � @ s� d dl mZ d dlmZmZ d dlmZmZ yd dl mZ W n e k rX ddl Z Y nX ddl Z ddl Z ddl Z y(e jd#k r�ddlZnddlZej� ZW n e k r� dZY nX dZe jd e je jB �Ze jd e je jB �Ze jd �Ze jd �Ze jd �Ze jd�Z da e jde j �Z e jd�Z e jd�Z!e jd�Z"e jd�Z#e jd�Z$e jd�Z%e jd�Z&dd� Z'dd� Z(dd � Z)d d � Z*d d � Z+G d!d"� d"e,�Z-dS )$� )�model)� COMMON_TYPES�resolve_common_type)�FFIError� CDefError)� _pycparser� N� z<cdef source string>z /\*.*?\*/|//([^\n\\]|\\.)*?$z?^\s*#\s*define\s+([A-Za-z_][A-Za-z_0-9]*)\b((?:[^\n\\]|\\.)*?)$z =\s*\.\.\.\s*[,}]|\.\.\.\s*\}z__dotdotdot\d+__$z\[\s*\.\.\.\s*\]z\w+|\Sz-?0?x?[0-9a-f]+[lu]*$z\b(__stdcall|WINAPI)\bz[(]\s*(__stdcall|WINAPI)\bz \b__cdecl\bz9\bextern\s*"(Python|Python\s*\+\s*C|C\s*\+\s*Python)"\s*.z'[*]\s*((const|volatile|restrict)\b\s*)+z3(\b(int|long|short|signed|unsigned|char)\s*)+\.\.\.z\b(double|float)\s*\.\.\.c C s t d krtj� a t S )N)� _parser_cache� pycparserZCParser� r r � /usr/lib64/python3.6/cparser.py� _get_parser* s r c C s g }x�t j| �}|sP |j| d |j� � � |jd� d}|j|j� � |j� }| jd|�rn|jd� |d7 }d}|}x`|t| �k r�| | }|dkr�|d7 }n.|dkr�|dkr�P |d8 }n|dkr�|dkr�P |d7 }qxW | ||� | | |d � } qW |j| � dj|�S )N�(�)�*r r z,;=� ) �_r_star_const_space�search�append�start�group�end� startswith�len�join)�csource�parts�match�closing�endpos�level�i�cr r r � _workaround_for_old_pycparser0 s< r$ c C s0 g }�xt j| �}|sP |j� d }|j| d |j� � � d|jd�krT|jd� n |jd� | | dkr�| jd|�}|dk r�td��| jd|d |�dkr�td ��|j| |d |� � | |d d � } nB| jd |�}|dk r�td ��|j| ||d � � | |d d � } |jd � qW |j| � d j |�S )Nr �Cz(void __cffi_extern_python_plus_c_start; z!void __cffi_extern_python_start; �{�}r z!'extern "Python" {': no '}' foundz7cannot use { } inside a block 'extern "Python" { ... }'�;z 'extern "Python": no ';' foundz void __cffi_extern_python_stop;r ) �_r_extern_pythonr r r r r �findr �NotImplementedErrorr )r r r r r Z semicolonr r r �_preprocess_extern_pythonZ s4 r, c C s� t jd| �} i }x6tj| �D ](}|j� \}}|jdd�j� }|||< q W tjd| �} tjdk rft | �} t jd| �} t jd| �} t jd| �} t | �} tjd| �} ttj| ��}x�tt|��D ]�\}}|j� }| | dk�r| jd ||j� �}||ks�t�d | d |� || |d d � f } q�| ||d � d k�s4t�d | d |� || |d d � f } q�W tjd | �} tjd| �} | jd d�|fS )N� z\ r z2.14z volatile volatile const(z volatile volatile const z[__dotdotdotarray__]�=z...z%s,__dotdotdot%d__ %sr z%s __dotdotdot%d__ %sz __dotdotdotint__ z __dotdotdotfloat__ z __dotdotdot__ )� _r_comment�sub� _r_define�finditer�groups�replace�stripr � __version__r$ � _r_stdcall2� _r_stdcall1�_r_cdeclr, �_r_partial_array�list�_r_partial_enum� enumerate�reversedr r* r �AssertionError�_r_int_dotdotdot�_r_float_dotdotdot) r �macrosr Z macronameZ macrovalueZmatchesZnumber�pZp2r r r � _preprocess� s8 rD c C s t t�}|jd� |jd� |jd� |jd� |jd� t � }d}d}d}x�tj| �D ]�}||kr�|dkr�|r�|j|� |j|� d}nj|dkr�d }d}nX|dkr�|d 7 }nF|dkr�|d 8 }n4|dkr�|r�|dkr�|j|� |j|� n |j|� |}qXW |S ) Nr( �,r r �typedefFr r Tr )�setr �add�_r_words�findall�discard)r Zlook_for_wordsZ words_usedZ is_typedefZparenZ previous_wordZwordr r r �_common_type_names� s> rL c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd8d d �Zd d � Zdd� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zd9d d �Zd d � Zd:d"d#�Zd;d$d%�Zd<d&d'�Zd(d)� Zd=d*d+�Zd,d-� Zd>d.d/�Zd0d1� Zd2d3� Zd4d5� Zd6d7� Z d!S )?�Parserc C s: i | _ t� | _d| _tj� | _i | _i | _g | _ d | _ d S )Nr ) � _declarationsrG �_included_declarations�_anonymous_counter�weakref�WeakKeyDictionary�_structnode2type�_options�_int_constants� _recomplete�_uses_new_feature)�selfr r r �__init__� s zParser.__init__c C s4 t |�\}}t|�}g }x<t| j�D ].}|jd�r$|dd � }|j|� |j|� q$W |t|�7 }g }|jd� x|D ]}|jd| � qvW |jd� |jdtf � |j|� dj|�}t d k r�t j � zJyt � j |�} W n4 t jjk �r } z| j| |� W Y d d } ~ X nX W d t d k �r(t j� X | ||fS )Nztypedef � z*# 1 "<cdef automatic initialization code>"ztypedef int %s;z@typedef int __dotdotdotint__, __dotdotdotfloat__, __dotdotdot__;z# 1 "%s"� )rD rL �sortedrN r r rK �CDEF_SOURCE_STRINGr �lock�acquirer �parser Zc_parserZ ParseError�convert_pycparser_error�release) rX r rB Zctn� typenames�name� csourcelines�typenameZ fullcsource�ast�er r r �_parse� s4 " z Parser._parsec C sf d }t |�}tjdtf |�}|rbt|jd�d�}|j� }d| koPt|�kn rb||d }|S )Nz %s:(\d+):r � )�str�rer r] �intr � splitlinesr )rX rh r �line�msgr Zlinenumre r r r �_convert_pycparser_error s z Parser._convert_pycparser_errorc C s@ | j ||�}t|�}|r*d|j� |f }n d|f }t|��d S )Nzcannot parse "%s" %szparse error %s)rq rk r5 r )rX rh r ro rp r r r ra + s z Parser.convert_pycparser_errorFc C s0 | j }z |||d�| _ | j|� W d || _ X d S )N)�override�packed� dllexport)rT �_internal_parse)rX r rr rs rt Z prev_optionsr r r r` 5 s z Parser.parsec C s$ | j |�\}}}| j|� t|j�}x |D ]}|jdkr*P q*W dsFt�d }�yBd| _�x4|D �]*}|}t|tj j �r�| j |� q\t|tj j ��rf|js�t d|��d}t|jjtj j�r�|jjjd jd�r�| j|�}nxt|jtj j��r6t|jjtj j��r6t|jjjtj j��r6|jjjjd jd��r6| j|�}n| j|j|jdd�\}}| jd |j ||d � q\|jjd k�rvq\t d |jj |��q\W W n� t k �r� } z&t| j�dk�r�| j|f | _� W Y d d } ~ X nN t k �r } z0| j | |�} | �r | jd d | f| _� W Y d d } ~ X nX d S )N� __dotdotdot__r �__cffi_extern_python_stopz!typedef does not declare any namer Z __dotdotdotT)rd �partial_length_okztypedef )�qualsZPragmazBunexpected <%s>: this construct is valid C but not valid in cdef()z *** Err: %s���rz ) ri �_process_macros�iter�extrd r? �_inside_extern_python� isinstancer �c_astZDecl� _parse_declZTypedefr �type�IdentifierType�namesr �_get_unknown_type�PtrDecl�TypeDecl�_get_unknown_ptr_type�_get_type_and_quals�_declare� __class__�__name__r �argsr rq ) rX r rg rB �iterator�declZ current_declry Zrealtyperh rp r r r ru ? sX zParser._internal_parsec C s8 || j kr*| j | |kr d S td|f ��|| j |< d S )Nz%multiple declarations of constant: %s)rU r )rX �key�valr r r �_add_constantsu s zParser._add_constantsc C s� |j � jd�}|jd�}|r(|dd � }|jd�rV|dkrV|jd� rVd|dd � }t|d�}|rj| }| j||� | jd| |� d S ) NZul�-r �0�0xZ0or zmacro )�lower�rstripr rm r� r� )rX rd Zint_str�negZpyvaluer r r �_add_integer_constant} s z Parser._add_integer_constantc C sh xb|j � D ]V\}}|j� }tj|�r2| j||� q |dkrL| jd| |� q td||||f ��q W d S )Nz...zmacro z�only supports one of the following syntax: #define %s ... (literally dot-dot-dot) #define %s NUMBER (with NUMBER an integer constant, decimal/hex/octal) got: #define %s %s)�itemsr5 �_r_int_literalr r� r� r )rX rB r� �valuer r r r{ � s zParser._process_macrosc C sX | j ||�}| jjd�r d}n$| jdkr.d}n| jdkr>d}nd}| j||j |� d S )Nrt zdllexport_python Z__cffi_extern_python_startzextern_python Z!__cffi_extern_python_plus_c_startzextern_python_plus_c z function )�_get_type_pointerrT �getr~ r� rd )rX �tpry r� �tagr r r �_declare_function� s zParser._declare_functionc C s |j }t|tjj�rJ| j||jd�\}}t|tj�s8t �| j |||� �n�t|tjj �rf| j d|� nHt|tjj �r�| j d|� n,t|tjj�r�| j d|� n|js�td|��|j�r | j|dd�\}}|jr�| j |||� �n*|j� �r(t|d��r(t|jd ��r(tj|jj��r(| j|j|jj� n�|j� �r�t|jtjj��r�|jjd k�r�t|jjd ��r�tj|jjj��r�| j|jd |jjj � n||tjk�r�|jj d ��r�|j| _ nX| j d k�r�td ��|tj @ �r�|j �r�| j d|j ||d� n| j d|j ||d� d S )N)rd �struct�union�enumz'construct does not declare any variableT)rx �initr� r� Z__cffi_extern_python_rw z<cannot declare constants or variables with 'extern "Python"'z constant )ry z variable )!r� r r r� �FuncDeclr� rd r �RawFunctionTyper? r� �Struct�_get_struct_union_enum_type�Union�Enumr Zis_raw_functionZis_integer_type�hasattrr� r� r r� r� �UnaryOp�op�expr� void_typer r~ �Q_CONSTZ is_array_typer� )rX r� Znoder� ry r r r r� � sP zParser._parse_declc C s | j |�d S )Nr )�parse_type_and_quals)rX �cdeclr r r � parse_type� s zParser.parse_typec C sb | j d| �d d� \}}| s$t�|jd jjjd }t|tjj �rVt d|j f ��| j |j�S )Nzvoid __dummy( %s );� r r zunknown identifier '%s'rz ) ri r? r} r� r� �paramsr r r� �IDr rd r� )rX r� rg rB �exprnoder r r r� � s zParser.parse_type_and_qualsr c C sx || j krF| j | \}}||kr,||kr,d S | jjd�sFtd|f ��d|j� ksVt�||f| j |< |rt| jj|� d S )Nrr zPmultiple declarations of %s (for interactive usage, try cdef(xx, override=True))rv )rN rT r� r �splitr? rO rH )rX rd �obj�includedry ZprevobjZ prevqualsr r r r� � s zParser._declarec C sZ d}t |tjjtjjf�rVd|jkr.|tjO }d|jkrB|tjO }d|jkrV|tj O }|S )Nr �const�volatileZrestrict) r r r� r� r� ry r r� Z Q_VOLATILEZ Q_RESTRICT)rX r� ry r r r �_extract_quals� s zParser._extract_qualsNc C sj t |tj�r|j� S t |tj�r^|jjd�r^|jdd � j� r^|jd kr^|d k r^tj |||�S tj ||�S )N�$r ) r r r� �as_function_pointerZStructOrUnionOrEnumrd r �isdigit� forcenameZNamedPointerType� PointerType)rX r� ry �declnamer r r r� s zParser._get_type_pointerc C sH t |tjj�rtt |jtjj�rtt|jj�dkrtd|jjd | jkrt| jd|jjd \}}|| j |�O }||fS t |tjj �r�|j d kr�d }n| j |j |d�}| j |j|d�\}}tj||�|fS t |tjj��r| j |j�\}}| j|||d�}| j |�}||fS t |tjj��r�| j |�}|j} t | tjj��rVt| j�} | ddgk�ri } x<| �r�| d }|dk�r�| j|d�d | |< | d= nP �qVW g } x4dD ],} x$t| j| d��D ]}| j| � �q�W �q�W | �s�d g} | d gk�r�d| k�s�d | k�r�g } | | } d j| �}|d k�r"tj|fS |dk�r<td|jj ��t| |�\}}|||B fS t | tjj ��r|| j d| |�}||fS t | tjj ��r�| j d| |�}||fS t | tjj ��r�| j d| |�}||fS t |tjj ��r�| j!||�dfS t |tjj ��r| j d||dd�dfS t |tjj ��r4| j d||dd�dfS td|jj ��d S )Nr ztypedef r )rx )r� �signed�char�short�long�unsignedrm r- �voidrv z:%d: bad usage of "..."r� r� r� T)�nestedz(:%d: bad or unsupported type declaration)r� r� r� r� )r� r� r� )"r r r� r� r� r� r r� rN r� Z ArrayDeclZdim�_parse_constantr� r � ArrayTyper� r� r; r� �ranger r r� r �coordro r r� r� r� r� r� �_parse_function_type)rX �typenoderd rx r� ry ZlengthZitemtypeZ itemqualsr� r� �prefixesZnewnames�prefixr" ZidentZtp0Zquals0r r r r� s� zParser._get_type_and_qualsc s< t t|jdg ��}x@t|�D ]4\}}t|d�s td|p8d|d t|dd�f ��q W t|�dko�t|d jt j j �o�t|d jjt j j �o�|d jjj d gk}|r�|j� |s�td |p�d ��� fd d �|D �}| r�|tjgkr�g }� j|j�\}} d } t|jd ��r(|jjdd � dddgk�r(d} tjt|�||| �S )Nr� r� zt%s arg %d: unknown type '%s' (if you meant to use the old C syntax of giving untyped arguments, it is not supported)z in expressionr rd �?r rv z=%s: a function with only '(...)' as argument is not correct Cc s g | ]}� j � j|j�� �qS r )� _as_func_argr� r� )�.0Z argdeclnode)rX r r � <listcomp>| s z/Parser._parse_function_type.<locals>.<listcomp>ry r r� r� Z __stdcallrz rz rz ���)r; �getattrr� r= r� r r r r� r r� r� r� r� �popr r� r� ry r� �tuple) rX r� �funcnamer� r" �argZellipsisr� �resultry �abir )rX r r� g s6 zParser._parse_function_typec C s6 t |tj�rtj|j|�S t |tj�r.|j� S |S d S )N)r r r� r� �itemr� r� )rX r� ry r r r r� � s zParser._as_func_argc C s, y | j | S tk r Y nX |}|j}|d krb|d k rDd| }n| jd7 _d| j }d }n"|}d||f }| jj|d�\}} |d k�r|dkr�tj|d d d �}nP|dkr�tj|d d d �}n6|dkr�|dkr�t d ��| j ||j �}nt d |f ��|d k �r2| j ||� n"|dk�r2|j d k �r2td | ��|j�sD|j|� |j�rjd |jk�rj| j d |j |� || j |< |dk�r�|S |jd k�r�|S |jd k �r�t d| ��g } g } g } g } x�|jD ]�}t|jtjj��r�dj|jj�dk�r�| j||� �q�|jd k�rd}n | j |j�}d| _ | j |jdd�\}}| j �rH| j||� t|tj��rj|j �rj| j||� | j |j�pxd� | j |� | j |� | j |� �q�W t!| �|_t!| �|_"t!| �|_#t!| �|_$| dgt%| � k�r t|tj��r |j �r td|f ��| j&jd�|_'|j(�r(d|_(| j)j |� |S )Nz$%sr z$%dz%s %sr� r� r� rv z!Enums cannot be declared with ...z kind = %rz^enum %s: the '{}' declaration should appear on the first time the enum is mentioned, not laterr� z anonymous %sz"duplicate declaration of struct %sr FT)rx z#%s: using both bitfields and '...;'rs r )NNrz rz )*rS �KeyErrorrd rP rN r� r Z StructTypeZ UnionTyper �_build_enum_type�valuesr? r� r+ r� Zforce_the_name�decls�fldnamesr r� r r� r� r r� � _make_partial�bitsizer� �_partial_lengthr� �partialr r� �fldtypes� fldbitsize�fldqualsr rT rs Z completedrV )rX �kindr� rd r� Z force_name� explicit_namer� r� �_r� r� r� r� r� r� Zfqualr r r r� � s� z"Parser._get_struct_union_enum_typec C sB t |tj�std|f ��|j� r8| r8td|f ��d|_d S )Nz%s cannot be partialz %s is partial but has no C nameT)r r Z StructOrUnionr Z has_c_namer+ r� )rX r� r� r r r r� s zParser._make_partialc C s� t |tjj�r�|j}|jd�rF|jd�s2|jd�r<t|d�S t|d�S d|d ko\dkn rlt|d �S |d d kr�|d d kr�t|�d ks�t|�d kr�|d dkr�t|d �S t d|f ��t |tjj �r�|j dkr�| j |j �S t |tjj ��r|j dk�r| j |j � S t |tjj��r:|j| jk�r:| j|j S t |tjj��rv|jdk�rv|�rfd| _dS td|jj ��t |tjj��r�|j dk�r�| j |j�| j |j� S t |tjj��r�|j dk�r�| j |j�| j |j� S td|jj ��d S )Nr� r� Z0X� rZ �1r �9rj �'r r � �\r� zinvalid constant %r�+r� Z__dotdotdotarray__Tz...zT:%d: unsupported '[...]' here, cannot derive the actual array length in this contextz?:%d: unsupported expression: expected a simple numeric constantrz ���)r r r� ZConstantr� r rm r �ordr r� r� r� r� r� rd rU r� r r� ro ZBinaryOp�left�right)rX r� rx �sr r r r� sL $ zParser._parse_constantc C s� |d k r�d}g }g }d}xb|j D ]X}tj|j�r6d}q |jd k rL| j|j�}|j|j� |j|� | j|j|� |d7 }q W t|�}t|�}t j |||�}||_ nt j |f f �}|S )NFr Tr ) � enumerators�_r_enum_dotdotdotr rd r� r� r r� r� r ZEnumTyper� ) rX r� r� r� r� Z enumvaluesZ nextenumvaluer� r� r r r r� B s* zParser._build_enum_typec C sz xP|j j� D ]B\}\}}|jd�r$q |jdd�d }|d kr | j||d |d � q W x"|jj� D ]\}}| j||� q^W d S ) Nzanonymous $enum_$r- r r r� r� r� � anonymousrF T)r� ry )r� r� r� r� rF )rN r� r r� r� rU r� )rX �otherrd r� ry r� �k�vr r r �includeZ s zParser.includec C s� |j j j}|dgkr tj|j�S |dgkrL| jd kr@d|j | _tj|j�S |dgkrx| jd krld|j | _tj|j�S td|j j ��d S )Nrv Z__dotdotdotint__z'typedef int... %s'Z__dotdotdotfloat__z'typedef float... %s'z*:%d: unsupported usage of "..." in typedef) r� r� r Z unknown_typerd rW ZUnknownIntegerTypeZUnknownFloatTyper r� ro )rX r� rc r r r r� d s zParser._get_unknown_typec C s2 |j j j jdgkr tj|j�S td|jj ��d S )Nrv z*:%d: unsupported usage of "..." in typedef)r� r� r Zunknown_ptr_typerd r r� ro )rX r� r r r r� w s z Parser._get_unknown_ptr_type)FFF)Fr )N)NF)N)NF)F) r� � __module__� __qualname__rY ri rq ra r` ru r� r� r{ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r� r� r r r r rM � s4 & 6 2 ^ # v 3 rM )r ).r r Z commontypesr r �errorr r r r � ImportErrorrQ rl �sys� version_infoZthread�_thread� allocate_lockr^ r] �compile�DOTALL� MULTILINEr/ r1 r< r� r: rI r � IGNORECASEr� r8 r7 r9 r) r r@ rA r r$ r, rD rL �objectrM r r r r �<module> sN *27(PK %�\( �� � ) __pycache__/__init__.cpython-36.opt-1.pycnu �[��� 3 M��Z� � @ sB d ddddgZ ddlmZ ddlmZmZmZmZ dZd Z d Z d S )�FFI�VerificationError�VerificationMissing� CDefError�FFIError� )r )r r r r z1.11.5� � z0.8.6N)r r r ) �__all__Zapir �errorr r r r � __version__Z__version_info__Z __version_verifier_modules__� r r � /usr/lib64/python3.6/__init__.py�<module> s PK %�\s ��iK iK & __pycache__/model.cpython-36.opt-1.pycnu �[��� 3 M��Z0T � @ s� d dl Z d dlZddlmZ ddlmZmZmZ dZdZ dZ dd� Z G d d � d e �Z G d d � d e �ZG d d� de�Ze� ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd � d e�ZG d d � d e�Zee�Zd d � Zee�ZG d!d"� d"e�Z G d#d$� d$e�Z e ed%�d�Z G d&d'� d'e �Z G d(d)� d)e �Z G d*d+� d+e �Z!G d,d-� d-e �Z"G d.d/� d/e �Z#d<d0d1�Z$d=d2d3�Z%e� Z&ej'� Z(d4d5� Z)d6d7� Z*d8d9� Z+d:d;� Z,dS )>� N� )� allocate_lock)� CDefError�VerificationError�VerificationMissing� � c C s@ | t @ rd|j� }| t@ r(d|j� }| t@ r<d|j� }|S )Nz const z volatile z __restrict )�Q_CONST�lstrip� Q_VOLATILE� Q_RESTRICT)�quals� replace_with� r � /usr/lib64/python3.6/model.py�qualify s r c @ sP e Zd ZdZdZddd�Zdd� Zd d � Zd d � Zdd d�Z dd� Z dd� Z dS )�BaseTypeByIdentityF� �a C filer c C sx | j }|j� }|rB|jd�r.d|kr.d| }n|d dkrBd| }t||�}|jd|�}d|krttd | j� |f ��|S ) N�*z&[z(%s)r z[(� �&�$z-cannot generate '%s' in %s: unknown type name)�c_name_with_marker�strip� startswithr �replacer � _get_c_name)�selfr �contextr �resultr r r � get_c_name s z BaseTypeByIdentity.get_c_namec C s | j jdd�S )Nr r )r r )r r r r r / s z BaseTypeByIdentity._get_c_namec C s d| j � kS )Nr )r )r r r r � has_c_name2 s z BaseTypeByIdentity.has_c_namec C s dS )NFr )r r r r �is_integer_type5 s z"BaseTypeByIdentity.is_integer_typec C sB y|j | }W n. tk r< | j||�}|j j| |�}Y nX |S )N)�_cached_btypes�KeyError�build_backend_type� setdefault)r �ffi� finishlist� can_delay�BTypeZBType2r r r �get_cached_btype8 s z#BaseTypeByIdentity.get_cached_btypec C s d| j � f S )Nz<%s>)r )r r r r �__repr__A s zBaseTypeByIdentity.__repr__c s � fdd�� j D �S )Nc s g | ]}|t � |�f�qS r )�getattr)�.0�name)r r r � <listcomp>E s z1BaseTypeByIdentity._get_items.<locals>.<listcomp>)�_attrs_)r r )r r � _get_itemsD s z BaseTypeByIdentity._get_itemsN)r r r )F) �__name__� __module__� __qualname__� is_array_type�is_raw_functionr! r r" r# r, r- r3 r r r r r s r c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�BaseTypec C s | j |j ko| j� |j� kS )N)� __class__r3 )r �otherr r r �__eq__J s zBaseType.__eq__c C s | |k S )Nr )r r; r r r �__ne__N s zBaseType.__ne__c C s t | jt| j� �f�S )N)�hashr: �tupler3 )r r r r �__hash__Q s zBaseType.__hash__N)r4 r5 r6 r< r= r@ r r r r r9 H s r9 c @ s e Zd Zf Zdd� Zdd� ZdS )�VoidTypec C s d| _ d S )Nzvoid&)r )r r r r �__init__X s zVoidType.__init__c C s t | |d�S )NZ new_void_type)� global_cache)r r( r) r r r r& [ s zVoidType.build_backend_typeN)r4 r5 r6 r2 rB r& r r r r rA U s rA c @ s e Zd Zdd� ZdS )�BasePrimitiveTypec C s dS )NFr )r r r r �is_complex_typeb s z!BasePrimitiveType.is_complex_typeN)r4 r5 r6 rE r r r r rD a s rD c 4 @ s� e Zd ZdZdddddddddddddddddddddddddddddddddddddddddddddddddddd�3Zdd� Zd d � Zd d � Zd d� Zdd� Z dd� Z dS )� PrimitiveTyper0 �c�i�f�j)3�charZshort�int�longz long longz signed charz unsigned charzunsigned shortz unsigned intz unsigned longzunsigned long long�floatZdoublez long doublezfloat _Complexzdouble _ComplexZ_BoolZwchar_tZchar16_tZchar32_tZint8_tZuint8_tZint16_tZuint16_tZint32_tZuint32_tZint64_tZuint64_tZ int_least8_tZ uint_least8_tZ int_least16_tZuint_least16_tZ int_least32_tZuint_least32_tZ int_least64_tZuint_least64_tZ int_fast8_tZ uint_fast8_tZ int_fast16_tZ uint_fast16_tZ int_fast32_tZ uint_fast32_tZ int_fast64_tZ uint_fast64_tZintptr_tZ uintptr_tZintmax_tZ uintmax_tZ ptrdiff_tZsize_tZssize_tc C s || _ |d | _d S )Nr )r0 r )r r0 r r r rB � s zPrimitiveType.__init__c C s | j | j dkS )NrG )�ALL_PRIMITIVE_TYPESr0 )r r r r � is_char_type� s zPrimitiveType.is_char_typec C s | j | j dkS )NrH )rO r0 )r r r r r# � s z PrimitiveType.is_integer_typec C s | j | j dkS )NrI )rO r0 )r r r r � is_float_type� s zPrimitiveType.is_float_typec C s | j | j dkS )NrJ )rO r0 )r r r r rE � s z PrimitiveType.is_complex_typec C s t | |d| j�S )NZnew_primitive_type)rC r0 )r r( r) r r r r& � s z PrimitiveType.build_backend_typeN)r0 ) r4 r5 r6 r2 rO rB rP r# rQ rE r& r r r r rF f st rF c @ s( e Zd Zd Zdd� Zdd� Zdd� ZdS ) �UnknownIntegerTyper0 c C s || _ |d | _d S )Nr )r0 r )r r0 r r r rB � s zUnknownIntegerType.__init__c C s dS )NTr )r r r r r# � s z"UnknownIntegerType.is_integer_typec C s t d| j ��d S )Nz4integer type '%s' can only be used after compilation)�NotImplementedErrorr0 )r r( r) r r r r& � s z%UnknownIntegerType.build_backend_typeN)r0 )r4 r5 r6 r2 rB r# r& r r r r rR � s rR c @ s e Zd ZdZdd� Zdd� ZdS )�UnknownFloatTyper0 c C s || _ |d | _d S )Nr )r0 r )r r0 r r r rB � s zUnknownFloatType.__init__c C s t d| j ��d S )Nz2float type '%s' can only be used after compilation)rS r0 )r r( r) r r r r& � s z#UnknownFloatType.build_backend_typeN)r0 )r4 r5 r6 r2 rB r& r r r r rT � s rT c @ s e Zd ZdZd dd�ZdS ) �BaseFunctionType�argsr �ellipsis�abiNc C s� || _ || _|| _|| _dd� | j D �}| jr8|jd� |p@dg}| jdj|�f }|d k r||d d� | d |dd � }| jjjd|�| _d S ) Nc S s g | ] }|j � �qS r )r )r/ �argr r r r1 � s z-BaseFunctionType.__init__.<locals>.<listcomp>z...�voidz, r r r ) rV r rW rX �append� _base_pattern�joinr r )r rV r rW rX Zreprargsr r r r rB � s zBaseFunctionType.__init__)rV r rW rX )N)r4 r5 r6 r2 rB r r r r rU � s rU c @ s$ e Zd ZdZdZdd� Zdd� ZdS )�RawFunctionTypez(&)(%s)Tc C s t d| f ��d S )NzPcannot render the type %r: it is a function type, not a pointer-to-function type)r )r r( r) r r r r& � s z"RawFunctionType.build_backend_typec C s t | j| j| j| j�S )N)�FunctionPtrTyperV r rW rX )r r r r �as_function_pointer� s z#RawFunctionType.as_function_pointerN)r4 r5 r6 r\ r8 r& r` r r r r r^ � s r^ c @ s e Zd ZdZdd� Zdd� ZdS )r_ z(*&)(%s)c C s� | j j||�}g }x | jD ]}|j|j||�� qW f }| jdkrl| jsly|jjf}W n tk rj Y nX t | |dt |�|| jf|�� S )NZ __stdcallZnew_function_type) r r, rV r[ rX rW �_backendZ FFI_STDCALL�AttributeErrorrC r? )r r( r) r rV �tpZabi_argsr r r r& � s z"FunctionPtrType.build_backend_typec C s t | j| j| j| j�S )N)r^ rV r rW rX )r r r r �as_raw_function s z FunctionPtrType.as_raw_functionN)r4 r5 r6 r\ r& rd r r r r r_ � s r_ c @ s" e Zd Zd Zd dd�Zdd� ZdS ) � PointerType�totyper r c C s> || _ || _t|d�}|jr*d|j� f }|jjd|�| _d S )Nz *&z(%s)r )rf r r r7 r r r )r rf r Zextrar r r rB s zPointerType.__init__c C s | j j||dd�}t| |d|�S )NT)r* �new_pointer_type)rf r, rC )r r( r) ZBItemr r r r& s z PointerType.build_backend_typeN)rf r )r )r4 r5 r6 r2 rB r& r r r r re s re c C s t | t�S )N)re r )rf r r r �ConstPointerType s rh c @ s e Zd ZdZddd�ZdS ) �NamedPointerTyperf r0 r c C s" t j| ||� || _|d | _d S )Nr )re rB r0 r )r rf r0 r r r r rB s zNamedPointerType.__init__N)rf r0 )r )r4 r5 r6 r2 rB r r r r ri s ri c @ s, e Zd Zd ZdZdd� Zdd� Zdd � Zd S ) � ArrayType�item�lengthTc C sF || _ || _|d krd}n|dkr(d}nd| }| j jjd|�| _d S )Nz&[]z...z &[/*...*/]z&[%s]r )rk rl r r )r rk rl Zbracketsr r r rB ) s zArrayType.__init__c C s t | j|�S )N)rj rk )r Z newlengthr r r �resolve_length6 s zArrayType.resolve_lengthc C sJ | j dkrtd| f ��| jj||� t| j�j||�}t| |d|| j �S )Nz...z)cannot render the type %r: unknown lengthZnew_array_type)rl r rk r, re rC )r r( r) ZBPtrItemr r r r& 9 s z ArrayType.build_backend_typeN)rk rl )r4 r5 r6 r2 r7 rB rm r& r r r r rj % s rj rK c @ s, e Zd Zd ZdZdd� Zdd� Zdd� ZdS ) �StructOrUnionOrEnumr0 Nc C s$ | j pd| j| jf }|d | _d S )Nz%s %sr )� forcename�kindr0 r )r r0 r r r �build_c_name_with_markerH s z,StructOrUnionOrEnum.build_c_name_with_markerc C s || _ | j� d S )N)ro rq )r ro r r r �force_the_nameL s z"StructOrUnionOrEnum.force_the_namec C s | j d d� S )Nr ���)r )r r r r �get_official_nameP s z%StructOrUnionOrEnum.get_official_name)r0 )r4 r5 r6 r2 ro rq rr rt r r r r rn D s rn c @ sj e Zd ZdZdZdZdZddd�Zdd� Zdd d �Z d d � Z dd d�Z dd� Z dd� Z dd� Zdd� ZdS )� StructOrUnionNr Fc C s* || _ || _|| _|| _|| _| j� d S )N)r0 �fldnames�fldtypes� fldbitsize�fldqualsrq )r r0 rv rw rx ry r r r rB [ s zStructOrUnion.__init__c c sB | j d k r>x2t| j| j �D ] \}}|dkrt|t�r|V qW d S )Nr )rw �ziprv � isinstanceru )r r0 �typer r r �anonymous_struct_fieldsc s z%StructOrUnion.anonymous_struct_fieldsTc c s� | j }|d kr dt| j� }xbt| j| j| j|�D ]J\}}}}|dkrnt|t�rn|rnx&|j� D ] }|V q^W q2||||fV q2W d S )Nr r )r ) ry �lenrv rz rw rx r{ ru � enumfields)r Z expand_anonymous_struct_unionry r0 r| �bitsizer r r r r r i s zStructOrUnion.enumfieldsc C s~ g }g }g }g }x@| j � D ]4\}}}}|j|� |j|� |j|� |j|� qW t|�| _t|�| _t|�| _t|�| _d S )N)r r[ r? rv rw rx ry ) r �names�typesZbitsizesry r0 r| r� r r r r � force_flattenw s zStructOrUnion.force_flattenc C s$ t j| |||�}|s | j||� |S )N)rn r, �finish_backend_type)r r( r) r* r+ r r r r, � s z StructOrUnion.get_cached_btypec s | j r$| j dkr td| jf ��d S � j| }d| _ | jd krB�n�| jd kr�� �fdd�| jD �}tt| j|| j ��}d}| j r�d}� j j ||| d d |� �nfg }| j\}}} } �x&t t| j��D �]} || } | j| } t| t�o�| jdk�rn| jj� ��}t| � j|��\}}|dk�r<| jd | j| j| �p4d f � | j|�} | jd | � | f | j| d d � | _| j� ��}t| t��r�| jd k�r�n8� j|�}|| k�r�| jd | j| j| �p�d || f � |j|� q�W tt| j|| j |��}� j j ||| | | � d| _ d S )Nr z(recursive structure declaration for '%s'r c s g | ]}|j � ���qS r )r, )r/ rc )r( r) r r r1 � s z5StructOrUnion.finish_backend_type.<locals>.<listcomp>r � z...z field '%s.%s' has a bogus size?z{}z=field '%s.%s' is declared as %d bytes, but is really %d bytesrs rs )� completedrS r0 r$ rw � fixedlayout�listrz rv rx �packedra Zcomplete_struct_or_union�ranger~ r{ rj rl rk r, �divmod�sizeof�_verification_errorrm r[ )r r( r) r+ rw ZlstZsflagsZfieldofsZ fieldsizeZ totalsizeZtotalalignmentrH ZfsizeZftypeZ BItemTypeZnlenZnrestZ BFieldTypeZ bitemsizer )r( r) r r� � s` z!StructOrUnion.finish_backend_typec C s t |��d S )N)r )r �msgr r r r� � s z!StructOrUnion._verification_errorc C s | j r | jd kr t| j� ��d S )N)�partialr� r r )r r r r �check_not_partial� s z StructOrUnion.check_not_partialc C s. | j � |j| � t| |d| j | j� | d�S )Nz new_%s_type)�key)r� r[ rC rp rt )r r( r) r r r r& � s z StructOrUnion.build_backend_type)N)T)F)r4 r5 r6 r� r� r� r� rB r} r r� r, r� r� r� r& r r r r ru U s <ru c @ s e Zd ZdZdS )� StructType�structN)r4 r5 r6 rp r r r r r� � s r� c @ s e Zd ZdZdS )� UnionType�unionN)r4 r5 r6 rp r r r r r� � s r� c @ sB e Zd ZdZdZdZddd�Zdd� Zdd � Zd d � Z d d � Z dS )�EnumType�enumFNc C s$ || _ || _|| _|| _| j� d S )N)r0 � enumerators� enumvalues� baseinttyperq )r r0 r� r� r� r r r rB � s zEnumType.__init__c C s4 t j| |� | jd kr0| j� }d|jdd� | _d S )Nr r �_)rn rr ro rt r )r ro r0 r r r rr � s zEnumType.force_the_namec C s | j r| j rt| j� ��d S )N)r� �partial_resolvedr r )r r r r r� � s zEnumType.check_not_partialc C s4 | j � | j||�}t| |d| j� | j| j|| d�S )NZ new_enum_type)r� )r� �build_baseinttyperC rt r� r� )r r( r) Z base_btyper r r r& � s zEnumType.build_backend_typec C sH | j d k r| j j||�S | jr4t| j�}t| j�}nDdd l}y tj� W n tk r\ Y nX |j d| j � � d }}|dk r�d}t d�}t d�}nd}t d�}t d�}|j||�} |j||�} |j | �} |j | �} |d d| d > ko�|dd| | > k �r| S |d d| d > k�r4|dd| | > k �r4| S t d | j � ��d S ) Nr zU%r has no values explicitly defined; guessing that it is equivalent to 'unsigned int'r rL rM z unsigned intz unsigned longr� z=%s values don't all fit into either 'long' or 'unsigned long'rs rs )r� r, r� �min�max�warningsZ__warningregistry__�clear� NameError�warnr rF r� r ) r r( r) Zsmallest_valueZ largest_valuer� ZsignZ candidate1Z candidate2Zbtype1Zbtype2Zsize1Zsize2r r r r� s@ zEnumType.build_baseinttype)N) r4 r5 r6 rp r� r� rB rr r� r& r� r r r r r� � s r� c C s2 |d krd| }t |d d d �}|j| � d|_|S )Nz$%s� unknown_type)r� rr �origin)r0 � structnamerc r r r r� * s r� c C s( |d krd| }t |d d d �}t|| �S )Nz$$%s)r� ri )r0 r� rc r r r �unknown_ptr_type2 s r� c C sF t | tj�rtS t�( tt| �d�s2tj� t| �_ t| �j S Q R X d S )N� __typecache) r{ r� � ModuleType�_typecache_cffi_backend� global_lock�hasattrr| �weakref�WeakValueDictionaryr� )Zbackendr r r � get_typecache< s r� c O s� |j d||f�}y |j| S tk r. Y nX yt|j|�|� }W n4 tk rx } ztd|| |f ��W Y d d }~X nX |j}t�( |j|�} | d kr�|||< |S | S W d Q R X d S )Nr� z %s: %r: %s)�popZ _typecacher% r. ra rS r� �get) Zsrctyper( �funcnamerV �kwdsr� �res�e�cacheZres1r r r rC G s $ rC c C s t d| d|�S )N�?rg )rC )r( r+ r r r � pointer_cache^ s r� c C s@ | j r<t| j d �tkr<d|| j d f f| j dd � | _ d S )Nr z%s: %sr )rV r| �str)r� r0 r r r �attach_exception_infoa s r� )N)N)-r� r� �lockr �errorr r r r r r r �objectr r9 rA Z void_typerD rF rR rT rU r^ r_ re Z voidp_typerh Zconst_voidp_typeri rj Zchar_array_typern ru r� r� r� r� r� r� r� r� r� rC r� r� r r r r �<module> sN / L G PK %�\�~�.F# F# ) __pycache__/verifier.cpython-36.opt-1.pycnu �[��� 3 M��Z�+ � @ s� d dl Z d dlZd dlZd dlZd dlZddlmZ ddlmZ ddlm Z e j dkrhd dl Z dd� Z nd dlZd d� Z e j d kr�ejZnG d d � d ej�ZG d d � d e�ZdZdd� Zdadd� Zdd� Zd dd�Zdd� Zdd� ZdS ) � N� )� __version_verifier_modules__)� ffiplatform)�VerificationError� c C s t jjd d � S )N)� importlib� machinery�EXTENSION_SUFFIXES� r r � /usr/lib64/python3.6/verifier.py�_extension_suffixes s r c C s dd� t j� D �S )Nc S s g | ]\}}}|t jkr|�qS r )�impZ C_EXTENSION)�.0�suffix�_�typer r r � <listcomp> s z'_extension_suffixes.<locals>.<listcomp>)r Z get_suffixesr r r r r s c s e Zd Z� fdd�Z� ZS )�NativeIOc s( t |t�r|jd�}tt| �j|� d S )N�ascii)� isinstanceZunicode�encode�superr �write)�self�s)� __class__r r r s zNativeIO.write)�__name__� __module__� __qualname__r � __classcell__r r )r r r s r c @ sz e Zd Zd dd�Zd dd�Zd d � Zd d � Zd d� Zdd� Zdd� Z dd� Z dd� Z dd� Z d!dd�Z dd � Zd d � ZdS )"�VerifierN� F�.cc K sv |j jrtd|j jf ��|| _|| _|s4tj| �} t||�} | | �| _| jj | � | | _ | j | | �| _ |rz|rxt d��n�djtjd d� t|| g|j �}tjdkr�|jd�}ttj|dd d� �d@ �}|jd �jd �}ttj|d d d� �d@ �}|jd �jd �}d || jj||f }t� d }|�p0t � | _ t j j| j || �| _ t j j| j || �| _!|| _"d| _#d| _$d S )NzKfeature not supported with ffi.verify(), but only with ffi.set_source(): %sz)can't specify both 'modulename' and 'tag'� r zutf-8r � l �� Z0x�Lr �0z_cffi_%s_%s%s%sF)r )%Z_parserZ_uses_new_featurer �ffi�preambler Zflatten�_locate_engine_class�_vengineZpatch_extension_kwds�flags�make_relative_to�kwds� TypeError�join�sys�versionr Z _cdefsources� version_infor �hex�binasciiZcrc32�lstrip�rstripZ _class_key�_get_so_suffixes�_caller_dir_pycache�tmpdir�os�path�sourcefilename�modulefilename� ext_package� _has_source� _has_module)r r' r( r9 Z modulenamer> �tag�force_generic_engineZsource_extensionr+ � relative_tor- Zflattened_kwdsZ vengine_class�keyZk1Zk2r r r r �__init__ sD zVerifier.__init__c C s8 | j j�& | jr |dkr td��| j|� W dQ R X dS )zkWrite the C source code. It is produced in 'self.sourcefilename', which can be tweaked beforehand.Nzsource code already written)r' �_lockr? r � _write_source)r �filer r r � write_sourceH s zVerifier.write_sourcec C s< | j j�* | jrtd��| js&| j� | j� W dQ R X dS )z�Write the C source code (if not done already) and compile it. This produces a dynamic link library in 'self.modulefilename'.zmodule already compiledN)r' rF r@ r r? rG �_compile_module)r r r r �compile_moduleQ s zVerifier.compile_modulec C sF | j j�4 | js4| j� | js4| js,| j� | j� | j� S Q R X dS )a" Get a C module from this Verifier instance. Returns an instance of a FFILibrary class that behaves like the objects returned by ffi.dlopen(), but that delegates all operations to the C module. If necessary, the C code is written and compiled first. N)r' rF r@ �_locate_moduler? rG rJ � _load_library)r r r r � load_library[ s zVerifier.load_libraryc C sB t jj| j�}|jdd�d }|jd�r>ttd�r>|d d� }|S )N�.r r Z_d�gettotalrefcountr$ ���)r: r; �basenamer= �split�endswith�hasattrr0 )r rR r r r �get_module_namek s zVerifier.get_module_namec C sV t j� | js0| jj� | js&| j� W d Q R X t j| j�}| j� }t j ||f| j �S )N) r Z_hack_at_distutilsr? r' rF rG Zmaybe_relative_pathr< rV � get_extensionr- )r Z sourcename�modnamer r r rW v s zVerifier.get_extensionc C s | j jS )N)r* Z_gen_python_module)r r r r �generates_python_module� s z Verifier.generates_python_modulec s~ |rzt jj|�rzt jj|�� |j� }xTtjD ]J}||kr,|| }t|ttf�s\t d|f ��� fdd�|D �}|||< q,W |S )Nz&keyword '%s' should be a list or tuplec s g | ]}t jj� |��qS r )r: r; r/ )r �fn)�dirnamer r r � s z-Verifier.make_relative_to.<locals>.<listcomp>) r: r; r[ �copyr ZLIST_OF_FILE_NAMESr �list�tupler. )r r- rC rD Zlstr )r[ r r, � s zVerifier.make_relative_toc C s� t jj| j�st| jrHyt| jd d dg�}W n tk r> d S X |j}nd }| jj | j � |t � �}|d krnd S || _| jj � d| _ d S )N�__doc__T)r: r; �isfiler= r> � __import__� ImportError�__path__r* � find_modulerV r7 Z collect_typesr@ )r Zpkgr; �filenamer r r rL � s zVerifier._locate_modulec C s$ || j _z| j j� W d | j `X d S )N)r* Z_fZwrite_source_to_f)r rH r r r �_write_source_to� s zVerifier._write_source_toc C s� |d k r| j |� n�t� }| j |� |j� }tjj| j�rbt| jd��}|j� |k }W d Q R X nd}|r�t | j� t| jd��}|j |� W d Q R X d| _ d S )N�rT�w) rf r �getvaluer: r; �existsr< �open�read� _ensure_dirr r? )r rH �fZ source_data�fpZ needs_writtenr r r rG � s zVerifier._write_sourcec C sp t jj| j�}tj|| j� �}ytj|| j�}W n t k rH d}Y nX |sft | j� t j || j� d| _ d S )NFT)r: r; r[ r< r �compilerW �samefiler= �OSErrorrm �shutilZmover@ )r r9 ZoutputfilenameZsamer r r rJ � s zVerifier._compile_modulec C s& | j d k r| jj| j �S | jj� S d S )N)r+ r* rN )r r r r rM � s zVerifier._load_library)NNNr! Fr" NN)N)N)r r r rE rI rK rN rV rW rY r, rL rf rG rJ rM r r r r r s & r Fc C s| t rd}|sPdtjkr d}n4y dd l}W n tk r@ d}Y nX | j|k rPd}|rfddlm} |jS ddlm } |j S d S )NTZ__pypy__r �?r )� vengine_gen)� vengine_cpy) �_FORCE_GENERIC_ENGINEr0 �builtin_module_names� _cffi_backendrb Z_backendr! ru ZVGenericEnginerv ZVCPythonEngine)r' rB ry ru rv r r r r) � s r) c C sH t rt S tjjd�} | r | S tjd�jj}tjj tjj tjj |�d��S )NZ CFFI_TMPDIRr$ � __pycache__) �_TMPDIRr: �environ�getr0 � _getframe�f_code� co_filenamer; �abspathr/ r[ )�resultre r r r r8 � s r8 c C s | a dS )z:Set the temporary directory to use instead of __pycache__.N)r{ )r[ r r r � set_tmpdir s r� c C s0 | pt � } ytj| �}W n tk r, dS X |r8d}nt� d j� }xd|D ]\}|j� jd�rL|j� j|�sz|j� jd�rLytjtj j | |�� W qL tk r� Y qLX qLW tj j | d�g}xn|D ]f}yJxDtj|�D ]6}tj j ||�}tj j |��r |j |� q�tj|� q�W W q� tk �r& Y q�X q�W dS )z}Clean up the temporary directory by removing all files in it called `_cffi_*.{c,so}` as well as the `build` subdirectory.Nz.cr Z_cffi_Zbuild) r8 r: �listdirrr r7 �lower� startswithrT �unlinkr; r/ �isdir�append)r9 Zkeep_soZfilelistr rZ Z clean_dir�dirr r r �cleanup_tmpdir s2 r� c C s& t � } | s"tjdkr dg} ndg} | S )NZwin32z.pydz.so)r r0 �platform)�suffixesr r r r7 $ s r7 c C s, t jj| �}|r(t jj|� r(t j|� d S )N)r: r; r[ r� �makedirs)re r[ r r r rm / s rm )r r )r )NF) r0 r: r4 rs �ior! r r �errorr r2 Zimportlib.machineryr r r �StringIOr �BytesIO�objectr rw r) r{ r8 r� r� r7 rm r r r r �<module> s* ( ? PK %�\!u60� � error.pynu �[��� class FFIError(Exception): pass class CDefError(Exception): def __str__(self): try: current_decl = self.args[1] filename = current_decl.coord.file linenum = current_decl.coord.line prefix = '%s:%d: ' % (filename, linenum) except (AttributeError, TypeError, IndexError): prefix = '' return '%s%s' % (prefix, self.args[0]) class VerificationError(Exception): """ An error raised when verification fails """ class VerificationMissing(Exception): """ An error raised when incomplete structures are passed into cdef, but no verification has been done """ PK %�\ ^�ٞ> �> _embedding.hnu �[��� /***** Support code for embedding *****/ #ifdef __cplusplus extern "C" { #endif #if defined(_WIN32) # define CFFI_DLLEXPORT __declspec(dllexport) #elif defined(__GNUC__) # define CFFI_DLLEXPORT __attribute__((visibility("default"))) #else # define CFFI_DLLEXPORT /* nothing */ #endif /* There are two global variables of type _cffi_call_python_fnptr: * _cffi_call_python, which we declare just below, is the one called by ``extern "Python"`` implementations. * _cffi_call_python_org, which on CPython is actually part of the _cffi_exports[] array, is the function pointer copied from _cffi_backend. After initialization is complete, both are equal. However, the first one remains equal to &_cffi_start_and_call_python until the very end of initialization, when we are (or should be) sure that concurrent threads also see a completely initialized world, and only then is it changed. */ #undef _cffi_call_python typedef void (*_cffi_call_python_fnptr)(struct _cffi_externpy_s *, char *); static void _cffi_start_and_call_python(struct _cffi_externpy_s *, char *); static _cffi_call_python_fnptr _cffi_call_python = &_cffi_start_and_call_python; #ifndef _MSC_VER /* --- Assuming a GCC not infinitely old --- */ # define cffi_compare_and_swap(l,o,n) __sync_bool_compare_and_swap(l,o,n) # define cffi_write_barrier() __sync_synchronize() # if !defined(__amd64__) && !defined(__x86_64__) && \ !defined(__i386__) && !defined(__i386) # define cffi_read_barrier() __sync_synchronize() # else # define cffi_read_barrier() (void)0 # endif #else /* --- Windows threads version --- */ # include <Windows.h> # define cffi_compare_and_swap(l,o,n) \ (InterlockedCompareExchangePointer(l,n,o) == (o)) # define cffi_write_barrier() InterlockedCompareExchange(&_cffi_dummy,0,0) # define cffi_read_barrier() (void)0 static volatile LONG _cffi_dummy; #endif #ifdef WITH_THREAD # ifndef _MSC_VER # include <pthread.h> static pthread_mutex_t _cffi_embed_startup_lock; # else static CRITICAL_SECTION _cffi_embed_startup_lock; # endif static char _cffi_embed_startup_lock_ready = 0; #endif static void _cffi_acquire_reentrant_mutex(void) { static void *volatile lock = NULL; while (!cffi_compare_and_swap(&lock, NULL, (void *)1)) { /* should ideally do a spin loop instruction here, but hard to do it portably and doesn't really matter I think: pthread_mutex_init() should be very fast, and this is only run at start-up anyway. */ } #ifdef WITH_THREAD if (!_cffi_embed_startup_lock_ready) { # ifndef _MSC_VER pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); pthread_mutex_init(&_cffi_embed_startup_lock, &attr); # else InitializeCriticalSection(&_cffi_embed_startup_lock); # endif _cffi_embed_startup_lock_ready = 1; } #endif while (!cffi_compare_and_swap(&lock, (void *)1, NULL)) ; #ifndef _MSC_VER pthread_mutex_lock(&_cffi_embed_startup_lock); #else EnterCriticalSection(&_cffi_embed_startup_lock); #endif } static void _cffi_release_reentrant_mutex(void) { #ifndef _MSC_VER pthread_mutex_unlock(&_cffi_embed_startup_lock); #else LeaveCriticalSection(&_cffi_embed_startup_lock); #endif } /********** CPython-specific section **********/ #ifndef PYPY_VERSION #include "_cffi_errors.h" #define _cffi_call_python_org _cffi_exports[_CFFI_CPIDX] PyMODINIT_FUNC _CFFI_PYTHON_STARTUP_FUNC(void); /* forward */ static void _cffi_py_initialize(void) { /* XXX use initsigs=0, which "skips initialization registration of signal handlers, which might be useful when Python is embedded" according to the Python docs. But review and think if it should be a user-controllable setting. XXX we should also give a way to write errors to a buffer instead of to stderr. XXX if importing 'site' fails, CPython (any version) calls exit(). Should we try to work around this behavior here? */ Py_InitializeEx(0); } static int _cffi_initialize_python(void) { /* This initializes Python, imports _cffi_backend, and then the present .dll/.so is set up as a CPython C extension module. */ int result; PyGILState_STATE state; PyObject *pycode=NULL, *global_dict=NULL, *x; state = PyGILState_Ensure(); /* Call the initxxx() function from the present module. It will create and initialize us as a CPython extension module, instead of letting the startup Python code do it---it might reimport the same .dll/.so and get maybe confused on some platforms. It might also have troubles locating the .dll/.so again for all I know. */ (void)_CFFI_PYTHON_STARTUP_FUNC(); if (PyErr_Occurred()) goto error; /* Now run the Python code provided to ffi.embedding_init_code(). */ pycode = Py_CompileString(_CFFI_PYTHON_STARTUP_CODE, "<init code for '" _CFFI_MODULE_NAME "'>", Py_file_input); if (pycode == NULL) goto error; global_dict = PyDict_New(); if (global_dict == NULL) goto error; if (PyDict_SetItemString(global_dict, "__builtins__", PyThreadState_GET()->interp->builtins) < 0) goto error; x = PyEval_EvalCode( #if PY_MAJOR_VERSION < 3 (PyCodeObject *) #endif pycode, global_dict, global_dict); if (x == NULL) goto error; Py_DECREF(x); /* Done! Now if we've been called from _cffi_start_and_call_python() in an ``extern "Python"``, we can only hope that the Python code did correctly set up the corresponding @ffi.def_extern() function. Otherwise, the general logic of ``extern "Python"`` functions (inside the _cffi_backend module) will find that the reference is still missing and print an error. */ result = 0; done: Py_XDECREF(pycode); Py_XDECREF(global_dict); PyGILState_Release(state); return result; error:; { /* Print as much information as potentially useful. Debugging load-time failures with embedding is not fun */ PyObject *ecap; PyObject *exception, *v, *tb, *f, *modules, *mod; PyErr_Fetch(&exception, &v, &tb); ecap = _cffi_start_error_capture(); f = PySys_GetObject((char *)"stderr"); if (f != NULL && f != Py_None) { PyFile_WriteString( "Failed to initialize the Python-CFFI embedding logic:\n\n", f); } if (exception != NULL) { PyErr_NormalizeException(&exception, &v, &tb); PyErr_Display(exception, v, tb); } Py_XDECREF(exception); Py_XDECREF(v); Py_XDECREF(tb); if (f != NULL && f != Py_None) { PyFile_WriteString("\nFrom: " _CFFI_MODULE_NAME "\ncompiled with cffi version: 1.11.5" "\n_cffi_backend module: ", f); modules = PyImport_GetModuleDict(); mod = PyDict_GetItemString(modules, "_cffi_backend"); if (mod == NULL) { PyFile_WriteString("not loaded", f); } else { v = PyObject_GetAttrString(mod, "__file__"); PyFile_WriteObject(v, f, 0); Py_XDECREF(v); } PyFile_WriteString("\nsys.path: ", f); PyFile_WriteObject(PySys_GetObject((char *)"path"), f, 0); PyFile_WriteString("\n\n", f); } _cffi_stop_error_capture(ecap); } result = -1; goto done; } PyAPI_DATA(char *) _PyParser_TokenNames[]; /* from CPython */ static int _cffi_carefully_make_gil(void) { /* This does the basic initialization of Python. It can be called completely concurrently from unrelated threads. It assumes that we don't hold the GIL before (if it exists), and we don't hold it afterwards. (What it really does used to be completely different in Python 2 and Python 3, with the Python 2 solution avoiding the spin-lock around the Py_InitializeEx() call. However, after recent changes to CPython 2.7 (issue #358) it no longer works. So we use the Python 3 solution everywhere.) This initializes Python by calling Py_InitializeEx(). Important: this must not be called concurrently at all. So we use a global variable as a simple spin lock. This global variable must be from 'libpythonX.Y.so', not from this cffi-based extension module, because it must be shared from different cffi-based extension modules. We choose _PyParser_TokenNames[0] as a completely arbitrary pointer value that is never written to. The default is to point to the string "ENDMARKER". We change it temporarily to point to the next character in that string. (Yes, I know it's REALLY obscure.) */ #ifdef WITH_THREAD char *volatile *lock = (char *volatile *)_PyParser_TokenNames; char *old_value; while (1) { /* spin loop */ old_value = *lock; if (old_value[0] == 'E') { assert(old_value[1] == 'N'); if (cffi_compare_and_swap(lock, old_value, old_value + 1)) break; } else { assert(old_value[0] == 'N'); /* should ideally do a spin loop instruction here, but hard to do it portably and doesn't really matter I think: PyEval_InitThreads() should be very fast, and this is only run at start-up anyway. */ } } #endif /* call Py_InitializeEx() */ { PyGILState_STATE state = PyGILState_UNLOCKED; if (!Py_IsInitialized()) _cffi_py_initialize(); else state = PyGILState_Ensure(); PyEval_InitThreads(); PyGILState_Release(state); } #ifdef WITH_THREAD /* release the lock */ while (!cffi_compare_and_swap(lock, old_value + 1, old_value)) ; #endif return 0; } /********** end CPython-specific section **********/ #else /********** PyPy-specific section **********/ PyMODINIT_FUNC _CFFI_PYTHON_STARTUP_FUNC(const void *[]); /* forward */ static struct _cffi_pypy_init_s { const char *name; void (*func)(const void *[]); const char *code; } _cffi_pypy_init = { _CFFI_MODULE_NAME, (void(*)(const void *[]))_CFFI_PYTHON_STARTUP_FUNC, _CFFI_PYTHON_STARTUP_CODE, }; extern int pypy_carefully_make_gil(const char *); extern int pypy_init_embedded_cffi_module(int, struct _cffi_pypy_init_s *); static int _cffi_carefully_make_gil(void) { return pypy_carefully_make_gil(_CFFI_MODULE_NAME); } static int _cffi_initialize_python(void) { return pypy_init_embedded_cffi_module(0xB011, &_cffi_pypy_init); } /********** end PyPy-specific section **********/ #endif #ifdef __GNUC__ __attribute__((noinline)) #endif static _cffi_call_python_fnptr _cffi_start_python(void) { /* Delicate logic to initialize Python. This function can be called multiple times concurrently, e.g. when the process calls its first ``extern "Python"`` functions in multiple threads at once. It can also be called recursively, in which case we must ignore it. We also have to consider what occurs if several different cffi-based extensions reach this code in parallel threads---it is a different copy of the code, then, and we can't have any shared global variable unless it comes from 'libpythonX.Y.so'. Idea: * _cffi_carefully_make_gil(): "carefully" call PyEval_InitThreads() (possibly with Py_InitializeEx() first). * then we use a (local) custom lock to make sure that a call to this cffi-based extension will wait if another call to the *same* extension is running the initialization in another thread. It is reentrant, so that a recursive call will not block, but only one from a different thread. * then we grab the GIL and (Python 2) we call Py_InitializeEx(). At this point, concurrent calls to Py_InitializeEx() are not possible: we have the GIL. * do the rest of the specific initialization, which may temporarily release the GIL but not the custom lock. Only release the custom lock when we are done. */ static char called = 0; if (_cffi_carefully_make_gil() != 0) return NULL; _cffi_acquire_reentrant_mutex(); /* Here the GIL exists, but we don't have it. We're only protected from concurrency by the reentrant mutex. */ /* This file only initializes the embedded module once, the first time this is called, even if there are subinterpreters. */ if (!called) { called = 1; /* invoke _cffi_initialize_python() only once, but don't set '_cffi_call_python' right now, otherwise concurrent threads won't call this function at all (we need them to wait) */ if (_cffi_initialize_python() == 0) { /* now initialization is finished. Switch to the fast-path. */ /* We would like nobody to see the new value of '_cffi_call_python' without also seeing the rest of the data initialized. However, this is not possible. But the new value of '_cffi_call_python' is the function 'cffi_call_python()' from _cffi_backend. So: */ cffi_write_barrier(); /* ^^^ we put a write barrier here, and a corresponding read barrier at the start of cffi_call_python(). This ensures that after that read barrier, we see everything done here before the write barrier. */ assert(_cffi_call_python_org != NULL); _cffi_call_python = (_cffi_call_python_fnptr)_cffi_call_python_org; } else { /* initialization failed. Reset this to NULL, even if it was already set to some other value. Future calls to _cffi_start_python() are still forced to occur, and will always return NULL from now on. */ _cffi_call_python_org = NULL; } } _cffi_release_reentrant_mutex(); return (_cffi_call_python_fnptr)_cffi_call_python_org; } static void _cffi_start_and_call_python(struct _cffi_externpy_s *externpy, char *args) { _cffi_call_python_fnptr fnptr; int current_err = errno; #ifdef _MSC_VER int current_lasterr = GetLastError(); #endif fnptr = _cffi_start_python(); if (fnptr == NULL) { fprintf(stderr, "function %s() called, but initialization code " "failed. Returning 0.\n", externpy->name); memset(args, 0, externpy->size_of_result); } #ifdef _MSC_VER SetLastError(current_lasterr); #endif errno = current_err; if (fnptr != NULL) fnptr(externpy, args); } /* The cffi_start_python() function makes sure Python is initialized and our cffi module is set up. It can be called manually from the user C code. The same effect is obtained automatically from any dll-exported ``extern "Python"`` function. This function returns -1 if initialization failed, 0 if all is OK. */ _CFFI_UNUSED_FN static int cffi_start_python(void) { if (_cffi_call_python == &_cffi_start_and_call_python) { if (_cffi_start_python() == NULL) return -1; } cffi_read_barrier(); return 0; } #undef cffi_compare_and_swap #undef cffi_write_barrier #undef cffi_read_barrier #ifdef __cplusplus } #endif PK %�\����� � commontypes.pynu �[��� import sys from . import model from .error import FFIError COMMON_TYPES = {} try: # fetch "bool" and all simple Windows types from _cffi_backend import _get_common_types _get_common_types(COMMON_TYPES) except ImportError: pass COMMON_TYPES['FILE'] = model.unknown_type('FILE', '_IO_FILE') COMMON_TYPES['bool'] = '_Bool' # in case we got ImportError above for _type in model.PrimitiveType.ALL_PRIMITIVE_TYPES: if _type.endswith('_t'): COMMON_TYPES[_type] = _type del _type _CACHE = {} def resolve_common_type(parser, commontype): try: return _CACHE[commontype] except KeyError: cdecl = COMMON_TYPES.get(commontype, commontype) if not isinstance(cdecl, str): result, quals = cdecl, 0 # cdecl is already a BaseType elif cdecl in model.PrimitiveType.ALL_PRIMITIVE_TYPES: result, quals = model.PrimitiveType(cdecl), 0 elif cdecl == 'set-unicode-needed': raise FFIError("The Windows type %r is only available after " "you call ffi.set_unicode()" % (commontype,)) else: if commontype == cdecl: raise FFIError( "Unsupported type: %r. Please look at " "http://cffi.readthedocs.io/en/latest/cdef.html#ffi-cdef-limitations " "and file an issue if you think this type should really " "be supported." % (commontype,)) result, quals = parser.parse_type_and_quals(cdecl) # recursive assert isinstance(result, model.BaseTypeByIdentity) _CACHE[commontype] = result, quals return result, quals # ____________________________________________________________ # extra types for Windows (most of them are in commontypes.c) def win_common_types(): return { "UNICODE_STRING": model.StructType( "_UNICODE_STRING", ["Length", "MaximumLength", "Buffer"], [model.PrimitiveType("unsigned short"), model.PrimitiveType("unsigned short"), model.PointerType(model.PrimitiveType("wchar_t"))], [-1, -1, -1]), "PUNICODE_STRING": "UNICODE_STRING *", "PCUNICODE_STRING": "const UNICODE_STRING *", "TBYTE": "set-unicode-needed", "TCHAR": "set-unicode-needed", "LPCTSTR": "set-unicode-needed", "PCTSTR": "set-unicode-needed", "LPTSTR": "set-unicode-needed", "PTSTR": "set-unicode-needed", "PTBYTE": "set-unicode-needed", "PTCHAR": "set-unicode-needed", } if sys.platform == 'win32': COMMON_TYPES.update(win_common_types()) PK %�\]H# setuptools_ext.pynu �[��� import os import sys try: basestring except NameError: # Python 3.x basestring = str def error(msg): from distutils.errors import DistutilsSetupError raise DistutilsSetupError(msg) def execfile(filename, glob): # We use execfile() (here rewritten for Python 3) instead of # __import__() to load the build script. The problem with # a normal import is that in some packages, the intermediate # __init__.py files may already try to import the file that # we are generating. with open(filename) as f: src = f.read() src += '\n' # Python 2.6 compatibility code = compile(src, filename, 'exec') exec(code, glob, glob) def add_cffi_module(dist, mod_spec): from cffi.api import FFI if not isinstance(mod_spec, basestring): error("argument to 'cffi_modules=...' must be a str or a list of str," " not %r" % (type(mod_spec).__name__,)) mod_spec = str(mod_spec) try: build_file_name, ffi_var_name = mod_spec.split(':') except ValueError: error("%r must be of the form 'path/build.py:ffi_variable'" % (mod_spec,)) if not os.path.exists(build_file_name): ext = '' rewritten = build_file_name.replace('.', '/') + '.py' if os.path.exists(rewritten): ext = ' (rewrite cffi_modules to [%r])' % ( rewritten + ':' + ffi_var_name,) error("%r does not name an existing file%s" % (build_file_name, ext)) mod_vars = {'__name__': '__cffi__', '__file__': build_file_name} execfile(build_file_name, mod_vars) try: ffi = mod_vars[ffi_var_name] except KeyError: error("%r: object %r not found in module" % (mod_spec, ffi_var_name)) if not isinstance(ffi, FFI): ffi = ffi() # maybe it's a function instead of directly an ffi if not isinstance(ffi, FFI): error("%r is not an FFI instance (got %r)" % (mod_spec, type(ffi).__name__)) if not hasattr(ffi, '_assigned_source'): error("%r: the set_source() method was not called" % (mod_spec,)) module_name, source, source_extension, kwds = ffi._assigned_source if ffi._windows_unicode: kwds = kwds.copy() ffi._apply_windows_unicode(kwds) if source is None: _add_py_module(dist, ffi, module_name) else: _add_c_module(dist, ffi, module_name, source, source_extension, kwds) def _set_py_limited_api(Extension, kwds): """ Add py_limited_api to kwds if setuptools >= 26 is in use. Do not alter the setting if it already exists. Setuptools takes care of ignoring the flag on Python 2 and PyPy. CPython itself should ignore the flag in a debugging version (by not listing .abi3.so in the extensions it supports), but it doesn't so far, creating troubles. That's why we check for "not hasattr(sys, 'gettotalrefcount')" (the 2.7 compatible equivalent of 'd' not in sys.abiflags). (http://bugs.python.org/issue28401) On Windows, it's better not to use py_limited_api until issue #355 can be resolved (by having virtualenv copy PYTHON3.DLL). See also the start of _cffi_include.h. """ if ('py_limited_api' not in kwds and not hasattr(sys, 'gettotalrefcount') and sys.platform != 'win32'): import setuptools try: setuptools_major_version = int(setuptools.__version__.partition('.')[0]) if setuptools_major_version >= 26: kwds['py_limited_api'] = True except ValueError: # certain development versions of setuptools # If we don't know the version number of setuptools, we # try to set 'py_limited_api' anyway. At worst, we get a # warning. kwds['py_limited_api'] = True return kwds def _add_c_module(dist, ffi, module_name, source, source_extension, kwds): from distutils.core import Extension # We are a setuptools extension. Need this build_ext for py_limited_api. from setuptools.command.build_ext import build_ext from distutils.dir_util import mkpath from distutils import log from cffi import recompiler allsources = ['$PLACEHOLDER'] allsources.extend(kwds.pop('sources', [])) kwds = _set_py_limited_api(Extension, kwds) ext = Extension(name=module_name, sources=allsources, **kwds) def make_mod(tmpdir, pre_run=None): c_file = os.path.join(tmpdir, module_name + source_extension) log.info("generating cffi module %r" % c_file) mkpath(tmpdir) # a setuptools-only, API-only hook: called with the "ext" and "ffi" # arguments just before we turn the ffi into C code. To use it, # subclass the 'distutils.command.build_ext.build_ext' class and # add a method 'def pre_run(self, ext, ffi)'. if pre_run is not None: pre_run(ext, ffi) updated = recompiler.make_c_source(ffi, module_name, source, c_file) if not updated: log.info("already up-to-date") return c_file if dist.ext_modules is None: dist.ext_modules = [] dist.ext_modules.append(ext) base_class = dist.cmdclass.get('build_ext', build_ext) class build_ext_make_mod(base_class): def run(self): if ext.sources[0] == '$PLACEHOLDER': pre_run = getattr(self, 'pre_run', None) ext.sources[0] = make_mod(self.build_temp, pre_run) base_class.run(self) dist.cmdclass['build_ext'] = build_ext_make_mod # NB. multiple runs here will create multiple 'build_ext_make_mod' # classes. Even in this case the 'build_ext' command should be # run once; but just in case, the logic above does nothing if # called again. def _add_py_module(dist, ffi, module_name): from distutils.dir_util import mkpath from setuptools.command.build_py import build_py from setuptools.command.build_ext import build_ext from distutils import log from cffi import recompiler def generate_mod(py_file): log.info("generating cffi module %r" % py_file) mkpath(os.path.dirname(py_file)) updated = recompiler.make_py_source(ffi, module_name, py_file) if not updated: log.info("already up-to-date") base_class = dist.cmdclass.get('build_py', build_py) class build_py_make_mod(base_class): def run(self): base_class.run(self) module_path = module_name.split('.') module_path[-1] += '.py' generate_mod(os.path.join(self.build_lib, *module_path)) dist.cmdclass['build_py'] = build_py_make_mod # distutils and setuptools have no notion I could find of a # generated python module. If we don't add module_name to # dist.py_modules, then things mostly work but there are some # combination of options (--root and --record) that will miss # the module. So we add it here, which gives a few apparently # harmless warnings about not finding the file outside the # build directory. if dist.py_modules is None: dist.py_modules = [] dist.py_modules.append(module_name) # the following is only for "build_ext -i" base_class_2 = dist.cmdclass.get('build_ext', build_ext) class build_ext_make_mod(base_class_2): def run(self): base_class_2.run(self) if self.inplace: # from get_ext_fullpath() in distutils/command/build_ext.py module_path = module_name.split('.') package = '.'.join(module_path[:-1]) build_py = self.get_finalized_command('build_py') package_dir = build_py.get_package_dir(package) file_name = module_path[-1] + '.py' generate_mod(os.path.join(package_dir, file_name)) dist.cmdclass['build_ext'] = build_ext_make_mod def cffi_modules(dist, attr, value): assert attr == 'cffi_modules' if isinstance(value, basestring): value = [value] for cffi_module in value: add_cffi_module(dist, cffi_module) PK %�\��Y��+ �+ verifier.pynu �[��� # # DEPRECATED: implementation for ffi.verify() # import sys, os, binascii, shutil, io from . import __version_verifier_modules__ from . import ffiplatform from .error import VerificationError if sys.version_info >= (3, 3): import importlib.machinery def _extension_suffixes(): return importlib.machinery.EXTENSION_SUFFIXES[:] else: import imp def _extension_suffixes(): return [suffix for suffix, _, type in imp.get_suffixes() if type == imp.C_EXTENSION] if sys.version_info >= (3,): NativeIO = io.StringIO else: class NativeIO(io.BytesIO): def write(self, s): if isinstance(s, unicode): s = s.encode('ascii') super(NativeIO, self).write(s) class Verifier(object): def __init__(self, ffi, preamble, tmpdir=None, modulename=None, ext_package=None, tag='', force_generic_engine=False, source_extension='.c', flags=None, relative_to=None, **kwds): if ffi._parser._uses_new_feature: raise VerificationError( "feature not supported with ffi.verify(), but only " "with ffi.set_source(): %s" % (ffi._parser._uses_new_feature,)) self.ffi = ffi self.preamble = preamble if not modulename: flattened_kwds = ffiplatform.flatten(kwds) vengine_class = _locate_engine_class(ffi, force_generic_engine) self._vengine = vengine_class(self) self._vengine.patch_extension_kwds(kwds) self.flags = flags self.kwds = self.make_relative_to(kwds, relative_to) # if modulename: if tag: raise TypeError("can't specify both 'modulename' and 'tag'") else: key = '\x00'.join([sys.version[:3], __version_verifier_modules__, preamble, flattened_kwds] + ffi._cdefsources) if sys.version_info >= (3,): key = key.encode('utf-8') k1 = hex(binascii.crc32(key[0::2]) & 0xffffffff) k1 = k1.lstrip('0x').rstrip('L') k2 = hex(binascii.crc32(key[1::2]) & 0xffffffff) k2 = k2.lstrip('0').rstrip('L') modulename = '_cffi_%s_%s%s%s' % (tag, self._vengine._class_key, k1, k2) suffix = _get_so_suffixes()[0] self.tmpdir = tmpdir or _caller_dir_pycache() self.sourcefilename = os.path.join(self.tmpdir, modulename + source_extension) self.modulefilename = os.path.join(self.tmpdir, modulename + suffix) self.ext_package = ext_package self._has_source = False self._has_module = False def write_source(self, file=None): """Write the C source code. It is produced in 'self.sourcefilename', which can be tweaked beforehand.""" with self.ffi._lock: if self._has_source and file is None: raise VerificationError( "source code already written") self._write_source(file) def compile_module(self): """Write the C source code (if not done already) and compile it. This produces a dynamic link library in 'self.modulefilename'.""" with self.ffi._lock: if self._has_module: raise VerificationError("module already compiled") if not self._has_source: self._write_source() self._compile_module() def load_library(self): """Get a C module from this Verifier instance. Returns an instance of a FFILibrary class that behaves like the objects returned by ffi.dlopen(), but that delegates all operations to the C module. If necessary, the C code is written and compiled first. """ with self.ffi._lock: if not self._has_module: self._locate_module() if not self._has_module: if not self._has_source: self._write_source() self._compile_module() return self._load_library() def get_module_name(self): basename = os.path.basename(self.modulefilename) # kill both the .so extension and the other .'s, as introduced # by Python 3: 'basename.cpython-33m.so' basename = basename.split('.', 1)[0] # and the _d added in Python 2 debug builds --- but try to be # conservative and not kill a legitimate _d if basename.endswith('_d') and hasattr(sys, 'gettotalrefcount'): basename = basename[:-2] return basename def get_extension(self): ffiplatform._hack_at_distutils() # backward compatibility hack if not self._has_source: with self.ffi._lock: if not self._has_source: self._write_source() sourcename = ffiplatform.maybe_relative_path(self.sourcefilename) modname = self.get_module_name() return ffiplatform.get_extension(sourcename, modname, **self.kwds) def generates_python_module(self): return self._vengine._gen_python_module def make_relative_to(self, kwds, relative_to): if relative_to and os.path.dirname(relative_to): dirname = os.path.dirname(relative_to) kwds = kwds.copy() for key in ffiplatform.LIST_OF_FILE_NAMES: if key in kwds: lst = kwds[key] if not isinstance(lst, (list, tuple)): raise TypeError("keyword '%s' should be a list or tuple" % (key,)) lst = [os.path.join(dirname, fn) for fn in lst] kwds[key] = lst return kwds # ---------- def _locate_module(self): if not os.path.isfile(self.modulefilename): if self.ext_package: try: pkg = __import__(self.ext_package, None, None, ['__doc__']) except ImportError: return # cannot import the package itself, give up # (e.g. it might be called differently before installation) path = pkg.__path__ else: path = None filename = self._vengine.find_module(self.get_module_name(), path, _get_so_suffixes()) if filename is None: return self.modulefilename = filename self._vengine.collect_types() self._has_module = True def _write_source_to(self, file): self._vengine._f = file try: self._vengine.write_source_to_f() finally: del self._vengine._f def _write_source(self, file=None): if file is not None: self._write_source_to(file) else: # Write our source file to an in memory file. f = NativeIO() self._write_source_to(f) source_data = f.getvalue() # Determine if this matches the current file if os.path.exists(self.sourcefilename): with open(self.sourcefilename, "r") as fp: needs_written = not (fp.read() == source_data) else: needs_written = True # Actually write the file out if it doesn't match if needs_written: _ensure_dir(self.sourcefilename) with open(self.sourcefilename, "w") as fp: fp.write(source_data) # Set this flag self._has_source = True def _compile_module(self): # compile this C source tmpdir = os.path.dirname(self.sourcefilename) outputfilename = ffiplatform.compile(tmpdir, self.get_extension()) try: same = ffiplatform.samefile(outputfilename, self.modulefilename) except OSError: same = False if not same: _ensure_dir(self.modulefilename) shutil.move(outputfilename, self.modulefilename) self._has_module = True def _load_library(self): assert self._has_module if self.flags is not None: return self._vengine.load_library(self.flags) else: return self._vengine.load_library() # ____________________________________________________________ _FORCE_GENERIC_ENGINE = False # for tests def _locate_engine_class(ffi, force_generic_engine): if _FORCE_GENERIC_ENGINE: force_generic_engine = True if not force_generic_engine: if '__pypy__' in sys.builtin_module_names: force_generic_engine = True else: try: import _cffi_backend except ImportError: _cffi_backend = '?' if ffi._backend is not _cffi_backend: force_generic_engine = True if force_generic_engine: from . import vengine_gen return vengine_gen.VGenericEngine else: from . import vengine_cpy return vengine_cpy.VCPythonEngine # ____________________________________________________________ _TMPDIR = None def _caller_dir_pycache(): if _TMPDIR: return _TMPDIR result = os.environ.get('CFFI_TMPDIR') if result: return result filename = sys._getframe(2).f_code.co_filename return os.path.abspath(os.path.join(os.path.dirname(filename), '__pycache__')) def set_tmpdir(dirname): """Set the temporary directory to use instead of __pycache__.""" global _TMPDIR _TMPDIR = dirname def cleanup_tmpdir(tmpdir=None, keep_so=False): """Clean up the temporary directory by removing all files in it called `_cffi_*.{c,so}` as well as the `build` subdirectory.""" tmpdir = tmpdir or _caller_dir_pycache() try: filelist = os.listdir(tmpdir) except OSError: return if keep_so: suffix = '.c' # only remove .c files else: suffix = _get_so_suffixes()[0].lower() for fn in filelist: if fn.lower().startswith('_cffi_') and ( fn.lower().endswith(suffix) or fn.lower().endswith('.c')): try: os.unlink(os.path.join(tmpdir, fn)) except OSError: pass clean_dir = [os.path.join(tmpdir, 'build')] for dir in clean_dir: try: for fn in os.listdir(dir): fn = os.path.join(dir, fn) if os.path.isdir(fn): clean_dir.append(fn) else: os.unlink(fn) except OSError: pass def _get_so_suffixes(): suffixes = _extension_suffixes() if not suffixes: # bah, no C_EXTENSION available. Occurs on pypy without cpyext if sys.platform == 'win32': suffixes = [".pyd"] else: suffixes = [".so"] return suffixes def _ensure_dir(filename): dirname = os.path.dirname(filename) if dirname and not os.path.isdir(dirname): os.makedirs(dirname) PK %�\��N�� �� vengine_cpy.pynu �[��� # # DEPRECATED: implementation for ffi.verify() # import sys, imp from . import model from .error import VerificationError class VCPythonEngine(object): _class_key = 'x' _gen_python_module = True def __init__(self, verifier): self.verifier = verifier self.ffi = verifier.ffi self._struct_pending_verification = {} self._types_of_builtin_functions = {} def patch_extension_kwds(self, kwds): pass def find_module(self, module_name, path, so_suffixes): try: f, filename, descr = imp.find_module(module_name, path) except ImportError: return None if f is not None: f.close() # Note that after a setuptools installation, there are both .py # and .so files with the same basename. The code here relies on # imp.find_module() locating the .so in priority. if descr[0] not in so_suffixes: return None return filename def collect_types(self): self._typesdict = {} self._generate("collecttype") def _prnt(self, what=''): self._f.write(what + '\n') def _gettypenum(self, type): # a KeyError here is a bug. please report it! :-) return self._typesdict[type] def _do_collect_type(self, tp): if ((not isinstance(tp, model.PrimitiveType) or tp.name == 'long double') and tp not in self._typesdict): num = len(self._typesdict) self._typesdict[tp] = num def write_source_to_f(self): self.collect_types() # # The new module will have a _cffi_setup() function that receives # objects from the ffi world, and that calls some setup code in # the module. This setup code is split in several independent # functions, e.g. one per constant. The functions are "chained" # by ending in a tail call to each other. # # This is further split in two chained lists, depending on if we # can do it at import-time or if we must wait for _cffi_setup() to # provide us with the <ctype> objects. This is needed because we # need the values of the enum constants in order to build the # <ctype 'enum'> that we may have to pass to _cffi_setup(). # # The following two 'chained_list_constants' items contains # the head of these two chained lists, as a string that gives the # call to do, if any. self._chained_list_constants = ['((void)lib,0)', '((void)lib,0)'] # prnt = self._prnt # first paste some standard set of lines that are mostly '#define' prnt(cffimod_header) prnt() # then paste the C source given by the user, verbatim. prnt(self.verifier.preamble) prnt() # # call generate_cpy_xxx_decl(), for every xxx found from # ffi._parser._declarations. This generates all the functions. self._generate("decl") # # implement the function _cffi_setup_custom() as calling the # head of the chained list. self._generate_setup_custom() prnt() # # produce the method table, including the entries for the # generated Python->C function wrappers, which are done # by generate_cpy_function_method(). prnt('static PyMethodDef _cffi_methods[] = {') self._generate("method") prnt(' {"_cffi_setup", _cffi_setup, METH_VARARGS, NULL},') prnt(' {NULL, NULL, 0, NULL} /* Sentinel */') prnt('};') prnt() # # standard init. modname = self.verifier.get_module_name() constants = self._chained_list_constants[False] prnt('#if PY_MAJOR_VERSION >= 3') prnt() prnt('static struct PyModuleDef _cffi_module_def = {') prnt(' PyModuleDef_HEAD_INIT,') prnt(' "%s",' % modname) prnt(' NULL,') prnt(' -1,') prnt(' _cffi_methods,') prnt(' NULL, NULL, NULL, NULL') prnt('};') prnt() prnt('PyMODINIT_FUNC') prnt('PyInit_%s(void)' % modname) prnt('{') prnt(' PyObject *lib;') prnt(' lib = PyModule_Create(&_cffi_module_def);') prnt(' if (lib == NULL)') prnt(' return NULL;') prnt(' if (%s < 0 || _cffi_init() < 0) {' % (constants,)) prnt(' Py_DECREF(lib);') prnt(' return NULL;') prnt(' }') prnt(' return lib;') prnt('}') prnt() prnt('#else') prnt() prnt('PyMODINIT_FUNC') prnt('init%s(void)' % modname) prnt('{') prnt(' PyObject *lib;') prnt(' lib = Py_InitModule("%s", _cffi_methods);' % modname) prnt(' if (lib == NULL)') prnt(' return;') prnt(' if (%s < 0 || _cffi_init() < 0)' % (constants,)) prnt(' return;') prnt(' return;') prnt('}') prnt() prnt('#endif') def load_library(self, flags=None): # XXX review all usages of 'self' here! # import it as a new extension module imp.acquire_lock() try: if hasattr(sys, "getdlopenflags"): previous_flags = sys.getdlopenflags() try: if hasattr(sys, "setdlopenflags") and flags is not None: sys.setdlopenflags(flags) module = imp.load_dynamic(self.verifier.get_module_name(), self.verifier.modulefilename) except ImportError as e: error = "importing %r: %s" % (self.verifier.modulefilename, e) raise VerificationError(error) finally: if hasattr(sys, "setdlopenflags"): sys.setdlopenflags(previous_flags) finally: imp.release_lock() # # call loading_cpy_struct() to get the struct layout inferred by # the C compiler self._load(module, 'loading') # # the C code will need the <ctype> objects. Collect them in # order in a list. revmapping = dict([(value, key) for (key, value) in self._typesdict.items()]) lst = [revmapping[i] for i in range(len(revmapping))] lst = list(map(self.ffi._get_cached_btype, lst)) # # build the FFILibrary class and instance and call _cffi_setup(). # this will set up some fields like '_cffi_types', and only then # it will invoke the chained list of functions that will really # build (notably) the constant objects, as <cdata> if they are # pointers, and store them as attributes on the 'library' object. class FFILibrary(object): _cffi_python_module = module _cffi_ffi = self.ffi _cffi_dir = [] def __dir__(self): return FFILibrary._cffi_dir + list(self.__dict__) library = FFILibrary() if module._cffi_setup(lst, VerificationError, library): import warnings warnings.warn("reimporting %r might overwrite older definitions" % (self.verifier.get_module_name())) # # finally, call the loaded_cpy_xxx() functions. This will perform # the final adjustments, like copying the Python->C wrapper # functions from the module to the 'library' object, and setting # up the FFILibrary class with properties for the global C variables. self._load(module, 'loaded', library=library) module._cffi_original_ffi = self.ffi module._cffi_types_of_builtin_funcs = self._types_of_builtin_functions return library def _get_declarations(self): lst = [(key, tp) for (key, (tp, qual)) in self.ffi._parser._declarations.items()] lst.sort() return lst def _generate(self, step_name): for name, tp in self._get_declarations(): kind, realname = name.split(' ', 1) try: method = getattr(self, '_generate_cpy_%s_%s' % (kind, step_name)) except AttributeError: raise VerificationError( "not implemented in verify(): %r" % name) try: method(tp, realname) except Exception as e: model.attach_exception_info(e, name) raise def _load(self, module, step_name, **kwds): for name, tp in self._get_declarations(): kind, realname = name.split(' ', 1) method = getattr(self, '_%s_cpy_%s' % (step_name, kind)) try: method(tp, realname, module, **kwds) except Exception as e: model.attach_exception_info(e, name) raise def _generate_nothing(self, tp, name): pass def _loaded_noop(self, tp, name, module, **kwds): pass # ---------- def _convert_funcarg_to_c(self, tp, fromvar, tovar, errcode): extraarg = '' if isinstance(tp, model.PrimitiveType): if tp.is_integer_type() and tp.name != '_Bool': converter = '_cffi_to_c_int' extraarg = ', %s' % tp.name else: converter = '(%s)_cffi_to_c_%s' % (tp.get_c_name(''), tp.name.replace(' ', '_')) errvalue = '-1' # elif isinstance(tp, model.PointerType): self._convert_funcarg_to_c_ptr_or_array(tp, fromvar, tovar, errcode) return # elif isinstance(tp, (model.StructOrUnion, model.EnumType)): # a struct (not a struct pointer) as a function argument self._prnt(' if (_cffi_to_c((char *)&%s, _cffi_type(%d), %s) < 0)' % (tovar, self._gettypenum(tp), fromvar)) self._prnt(' %s;' % errcode) return # elif isinstance(tp, model.FunctionPtrType): converter = '(%s)_cffi_to_c_pointer' % tp.get_c_name('') extraarg = ', _cffi_type(%d)' % self._gettypenum(tp) errvalue = 'NULL' # else: raise NotImplementedError(tp) # self._prnt(' %s = %s(%s%s);' % (tovar, converter, fromvar, extraarg)) self._prnt(' if (%s == (%s)%s && PyErr_Occurred())' % ( tovar, tp.get_c_name(''), errvalue)) self._prnt(' %s;' % errcode) def _extra_local_variables(self, tp, localvars): if isinstance(tp, model.PointerType): localvars.add('Py_ssize_t datasize') def _convert_funcarg_to_c_ptr_or_array(self, tp, fromvar, tovar, errcode): self._prnt(' datasize = _cffi_prepare_pointer_call_argument(') self._prnt(' _cffi_type(%d), %s, (char **)&%s);' % ( self._gettypenum(tp), fromvar, tovar)) self._prnt(' if (datasize != 0) {') self._prnt(' if (datasize < 0)') self._prnt(' %s;' % errcode) self._prnt(' %s = alloca((size_t)datasize);' % (tovar,)) self._prnt(' memset((void *)%s, 0, (size_t)datasize);' % (tovar,)) self._prnt(' if (_cffi_convert_array_from_object(' '(char *)%s, _cffi_type(%d), %s) < 0)' % ( tovar, self._gettypenum(tp), fromvar)) self._prnt(' %s;' % errcode) self._prnt(' }') def _convert_expr_from_c(self, tp, var, context): if isinstance(tp, model.PrimitiveType): if tp.is_integer_type() and tp.name != '_Bool': return '_cffi_from_c_int(%s, %s)' % (var, tp.name) elif tp.name != 'long double': return '_cffi_from_c_%s(%s)' % (tp.name.replace(' ', '_'), var) else: return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % ( var, self._gettypenum(tp)) elif isinstance(tp, (model.PointerType, model.FunctionPtrType)): return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % ( var, self._gettypenum(tp)) elif isinstance(tp, model.ArrayType): return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % ( var, self._gettypenum(model.PointerType(tp.item))) elif isinstance(tp, model.StructOrUnion): if tp.fldnames is None: raise TypeError("'%s' is used as %s, but is opaque" % ( tp._get_c_name(), context)) return '_cffi_from_c_struct((char *)&%s, _cffi_type(%d))' % ( var, self._gettypenum(tp)) elif isinstance(tp, model.EnumType): return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % ( var, self._gettypenum(tp)) else: raise NotImplementedError(tp) # ---------- # typedefs: generates no code so far _generate_cpy_typedef_collecttype = _generate_nothing _generate_cpy_typedef_decl = _generate_nothing _generate_cpy_typedef_method = _generate_nothing _loading_cpy_typedef = _loaded_noop _loaded_cpy_typedef = _loaded_noop # ---------- # function declarations def _generate_cpy_function_collecttype(self, tp, name): assert isinstance(tp, model.FunctionPtrType) if tp.ellipsis: self._do_collect_type(tp) else: # don't call _do_collect_type(tp) in this common case, # otherwise test_autofilled_struct_as_argument fails for type in tp.args: self._do_collect_type(type) self._do_collect_type(tp.result) def _generate_cpy_function_decl(self, tp, name): assert isinstance(tp, model.FunctionPtrType) if tp.ellipsis: # cannot support vararg functions better than this: check for its # exact type (including the fixed arguments), and build it as a # constant function pointer (no CPython wrapper) self._generate_cpy_const(False, name, tp) return prnt = self._prnt numargs = len(tp.args) if numargs == 0: argname = 'noarg' elif numargs == 1: argname = 'arg0' else: argname = 'args' prnt('static PyObject *') prnt('_cffi_f_%s(PyObject *self, PyObject *%s)' % (name, argname)) prnt('{') # context = 'argument of %s' % name for i, type in enumerate(tp.args): prnt(' %s;' % type.get_c_name(' x%d' % i, context)) # localvars = set() for type in tp.args: self._extra_local_variables(type, localvars) for decl in localvars: prnt(' %s;' % (decl,)) # if not isinstance(tp.result, model.VoidType): result_code = 'result = ' context = 'result of %s' % name prnt(' %s;' % tp.result.get_c_name(' result', context)) else: result_code = '' # if len(tp.args) > 1: rng = range(len(tp.args)) for i in rng: prnt(' PyObject *arg%d;' % i) prnt() prnt(' if (!PyArg_ParseTuple(args, "%s:%s", %s))' % ( 'O' * numargs, name, ', '.join(['&arg%d' % i for i in rng]))) prnt(' return NULL;') prnt() # for i, type in enumerate(tp.args): self._convert_funcarg_to_c(type, 'arg%d' % i, 'x%d' % i, 'return NULL') prnt() # prnt(' Py_BEGIN_ALLOW_THREADS') prnt(' _cffi_restore_errno();') prnt(' { %s%s(%s); }' % ( result_code, name, ', '.join(['x%d' % i for i in range(len(tp.args))]))) prnt(' _cffi_save_errno();') prnt(' Py_END_ALLOW_THREADS') prnt() # prnt(' (void)self; /* unused */') if numargs == 0: prnt(' (void)noarg; /* unused */') if result_code: prnt(' return %s;' % self._convert_expr_from_c(tp.result, 'result', 'result type')) else: prnt(' Py_INCREF(Py_None);') prnt(' return Py_None;') prnt('}') prnt() def _generate_cpy_function_method(self, tp, name): if tp.ellipsis: return numargs = len(tp.args) if numargs == 0: meth = 'METH_NOARGS' elif numargs == 1: meth = 'METH_O' else: meth = 'METH_VARARGS' self._prnt(' {"%s", _cffi_f_%s, %s, NULL},' % (name, name, meth)) _loading_cpy_function = _loaded_noop def _loaded_cpy_function(self, tp, name, module, library): if tp.ellipsis: return func = getattr(module, name) setattr(library, name, func) self._types_of_builtin_functions[func] = tp # ---------- # named structs _generate_cpy_struct_collecttype = _generate_nothing def _generate_cpy_struct_decl(self, tp, name): assert name == tp.name self._generate_struct_or_union_decl(tp, 'struct', name) def _generate_cpy_struct_method(self, tp, name): self._generate_struct_or_union_method(tp, 'struct', name) def _loading_cpy_struct(self, tp, name, module): self._loading_struct_or_union(tp, 'struct', name, module) def _loaded_cpy_struct(self, tp, name, module, **kwds): self._loaded_struct_or_union(tp) _generate_cpy_union_collecttype = _generate_nothing def _generate_cpy_union_decl(self, tp, name): assert name == tp.name self._generate_struct_or_union_decl(tp, 'union', name) def _generate_cpy_union_method(self, tp, name): self._generate_struct_or_union_method(tp, 'union', name) def _loading_cpy_union(self, tp, name, module): self._loading_struct_or_union(tp, 'union', name, module) def _loaded_cpy_union(self, tp, name, module, **kwds): self._loaded_struct_or_union(tp) def _generate_struct_or_union_decl(self, tp, prefix, name): if tp.fldnames is None: return # nothing to do with opaque structs checkfuncname = '_cffi_check_%s_%s' % (prefix, name) layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name) cname = ('%s %s' % (prefix, name)).strip() # prnt = self._prnt prnt('static void %s(%s *p)' % (checkfuncname, cname)) prnt('{') prnt(' /* only to generate compile-time warnings or errors */') prnt(' (void)p;') for fname, ftype, fbitsize, fqual in tp.enumfields(): if (isinstance(ftype, model.PrimitiveType) and ftype.is_integer_type()) or fbitsize >= 0: # accept all integers, but complain on float or double prnt(' (void)((p->%s) << 1);' % fname) else: # only accept exactly the type declared. try: prnt(' { %s = &p->%s; (void)tmp; }' % ( ftype.get_c_name('*tmp', 'field %r'%fname, quals=fqual), fname)) except VerificationError as e: prnt(' /* %s */' % str(e)) # cannot verify it, ignore prnt('}') prnt('static PyObject *') prnt('%s(PyObject *self, PyObject *noarg)' % (layoutfuncname,)) prnt('{') prnt(' struct _cffi_aligncheck { char x; %s y; };' % cname) prnt(' static Py_ssize_t nums[] = {') prnt(' sizeof(%s),' % cname) prnt(' offsetof(struct _cffi_aligncheck, y),') for fname, ftype, fbitsize, fqual in tp.enumfields(): if fbitsize >= 0: continue # xxx ignore fbitsize for now prnt(' offsetof(%s, %s),' % (cname, fname)) if isinstance(ftype, model.ArrayType) and ftype.length is None: prnt(' 0, /* %s */' % ftype._get_c_name()) else: prnt(' sizeof(((%s *)0)->%s),' % (cname, fname)) prnt(' -1') prnt(' };') prnt(' (void)self; /* unused */') prnt(' (void)noarg; /* unused */') prnt(' return _cffi_get_struct_layout(nums);') prnt(' /* the next line is not executed, but compiled */') prnt(' %s(0);' % (checkfuncname,)) prnt('}') prnt() def _generate_struct_or_union_method(self, tp, prefix, name): if tp.fldnames is None: return # nothing to do with opaque structs layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name) self._prnt(' {"%s", %s, METH_NOARGS, NULL},' % (layoutfuncname, layoutfuncname)) def _loading_struct_or_union(self, tp, prefix, name, module): if tp.fldnames is None: return # nothing to do with opaque structs layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name) # function = getattr(module, layoutfuncname) layout = function() if isinstance(tp, model.StructOrUnion) and tp.partial: # use the function()'s sizes and offsets to guide the # layout of the struct totalsize = layout[0] totalalignment = layout[1] fieldofs = layout[2::2] fieldsize = layout[3::2] tp.force_flatten() assert len(fieldofs) == len(fieldsize) == len(tp.fldnames) tp.fixedlayout = fieldofs, fieldsize, totalsize, totalalignment else: cname = ('%s %s' % (prefix, name)).strip() self._struct_pending_verification[tp] = layout, cname def _loaded_struct_or_union(self, tp): if tp.fldnames is None: return # nothing to do with opaque structs self.ffi._get_cached_btype(tp) # force 'fixedlayout' to be considered if tp in self._struct_pending_verification: # check that the layout sizes and offsets match the real ones def check(realvalue, expectedvalue, msg): if realvalue != expectedvalue: raise VerificationError( "%s (we have %d, but C compiler says %d)" % (msg, expectedvalue, realvalue)) ffi = self.ffi BStruct = ffi._get_cached_btype(tp) layout, cname = self._struct_pending_verification.pop(tp) check(layout[0], ffi.sizeof(BStruct), "wrong total size") check(layout[1], ffi.alignof(BStruct), "wrong total alignment") i = 2 for fname, ftype, fbitsize, fqual in tp.enumfields(): if fbitsize >= 0: continue # xxx ignore fbitsize for now check(layout[i], ffi.offsetof(BStruct, fname), "wrong offset for field %r" % (fname,)) if layout[i+1] != 0: BField = ffi._get_cached_btype(ftype) check(layout[i+1], ffi.sizeof(BField), "wrong size for field %r" % (fname,)) i += 2 assert i == len(layout) # ---------- # 'anonymous' declarations. These are produced for anonymous structs # or unions; the 'name' is obtained by a typedef. _generate_cpy_anonymous_collecttype = _generate_nothing def _generate_cpy_anonymous_decl(self, tp, name): if isinstance(tp, model.EnumType): self._generate_cpy_enum_decl(tp, name, '') else: self._generate_struct_or_union_decl(tp, '', name) def _generate_cpy_anonymous_method(self, tp, name): if not isinstance(tp, model.EnumType): self._generate_struct_or_union_method(tp, '', name) def _loading_cpy_anonymous(self, tp, name, module): if isinstance(tp, model.EnumType): self._loading_cpy_enum(tp, name, module) else: self._loading_struct_or_union(tp, '', name, module) def _loaded_cpy_anonymous(self, tp, name, module, **kwds): if isinstance(tp, model.EnumType): self._loaded_cpy_enum(tp, name, module, **kwds) else: self._loaded_struct_or_union(tp) # ---------- # constants, likely declared with '#define' def _generate_cpy_const(self, is_int, name, tp=None, category='const', vartp=None, delayed=True, size_too=False, check_value=None): prnt = self._prnt funcname = '_cffi_%s_%s' % (category, name) prnt('static int %s(PyObject *lib)' % funcname) prnt('{') prnt(' PyObject *o;') prnt(' int res;') if not is_int: prnt(' %s;' % (vartp or tp).get_c_name(' i', name)) else: assert category == 'const' # if check_value is not None: self._check_int_constant_value(name, check_value) # if not is_int: if category == 'var': realexpr = '&' + name else: realexpr = name prnt(' i = (%s);' % (realexpr,)) prnt(' o = %s;' % (self._convert_expr_from_c(tp, 'i', 'variable type'),)) assert delayed else: prnt(' o = _cffi_from_c_int_const(%s);' % name) prnt(' if (o == NULL)') prnt(' return -1;') if size_too: prnt(' {') prnt(' PyObject *o1 = o;') prnt(' o = Py_BuildValue("On", o1, (Py_ssize_t)sizeof(%s));' % (name,)) prnt(' Py_DECREF(o1);') prnt(' if (o == NULL)') prnt(' return -1;') prnt(' }') prnt(' res = PyObject_SetAttrString(lib, "%s", o);' % name) prnt(' Py_DECREF(o);') prnt(' if (res < 0)') prnt(' return -1;') prnt(' return %s;' % self._chained_list_constants[delayed]) self._chained_list_constants[delayed] = funcname + '(lib)' prnt('}') prnt() def _generate_cpy_constant_collecttype(self, tp, name): is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type() if not is_int: self._do_collect_type(tp) def _generate_cpy_constant_decl(self, tp, name): is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type() self._generate_cpy_const(is_int, name, tp) _generate_cpy_constant_method = _generate_nothing _loading_cpy_constant = _loaded_noop _loaded_cpy_constant = _loaded_noop # ---------- # enums def _check_int_constant_value(self, name, value, err_prefix=''): prnt = self._prnt if value <= 0: prnt(' if ((%s) > 0 || (long)(%s) != %dL) {' % ( name, name, value)) else: prnt(' if ((%s) <= 0 || (unsigned long)(%s) != %dUL) {' % ( name, name, value)) prnt(' char buf[64];') prnt(' if ((%s) <= 0)' % name) prnt(' snprintf(buf, 63, "%%ld", (long)(%s));' % name) prnt(' else') prnt(' snprintf(buf, 63, "%%lu", (unsigned long)(%s));' % name) prnt(' PyErr_Format(_cffi_VerificationError,') prnt(' "%s%s has the real value %s, not %s",') prnt(' "%s", "%s", buf, "%d");' % ( err_prefix, name, value)) prnt(' return -1;') prnt(' }') def _enum_funcname(self, prefix, name): # "$enum_$1" => "___D_enum____D_1" name = name.replace('$', '___D_') return '_cffi_e_%s_%s' % (prefix, name) def _generate_cpy_enum_decl(self, tp, name, prefix='enum'): if tp.partial: for enumerator in tp.enumerators: self._generate_cpy_const(True, enumerator, delayed=False) return # funcname = self._enum_funcname(prefix, name) prnt = self._prnt prnt('static int %s(PyObject *lib)' % funcname) prnt('{') for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues): self._check_int_constant_value(enumerator, enumvalue, "enum %s: " % name) prnt(' return %s;' % self._chained_list_constants[True]) self._chained_list_constants[True] = funcname + '(lib)' prnt('}') prnt() _generate_cpy_enum_collecttype = _generate_nothing _generate_cpy_enum_method = _generate_nothing def _loading_cpy_enum(self, tp, name, module): if tp.partial: enumvalues = [getattr(module, enumerator) for enumerator in tp.enumerators] tp.enumvalues = tuple(enumvalues) tp.partial_resolved = True def _loaded_cpy_enum(self, tp, name, module, library): for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues): setattr(library, enumerator, enumvalue) # ---------- # macros: for now only for integers def _generate_cpy_macro_decl(self, tp, name): if tp == '...': check_value = None else: check_value = tp # an integer self._generate_cpy_const(True, name, check_value=check_value) _generate_cpy_macro_collecttype = _generate_nothing _generate_cpy_macro_method = _generate_nothing _loading_cpy_macro = _loaded_noop _loaded_cpy_macro = _loaded_noop # ---------- # global variables def _generate_cpy_variable_collecttype(self, tp, name): if isinstance(tp, model.ArrayType): tp_ptr = model.PointerType(tp.item) else: tp_ptr = model.PointerType(tp) self._do_collect_type(tp_ptr) def _generate_cpy_variable_decl(self, tp, name): if isinstance(tp, model.ArrayType): tp_ptr = model.PointerType(tp.item) self._generate_cpy_const(False, name, tp, vartp=tp_ptr, size_too = (tp.length == '...')) else: tp_ptr = model.PointerType(tp) self._generate_cpy_const(False, name, tp_ptr, category='var') _generate_cpy_variable_method = _generate_nothing _loading_cpy_variable = _loaded_noop def _loaded_cpy_variable(self, tp, name, module, library): value = getattr(library, name) if isinstance(tp, model.ArrayType): # int a[5] is "constant" in the # sense that "a=..." is forbidden if tp.length == '...': assert isinstance(value, tuple) (value, size) = value BItemType = self.ffi._get_cached_btype(tp.item) length, rest = divmod(size, self.ffi.sizeof(BItemType)) if rest != 0: raise VerificationError( "bad size: %r does not seem to be an array of %s" % (name, tp.item)) tp = tp.resolve_length(length) # 'value' is a <cdata 'type *'> which we have to replace with # a <cdata 'type[N]'> if the N is actually known if tp.length is not None: BArray = self.ffi._get_cached_btype(tp) value = self.ffi.cast(BArray, value) setattr(library, name, value) return # remove ptr=<cdata 'int *'> from the library instance, and replace # it by a property on the class, which reads/writes into ptr[0]. ptr = value delattr(library, name) def getter(library): return ptr[0] def setter(library, value): ptr[0] = value setattr(type(library), name, property(getter, setter)) type(library)._cffi_dir.append(name) # ---------- def _generate_setup_custom(self): prnt = self._prnt prnt('static int _cffi_setup_custom(PyObject *lib)') prnt('{') prnt(' return %s;' % self._chained_list_constants[True]) prnt('}') cffimod_header = r''' #include <Python.h> #include <stddef.h> /* this block of #ifs should be kept exactly identical between c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py and cffi/_cffi_include.h */ #if defined(_MSC_VER) # include <malloc.h> /* for alloca() */ # if _MSC_VER < 1600 /* MSVC < 2010 */ typedef __int8 int8_t; typedef __int16 int16_t; typedef __int32 int32_t; typedef __int64 int64_t; typedef unsigned __int8 uint8_t; typedef unsigned __int16 uint16_t; typedef unsigned __int32 uint32_t; typedef unsigned __int64 uint64_t; typedef __int8 int_least8_t; typedef __int16 int_least16_t; typedef __int32 int_least32_t; typedef __int64 int_least64_t; typedef unsigned __int8 uint_least8_t; typedef unsigned __int16 uint_least16_t; typedef unsigned __int32 uint_least32_t; typedef unsigned __int64 uint_least64_t; typedef __int8 int_fast8_t; typedef __int16 int_fast16_t; typedef __int32 int_fast32_t; typedef __int64 int_fast64_t; typedef unsigned __int8 uint_fast8_t; typedef unsigned __int16 uint_fast16_t; typedef unsigned __int32 uint_fast32_t; typedef unsigned __int64 uint_fast64_t; typedef __int64 intmax_t; typedef unsigned __int64 uintmax_t; # else # include <stdint.h> # endif # if _MSC_VER < 1800 /* MSVC < 2013 */ # ifndef __cplusplus typedef unsigned char _Bool; # endif # endif #else # include <stdint.h> # if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux) # include <alloca.h> # endif #endif #if PY_MAJOR_VERSION < 3 # undef PyCapsule_CheckExact # undef PyCapsule_GetPointer # define PyCapsule_CheckExact(capsule) (PyCObject_Check(capsule)) # define PyCapsule_GetPointer(capsule, name) \ (PyCObject_AsVoidPtr(capsule)) #endif #if PY_MAJOR_VERSION >= 3 # define PyInt_FromLong PyLong_FromLong #endif #define _cffi_from_c_double PyFloat_FromDouble #define _cffi_from_c_float PyFloat_FromDouble #define _cffi_from_c_long PyInt_FromLong #define _cffi_from_c_ulong PyLong_FromUnsignedLong #define _cffi_from_c_longlong PyLong_FromLongLong #define _cffi_from_c_ulonglong PyLong_FromUnsignedLongLong #define _cffi_from_c__Bool PyBool_FromLong #define _cffi_to_c_double PyFloat_AsDouble #define _cffi_to_c_float PyFloat_AsDouble #define _cffi_from_c_int_const(x) \ (((x) > 0) ? \ ((unsigned long long)(x) <= (unsigned long long)LONG_MAX) ? \ PyInt_FromLong((long)(x)) : \ PyLong_FromUnsignedLongLong((unsigned long long)(x)) : \ ((long long)(x) >= (long long)LONG_MIN) ? \ PyInt_FromLong((long)(x)) : \ PyLong_FromLongLong((long long)(x))) #define _cffi_from_c_int(x, type) \ (((type)-1) > 0 ? /* unsigned */ \ (sizeof(type) < sizeof(long) ? \ PyInt_FromLong((long)x) : \ sizeof(type) == sizeof(long) ? \ PyLong_FromUnsignedLong((unsigned long)x) : \ PyLong_FromUnsignedLongLong((unsigned long long)x)) : \ (sizeof(type) <= sizeof(long) ? \ PyInt_FromLong((long)x) : \ PyLong_FromLongLong((long long)x))) #define _cffi_to_c_int(o, type) \ ((type)( \ sizeof(type) == 1 ? (((type)-1) > 0 ? (type)_cffi_to_c_u8(o) \ : (type)_cffi_to_c_i8(o)) : \ sizeof(type) == 2 ? (((type)-1) > 0 ? (type)_cffi_to_c_u16(o) \ : (type)_cffi_to_c_i16(o)) : \ sizeof(type) == 4 ? (((type)-1) > 0 ? (type)_cffi_to_c_u32(o) \ : (type)_cffi_to_c_i32(o)) : \ sizeof(type) == 8 ? (((type)-1) > 0 ? (type)_cffi_to_c_u64(o) \ : (type)_cffi_to_c_i64(o)) : \ (Py_FatalError("unsupported size for type " #type), (type)0))) #define _cffi_to_c_i8 \ ((int(*)(PyObject *))_cffi_exports[1]) #define _cffi_to_c_u8 \ ((int(*)(PyObject *))_cffi_exports[2]) #define _cffi_to_c_i16 \ ((int(*)(PyObject *))_cffi_exports[3]) #define _cffi_to_c_u16 \ ((int(*)(PyObject *))_cffi_exports[4]) #define _cffi_to_c_i32 \ ((int(*)(PyObject *))_cffi_exports[5]) #define _cffi_to_c_u32 \ ((unsigned int(*)(PyObject *))_cffi_exports[6]) #define _cffi_to_c_i64 \ ((long long(*)(PyObject *))_cffi_exports[7]) #define _cffi_to_c_u64 \ ((unsigned long long(*)(PyObject *))_cffi_exports[8]) #define _cffi_to_c_char \ ((int(*)(PyObject *))_cffi_exports[9]) #define _cffi_from_c_pointer \ ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[10]) #define _cffi_to_c_pointer \ ((char *(*)(PyObject *, CTypeDescrObject *))_cffi_exports[11]) #define _cffi_get_struct_layout \ ((PyObject *(*)(Py_ssize_t[]))_cffi_exports[12]) #define _cffi_restore_errno \ ((void(*)(void))_cffi_exports[13]) #define _cffi_save_errno \ ((void(*)(void))_cffi_exports[14]) #define _cffi_from_c_char \ ((PyObject *(*)(char))_cffi_exports[15]) #define _cffi_from_c_deref \ ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[16]) #define _cffi_to_c \ ((int(*)(char *, CTypeDescrObject *, PyObject *))_cffi_exports[17]) #define _cffi_from_c_struct \ ((PyObject *(*)(char *, CTypeDescrObject *))_cffi_exports[18]) #define _cffi_to_c_wchar_t \ ((wchar_t(*)(PyObject *))_cffi_exports[19]) #define _cffi_from_c_wchar_t \ ((PyObject *(*)(wchar_t))_cffi_exports[20]) #define _cffi_to_c_long_double \ ((long double(*)(PyObject *))_cffi_exports[21]) #define _cffi_to_c__Bool \ ((_Bool(*)(PyObject *))_cffi_exports[22]) #define _cffi_prepare_pointer_call_argument \ ((Py_ssize_t(*)(CTypeDescrObject *, PyObject *, char **))_cffi_exports[23]) #define _cffi_convert_array_from_object \ ((int(*)(char *, CTypeDescrObject *, PyObject *))_cffi_exports[24]) #define _CFFI_NUM_EXPORTS 25 typedef struct _ctypedescr CTypeDescrObject; static void *_cffi_exports[_CFFI_NUM_EXPORTS]; static PyObject *_cffi_types, *_cffi_VerificationError; static int _cffi_setup_custom(PyObject *lib); /* forward */ static PyObject *_cffi_setup(PyObject *self, PyObject *args) { PyObject *library; int was_alive = (_cffi_types != NULL); (void)self; /* unused */ if (!PyArg_ParseTuple(args, "OOO", &_cffi_types, &_cffi_VerificationError, &library)) return NULL; Py_INCREF(_cffi_types); Py_INCREF(_cffi_VerificationError); if (_cffi_setup_custom(library) < 0) return NULL; return PyBool_FromLong(was_alive); } static int _cffi_init(void) { PyObject *module, *c_api_object = NULL; module = PyImport_ImportModule("_cffi_backend"); if (module == NULL) goto failure; c_api_object = PyObject_GetAttrString(module, "_C_API"); if (c_api_object == NULL) goto failure; if (!PyCapsule_CheckExact(c_api_object)) { PyErr_SetNone(PyExc_ImportError); goto failure; } memcpy(_cffi_exports, PyCapsule_GetPointer(c_api_object, "cffi"), _CFFI_NUM_EXPORTS * sizeof(void *)); Py_DECREF(module); Py_DECREF(c_api_object); return 0; failure: Py_XDECREF(module); Py_XDECREF(c_api_object); return -1; } #define _cffi_type(num) ((CTypeDescrObject *)PyList_GET_ITEM(_cffi_types, num)) /**********/ ''' PK %�\������ �� recompiler.pynu �[��� import os, sys, io from . import ffiplatform, model from .error import VerificationError from .cffi_opcode import * VERSION_BASE = 0x2601 VERSION_EMBEDDED = 0x2701 VERSION_CHAR16CHAR32 = 0x2801 class GlobalExpr: def __init__(self, name, address, type_op, size=0, check_value=0): self.name = name self.address = address self.type_op = type_op self.size = size self.check_value = check_value def as_c_expr(self): return ' { "%s", (void *)%s, %s, (void *)%s },' % ( self.name, self.address, self.type_op.as_c_expr(), self.size) def as_python_expr(self): return "b'%s%s',%d" % (self.type_op.as_python_bytes(), self.name, self.check_value) class FieldExpr: def __init__(self, name, field_offset, field_size, fbitsize, field_type_op): self.name = name self.field_offset = field_offset self.field_size = field_size self.fbitsize = fbitsize self.field_type_op = field_type_op def as_c_expr(self): spaces = " " * len(self.name) return (' { "%s", %s,\n' % (self.name, self.field_offset) + ' %s %s,\n' % (spaces, self.field_size) + ' %s %s },' % (spaces, self.field_type_op.as_c_expr())) def as_python_expr(self): raise NotImplementedError def as_field_python_expr(self): if self.field_type_op.op == OP_NOOP: size_expr = '' elif self.field_type_op.op == OP_BITFIELD: size_expr = format_four_bytes(self.fbitsize) else: raise NotImplementedError return "b'%s%s%s'" % (self.field_type_op.as_python_bytes(), size_expr, self.name) class StructUnionExpr: def __init__(self, name, type_index, flags, size, alignment, comment, first_field_index, c_fields): self.name = name self.type_index = type_index self.flags = flags self.size = size self.alignment = alignment self.comment = comment self.first_field_index = first_field_index self.c_fields = c_fields def as_c_expr(self): return (' { "%s", %d, %s,' % (self.name, self.type_index, self.flags) + '\n %s, %s, ' % (self.size, self.alignment) + '%d, %d ' % (self.first_field_index, len(self.c_fields)) + ('/* %s */ ' % self.comment if self.comment else '') + '},') def as_python_expr(self): flags = eval(self.flags, G_FLAGS) fields_expr = [c_field.as_field_python_expr() for c_field in self.c_fields] return "(b'%s%s%s',%s)" % ( format_four_bytes(self.type_index), format_four_bytes(flags), self.name, ','.join(fields_expr)) class EnumExpr: def __init__(self, name, type_index, size, signed, allenums): self.name = name self.type_index = type_index self.size = size self.signed = signed self.allenums = allenums def as_c_expr(self): return (' { "%s", %d, _cffi_prim_int(%s, %s),\n' ' "%s" },' % (self.name, self.type_index, self.size, self.signed, self.allenums)) def as_python_expr(self): prim_index = { (1, 0): PRIM_UINT8, (1, 1): PRIM_INT8, (2, 0): PRIM_UINT16, (2, 1): PRIM_INT16, (4, 0): PRIM_UINT32, (4, 1): PRIM_INT32, (8, 0): PRIM_UINT64, (8, 1): PRIM_INT64, }[self.size, self.signed] return "b'%s%s%s\\x00%s'" % (format_four_bytes(self.type_index), format_four_bytes(prim_index), self.name, self.allenums) class TypenameExpr: def __init__(self, name, type_index): self.name = name self.type_index = type_index def as_c_expr(self): return ' { "%s", %d },' % (self.name, self.type_index) def as_python_expr(self): return "b'%s%s'" % (format_four_bytes(self.type_index), self.name) # ____________________________________________________________ class Recompiler: _num_externpy = 0 def __init__(self, ffi, module_name, target_is_python=False): self.ffi = ffi self.module_name = module_name self.target_is_python = target_is_python self._version = VERSION_BASE def needs_version(self, ver): self._version = max(self._version, ver) def collect_type_table(self): self._typesdict = {} self._generate("collecttype") # all_decls = sorted(self._typesdict, key=str) # # prepare all FUNCTION bytecode sequences first self.cffi_types = [] for tp in all_decls: if tp.is_raw_function: assert self._typesdict[tp] is None self._typesdict[tp] = len(self.cffi_types) self.cffi_types.append(tp) # placeholder for tp1 in tp.args: assert isinstance(tp1, (model.VoidType, model.BasePrimitiveType, model.PointerType, model.StructOrUnionOrEnum, model.FunctionPtrType)) if self._typesdict[tp1] is None: self._typesdict[tp1] = len(self.cffi_types) self.cffi_types.append(tp1) # placeholder self.cffi_types.append('END') # placeholder # # prepare all OTHER bytecode sequences for tp in all_decls: if not tp.is_raw_function and self._typesdict[tp] is None: self._typesdict[tp] = len(self.cffi_types) self.cffi_types.append(tp) # placeholder if tp.is_array_type and tp.length is not None: self.cffi_types.append('LEN') # placeholder assert None not in self._typesdict.values() # # collect all structs and unions and enums self._struct_unions = {} self._enums = {} for tp in all_decls: if isinstance(tp, model.StructOrUnion): self._struct_unions[tp] = None elif isinstance(tp, model.EnumType): self._enums[tp] = None for i, tp in enumerate(sorted(self._struct_unions, key=lambda tp: tp.name)): self._struct_unions[tp] = i for i, tp in enumerate(sorted(self._enums, key=lambda tp: tp.name)): self._enums[tp] = i # # emit all bytecode sequences now for tp in all_decls: method = getattr(self, '_emit_bytecode_' + tp.__class__.__name__) method(tp, self._typesdict[tp]) # # consistency check for op in self.cffi_types: assert isinstance(op, CffiOp) self.cffi_types = tuple(self.cffi_types) # don't change any more def _do_collect_type(self, tp): if not isinstance(tp, model.BaseTypeByIdentity): if isinstance(tp, tuple): for x in tp: self._do_collect_type(x) return if tp not in self._typesdict: self._typesdict[tp] = None if isinstance(tp, model.FunctionPtrType): self._do_collect_type(tp.as_raw_function()) elif isinstance(tp, model.StructOrUnion): if tp.fldtypes is not None and ( tp not in self.ffi._parser._included_declarations): for name1, tp1, _, _ in tp.enumfields(): self._do_collect_type(self._field_type(tp, name1, tp1)) else: for _, x in tp._get_items(): self._do_collect_type(x) def _generate(self, step_name): lst = self.ffi._parser._declarations.items() for name, (tp, quals) in sorted(lst): kind, realname = name.split(' ', 1) try: method = getattr(self, '_generate_cpy_%s_%s' % (kind, step_name)) except AttributeError: raise VerificationError( "not implemented in recompile(): %r" % name) try: self._current_quals = quals method(tp, realname) except Exception as e: model.attach_exception_info(e, name) raise # ---------- ALL_STEPS = ["global", "field", "struct_union", "enum", "typename"] def collect_step_tables(self): # collect the declarations for '_cffi_globals', '_cffi_typenames', etc. self._lsts = {} for step_name in self.ALL_STEPS: self._lsts[step_name] = [] self._seen_struct_unions = set() self._generate("ctx") self._add_missing_struct_unions() # for step_name in self.ALL_STEPS: lst = self._lsts[step_name] if step_name != "field": lst.sort(key=lambda entry: entry.name) self._lsts[step_name] = tuple(lst) # don't change any more # # check for a possible internal inconsistency: _cffi_struct_unions # should have been generated with exactly self._struct_unions lst = self._lsts["struct_union"] for tp, i in self._struct_unions.items(): assert i < len(lst) assert lst[i].name == tp.name assert len(lst) == len(self._struct_unions) # same with enums lst = self._lsts["enum"] for tp, i in self._enums.items(): assert i < len(lst) assert lst[i].name == tp.name assert len(lst) == len(self._enums) # ---------- def _prnt(self, what=''): self._f.write(what + '\n') def write_source_to_f(self, f, preamble): if self.target_is_python: assert preamble is None self.write_py_source_to_f(f) else: assert preamble is not None self.write_c_source_to_f(f, preamble) def _rel_readlines(self, filename): g = open(os.path.join(os.path.dirname(__file__), filename), 'r') lines = g.readlines() g.close() return lines def write_c_source_to_f(self, f, preamble): self._f = f prnt = self._prnt if self.ffi._embedding is not None: prnt('#define _CFFI_USE_EMBEDDING') # # first the '#include' (actually done by inlining the file's content) lines = self._rel_readlines('_cffi_include.h') i = lines.index('#include "parse_c_type.h"\n') lines[i:i+1] = self._rel_readlines('parse_c_type.h') prnt(''.join(lines)) # # if we have ffi._embedding != None, we give it here as a macro # and include an extra file base_module_name = self.module_name.split('.')[-1] if self.ffi._embedding is not None: prnt('#define _CFFI_MODULE_NAME "%s"' % (self.module_name,)) prnt('static const char _CFFI_PYTHON_STARTUP_CODE[] = {') self._print_string_literal_in_array(self.ffi._embedding) prnt('0 };') prnt('#ifdef PYPY_VERSION') prnt('# define _CFFI_PYTHON_STARTUP_FUNC _cffi_pypyinit_%s' % ( base_module_name,)) prnt('#elif PY_MAJOR_VERSION >= 3') prnt('# define _CFFI_PYTHON_STARTUP_FUNC PyInit_%s' % ( base_module_name,)) prnt('#else') prnt('# define _CFFI_PYTHON_STARTUP_FUNC init%s' % ( base_module_name,)) prnt('#endif') lines = self._rel_readlines('_embedding.h') i = lines.index('#include "_cffi_errors.h"\n') lines[i:i+1] = self._rel_readlines('_cffi_errors.h') prnt(''.join(lines)) self.needs_version(VERSION_EMBEDDED) # # then paste the C source given by the user, verbatim. prnt('/************************************************************/') prnt() prnt(preamble) prnt() prnt('/************************************************************/') prnt() # # the declaration of '_cffi_types' prnt('static void *_cffi_types[] = {') typeindex2type = dict([(i, tp) for (tp, i) in self._typesdict.items()]) for i, op in enumerate(self.cffi_types): comment = '' if i in typeindex2type: comment = ' // ' + typeindex2type[i]._get_c_name() prnt('/* %2d */ %s,%s' % (i, op.as_c_expr(), comment)) if not self.cffi_types: prnt(' 0') prnt('};') prnt() # # call generate_cpy_xxx_decl(), for every xxx found from # ffi._parser._declarations. This generates all the functions. self._seen_constants = set() self._generate("decl") # # the declaration of '_cffi_globals' and '_cffi_typenames' nums = {} for step_name in self.ALL_STEPS: lst = self._lsts[step_name] nums[step_name] = len(lst) if nums[step_name] > 0: prnt('static const struct _cffi_%s_s _cffi_%ss[] = {' % ( step_name, step_name)) for entry in lst: prnt(entry.as_c_expr()) prnt('};') prnt() # # the declaration of '_cffi_includes' if self.ffi._included_ffis: prnt('static const char * const _cffi_includes[] = {') for ffi_to_include in self.ffi._included_ffis: try: included_module_name, included_source = ( ffi_to_include._assigned_source[:2]) except AttributeError: raise VerificationError( "ffi object %r includes %r, but the latter has not " "been prepared with set_source()" % ( self.ffi, ffi_to_include,)) if included_source is None: raise VerificationError( "not implemented yet: ffi.include() of a Python-based " "ffi inside a C-based ffi") prnt(' "%s",' % (included_module_name,)) prnt(' NULL') prnt('};') prnt() # # the declaration of '_cffi_type_context' prnt('static const struct _cffi_type_context_s _cffi_type_context = {') prnt(' _cffi_types,') for step_name in self.ALL_STEPS: if nums[step_name] > 0: prnt(' _cffi_%ss,' % step_name) else: prnt(' NULL, /* no %ss */' % step_name) for step_name in self.ALL_STEPS: if step_name != "field": prnt(' %d, /* num_%ss */' % (nums[step_name], step_name)) if self.ffi._included_ffis: prnt(' _cffi_includes,') else: prnt(' NULL, /* no includes */') prnt(' %d, /* num_types */' % (len(self.cffi_types),)) flags = 0 if self._num_externpy: flags |= 1 # set to mean that we use extern "Python" prnt(' %d, /* flags */' % flags) prnt('};') prnt() # # the init function prnt('#ifdef __GNUC__') prnt('# pragma GCC visibility push(default) /* for -fvisibility= */') prnt('#endif') prnt() prnt('#ifdef PYPY_VERSION') prnt('PyMODINIT_FUNC') prnt('_cffi_pypyinit_%s(const void *p[])' % (base_module_name,)) prnt('{') if self._num_externpy: prnt(' if (((intptr_t)p[0]) >= 0x0A03) {') prnt(' _cffi_call_python_org = ' '(void(*)(struct _cffi_externpy_s *, char *))p[1];') prnt(' }') prnt(' p[0] = (const void *)0x%x;' % self._version) prnt(' p[1] = &_cffi_type_context;') prnt('#if PY_MAJOR_VERSION >= 3') prnt(' return NULL;') prnt('#endif') prnt('}') # on Windows, distutils insists on putting init_cffi_xyz in # 'export_symbols', so instead of fighting it, just give up and # give it one prnt('# ifdef _MSC_VER') prnt(' PyMODINIT_FUNC') prnt('# if PY_MAJOR_VERSION >= 3') prnt(' PyInit_%s(void) { return NULL; }' % (base_module_name,)) prnt('# else') prnt(' init%s(void) { }' % (base_module_name,)) prnt('# endif') prnt('# endif') prnt('#elif PY_MAJOR_VERSION >= 3') prnt('PyMODINIT_FUNC') prnt('PyInit_%s(void)' % (base_module_name,)) prnt('{') prnt(' return _cffi_init("%s", 0x%x, &_cffi_type_context);' % ( self.module_name, self._version)) prnt('}') prnt('#else') prnt('PyMODINIT_FUNC') prnt('init%s(void)' % (base_module_name,)) prnt('{') prnt(' _cffi_init("%s", 0x%x, &_cffi_type_context);' % ( self.module_name, self._version)) prnt('}') prnt('#endif') prnt() prnt('#ifdef __GNUC__') prnt('# pragma GCC visibility pop') prnt('#endif') self._version = None def _to_py(self, x): if isinstance(x, str): return "b'%s'" % (x,) if isinstance(x, (list, tuple)): rep = [self._to_py(item) for item in x] if len(rep) == 1: rep.append('') return "(%s)" % (','.join(rep),) return x.as_python_expr() # Py2: unicode unexpected; Py3: bytes unexp. def write_py_source_to_f(self, f): self._f = f prnt = self._prnt # # header prnt("# auto-generated file") prnt("import _cffi_backend") # # the 'import' of the included ffis num_includes = len(self.ffi._included_ffis or ()) for i in range(num_includes): ffi_to_include = self.ffi._included_ffis[i] try: included_module_name, included_source = ( ffi_to_include._assigned_source[:2]) except AttributeError: raise VerificationError( "ffi object %r includes %r, but the latter has not " "been prepared with set_source()" % ( self.ffi, ffi_to_include,)) if included_source is not None: raise VerificationError( "not implemented yet: ffi.include() of a C-based " "ffi inside a Python-based ffi") prnt('from %s import ffi as _ffi%d' % (included_module_name, i)) prnt() prnt("ffi = _cffi_backend.FFI('%s'," % (self.module_name,)) prnt(" _version = 0x%x," % (self._version,)) self._version = None # # the '_types' keyword argument self.cffi_types = tuple(self.cffi_types) # don't change any more types_lst = [op.as_python_bytes() for op in self.cffi_types] prnt(' _types = %s,' % (self._to_py(''.join(types_lst)),)) typeindex2type = dict([(i, tp) for (tp, i) in self._typesdict.items()]) # # the keyword arguments from ALL_STEPS for step_name in self.ALL_STEPS: lst = self._lsts[step_name] if len(lst) > 0 and step_name != "field": prnt(' _%ss = %s,' % (step_name, self._to_py(lst))) # # the '_includes' keyword argument if num_includes > 0: prnt(' _includes = (%s,),' % ( ', '.join(['_ffi%d' % i for i in range(num_includes)]),)) # # the footer prnt(')') # ---------- def _gettypenum(self, type): # a KeyError here is a bug. please report it! :-) return self._typesdict[type] def _convert_funcarg_to_c(self, tp, fromvar, tovar, errcode): extraarg = '' if isinstance(tp, model.BasePrimitiveType) and not tp.is_complex_type(): if tp.is_integer_type() and tp.name != '_Bool': converter = '_cffi_to_c_int' extraarg = ', %s' % tp.name elif isinstance(tp, model.UnknownFloatType): # don't check with is_float_type(): it may be a 'long # double' here, and _cffi_to_c_double would loose precision converter = '(%s)_cffi_to_c_double' % (tp.get_c_name(''),) else: cname = tp.get_c_name('') converter = '(%s)_cffi_to_c_%s' % (cname, tp.name.replace(' ', '_')) if cname in ('char16_t', 'char32_t'): self.needs_version(VERSION_CHAR16CHAR32) errvalue = '-1' # elif isinstance(tp, model.PointerType): self._convert_funcarg_to_c_ptr_or_array(tp, fromvar, tovar, errcode) return # elif (isinstance(tp, model.StructOrUnionOrEnum) or isinstance(tp, model.BasePrimitiveType)): # a struct (not a struct pointer) as a function argument; # or, a complex (the same code works) self._prnt(' if (_cffi_to_c((char *)&%s, _cffi_type(%d), %s) < 0)' % (tovar, self._gettypenum(tp), fromvar)) self._prnt(' %s;' % errcode) return # elif isinstance(tp, model.FunctionPtrType): converter = '(%s)_cffi_to_c_pointer' % tp.get_c_name('') extraarg = ', _cffi_type(%d)' % self._gettypenum(tp) errvalue = 'NULL' # else: raise NotImplementedError(tp) # self._prnt(' %s = %s(%s%s);' % (tovar, converter, fromvar, extraarg)) self._prnt(' if (%s == (%s)%s && PyErr_Occurred())' % ( tovar, tp.get_c_name(''), errvalue)) self._prnt(' %s;' % errcode) def _extra_local_variables(self, tp, localvars): if isinstance(tp, model.PointerType): localvars.add('Py_ssize_t datasize') def _convert_funcarg_to_c_ptr_or_array(self, tp, fromvar, tovar, errcode): self._prnt(' datasize = _cffi_prepare_pointer_call_argument(') self._prnt(' _cffi_type(%d), %s, (char **)&%s);' % ( self._gettypenum(tp), fromvar, tovar)) self._prnt(' if (datasize != 0) {') self._prnt(' if (datasize < 0)') self._prnt(' %s;' % errcode) self._prnt(' %s = (%s)alloca((size_t)datasize);' % ( tovar, tp.get_c_name(''))) self._prnt(' memset((void *)%s, 0, (size_t)datasize);' % (tovar,)) self._prnt(' if (_cffi_convert_array_from_object(' '(char *)%s, _cffi_type(%d), %s) < 0)' % ( tovar, self._gettypenum(tp), fromvar)) self._prnt(' %s;' % errcode) self._prnt(' }') def _convert_expr_from_c(self, tp, var, context): if isinstance(tp, model.BasePrimitiveType): if tp.is_integer_type() and tp.name != '_Bool': return '_cffi_from_c_int(%s, %s)' % (var, tp.name) elif isinstance(tp, model.UnknownFloatType): return '_cffi_from_c_double(%s)' % (var,) elif tp.name != 'long double' and not tp.is_complex_type(): cname = tp.name.replace(' ', '_') if cname in ('char16_t', 'char32_t'): self.needs_version(VERSION_CHAR16CHAR32) return '_cffi_from_c_%s(%s)' % (cname, var) else: return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % ( var, self._gettypenum(tp)) elif isinstance(tp, (model.PointerType, model.FunctionPtrType)): return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % ( var, self._gettypenum(tp)) elif isinstance(tp, model.ArrayType): return '_cffi_from_c_pointer((char *)%s, _cffi_type(%d))' % ( var, self._gettypenum(model.PointerType(tp.item))) elif isinstance(tp, model.StructOrUnion): if tp.fldnames is None: raise TypeError("'%s' is used as %s, but is opaque" % ( tp._get_c_name(), context)) return '_cffi_from_c_struct((char *)&%s, _cffi_type(%d))' % ( var, self._gettypenum(tp)) elif isinstance(tp, model.EnumType): return '_cffi_from_c_deref((char *)&%s, _cffi_type(%d))' % ( var, self._gettypenum(tp)) else: raise NotImplementedError(tp) # ---------- # typedefs def _typedef_type(self, tp, name): return self._global_type(tp, "(*(%s *)0)" % (name,)) def _generate_cpy_typedef_collecttype(self, tp, name): self._do_collect_type(self._typedef_type(tp, name)) def _generate_cpy_typedef_decl(self, tp, name): pass def _typedef_ctx(self, tp, name): type_index = self._typesdict[tp] self._lsts["typename"].append(TypenameExpr(name, type_index)) def _generate_cpy_typedef_ctx(self, tp, name): tp = self._typedef_type(tp, name) self._typedef_ctx(tp, name) if getattr(tp, "origin", None) == "unknown_type": self._struct_ctx(tp, tp.name, approxname=None) elif isinstance(tp, model.NamedPointerType): self._struct_ctx(tp.totype, tp.totype.name, approxname=tp.name, named_ptr=tp) # ---------- # function declarations def _generate_cpy_function_collecttype(self, tp, name): self._do_collect_type(tp.as_raw_function()) if tp.ellipsis and not self.target_is_python: self._do_collect_type(tp) def _generate_cpy_function_decl(self, tp, name): assert not self.target_is_python assert isinstance(tp, model.FunctionPtrType) if tp.ellipsis: # cannot support vararg functions better than this: check for its # exact type (including the fixed arguments), and build it as a # constant function pointer (no CPython wrapper) self._generate_cpy_constant_decl(tp, name) return prnt = self._prnt numargs = len(tp.args) if numargs == 0: argname = 'noarg' elif numargs == 1: argname = 'arg0' else: argname = 'args' # # ------------------------------ # the 'd' version of the function, only for addressof(lib, 'func') arguments = [] call_arguments = [] context = 'argument of %s' % name for i, type in enumerate(tp.args): arguments.append(type.get_c_name(' x%d' % i, context)) call_arguments.append('x%d' % i) repr_arguments = ', '.join(arguments) repr_arguments = repr_arguments or 'void' if tp.abi: abi = tp.abi + ' ' else: abi = '' name_and_arguments = '%s_cffi_d_%s(%s)' % (abi, name, repr_arguments) prnt('static %s' % (tp.result.get_c_name(name_and_arguments),)) prnt('{') call_arguments = ', '.join(call_arguments) result_code = 'return ' if isinstance(tp.result, model.VoidType): result_code = '' prnt(' %s%s(%s);' % (result_code, name, call_arguments)) prnt('}') # prnt('#ifndef PYPY_VERSION') # ------------------------------ # prnt('static PyObject *') prnt('_cffi_f_%s(PyObject *self, PyObject *%s)' % (name, argname)) prnt('{') # context = 'argument of %s' % name for i, type in enumerate(tp.args): arg = type.get_c_name(' x%d' % i, context) prnt(' %s;' % arg) # localvars = set() for type in tp.args: self._extra_local_variables(type, localvars) for decl in localvars: prnt(' %s;' % (decl,)) # if not isinstance(tp.result, model.VoidType): result_code = 'result = ' context = 'result of %s' % name result_decl = ' %s;' % tp.result.get_c_name(' result', context) prnt(result_decl) else: result_decl = None result_code = '' # if len(tp.args) > 1: rng = range(len(tp.args)) for i in rng: prnt(' PyObject *arg%d;' % i) prnt() prnt(' if (!PyArg_UnpackTuple(args, "%s", %d, %d, %s))' % ( name, len(rng), len(rng), ', '.join(['&arg%d' % i for i in rng]))) prnt(' return NULL;') prnt() # for i, type in enumerate(tp.args): self._convert_funcarg_to_c(type, 'arg%d' % i, 'x%d' % i, 'return NULL') prnt() # prnt(' Py_BEGIN_ALLOW_THREADS') prnt(' _cffi_restore_errno();') call_arguments = ['x%d' % i for i in range(len(tp.args))] call_arguments = ', '.join(call_arguments) prnt(' { %s%s(%s); }' % (result_code, name, call_arguments)) prnt(' _cffi_save_errno();') prnt(' Py_END_ALLOW_THREADS') prnt() # prnt(' (void)self; /* unused */') if numargs == 0: prnt(' (void)noarg; /* unused */') if result_code: prnt(' return %s;' % self._convert_expr_from_c(tp.result, 'result', 'result type')) else: prnt(' Py_INCREF(Py_None);') prnt(' return Py_None;') prnt('}') # prnt('#else') # ------------------------------ # # the PyPy version: need to replace struct/union arguments with # pointers, and if the result is a struct/union, insert a first # arg that is a pointer to the result. We also do that for # complex args and return type. def need_indirection(type): return (isinstance(type, model.StructOrUnion) or (isinstance(type, model.PrimitiveType) and type.is_complex_type())) difference = False arguments = [] call_arguments = [] context = 'argument of %s' % name for i, type in enumerate(tp.args): indirection = '' if need_indirection(type): indirection = '*' difference = True arg = type.get_c_name(' %sx%d' % (indirection, i), context) arguments.append(arg) call_arguments.append('%sx%d' % (indirection, i)) tp_result = tp.result if need_indirection(tp_result): context = 'result of %s' % name arg = tp_result.get_c_name(' *result', context) arguments.insert(0, arg) tp_result = model.void_type result_decl = None result_code = '*result = ' difference = True if difference: repr_arguments = ', '.join(arguments) repr_arguments = repr_arguments or 'void' name_and_arguments = '%s_cffi_f_%s(%s)' % (abi, name, repr_arguments) prnt('static %s' % (tp_result.get_c_name(name_and_arguments),)) prnt('{') if result_decl: prnt(result_decl) call_arguments = ', '.join(call_arguments) prnt(' { %s%s(%s); }' % (result_code, name, call_arguments)) if result_decl: prnt(' return result;') prnt('}') else: prnt('# define _cffi_f_%s _cffi_d_%s' % (name, name)) # prnt('#endif') # ------------------------------ prnt() def _generate_cpy_function_ctx(self, tp, name): if tp.ellipsis and not self.target_is_python: self._generate_cpy_constant_ctx(tp, name) return type_index = self._typesdict[tp.as_raw_function()] numargs = len(tp.args) if self.target_is_python: meth_kind = OP_DLOPEN_FUNC elif numargs == 0: meth_kind = OP_CPYTHON_BLTN_N # 'METH_NOARGS' elif numargs == 1: meth_kind = OP_CPYTHON_BLTN_O # 'METH_O' else: meth_kind = OP_CPYTHON_BLTN_V # 'METH_VARARGS' self._lsts["global"].append( GlobalExpr(name, '_cffi_f_%s' % name, CffiOp(meth_kind, type_index), size='_cffi_d_%s' % name)) # ---------- # named structs or unions def _field_type(self, tp_struct, field_name, tp_field): if isinstance(tp_field, model.ArrayType): actual_length = tp_field.length if actual_length == '...': ptr_struct_name = tp_struct.get_c_name('*') actual_length = '_cffi_array_len(((%s)0)->%s)' % ( ptr_struct_name, field_name) tp_item = self._field_type(tp_struct, '%s[0]' % field_name, tp_field.item) tp_field = model.ArrayType(tp_item, actual_length) return tp_field def _struct_collecttype(self, tp): self._do_collect_type(tp) if self.target_is_python: # also requires nested anon struct/unions in ABI mode, recursively for fldtype in tp.anonymous_struct_fields(): self._struct_collecttype(fldtype) def _struct_decl(self, tp, cname, approxname): if tp.fldtypes is None: return prnt = self._prnt checkfuncname = '_cffi_checkfld_%s' % (approxname,) prnt('_CFFI_UNUSED_FN') prnt('static void %s(%s *p)' % (checkfuncname, cname)) prnt('{') prnt(' /* only to generate compile-time warnings or errors */') prnt(' (void)p;') for fname, ftype, fbitsize, fqual in tp.enumfields(): try: if ftype.is_integer_type() or fbitsize >= 0: # accept all integers, but complain on float or double prnt(" (void)((p->%s) | 0); /* check that '%s.%s' is " "an integer */" % (fname, cname, fname)) continue # only accept exactly the type declared, except that '[]' # is interpreted as a '*' and so will match any array length. # (It would also match '*', but that's harder to detect...) while (isinstance(ftype, model.ArrayType) and (ftype.length is None or ftype.length == '...')): ftype = ftype.item fname = fname + '[0]' prnt(' { %s = &p->%s; (void)tmp; }' % ( ftype.get_c_name('*tmp', 'field %r'%fname, quals=fqual), fname)) except VerificationError as e: prnt(' /* %s */' % str(e)) # cannot verify it, ignore prnt('}') prnt('struct _cffi_align_%s { char x; %s y; };' % (approxname, cname)) prnt() def _struct_ctx(self, tp, cname, approxname, named_ptr=None): type_index = self._typesdict[tp] reason_for_not_expanding = None flags = [] if isinstance(tp, model.UnionType): flags.append("_CFFI_F_UNION") if tp.fldtypes is None: flags.append("_CFFI_F_OPAQUE") reason_for_not_expanding = "opaque" if (tp not in self.ffi._parser._included_declarations and (named_ptr is None or named_ptr not in self.ffi._parser._included_declarations)): if tp.fldtypes is None: pass # opaque elif tp.partial or any(tp.anonymous_struct_fields()): pass # field layout obtained silently from the C compiler else: flags.append("_CFFI_F_CHECK_FIELDS") if tp.packed: flags.append("_CFFI_F_PACKED") else: flags.append("_CFFI_F_EXTERNAL") reason_for_not_expanding = "external" flags = '|'.join(flags) or '0' c_fields = [] if reason_for_not_expanding is None: expand_anonymous_struct_union = not self.target_is_python enumfields = list(tp.enumfields(expand_anonymous_struct_union)) for fldname, fldtype, fbitsize, fqual in enumfields: fldtype = self._field_type(tp, fldname, fldtype) self._check_not_opaque(fldtype, "field '%s.%s'" % (tp.name, fldname)) # cname is None for _add_missing_struct_unions() only op = OP_NOOP if fbitsize >= 0: op = OP_BITFIELD size = '%d /* bits */' % fbitsize elif cname is None or ( isinstance(fldtype, model.ArrayType) and fldtype.length is None): size = '(size_t)-1' else: size = 'sizeof(((%s)0)->%s)' % ( tp.get_c_name('*') if named_ptr is None else named_ptr.name, fldname) if cname is None or fbitsize >= 0: offset = '(size_t)-1' elif named_ptr is not None: offset = '((char *)&((%s)0)->%s) - (char *)0' % ( named_ptr.name, fldname) else: offset = 'offsetof(%s, %s)' % (tp.get_c_name(''), fldname) c_fields.append( FieldExpr(fldname, offset, size, fbitsize, CffiOp(op, self._typesdict[fldtype]))) first_field_index = len(self._lsts["field"]) self._lsts["field"].extend(c_fields) # if cname is None: # unknown name, for _add_missing_struct_unions size = '(size_t)-2' align = -2 comment = "unnamed" else: if named_ptr is not None: size = 'sizeof(*(%s)0)' % (named_ptr.name,) align = '-1 /* unknown alignment */' else: size = 'sizeof(%s)' % (cname,) align = 'offsetof(struct _cffi_align_%s, y)' % (approxname,) comment = None else: size = '(size_t)-1' align = -1 first_field_index = -1 comment = reason_for_not_expanding self._lsts["struct_union"].append( StructUnionExpr(tp.name, type_index, flags, size, align, comment, first_field_index, c_fields)) self._seen_struct_unions.add(tp) def _check_not_opaque(self, tp, location): while isinstance(tp, model.ArrayType): tp = tp.item if isinstance(tp, model.StructOrUnion) and tp.fldtypes is None: raise TypeError( "%s is of an opaque type (not declared in cdef())" % location) def _add_missing_struct_unions(self): # not very nice, but some struct declarations might be missing # because they don't have any known C name. Check that they are # not partial (we can't complete or verify them!) and emit them # anonymously. lst = list(self._struct_unions.items()) lst.sort(key=lambda tp_order: tp_order[1]) for tp, order in lst: if tp not in self._seen_struct_unions: if tp.partial: raise NotImplementedError("internal inconsistency: %r is " "partial but was not seen at " "this point" % (tp,)) if tp.name.startswith('$') and tp.name[1:].isdigit(): approxname = tp.name[1:] elif tp.name == '_IO_FILE' and tp.forcename == 'FILE': approxname = 'FILE' self._typedef_ctx(tp, 'FILE') else: raise NotImplementedError("internal inconsistency: %r" % (tp,)) self._struct_ctx(tp, None, approxname) def _generate_cpy_struct_collecttype(self, tp, name): self._struct_collecttype(tp) _generate_cpy_union_collecttype = _generate_cpy_struct_collecttype def _struct_names(self, tp): cname = tp.get_c_name('') if ' ' in cname: return cname, cname.replace(' ', '_') else: return cname, '_' + cname def _generate_cpy_struct_decl(self, tp, name): self._struct_decl(tp, *self._struct_names(tp)) _generate_cpy_union_decl = _generate_cpy_struct_decl def _generate_cpy_struct_ctx(self, tp, name): self._struct_ctx(tp, *self._struct_names(tp)) _generate_cpy_union_ctx = _generate_cpy_struct_ctx # ---------- # 'anonymous' declarations. These are produced for anonymous structs # or unions; the 'name' is obtained by a typedef. def _generate_cpy_anonymous_collecttype(self, tp, name): if isinstance(tp, model.EnumType): self._generate_cpy_enum_collecttype(tp, name) else: self._struct_collecttype(tp) def _generate_cpy_anonymous_decl(self, tp, name): if isinstance(tp, model.EnumType): self._generate_cpy_enum_decl(tp) else: self._struct_decl(tp, name, 'typedef_' + name) def _generate_cpy_anonymous_ctx(self, tp, name): if isinstance(tp, model.EnumType): self._enum_ctx(tp, name) else: self._struct_ctx(tp, name, 'typedef_' + name) # ---------- # constants, declared with "static const ..." def _generate_cpy_const(self, is_int, name, tp=None, category='const', check_value=None): if (category, name) in self._seen_constants: raise VerificationError( "duplicate declaration of %s '%s'" % (category, name)) self._seen_constants.add((category, name)) # prnt = self._prnt funcname = '_cffi_%s_%s' % (category, name) if is_int: prnt('static int %s(unsigned long long *o)' % funcname) prnt('{') prnt(' int n = (%s) <= 0;' % (name,)) prnt(' *o = (unsigned long long)((%s) | 0);' ' /* check that %s is an integer */' % (name, name)) if check_value is not None: if check_value > 0: check_value = '%dU' % (check_value,) prnt(' if (!_cffi_check_int(*o, n, %s))' % (check_value,)) prnt(' n |= 2;') prnt(' return n;') prnt('}') else: assert check_value is None prnt('static void %s(char *o)' % funcname) prnt('{') prnt(' *(%s)o = %s;' % (tp.get_c_name('*'), name)) prnt('}') prnt() def _generate_cpy_constant_collecttype(self, tp, name): is_int = tp.is_integer_type() if not is_int or self.target_is_python: self._do_collect_type(tp) def _generate_cpy_constant_decl(self, tp, name): is_int = tp.is_integer_type() self._generate_cpy_const(is_int, name, tp) def _generate_cpy_constant_ctx(self, tp, name): if not self.target_is_python and tp.is_integer_type(): type_op = CffiOp(OP_CONSTANT_INT, -1) else: if self.target_is_python: const_kind = OP_DLOPEN_CONST else: const_kind = OP_CONSTANT type_index = self._typesdict[tp] type_op = CffiOp(const_kind, type_index) self._lsts["global"].append( GlobalExpr(name, '_cffi_const_%s' % name, type_op)) # ---------- # enums def _generate_cpy_enum_collecttype(self, tp, name): self._do_collect_type(tp) def _generate_cpy_enum_decl(self, tp, name=None): for enumerator in tp.enumerators: self._generate_cpy_const(True, enumerator) def _enum_ctx(self, tp, cname): type_index = self._typesdict[tp] type_op = CffiOp(OP_ENUM, -1) if self.target_is_python: tp.check_not_partial() for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues): self._lsts["global"].append( GlobalExpr(enumerator, '_cffi_const_%s' % enumerator, type_op, check_value=enumvalue)) # if cname is not None and '$' not in cname and not self.target_is_python: size = "sizeof(%s)" % cname signed = "((%s)-1) <= 0" % cname else: basetp = tp.build_baseinttype(self.ffi, []) size = self.ffi.sizeof(basetp) signed = int(int(self.ffi.cast(basetp, -1)) < 0) allenums = ",".join(tp.enumerators) self._lsts["enum"].append( EnumExpr(tp.name, type_index, size, signed, allenums)) def _generate_cpy_enum_ctx(self, tp, name): self._enum_ctx(tp, tp._get_c_name()) # ---------- # macros: for now only for integers def _generate_cpy_macro_collecttype(self, tp, name): pass def _generate_cpy_macro_decl(self, tp, name): if tp == '...': check_value = None else: check_value = tp # an integer self._generate_cpy_const(True, name, check_value=check_value) def _generate_cpy_macro_ctx(self, tp, name): if tp == '...': if self.target_is_python: raise VerificationError( "cannot use the syntax '...' in '#define %s ...' when " "using the ABI mode" % (name,)) check_value = None else: check_value = tp # an integer type_op = CffiOp(OP_CONSTANT_INT, -1) self._lsts["global"].append( GlobalExpr(name, '_cffi_const_%s' % name, type_op, check_value=check_value)) # ---------- # global variables def _global_type(self, tp, global_name): if isinstance(tp, model.ArrayType): actual_length = tp.length if actual_length == '...': actual_length = '_cffi_array_len(%s)' % (global_name,) tp_item = self._global_type(tp.item, '%s[0]' % global_name) tp = model.ArrayType(tp_item, actual_length) return tp def _generate_cpy_variable_collecttype(self, tp, name): self._do_collect_type(self._global_type(tp, name)) def _generate_cpy_variable_decl(self, tp, name): prnt = self._prnt tp = self._global_type(tp, name) if isinstance(tp, model.ArrayType) and tp.length is None: tp = tp.item ampersand = '' else: ampersand = '&' # This code assumes that casts from "tp *" to "void *" is a # no-op, i.e. a function that returns a "tp *" can be called # as if it returned a "void *". This should be generally true # on any modern machine. The only exception to that rule (on # uncommon architectures, and as far as I can tell) might be # if 'tp' were a function type, but that is not possible here. # (If 'tp' is a function _pointer_ type, then casts from "fn_t # **" to "void *" are again no-ops, as far as I can tell.) decl = '*_cffi_var_%s(void)' % (name,) prnt('static ' + tp.get_c_name(decl, quals=self._current_quals)) prnt('{') prnt(' return %s(%s);' % (ampersand, name)) prnt('}') prnt() def _generate_cpy_variable_ctx(self, tp, name): tp = self._global_type(tp, name) type_index = self._typesdict[tp] if self.target_is_python: op = OP_GLOBAL_VAR else: op = OP_GLOBAL_VAR_F self._lsts["global"].append( GlobalExpr(name, '_cffi_var_%s' % name, CffiOp(op, type_index))) # ---------- # extern "Python" def _generate_cpy_extern_python_collecttype(self, tp, name): assert isinstance(tp, model.FunctionPtrType) self._do_collect_type(tp) _generate_cpy_dllexport_python_collecttype = \ _generate_cpy_extern_python_plus_c_collecttype = \ _generate_cpy_extern_python_collecttype def _extern_python_decl(self, tp, name, tag_and_space): prnt = self._prnt if isinstance(tp.result, model.VoidType): size_of_result = '0' else: context = 'result of %s' % name size_of_result = '(int)sizeof(%s)' % ( tp.result.get_c_name('', context),) prnt('static struct _cffi_externpy_s _cffi_externpy__%s =' % name) prnt(' { "%s.%s", %s };' % (self.module_name, name, size_of_result)) prnt() # arguments = [] context = 'argument of %s' % name for i, type in enumerate(tp.args): arg = type.get_c_name(' a%d' % i, context) arguments.append(arg) # repr_arguments = ', '.join(arguments) repr_arguments = repr_arguments or 'void' name_and_arguments = '%s(%s)' % (name, repr_arguments) if tp.abi == "__stdcall": name_and_arguments = '_cffi_stdcall ' + name_and_arguments # def may_need_128_bits(tp): return (isinstance(tp, model.PrimitiveType) and tp.name == 'long double') # size_of_a = max(len(tp.args)*8, 8) if may_need_128_bits(tp.result): size_of_a = max(size_of_a, 16) if isinstance(tp.result, model.StructOrUnion): size_of_a = 'sizeof(%s) > %d ? sizeof(%s) : %d' % ( tp.result.get_c_name(''), size_of_a, tp.result.get_c_name(''), size_of_a) prnt('%s%s' % (tag_and_space, tp.result.get_c_name(name_and_arguments))) prnt('{') prnt(' char a[%s];' % size_of_a) prnt(' char *p = a;') for i, type in enumerate(tp.args): arg = 'a%d' % i if (isinstance(type, model.StructOrUnion) or may_need_128_bits(type)): arg = '&' + arg type = model.PointerType(type) prnt(' *(%s)(p + %d) = %s;' % (type.get_c_name('*'), i*8, arg)) prnt(' _cffi_call_python(&_cffi_externpy__%s, p);' % name) if not isinstance(tp.result, model.VoidType): prnt(' return *(%s)p;' % (tp.result.get_c_name('*'),)) prnt('}') prnt() self._num_externpy += 1 def _generate_cpy_extern_python_decl(self, tp, name): self._extern_python_decl(tp, name, 'static ') def _generate_cpy_dllexport_python_decl(self, tp, name): self._extern_python_decl(tp, name, 'CFFI_DLLEXPORT ') def _generate_cpy_extern_python_plus_c_decl(self, tp, name): self._extern_python_decl(tp, name, '') def _generate_cpy_extern_python_ctx(self, tp, name): if self.target_is_python: raise VerificationError( "cannot use 'extern \"Python\"' in the ABI mode") if tp.ellipsis: raise NotImplementedError("a vararg function is extern \"Python\"") type_index = self._typesdict[tp] type_op = CffiOp(OP_EXTERN_PYTHON, type_index) self._lsts["global"].append( GlobalExpr(name, '&_cffi_externpy__%s' % name, type_op, name)) _generate_cpy_dllexport_python_ctx = \ _generate_cpy_extern_python_plus_c_ctx = \ _generate_cpy_extern_python_ctx def _print_string_literal_in_array(self, s): prnt = self._prnt prnt('// # NB. this is not a string because of a size limit in MSVC') for line in s.splitlines(True): prnt(('// ' + line).rstrip()) printed_line = '' for c in line: if len(printed_line) >= 76: prnt(printed_line) printed_line = '' printed_line += '%d,' % (ord(c),) prnt(printed_line) # ---------- # emitting the opcodes for individual types def _emit_bytecode_VoidType(self, tp, index): self.cffi_types[index] = CffiOp(OP_PRIMITIVE, PRIM_VOID) def _emit_bytecode_PrimitiveType(self, tp, index): prim_index = PRIMITIVE_TO_INDEX[tp.name] self.cffi_types[index] = CffiOp(OP_PRIMITIVE, prim_index) def _emit_bytecode_UnknownIntegerType(self, tp, index): s = ('_cffi_prim_int(sizeof(%s), (\n' ' ((%s)-1) | 0 /* check that %s is an integer type */\n' ' ) <= 0)' % (tp.name, tp.name, tp.name)) self.cffi_types[index] = CffiOp(OP_PRIMITIVE, s) def _emit_bytecode_UnknownFloatType(self, tp, index): s = ('_cffi_prim_float(sizeof(%s) *\n' ' (((%s)1) / 2) * 2 /* integer => 0, float => 1 */\n' ' )' % (tp.name, tp.name)) self.cffi_types[index] = CffiOp(OP_PRIMITIVE, s) def _emit_bytecode_RawFunctionType(self, tp, index): self.cffi_types[index] = CffiOp(OP_FUNCTION, self._typesdict[tp.result]) index += 1 for tp1 in tp.args: realindex = self._typesdict[tp1] if index != realindex: if isinstance(tp1, model.PrimitiveType): self._emit_bytecode_PrimitiveType(tp1, index) else: self.cffi_types[index] = CffiOp(OP_NOOP, realindex) index += 1 flags = int(tp.ellipsis) if tp.abi is not None: if tp.abi == '__stdcall': flags |= 2 else: raise NotImplementedError("abi=%r" % (tp.abi,)) self.cffi_types[index] = CffiOp(OP_FUNCTION_END, flags) def _emit_bytecode_PointerType(self, tp, index): self.cffi_types[index] = CffiOp(OP_POINTER, self._typesdict[tp.totype]) _emit_bytecode_ConstPointerType = _emit_bytecode_PointerType _emit_bytecode_NamedPointerType = _emit_bytecode_PointerType def _emit_bytecode_FunctionPtrType(self, tp, index): raw = tp.as_raw_function() self.cffi_types[index] = CffiOp(OP_POINTER, self._typesdict[raw]) def _emit_bytecode_ArrayType(self, tp, index): item_index = self._typesdict[tp.item] if tp.length is None: self.cffi_types[index] = CffiOp(OP_OPEN_ARRAY, item_index) elif tp.length == '...': raise VerificationError( "type %s badly placed: the '...' array length can only be " "used on global arrays or on fields of structures" % ( str(tp).replace('/*...*/', '...'),)) else: assert self.cffi_types[index + 1] == 'LEN' self.cffi_types[index] = CffiOp(OP_ARRAY, item_index) self.cffi_types[index + 1] = CffiOp(None, str(tp.length)) def _emit_bytecode_StructType(self, tp, index): struct_index = self._struct_unions[tp] self.cffi_types[index] = CffiOp(OP_STRUCT_UNION, struct_index) _emit_bytecode_UnionType = _emit_bytecode_StructType def _emit_bytecode_EnumType(self, tp, index): enum_index = self._enums[tp] self.cffi_types[index] = CffiOp(OP_ENUM, enum_index) if sys.version_info >= (3,): NativeIO = io.StringIO else: class NativeIO(io.BytesIO): def write(self, s): if isinstance(s, unicode): s = s.encode('ascii') super(NativeIO, self).write(s) def _make_c_or_py_source(ffi, module_name, preamble, target_file, verbose): if verbose: print("generating %s" % (target_file,)) recompiler = Recompiler(ffi, module_name, target_is_python=(preamble is None)) recompiler.collect_type_table() recompiler.collect_step_tables() f = NativeIO() recompiler.write_source_to_f(f, preamble) output = f.getvalue() try: with open(target_file, 'r') as f1: if f1.read(len(output) + 1) != output: raise IOError if verbose: print("(already up-to-date)") return False # already up-to-date except IOError: tmp_file = '%s.~%d' % (target_file, os.getpid()) with open(tmp_file, 'w') as f1: f1.write(output) try: os.rename(tmp_file, target_file) except OSError: os.unlink(target_file) os.rename(tmp_file, target_file) return True def make_c_source(ffi, module_name, preamble, target_c_file, verbose=False): assert preamble is not None return _make_c_or_py_source(ffi, module_name, preamble, target_c_file, verbose) def make_py_source(ffi, module_name, target_py_file, verbose=False): return _make_c_or_py_source(ffi, module_name, None, target_py_file, verbose) def _modname_to_file(outputdir, modname, extension): parts = modname.split('.') try: os.makedirs(os.path.join(outputdir, *parts[:-1])) except OSError: pass parts[-1] += extension return os.path.join(outputdir, *parts), parts # Aaargh. Distutils is not tested at all for the purpose of compiling # DLLs that are not extension modules. Here are some hacks to work # around that, in the _patch_for_*() functions... def _patch_meth(patchlist, cls, name, new_meth): old = getattr(cls, name) patchlist.append((cls, name, old)) setattr(cls, name, new_meth) return old def _unpatch_meths(patchlist): for cls, name, old_meth in reversed(patchlist): setattr(cls, name, old_meth) def _patch_for_embedding(patchlist): if sys.platform == 'win32': # we must not remove the manifest when building for embedding! from distutils.msvc9compiler import MSVCCompiler _patch_meth(patchlist, MSVCCompiler, '_remove_visual_c_ref', lambda self, manifest_file: manifest_file) if sys.platform == 'darwin': # we must not make a '-bundle', but a '-dynamiclib' instead from distutils.ccompiler import CCompiler def my_link_shared_object(self, *args, **kwds): if '-bundle' in self.linker_so: self.linker_so = list(self.linker_so) i = self.linker_so.index('-bundle') self.linker_so[i] = '-dynamiclib' return old_link_shared_object(self, *args, **kwds) old_link_shared_object = _patch_meth(patchlist, CCompiler, 'link_shared_object', my_link_shared_object) def _patch_for_target(patchlist, target): from distutils.command.build_ext import build_ext # if 'target' is different from '*', we need to patch some internal # method to just return this 'target' value, instead of having it # built from module_name if target.endswith('.*'): target = target[:-2] if sys.platform == 'win32': target += '.dll' elif sys.platform == 'darwin': target += '.dylib' else: target += '.so' _patch_meth(patchlist, build_ext, 'get_ext_filename', lambda self, ext_name: target) def recompile(ffi, module_name, preamble, tmpdir='.', call_c_compiler=True, c_file=None, source_extension='.c', extradir=None, compiler_verbose=1, target=None, debug=None, **kwds): if not isinstance(module_name, str): module_name = module_name.encode('ascii') if ffi._windows_unicode: ffi._apply_windows_unicode(kwds) if preamble is not None: embedding = (ffi._embedding is not None) if embedding: ffi._apply_embedding_fix(kwds) if c_file is None: c_file, parts = _modname_to_file(tmpdir, module_name, source_extension) if extradir: parts = [extradir] + parts ext_c_file = os.path.join(*parts) else: ext_c_file = c_file # if target is None: if embedding: target = '%s.*' % module_name else: target = '*' # ext = ffiplatform.get_extension(ext_c_file, module_name, **kwds) updated = make_c_source(ffi, module_name, preamble, c_file, verbose=compiler_verbose) if call_c_compiler: patchlist = [] cwd = os.getcwd() try: if embedding: _patch_for_embedding(patchlist) if target != '*': _patch_for_target(patchlist, target) if compiler_verbose: if tmpdir == '.': msg = 'the current directory is' else: msg = 'setting the current directory to' print('%s %r' % (msg, os.path.abspath(tmpdir))) os.chdir(tmpdir) outputfilename = ffiplatform.compile('.', ext, compiler_verbose, debug) finally: os.chdir(cwd) _unpatch_meths(patchlist) return outputfilename else: return ext, updated else: if c_file is None: c_file, _ = _modname_to_file(tmpdir, module_name, '.py') updated = make_py_source(ffi, module_name, c_file, verbose=compiler_verbose) if call_c_compiler: return c_file else: return None, updated def _verify(ffi, module_name, preamble, *args, **kwds): # FOR TESTS ONLY from testing.udir import udir import imp assert module_name not in sys.modules, "module name conflict: %r" % ( module_name,) kwds.setdefault('tmpdir', str(udir)) outputfilename = recompile(ffi, module_name, preamble, *args, **kwds) module = imp.load_dynamic(module_name, outputfilename) # # hack hack hack: copy all *bound methods* from module.ffi back to the # ffi instance. Then calls like ffi.new() will invoke module.ffi.new(). for name in dir(module.ffi): if not name.startswith('_'): attr = getattr(module.ffi, name) if attr is not getattr(ffi, name, object()): setattr(ffi, name, attr) def typeof_disabled(*args, **kwds): raise NotImplementedError ffi._typeof = typeof_disabled for name in dir(ffi): if not name.startswith('_') and not hasattr(module.ffi, name): setattr(ffi, name, NotImplemented) return module.lib PK %�\x�ޏ0T 0T model.pynu �[��� import types import weakref from .lock import allocate_lock from .error import CDefError, VerificationError, VerificationMissing # type qualifiers Q_CONST = 0x01 Q_RESTRICT = 0x02 Q_VOLATILE = 0x04 def qualify(quals, replace_with): if quals & Q_CONST: replace_with = ' const ' + replace_with.lstrip() if quals & Q_VOLATILE: replace_with = ' volatile ' + replace_with.lstrip() if quals & Q_RESTRICT: # It seems that __restrict is supported by gcc and msvc. # If you hit some different compiler, add a #define in # _cffi_include.h for it (and in its copies, documented there) replace_with = ' __restrict ' + replace_with.lstrip() return replace_with class BaseTypeByIdentity(object): is_array_type = False is_raw_function = False def get_c_name(self, replace_with='', context='a C file', quals=0): result = self.c_name_with_marker assert result.count('&') == 1 # some logic duplication with ffi.getctype()... :-( replace_with = replace_with.strip() if replace_with: if replace_with.startswith('*') and '&[' in result: replace_with = '(%s)' % replace_with elif not replace_with[0] in '[(': replace_with = ' ' + replace_with replace_with = qualify(quals, replace_with) result = result.replace('&', replace_with) if '$' in result: raise VerificationError( "cannot generate '%s' in %s: unknown type name" % (self._get_c_name(), context)) return result def _get_c_name(self): return self.c_name_with_marker.replace('&', '') def has_c_name(self): return '$' not in self._get_c_name() def is_integer_type(self): return False def get_cached_btype(self, ffi, finishlist, can_delay=False): try: BType = ffi._cached_btypes[self] except KeyError: BType = self.build_backend_type(ffi, finishlist) BType2 = ffi._cached_btypes.setdefault(self, BType) assert BType2 is BType return BType def __repr__(self): return '<%s>' % (self._get_c_name(),) def _get_items(self): return [(name, getattr(self, name)) for name in self._attrs_] class BaseType(BaseTypeByIdentity): def __eq__(self, other): return (self.__class__ == other.__class__ and self._get_items() == other._get_items()) def __ne__(self, other): return not self == other def __hash__(self): return hash((self.__class__, tuple(self._get_items()))) class VoidType(BaseType): _attrs_ = () def __init__(self): self.c_name_with_marker = 'void&' def build_backend_type(self, ffi, finishlist): return global_cache(self, ffi, 'new_void_type') void_type = VoidType() class BasePrimitiveType(BaseType): def is_complex_type(self): return False class PrimitiveType(BasePrimitiveType): _attrs_ = ('name',) ALL_PRIMITIVE_TYPES = { 'char': 'c', 'short': 'i', 'int': 'i', 'long': 'i', 'long long': 'i', 'signed char': 'i', 'unsigned char': 'i', 'unsigned short': 'i', 'unsigned int': 'i', 'unsigned long': 'i', 'unsigned long long': 'i', 'float': 'f', 'double': 'f', 'long double': 'f', 'float _Complex': 'j', 'double _Complex': 'j', '_Bool': 'i', # the following types are not primitive in the C sense 'wchar_t': 'c', 'char16_t': 'c', 'char32_t': 'c', 'int8_t': 'i', 'uint8_t': 'i', 'int16_t': 'i', 'uint16_t': 'i', 'int32_t': 'i', 'uint32_t': 'i', 'int64_t': 'i', 'uint64_t': 'i', 'int_least8_t': 'i', 'uint_least8_t': 'i', 'int_least16_t': 'i', 'uint_least16_t': 'i', 'int_least32_t': 'i', 'uint_least32_t': 'i', 'int_least64_t': 'i', 'uint_least64_t': 'i', 'int_fast8_t': 'i', 'uint_fast8_t': 'i', 'int_fast16_t': 'i', 'uint_fast16_t': 'i', 'int_fast32_t': 'i', 'uint_fast32_t': 'i', 'int_fast64_t': 'i', 'uint_fast64_t': 'i', 'intptr_t': 'i', 'uintptr_t': 'i', 'intmax_t': 'i', 'uintmax_t': 'i', 'ptrdiff_t': 'i', 'size_t': 'i', 'ssize_t': 'i', } def __init__(self, name): assert name in self.ALL_PRIMITIVE_TYPES self.name = name self.c_name_with_marker = name + '&' def is_char_type(self): return self.ALL_PRIMITIVE_TYPES[self.name] == 'c' def is_integer_type(self): return self.ALL_PRIMITIVE_TYPES[self.name] == 'i' def is_float_type(self): return self.ALL_PRIMITIVE_TYPES[self.name] == 'f' def is_complex_type(self): return self.ALL_PRIMITIVE_TYPES[self.name] == 'j' def build_backend_type(self, ffi, finishlist): return global_cache(self, ffi, 'new_primitive_type', self.name) class UnknownIntegerType(BasePrimitiveType): _attrs_ = ('name',) def __init__(self, name): self.name = name self.c_name_with_marker = name + '&' def is_integer_type(self): return True def build_backend_type(self, ffi, finishlist): raise NotImplementedError("integer type '%s' can only be used after " "compilation" % self.name) class UnknownFloatType(BasePrimitiveType): _attrs_ = ('name', ) def __init__(self, name): self.name = name self.c_name_with_marker = name + '&' def build_backend_type(self, ffi, finishlist): raise NotImplementedError("float type '%s' can only be used after " "compilation" % self.name) class BaseFunctionType(BaseType): _attrs_ = ('args', 'result', 'ellipsis', 'abi') def __init__(self, args, result, ellipsis, abi=None): self.args = args self.result = result self.ellipsis = ellipsis self.abi = abi # reprargs = [arg._get_c_name() for arg in self.args] if self.ellipsis: reprargs.append('...') reprargs = reprargs or ['void'] replace_with = self._base_pattern % (', '.join(reprargs),) if abi is not None: replace_with = replace_with[:1] + abi + ' ' + replace_with[1:] self.c_name_with_marker = ( self.result.c_name_with_marker.replace('&', replace_with)) class RawFunctionType(BaseFunctionType): # Corresponds to a C type like 'int(int)', which is the C type of # a function, but not a pointer-to-function. The backend has no # notion of such a type; it's used temporarily by parsing. _base_pattern = '(&)(%s)' is_raw_function = True def build_backend_type(self, ffi, finishlist): raise CDefError("cannot render the type %r: it is a function " "type, not a pointer-to-function type" % (self,)) def as_function_pointer(self): return FunctionPtrType(self.args, self.result, self.ellipsis, self.abi) class FunctionPtrType(BaseFunctionType): _base_pattern = '(*&)(%s)' def build_backend_type(self, ffi, finishlist): result = self.result.get_cached_btype(ffi, finishlist) args = [] for tp in self.args: args.append(tp.get_cached_btype(ffi, finishlist)) abi_args = () if self.abi == "__stdcall": if not self.ellipsis: # __stdcall ignored for variadic funcs try: abi_args = (ffi._backend.FFI_STDCALL,) except AttributeError: pass return global_cache(self, ffi, 'new_function_type', tuple(args), result, self.ellipsis, *abi_args) def as_raw_function(self): return RawFunctionType(self.args, self.result, self.ellipsis, self.abi) class PointerType(BaseType): _attrs_ = ('totype', 'quals') def __init__(self, totype, quals=0): self.totype = totype self.quals = quals extra = qualify(quals, " *&") if totype.is_array_type: extra = "(%s)" % (extra.lstrip(),) self.c_name_with_marker = totype.c_name_with_marker.replace('&', extra) def build_backend_type(self, ffi, finishlist): BItem = self.totype.get_cached_btype(ffi, finishlist, can_delay=True) return global_cache(self, ffi, 'new_pointer_type', BItem) voidp_type = PointerType(void_type) def ConstPointerType(totype): return PointerType(totype, Q_CONST) const_voidp_type = ConstPointerType(void_type) class NamedPointerType(PointerType): _attrs_ = ('totype', 'name') def __init__(self, totype, name, quals=0): PointerType.__init__(self, totype, quals) self.name = name self.c_name_with_marker = name + '&' class ArrayType(BaseType): _attrs_ = ('item', 'length') is_array_type = True def __init__(self, item, length): self.item = item self.length = length # if length is None: brackets = '&[]' elif length == '...': brackets = '&[/*...*/]' else: brackets = '&[%s]' % length self.c_name_with_marker = ( self.item.c_name_with_marker.replace('&', brackets)) def resolve_length(self, newlength): return ArrayType(self.item, newlength) def build_backend_type(self, ffi, finishlist): if self.length == '...': raise CDefError("cannot render the type %r: unknown length" % (self,)) self.item.get_cached_btype(ffi, finishlist) # force the item BType BPtrItem = PointerType(self.item).get_cached_btype(ffi, finishlist) return global_cache(self, ffi, 'new_array_type', BPtrItem, self.length) char_array_type = ArrayType(PrimitiveType('char'), None) class StructOrUnionOrEnum(BaseTypeByIdentity): _attrs_ = ('name',) forcename = None def build_c_name_with_marker(self): name = self.forcename or '%s %s' % (self.kind, self.name) self.c_name_with_marker = name + '&' def force_the_name(self, forcename): self.forcename = forcename self.build_c_name_with_marker() def get_official_name(self): assert self.c_name_with_marker.endswith('&') return self.c_name_with_marker[:-1] class StructOrUnion(StructOrUnionOrEnum): fixedlayout = None completed = 0 partial = False packed = False def __init__(self, name, fldnames, fldtypes, fldbitsize, fldquals=None): self.name = name self.fldnames = fldnames self.fldtypes = fldtypes self.fldbitsize = fldbitsize self.fldquals = fldquals self.build_c_name_with_marker() def anonymous_struct_fields(self): if self.fldtypes is not None: for name, type in zip(self.fldnames, self.fldtypes): if name == '' and isinstance(type, StructOrUnion): yield type def enumfields(self, expand_anonymous_struct_union=True): fldquals = self.fldquals if fldquals is None: fldquals = (0,) * len(self.fldnames) for name, type, bitsize, quals in zip(self.fldnames, self.fldtypes, self.fldbitsize, fldquals): if (name == '' and isinstance(type, StructOrUnion) and expand_anonymous_struct_union): # nested anonymous struct/union for result in type.enumfields(): yield result else: yield (name, type, bitsize, quals) def force_flatten(self): # force the struct or union to have a declaration that lists # directly all fields returned by enumfields(), flattening # nested anonymous structs/unions. names = [] types = [] bitsizes = [] fldquals = [] for name, type, bitsize, quals in self.enumfields(): names.append(name) types.append(type) bitsizes.append(bitsize) fldquals.append(quals) self.fldnames = tuple(names) self.fldtypes = tuple(types) self.fldbitsize = tuple(bitsizes) self.fldquals = tuple(fldquals) def get_cached_btype(self, ffi, finishlist, can_delay=False): BType = StructOrUnionOrEnum.get_cached_btype(self, ffi, finishlist, can_delay) if not can_delay: self.finish_backend_type(ffi, finishlist) return BType def finish_backend_type(self, ffi, finishlist): if self.completed: if self.completed != 2: raise NotImplementedError("recursive structure declaration " "for '%s'" % (self.name,)) return BType = ffi._cached_btypes[self] # self.completed = 1 # if self.fldtypes is None: pass # not completing it: it's an opaque struct # elif self.fixedlayout is None: fldtypes = [tp.get_cached_btype(ffi, finishlist) for tp in self.fldtypes] lst = list(zip(self.fldnames, fldtypes, self.fldbitsize)) sflags = 0 if self.packed: sflags = 8 # SF_PACKED ffi._backend.complete_struct_or_union(BType, lst, self, -1, -1, sflags) # else: fldtypes = [] fieldofs, fieldsize, totalsize, totalalignment = self.fixedlayout for i in range(len(self.fldnames)): fsize = fieldsize[i] ftype = self.fldtypes[i] # if isinstance(ftype, ArrayType) and ftype.length == '...': # fix the length to match the total size BItemType = ftype.item.get_cached_btype(ffi, finishlist) nlen, nrest = divmod(fsize, ffi.sizeof(BItemType)) if nrest != 0: self._verification_error( "field '%s.%s' has a bogus size?" % ( self.name, self.fldnames[i] or '{}')) ftype = ftype.resolve_length(nlen) self.fldtypes = (self.fldtypes[:i] + (ftype,) + self.fldtypes[i+1:]) # BFieldType = ftype.get_cached_btype(ffi, finishlist) if isinstance(ftype, ArrayType) and ftype.length is None: assert fsize == 0 else: bitemsize = ffi.sizeof(BFieldType) if bitemsize != fsize: self._verification_error( "field '%s.%s' is declared as %d bytes, but is " "really %d bytes" % (self.name, self.fldnames[i] or '{}', bitemsize, fsize)) fldtypes.append(BFieldType) # lst = list(zip(self.fldnames, fldtypes, self.fldbitsize, fieldofs)) ffi._backend.complete_struct_or_union(BType, lst, self, totalsize, totalalignment) self.completed = 2 def _verification_error(self, msg): raise VerificationError(msg) def check_not_partial(self): if self.partial and self.fixedlayout is None: raise VerificationMissing(self._get_c_name()) def build_backend_type(self, ffi, finishlist): self.check_not_partial() finishlist.append(self) # return global_cache(self, ffi, 'new_%s_type' % self.kind, self.get_official_name(), key=self) class StructType(StructOrUnion): kind = 'struct' class UnionType(StructOrUnion): kind = 'union' class EnumType(StructOrUnionOrEnum): kind = 'enum' partial = False partial_resolved = False def __init__(self, name, enumerators, enumvalues, baseinttype=None): self.name = name self.enumerators = enumerators self.enumvalues = enumvalues self.baseinttype = baseinttype self.build_c_name_with_marker() def force_the_name(self, forcename): StructOrUnionOrEnum.force_the_name(self, forcename) if self.forcename is None: name = self.get_official_name() self.forcename = '$' + name.replace(' ', '_') def check_not_partial(self): if self.partial and not self.partial_resolved: raise VerificationMissing(self._get_c_name()) def build_backend_type(self, ffi, finishlist): self.check_not_partial() base_btype = self.build_baseinttype(ffi, finishlist) return global_cache(self, ffi, 'new_enum_type', self.get_official_name(), self.enumerators, self.enumvalues, base_btype, key=self) def build_baseinttype(self, ffi, finishlist): if self.baseinttype is not None: return self.baseinttype.get_cached_btype(ffi, finishlist) # if self.enumvalues: smallest_value = min(self.enumvalues) largest_value = max(self.enumvalues) else: import warnings try: # XXX! The goal is to ensure that the warnings.warn() # will not suppress the warning. We want to get it # several times if we reach this point several times. __warningregistry__.clear() except NameError: pass warnings.warn("%r has no values explicitly defined; " "guessing that it is equivalent to 'unsigned int'" % self._get_c_name()) smallest_value = largest_value = 0 if smallest_value < 0: # needs a signed type sign = 1 candidate1 = PrimitiveType("int") candidate2 = PrimitiveType("long") else: sign = 0 candidate1 = PrimitiveType("unsigned int") candidate2 = PrimitiveType("unsigned long") btype1 = candidate1.get_cached_btype(ffi, finishlist) btype2 = candidate2.get_cached_btype(ffi, finishlist) size1 = ffi.sizeof(btype1) size2 = ffi.sizeof(btype2) if (smallest_value >= ((-1) << (8*size1-1)) and largest_value < (1 << (8*size1-sign))): return btype1 if (smallest_value >= ((-1) << (8*size2-1)) and largest_value < (1 << (8*size2-sign))): return btype2 raise CDefError("%s values don't all fit into either 'long' " "or 'unsigned long'" % self._get_c_name()) def unknown_type(name, structname=None): if structname is None: structname = '$%s' % name tp = StructType(structname, None, None, None) tp.force_the_name(name) tp.origin = "unknown_type" return tp def unknown_ptr_type(name, structname=None): if structname is None: structname = '$$%s' % name tp = StructType(structname, None, None, None) return NamedPointerType(tp, name) global_lock = allocate_lock() _typecache_cffi_backend = weakref.WeakValueDictionary() def get_typecache(backend): # returns _typecache_cffi_backend if backend is the _cffi_backend # module, or type(backend).__typecache if backend is an instance of # CTypesBackend (or some FakeBackend class during tests) if isinstance(backend, types.ModuleType): return _typecache_cffi_backend with global_lock: if not hasattr(type(backend), '__typecache'): type(backend).__typecache = weakref.WeakValueDictionary() return type(backend).__typecache def global_cache(srctype, ffi, funcname, *args, **kwds): key = kwds.pop('key', (funcname, args)) assert not kwds try: return ffi._typecache[key] except KeyError: pass try: res = getattr(ffi._backend, funcname)(*args) except NotImplementedError as e: raise NotImplementedError("%s: %r: %s" % (funcname, srctype, e)) # note that setdefault() on WeakValueDictionary is not atomic # and contains a rare bug (http://bugs.python.org/issue19542); # we have to use a lock and do it ourselves cache = ffi._typecache with global_lock: res1 = cache.get(key) if res1 is None: cache[key] = res return res else: return res1 def pointer_cache(ffi, BType): return global_cache('?', ffi, 'new_pointer_type', BType) def attach_exception_info(e, name): if e.args and type(e.args[0]) is str: e.args = ('%s: %s' % (name, e.args[0]),) + e.args[1:] PK %�\� f�\ \ cffi_opcode.pynu �[��� from .error import VerificationError class CffiOp(object): def __init__(self, op, arg): self.op = op self.arg = arg def as_c_expr(self): if self.op is None: assert isinstance(self.arg, str) return '(_cffi_opcode_t)(%s)' % (self.arg,) classname = CLASS_NAME[self.op] return '_CFFI_OP(_CFFI_OP_%s, %s)' % (classname, self.arg) def as_python_bytes(self): if self.op is None and self.arg.isdigit(): value = int(self.arg) # non-negative: '-' not in self.arg if value >= 2**31: raise OverflowError("cannot emit %r: limited to 2**31-1" % (self.arg,)) return format_four_bytes(value) if isinstance(self.arg, str): raise VerificationError("cannot emit to Python: %r" % (self.arg,)) return format_four_bytes((self.arg << 8) | self.op) def __str__(self): classname = CLASS_NAME.get(self.op, self.op) return '(%s %s)' % (classname, self.arg) def format_four_bytes(num): return '\\x%02X\\x%02X\\x%02X\\x%02X' % ( (num >> 24) & 0xFF, (num >> 16) & 0xFF, (num >> 8) & 0xFF, (num ) & 0xFF) OP_PRIMITIVE = 1 OP_POINTER = 3 OP_ARRAY = 5 OP_OPEN_ARRAY = 7 OP_STRUCT_UNION = 9 OP_ENUM = 11 OP_FUNCTION = 13 OP_FUNCTION_END = 15 OP_NOOP = 17 OP_BITFIELD = 19 OP_TYPENAME = 21 OP_CPYTHON_BLTN_V = 23 # varargs OP_CPYTHON_BLTN_N = 25 # noargs OP_CPYTHON_BLTN_O = 27 # O (i.e. a single arg) OP_CONSTANT = 29 OP_CONSTANT_INT = 31 OP_GLOBAL_VAR = 33 OP_DLOPEN_FUNC = 35 OP_DLOPEN_CONST = 37 OP_GLOBAL_VAR_F = 39 OP_EXTERN_PYTHON = 41 PRIM_VOID = 0 PRIM_BOOL = 1 PRIM_CHAR = 2 PRIM_SCHAR = 3 PRIM_UCHAR = 4 PRIM_SHORT = 5 PRIM_USHORT = 6 PRIM_INT = 7 PRIM_UINT = 8 PRIM_LONG = 9 PRIM_ULONG = 10 PRIM_LONGLONG = 11 PRIM_ULONGLONG = 12 PRIM_FLOAT = 13 PRIM_DOUBLE = 14 PRIM_LONGDOUBLE = 15 PRIM_WCHAR = 16 PRIM_INT8 = 17 PRIM_UINT8 = 18 PRIM_INT16 = 19 PRIM_UINT16 = 20 PRIM_INT32 = 21 PRIM_UINT32 = 22 PRIM_INT64 = 23 PRIM_UINT64 = 24 PRIM_INTPTR = 25 PRIM_UINTPTR = 26 PRIM_PTRDIFF = 27 PRIM_SIZE = 28 PRIM_SSIZE = 29 PRIM_INT_LEAST8 = 30 PRIM_UINT_LEAST8 = 31 PRIM_INT_LEAST16 = 32 PRIM_UINT_LEAST16 = 33 PRIM_INT_LEAST32 = 34 PRIM_UINT_LEAST32 = 35 PRIM_INT_LEAST64 = 36 PRIM_UINT_LEAST64 = 37 PRIM_INT_FAST8 = 38 PRIM_UINT_FAST8 = 39 PRIM_INT_FAST16 = 40 PRIM_UINT_FAST16 = 41 PRIM_INT_FAST32 = 42 PRIM_UINT_FAST32 = 43 PRIM_INT_FAST64 = 44 PRIM_UINT_FAST64 = 45 PRIM_INTMAX = 46 PRIM_UINTMAX = 47 PRIM_FLOATCOMPLEX = 48 PRIM_DOUBLECOMPLEX = 49 PRIM_CHAR16 = 50 PRIM_CHAR32 = 51 _NUM_PRIM = 52 _UNKNOWN_PRIM = -1 _UNKNOWN_FLOAT_PRIM = -2 _UNKNOWN_LONG_DOUBLE = -3 _IO_FILE_STRUCT = -1 PRIMITIVE_TO_INDEX = { 'char': PRIM_CHAR, 'short': PRIM_SHORT, 'int': PRIM_INT, 'long': PRIM_LONG, 'long long': PRIM_LONGLONG, 'signed char': PRIM_SCHAR, 'unsigned char': PRIM_UCHAR, 'unsigned short': PRIM_USHORT, 'unsigned int': PRIM_UINT, 'unsigned long': PRIM_ULONG, 'unsigned long long': PRIM_ULONGLONG, 'float': PRIM_FLOAT, 'double': PRIM_DOUBLE, 'long double': PRIM_LONGDOUBLE, 'float _Complex': PRIM_FLOATCOMPLEX, 'double _Complex': PRIM_DOUBLECOMPLEX, '_Bool': PRIM_BOOL, 'wchar_t': PRIM_WCHAR, 'char16_t': PRIM_CHAR16, 'char32_t': PRIM_CHAR32, 'int8_t': PRIM_INT8, 'uint8_t': PRIM_UINT8, 'int16_t': PRIM_INT16, 'uint16_t': PRIM_UINT16, 'int32_t': PRIM_INT32, 'uint32_t': PRIM_UINT32, 'int64_t': PRIM_INT64, 'uint64_t': PRIM_UINT64, 'intptr_t': PRIM_INTPTR, 'uintptr_t': PRIM_UINTPTR, 'ptrdiff_t': PRIM_PTRDIFF, 'size_t': PRIM_SIZE, 'ssize_t': PRIM_SSIZE, 'int_least8_t': PRIM_INT_LEAST8, 'uint_least8_t': PRIM_UINT_LEAST8, 'int_least16_t': PRIM_INT_LEAST16, 'uint_least16_t': PRIM_UINT_LEAST16, 'int_least32_t': PRIM_INT_LEAST32, 'uint_least32_t': PRIM_UINT_LEAST32, 'int_least64_t': PRIM_INT_LEAST64, 'uint_least64_t': PRIM_UINT_LEAST64, 'int_fast8_t': PRIM_INT_FAST8, 'uint_fast8_t': PRIM_UINT_FAST8, 'int_fast16_t': PRIM_INT_FAST16, 'uint_fast16_t': PRIM_UINT_FAST16, 'int_fast32_t': PRIM_INT_FAST32, 'uint_fast32_t': PRIM_UINT_FAST32, 'int_fast64_t': PRIM_INT_FAST64, 'uint_fast64_t': PRIM_UINT_FAST64, 'intmax_t': PRIM_INTMAX, 'uintmax_t': PRIM_UINTMAX, } F_UNION = 0x01 F_CHECK_FIELDS = 0x02 F_PACKED = 0x04 F_EXTERNAL = 0x08 F_OPAQUE = 0x10 G_FLAGS = dict([('_CFFI_' + _key, globals()[_key]) for _key in ['F_UNION', 'F_CHECK_FIELDS', 'F_PACKED', 'F_EXTERNAL', 'F_OPAQUE']]) CLASS_NAME = {} for _name, _value in list(globals().items()): if _name.startswith('OP_') and isinstance(_value, int): CLASS_NAME[_value] = _name[3:] PK %�\˷b6� � lock.pynu �[��� import sys if sys.version_info < (3,): try: from thread import allocate_lock except ImportError: from dummy_thread import allocate_lock else: try: from _thread import allocate_lock except ImportError: from _dummy_thread import allocate_lock ##import sys ##l1 = allocate_lock ##class allocate_lock(object): ## def __init__(self): ## self._real = l1() ## def __enter__(self): ## for i in range(4, 0, -1): ## print sys._getframe(i).f_code ## print ## return self._real.__enter__() ## def __exit__(self, *args): ## return self._real.__exit__(*args) ## def acquire(self, f): ## assert f is False ## return self._real.acquire(f) PK %�\2��t� � ffiplatform.pynu �[��� PK %�\�`C�4h 4h vengine_gen.pynu �[��� PK %�\ � � � ~x __init__.pynu �[��� PK %�\��kX X �z parse_c_type.hnu �[��� PK %�\��;�f� f� .� backend_ctypes.pynu �[��� PK %�\2@�� � �6 api.pynu �[��� PK %�\��3�R� R� �� cparser.pynu �[��� PK %�\�M� � xo _cffi_errors.hnu �[��� PK %�\ �au/ u/ �~ _cffi_include.hnu �[��� PK %�\JЁ�1R 1R & F� __pycache__/vengine_gen.cpython-36.pycnu �[��� PK %�\�v�!� � & � __pycache__/error.cpython-36.opt-1.pycnu �[��� PK %�\���@� @� & � __pycache__/vengine_cpy.cpython-36.pycnu �[��� PK %�\�4� *� *� t� __pycache__/api.cpython-36.pycnu �[��� PK %�\M��Rl� l� ) � __pycache__/backend_ctypes.cpython-36.pycnu �[��� PK %�\T*�� ) �� __pycache__/setuptools_ext.cpython-36.pycnu �[��� PK %�\kRC3� 3� , � __pycache__/vengine_cpy.cpython-36.opt-1.pycnu �[��� PK %�\]XAn n & �D __pycache__/ffiplatform.cpython-36.pycnu �[��� PK %�\�Z�2� � $ qR __pycache__/api.cpython-36.opt-1.pycnu �[��� PK %�\�H��L L �� __pycache__/model.cpython-36.pycnu �[��� PK %�\��OC C & � __pycache__/commontypes.cpython-36.pycnu �[��� PK %�\����s s & �& __pycache__/cffi_opcode.cpython-36.pycnu �[��� PK %�\NH�k k S9 __pycache__/lock.cpython-36.pycnu �[��� PK %�\��� , ; __pycache__/commontypes.cpython-36.opt-1.pycnu �[��� PK %�\�v�!� � vB __pycache__/error.cpython-36.pycnu �[��� PK %�\d��,M� M� + �G __pycache__/recompiler.cpython-36.opt-1.pycnu �[��� PK %�\�x���O �O ( )� __pycache__/cparser.cpython-36.opt-1.pycnu �[��� PK %�\- W�G G , L __pycache__/cffi_opcode.cpython-36.opt-1.pycnu �[��� PK %�\NH�k k % �^ __pycache__/lock.cpython-36.opt-1.pycnu �[��� PK %�\ - v}� }� % �` __pycache__/recompiler.cpython-36.pycnu �[��� PK %�\B�S�Q Q , R __pycache__/vengine_gen.cpython-36.opt-1.pycnu �[��� PK %�\]XAn n , �h __pycache__/ffiplatform.cpython-36.opt-1.pycnu �[��� PK %�\��*N� � / }v __pycache__/setuptools_ext.cpython-36.opt-1.pycnu �[��� PK %�\�uU^g# g# # ͐ __pycache__/verifier.cpython-36.pycnu �[��� PK %�\( �� � # �� __pycache__/__init__.cpython-36.pycnu �[��� PK %�\�1��/� /� / �� __pycache__/backend_ctypes.cpython-36.opt-1.pycnu �[��� PK %�\�w�.P .P " Q __pycache__/cparser.cpython-36.pycnu �[��� PK %�\( �� � ) �� __pycache__/__init__.cpython-36.opt-1.pycnu �[��� PK %�\s ��iK iK & �� __pycache__/model.cpython-36.opt-1.pycnu �[��� PK %�\�~�.F# F# ) f� __pycache__/verifier.cpython-36.opt-1.pycnu �[��� PK %�\!u60� � error.pynu �[��� PK %�\ ^�ٞ> �> � _embedding.hnu �[��� PK %�\����� � �T commontypes.pynu �[��� PK %�\]H# p_ setuptools_ext.pynu �[��� PK %�\��Y��+ �+ � verifier.pynu �[��� PK %�\��N�� �� �� vengine_cpy.pynu �[��� PK %�\������ �� �M recompiler.pynu �[��� PK %�\x�ޏ0T 0T �E model.pynu �[��� PK %�\� f�\ \ N� cffi_opcode.pynu �[��� PK %�\˷b6� � � lock.pynu �[��� PK 1 1 � �
| ver. 1.4 |
Github
|
.
| PHP 8.1.34 | ���֧ߧ֧�ѧ�ڧ� ����ѧߧڧ��: 0.8 |
proxy
|
phpinfo
|
���ѧ����ۧܧ�