Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/cffi/api.py: 21%

1import sys, types 

2from .lock import allocate_lock 

3from .error import CDefError 

4from . import model 

5 

6try: 

7 callable 

8except NameError: 

9 # Python 3.1 

10 from collections import Callable 

11 callable = lambda x: isinstance(x, Callable) 

12 

13try: 

14 basestring 

15except NameError: 

16 # Python 3.x 

17 basestring = str 

18 

19_unspecified = object() 

20 

21 

22 

23class FFI(object): 

24 r''' 

25 The main top-level class that you instantiate once, or once per module. 

26 

27 Example usage: 

28 

29 ffi = FFI() 

30 ffi.cdef(""" 

31 int printf(const char *, ...); 

32 """) 

33 

34 C = ffi.dlopen(None) # standard library 

35 -or- 

36 C = ffi.verify() # use a C compiler: verify the decl above is right 

37 

38 C.printf("hello, %s!\n", ffi.new("char[]", "world")) 

39 ''' 

40 

41 def __init__(self, backend=None): 

42 """Create an FFI instance. The 'backend' argument is used to 

43 select a non-default backend, mostly for tests. 

44 """ 

45 if backend is None: 

46 # You need PyPy (>= 2.0 beta), or a CPython (>= 2.6) with 

47 # _cffi_backend.so compiled. 

48 import _cffi_backend as backend 

49 from . import __version__ 

50 if backend.__version__ != __version__: 

51 # bad version! Try to be as explicit as possible. 

52 if hasattr(backend, '__file__'): 

53 # CPython 

54 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." % ( 

55 __version__, __file__, 

56 backend.__version__, backend.__file__)) 

57 else: 

58 # PyPy 

59 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." % ( 

60 __version__, __file__, backend.__version__)) 

61 # (If you insist you can also try to pass the option 

62 # 'backend=backend_ctypes.CTypesBackend()', but don't 

63 # rely on it! It's probably not going to work well.) 

64 

65 from . import cparser 

66 self._backend = backend 

67 self._lock = allocate_lock() 

68 self._parser = cparser.Parser() 

69 self._cached_btypes = {} 

70 self._parsed_types = types.ModuleType('parsed_types').__dict__ 

71 self._new_types = types.ModuleType('new_types').__dict__ 

72 self._function_caches = [] 

73 self._libraries = [] 

74 self._cdefsources = [] 

75 self._included_ffis = [] 

76 self._windows_unicode = None 

77 self._init_once_cache = {} 

78 self._cdef_version = None 

79 self._embedding = None 

80 self._typecache = model.get_typecache(backend) 

81 if hasattr(backend, 'set_ffi'): 

82 backend.set_ffi(self) 

83 for name in list(backend.__dict__): 

84 if name.startswith('RTLD_'): 

85 setattr(self, name, getattr(backend, name)) 

86 # 

87 with self._lock: 

88 self.BVoidP = self._get_cached_btype(model.voidp_type) 

89 self.BCharA = self._get_cached_btype(model.char_array_type) 

90 if isinstance(backend, types.ModuleType): 

91 # _cffi_backend: attach these constants to the class 

92 if not hasattr(FFI, 'NULL'): 

93 FFI.NULL = self.cast(self.BVoidP, 0) 

94 FFI.CData, FFI.CType = backend._get_types() 

95 else: 

96 # ctypes backend: attach these constants to the instance 

97 self.NULL = self.cast(self.BVoidP, 0) 

98 self.CData, self.CType = backend._get_types() 

99 self.buffer = backend.buffer 

100 

101 def cdef(self, csource, override=False, packed=False, pack=None): 

102 """Parse the given C source. This registers all declared functions, 

103 types, and global variables. The functions and global variables can 

104 then be accessed via either 'ffi.dlopen()' or 'ffi.verify()'. 

105 The types can be used in 'ffi.new()' and other functions. 

106 If 'packed' is specified as True, all structs declared inside this 

107 cdef are packed, i.e. laid out without any field alignment at all. 

108 Alternatively, 'pack' can be a small integer, and requests for 

109 alignment greater than that are ignored (pack=1 is equivalent to 

110 packed=True). 

111 """ 

112 self._cdef(csource, override=override, packed=packed, pack=pack) 

113 

114 def embedding_api(self, csource, packed=False, pack=None): 

115 self._cdef(csource, packed=packed, pack=pack, dllexport=True) 

116 if self._embedding is None: 

117 self._embedding = '' 

118 

119 def _cdef(self, csource, override=False, **options): 

120 if not isinstance(csource, str): # unicode, on Python 2 

121 if not isinstance(csource, basestring): 

122 raise TypeError("cdef() argument must be a string") 

123 csource = csource.encode('ascii') 

124 with self._lock: 

125 self._cdef_version = object() 

126 self._parser.parse(csource, override=override, **options) 

127 self._cdefsources.append(csource) 

128 if override: 

129 for cache in self._function_caches: 

130 cache.clear() 

131 finishlist = self._parser._recomplete 

132 if finishlist: 

133 self._parser._recomplete = [] 

134 for tp in finishlist: 

135 tp.finish_backend_type(self, finishlist) 

136 

137 def dlopen(self, name, flags=0): 

138 """Load and return a dynamic library identified by 'name'. 

139 The standard C library can be loaded by passing None. 

140 Note that functions and types declared by 'ffi.cdef()' are not 

141 linked to a particular library, just like C headers; in the 

142 library we only look for the actual (untyped) symbols. 

143 """ 

144 if not (isinstance(name, basestring) or 

145 name is None or 

146 isinstance(name, self.CData)): 

147 raise TypeError("dlopen(name): name must be a file name, None, " 

148 "or an already-opened 'void *' handle") 

149 with self._lock: 

150 lib, function_cache = _make_ffi_library(self, name, flags) 

151 self._function_caches.append(function_cache) 

152 self._libraries.append(lib) 

153 return lib 

154 

155 def dlclose(self, lib): 

156 """Close a library obtained with ffi.dlopen(). After this call, 

157 access to functions or variables from the library will fail 

158 (possibly with a segmentation fault). 

159 """ 

160 type(lib).__cffi_close__(lib) 

161 

162 def _typeof_locked(self, cdecl): 

163 # call me with the lock! 

164 key = cdecl 

165 if key in self._parsed_types: 

166 return self._parsed_types[key] 

167 # 

168 if not isinstance(cdecl, str): # unicode, on Python 2 

169 cdecl = cdecl.encode('ascii') 

170 # 

171 type = self._parser.parse_type(cdecl) 

172 really_a_function_type = type.is_raw_function 

173 if really_a_function_type: 

174 type = type.as_function_pointer() 

175 btype = self._get_cached_btype(type) 

176 result = btype, really_a_function_type 

177 self._parsed_types[key] = result 

178 return result 

179 

180 def _typeof(self, cdecl, consider_function_as_funcptr=False): 

181 # string -> ctype object 

182 try: 

183 result = self._parsed_types[cdecl] 

184 except KeyError: 

185 with self._lock: 

186 result = self._typeof_locked(cdecl) 

187 # 

188 btype, really_a_function_type = result 

189 if really_a_function_type and not consider_function_as_funcptr: 

190 raise CDefError("the type %r is a function type, not a " 

191 "pointer-to-function type" % (cdecl,)) 

192 return btype 

193 

194 def typeof(self, cdecl): 

195 """Parse the C type given as a string and return the 

196 corresponding <ctype> object. 

197 It can also be used on 'cdata' instance to get its C type. 

198 """ 

199 if isinstance(cdecl, basestring): 

200 return self._typeof(cdecl) 

201 if isinstance(cdecl, self.CData): 

202 return self._backend.typeof(cdecl) 

203 if isinstance(cdecl, types.BuiltinFunctionType): 

204 res = _builtin_function_type(cdecl) 

205 if res is not None: 

206 return res 

207 if (isinstance(cdecl, types.FunctionType) 

208 and hasattr(cdecl, '_cffi_base_type')): 

209 with self._lock: 

210 return self._get_cached_btype(cdecl._cffi_base_type) 

211 raise TypeError(type(cdecl)) 

212 

213 def sizeof(self, cdecl): 

214 """Return the size in bytes of the argument. It can be a 

215 string naming a C type, or a 'cdata' instance. 

216 """ 

217 if isinstance(cdecl, basestring): 

218 BType = self._typeof(cdecl) 

219 return self._backend.sizeof(BType) 

220 else: 

221 return self._backend.sizeof(cdecl) 

222 

223 def alignof(self, cdecl): 

224 """Return the natural alignment size in bytes of the C type 

225 given as a string. 

226 """ 

227 if isinstance(cdecl, basestring): 

228 cdecl = self._typeof(cdecl) 

229 return self._backend.alignof(cdecl) 

230 

231 def offsetof(self, cdecl, *fields_or_indexes): 

232 """Return the offset of the named field inside the given 

233 structure or array, which must be given as a C type name. 

234 You can give several field names in case of nested structures. 

235 You can also give numeric values which correspond to array 

236 items, in case of an array type. 

237 """ 

238 if isinstance(cdecl, basestring): 

239 cdecl = self._typeof(cdecl) 

240 return self._typeoffsetof(cdecl, *fields_or_indexes)[1] 

241 

242 def new(self, cdecl, init=None): 

243 """Allocate an instance according to the specified C type and 

244 return a pointer to it. The specified C type must be either a 

245 pointer or an array: ``new('X *')`` allocates an X and returns 

246 a pointer to it, whereas ``new('X[n]')`` allocates an array of 

247 n X'es and returns an array referencing it (which works 

248 mostly like a pointer, like in C). You can also use 

249 ``new('X[]', n)`` to allocate an array of a non-constant 

250 length n. 

251 

252 The memory is initialized following the rules of declaring a 

253 global variable in C: by default it is zero-initialized, but 

254 an explicit initializer can be given which can be used to 

255 fill all or part of the memory. 

256 

257 When the returned <cdata> object goes out of scope, the memory 

258 is freed. In other words the returned <cdata> object has 

259 ownership of the value of type 'cdecl' that it points to. This 

260 means that the raw data can be used as long as this object is 

261 kept alive, but must not be used for a longer time. Be careful 

262 about that when copying the pointer to the memory somewhere 

263 else, e.g. into another structure. 

264 """ 

265 if isinstance(cdecl, basestring): 

266 cdecl = self._typeof(cdecl) 

267 return self._backend.newp(cdecl, init) 

268 

269 def new_allocator(self, alloc=None, free=None, 

270 should_clear_after_alloc=True): 

271 """Return a new allocator, i.e. a function that behaves like ffi.new() 

272 but uses the provided low-level 'alloc' and 'free' functions. 

273 

274 'alloc' is called with the size as argument. If it returns NULL, a 

275 MemoryError is raised. 'free' is called with the result of 'alloc' 

276 as argument. Both can be either Python function or directly C 

277 functions. If 'free' is None, then no free function is called. 

278 If both 'alloc' and 'free' are None, the default is used. 

279 

280 If 'should_clear_after_alloc' is set to False, then the memory 

281 returned by 'alloc' is assumed to be already cleared (or you are 

282 fine with garbage); otherwise CFFI will clear it. 

283 """ 

284 compiled_ffi = self._backend.FFI() 

285 allocator = compiled_ffi.new_allocator(alloc, free, 

286 should_clear_after_alloc) 

287 def allocate(cdecl, init=None): 

288 if isinstance(cdecl, basestring): 

289 cdecl = self._typeof(cdecl) 

290 return allocator(cdecl, init) 

291 return allocate 

292 

293 def cast(self, cdecl, source): 

294 """Similar to a C cast: returns an instance of the named C 

295 type initialized with the given 'source'. The source is 

296 casted between integers or pointers of any type. 

297 """ 

298 if isinstance(cdecl, basestring): 

299 cdecl = self._typeof(cdecl) 

300 return self._backend.cast(cdecl, source) 

301 

302 def string(self, cdata, maxlen=-1): 

303 """Return a Python string (or unicode string) from the 'cdata'. 

304 If 'cdata' is a pointer or array of characters or bytes, returns 

305 the null-terminated string. The returned string extends until 

306 the first null character, or at most 'maxlen' characters. If 

307 'cdata' is an array then 'maxlen' defaults to its length. 

308 

309 If 'cdata' is a pointer or array of wchar_t, returns a unicode 

310 string following the same rules. 

311 

312 If 'cdata' is a single character or byte or a wchar_t, returns 

313 it as a string or unicode string. 

314 

315 If 'cdata' is an enum, returns the value of the enumerator as a 

316 string, or 'NUMBER' if the value is out of range. 

317 """ 

318 return self._backend.string(cdata, maxlen) 

319 

320 def unpack(self, cdata, length): 

321 """Unpack an array of C data of the given length, 

322 returning a Python string/unicode/list. 

323 

324 If 'cdata' is a pointer to 'char', returns a byte string. 

325 It does not stop at the first null. This is equivalent to: 

326 ffi.buffer(cdata, length)[:] 

327 

328 If 'cdata' is a pointer to 'wchar_t', returns a unicode string. 

329 'length' is measured in wchar_t's; it is not the size in bytes. 

330 

331 If 'cdata' is a pointer to anything else, returns a list of 

332 'length' items. This is a faster equivalent to: 

333 [cdata[i] for i in range(length)] 

334 """ 

335 return self._backend.unpack(cdata, length) 

336 

337 #def buffer(self, cdata, size=-1): 

338 # """Return a read-write buffer object that references the raw C data 

339 # pointed to by the given 'cdata'. The 'cdata' must be a pointer or 

340 # an array. Can be passed to functions expecting a buffer, or directly 

341 # manipulated with: 

342 # 

343 # buf[:] get a copy of it in a regular string, or 

344 # buf[idx] as a single character 

345 # buf[:] = ... 

346 # buf[idx] = ... change the content 

347 # """ 

348 # note that 'buffer' is a type, set on this instance by __init__ 

349 

350 def from_buffer(self, cdecl, python_buffer=_unspecified, 

351 require_writable=False): 

352 """Return a cdata of the given type pointing to the data of the 

353 given Python object, which must support the buffer interface. 

354 Note that this is not meant to be used on the built-in types 

355 str or unicode (you can build 'char[]' arrays explicitly) 

356 but only on objects containing large quantities of raw data 

357 in some other format, like 'array.array' or numpy arrays. 

358 

359 The first argument is optional and default to 'char[]'. 

360 """ 

361 if python_buffer is _unspecified: 

362 cdecl, python_buffer = self.BCharA, cdecl 

363 elif isinstance(cdecl, basestring): 

364 cdecl = self._typeof(cdecl) 

365 return self._backend.from_buffer(cdecl, python_buffer, 

366 require_writable) 

367 

368 def memmove(self, dest, src, n): 

369 """ffi.memmove(dest, src, n) copies n bytes of memory from src to dest. 

370 

371 Like the C function memmove(), the memory areas may overlap; 

372 apart from that it behaves like the C function memcpy(). 

373 

374 'src' can be any cdata ptr or array, or any Python buffer object. 

375 'dest' can be any cdata ptr or array, or a writable Python buffer 

376 object. The size to copy, 'n', is always measured in bytes. 

377 

378 Unlike other methods, this one supports all Python buffer including 

379 byte strings and bytearrays---but it still does not support 

380 non-contiguous buffers. 

381 """ 

382 return self._backend.memmove(dest, src, n) 

383 

384 def callback(self, cdecl, python_callable=None, error=None, onerror=None): 

385 """Return a callback object or a decorator making such a 

386 callback object. 'cdecl' must name a C function pointer type. 

387 The callback invokes the specified 'python_callable' (which may 

388 be provided either directly or via a decorator). Important: the 

389 callback object must be manually kept alive for as long as the 

390 callback may be invoked from the C level. 

391 """ 

392 def callback_decorator_wrap(python_callable): 

393 if not callable(python_callable): 

394 raise TypeError("the 'python_callable' argument " 

395 "is not callable") 

396 return self._backend.callback(cdecl, python_callable, 

397 error, onerror) 

398 if isinstance(cdecl, basestring): 

399 cdecl = self._typeof(cdecl, consider_function_as_funcptr=True) 

400 if python_callable is None: 

401 return callback_decorator_wrap # decorator mode 

402 else: 

403 return callback_decorator_wrap(python_callable) # direct mode 

404 

405 def getctype(self, cdecl, replace_with=''): 

406 """Return a string giving the C type 'cdecl', which may be itself 

407 a string or a <ctype> object. If 'replace_with' is given, it gives 

408 extra text to append (or insert for more complicated C types), like 

409 a variable name, or '*' to get actually the C type 'pointer-to-cdecl'. 

410 """ 

411 if isinstance(cdecl, basestring): 

412 cdecl = self._typeof(cdecl) 

413 replace_with = replace_with.strip() 

414 if (replace_with.startswith('*') 

415 and '&[' in self._backend.getcname(cdecl, '&')): 

416 replace_with = '(%s)' % replace_with 

417 elif replace_with and not replace_with[0] in '[(': 

418 replace_with = ' ' + replace_with 

419 return self._backend.getcname(cdecl, replace_with) 

420 

421 def gc(self, cdata, destructor, size=0): 

422 """Return a new cdata object that points to the same 

423 data. Later, when this new cdata object is garbage-collected, 

424 'destructor(old_cdata_object)' will be called. 

425 

426 The optional 'size' gives an estimate of the size, used to 

427 trigger the garbage collection more eagerly. So far only used 

428 on PyPy. It tells the GC that the returned object keeps alive 

429 roughly 'size' bytes of external memory. 

430 """ 

431 return self._backend.gcp(cdata, destructor, size) 

432 

433 def _get_cached_btype(self, type): 

434 assert self._lock.acquire(False) is False 

435 # call me with the lock! 

436 try: 

437 BType = self._cached_btypes[type] 

438 except KeyError: 

439 finishlist = [] 

440 BType = type.get_cached_btype(self, finishlist) 

441 for type in finishlist: 

442 type.finish_backend_type(self, finishlist) 

443 return BType 

444 

445 def verify(self, source='', tmpdir=None, **kwargs): 

446 """Verify that the current ffi signatures compile on this 

447 machine, and return a dynamic library object. The dynamic 

448 library can be used to call functions and access global 

449 variables declared in this 'ffi'. The library is compiled 

450 by the C compiler: it gives you C-level API compatibility 

451 (including calling macros). This is unlike 'ffi.dlopen()', 

452 which requires binary compatibility in the signatures. 

453 """ 

454 from .verifier import Verifier, _caller_dir_pycache 

455 # 

456 # If set_unicode(True) was called, insert the UNICODE and 

457 # _UNICODE macro declarations 

458 if self._windows_unicode: 

459 self._apply_windows_unicode(kwargs) 

460 # 

461 # Set the tmpdir here, and not in Verifier.__init__: it picks 

462 # up the caller's directory, which we want to be the caller of 

463 # ffi.verify(), as opposed to the caller of Veritier(). 

464 tmpdir = tmpdir or _caller_dir_pycache() 

465 # 

466 # Make a Verifier() and use it to load the library. 

467 self.verifier = Verifier(self, source, tmpdir, **kwargs) 

468 lib = self.verifier.load_library() 

469 # 

470 # Save the loaded library for keep-alive purposes, even 

471 # if the caller doesn't keep it alive itself (it should). 

472 self._libraries.append(lib) 

473 return lib 

474 

475 def _get_errno(self): 

476 return self._backend.get_errno() 

477 def _set_errno(self, errno): 

478 self._backend.set_errno(errno) 

479 errno = property(_get_errno, _set_errno, None, 

480 "the value of 'errno' from/to the C calls") 

481 

482 def getwinerror(self, code=-1): 

483 return self._backend.getwinerror(code) 

484 

485 def _pointer_to(self, ctype): 

486 with self._lock: 

487 return model.pointer_cache(self, ctype) 

488 

489 def addressof(self, cdata, *fields_or_indexes): 

490 """Return the address of a <cdata 'struct-or-union'>. 

491 If 'fields_or_indexes' are given, returns the address of that 

492 field or array item in the structure or array, recursively in 

493 case of nested structures. 

494 """ 

495 try: 

496 ctype = self._backend.typeof(cdata) 

497 except TypeError: 

498 if '__addressof__' in type(cdata).__dict__: 

499 return type(cdata).__addressof__(cdata, *fields_or_indexes) 

500 raise 

501 if fields_or_indexes: 

502 ctype, offset = self._typeoffsetof(ctype, *fields_or_indexes) 

503 else: 

504 if ctype.kind == "pointer": 

505 raise TypeError("addressof(pointer)") 

506 offset = 0 

507 ctypeptr = self._pointer_to(ctype) 

508 return self._backend.rawaddressof(ctypeptr, cdata, offset) 

509 

510 def _typeoffsetof(self, ctype, field_or_index, *fields_or_indexes): 

511 ctype, offset = self._backend.typeoffsetof(ctype, field_or_index) 

512 for field1 in fields_or_indexes: 

513 ctype, offset1 = self._backend.typeoffsetof(ctype, field1, 1) 

514 offset += offset1 

515 return ctype, offset 

516 

517 def include(self, ffi_to_include): 

518 """Includes the typedefs, structs, unions and enums defined 

519 in another FFI instance. Usage is similar to a #include in C, 

520 where a part of the program might include types defined in 

521 another part for its own usage. Note that the include() 

522 method has no effect on functions, constants and global 

523 variables, which must anyway be accessed directly from the 

524 lib object returned by the original FFI instance. 

525 """ 

526 if not isinstance(ffi_to_include, FFI): 

527 raise TypeError("ffi.include() expects an argument that is also of" 

528 " type cffi.FFI, not %r" % ( 

529 type(ffi_to_include).__name__,)) 

530 if ffi_to_include is self: 

531 raise ValueError("self.include(self)") 

532 with ffi_to_include._lock: 

533 with self._lock: 

534 self._parser.include(ffi_to_include._parser) 

535 self._cdefsources.append('[') 

536 self._cdefsources.extend(ffi_to_include._cdefsources) 

537 self._cdefsources.append(']') 

538 self._included_ffis.append(ffi_to_include) 

539 

540 def new_handle(self, x): 

541 return self._backend.newp_handle(self.BVoidP, x) 

542 

543 def from_handle(self, x): 

544 return self._backend.from_handle(x) 

545 

546 def release(self, x): 

547 self._backend.release(x) 

548 

549 def set_unicode(self, enabled_flag): 

550 """Windows: if 'enabled_flag' is True, enable the UNICODE and 

551 _UNICODE defines in C, and declare the types like TCHAR and LPTCSTR 

552 to be (pointers to) wchar_t. If 'enabled_flag' is False, 

553 declare these types to be (pointers to) plain 8-bit characters. 

554 This is mostly for backward compatibility; you usually want True. 

555 """ 

556 if self._windows_unicode is not None: 

557 raise ValueError("set_unicode() can only be called once") 

558 enabled_flag = bool(enabled_flag) 

559 if enabled_flag: 

560 self.cdef("typedef wchar_t TBYTE;" 

561 "typedef wchar_t TCHAR;" 

562 "typedef const wchar_t *LPCTSTR;" 

563 "typedef const wchar_t *PCTSTR;" 

564 "typedef wchar_t *LPTSTR;" 

565 "typedef wchar_t *PTSTR;" 

566 "typedef TBYTE *PTBYTE;" 

567 "typedef TCHAR *PTCHAR;") 

568 else: 

569 self.cdef("typedef char TBYTE;" 

570 "typedef char TCHAR;" 

571 "typedef const char *LPCTSTR;" 

572 "typedef const char *PCTSTR;" 

573 "typedef char *LPTSTR;" 

574 "typedef char *PTSTR;" 

575 "typedef TBYTE *PTBYTE;" 

576 "typedef TCHAR *PTCHAR;") 

577 self._windows_unicode = enabled_flag 

578 

579 def _apply_windows_unicode(self, kwds): 

580 defmacros = kwds.get('define_macros', ()) 

581 if not isinstance(defmacros, (list, tuple)): 

582 raise TypeError("'define_macros' must be a list or tuple") 

583 defmacros = list(defmacros) + [('UNICODE', '1'), 

584 ('_UNICODE', '1')] 

585 kwds['define_macros'] = defmacros 

586 

587 def _apply_embedding_fix(self, kwds): 

588 # must include an argument like "-lpython2.7" for the compiler 

589 def ensure(key, value): 

590 lst = kwds.setdefault(key, []) 

591 if value not in lst: 

592 lst.append(value) 

593 # 

594 if '__pypy__' in sys.builtin_module_names: 

595 import os 

596 if sys.platform == "win32": 

597 # we need 'libpypy-c.lib'. Current distributions of 

598 # pypy (>= 4.1) contain it as 'libs/python27.lib'. 

599 pythonlib = "python{0[0]}{0[1]}".format(sys.version_info) 

600 if hasattr(sys, 'prefix'): 

601 ensure('library_dirs', os.path.join(sys.prefix, 'libs')) 

602 else: 

603 # we need 'libpypy-c.{so,dylib}', which should be by 

604 # default located in 'sys.prefix/bin' for installed 

605 # systems. 

606 if sys.version_info < (3,): 

607 pythonlib = "pypy-c" 

608 else: 

609 pythonlib = "pypy3-c" 

610 if hasattr(sys, 'prefix'): 

611 ensure('library_dirs', os.path.join(sys.prefix, 'bin')) 

612 # On uninstalled pypy's, the libpypy-c is typically found in 

613 # .../pypy/goal/. 

614 if hasattr(sys, 'prefix'): 

615 ensure('library_dirs', os.path.join(sys.prefix, 'pypy', 'goal')) 

616 else: 

617 if sys.platform == "win32": 

618 template = "python%d%d" 

619 if hasattr(sys, 'gettotalrefcount'): 

620 template += '_d' 

621 else: 

622 try: 

623 import sysconfig 

624 except ImportError: # 2.6 

625 from distutils import sysconfig 

626 template = "python%d.%d" 

627 if sysconfig.get_config_var('DEBUG_EXT'): 

628 template += sysconfig.get_config_var('DEBUG_EXT') 

629 pythonlib = (template % 

630 (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff)) 

631 if hasattr(sys, 'abiflags'): 

632 pythonlib += sys.abiflags 

633 ensure('libraries', pythonlib) 

634 if sys.platform == "win32": 

635 ensure('extra_link_args', '/MANIFEST') 

636 

637 def set_source(self, module_name, source, source_extension='.c', **kwds): 

638 import os 

639 if hasattr(self, '_assigned_source'): 

640 raise ValueError("set_source() cannot be called several times " 

641 "per ffi object") 

642 if not isinstance(module_name, basestring): 

643 raise TypeError("'module_name' must be a string") 

644 if os.sep in module_name or (os.altsep and os.altsep in module_name): 

645 raise ValueError("'module_name' must not contain '/': use a dotted " 

646 "name to make a 'package.module' location") 

647 self._assigned_source = (str(module_name), source, 

648 source_extension, kwds) 

649 

650 def set_source_pkgconfig(self, module_name, pkgconfig_libs, source, 

651 source_extension='.c', **kwds): 

652 from . import pkgconfig 

653 if not isinstance(pkgconfig_libs, list): 

654 raise TypeError("the pkgconfig_libs argument must be a list " 

655 "of package names") 

656 kwds2 = pkgconfig.flags_from_pkgconfig(pkgconfig_libs) 

657 pkgconfig.merge_flags(kwds, kwds2) 

658 self.set_source(module_name, source, source_extension, **kwds) 

659 

660 def distutils_extension(self, tmpdir='build', verbose=True): 

661 from distutils.dir_util import mkpath 

662 from .recompiler import recompile 

663 # 

664 if not hasattr(self, '_assigned_source'): 

665 if hasattr(self, 'verifier'): # fallback, 'tmpdir' ignored 

666 return self.verifier.get_extension() 

667 raise ValueError("set_source() must be called before" 

668 " distutils_extension()") 

669 module_name, source, source_extension, kwds = self._assigned_source 

670 if source is None: 

671 raise TypeError("distutils_extension() is only for C extension " 

672 "modules, not for dlopen()-style pure Python " 

673 "modules") 

674 mkpath(tmpdir) 

675 ext, updated = recompile(self, module_name, 

676 source, tmpdir=tmpdir, extradir=tmpdir, 

677 source_extension=source_extension, 

678 call_c_compiler=False, **kwds) 

679 if verbose: 

680 if updated: 

681 sys.stderr.write("regenerated: %r\n" % (ext.sources[0],)) 

682 else: 

683 sys.stderr.write("not modified: %r\n" % (ext.sources[0],)) 

684 return ext 

685 

686 def emit_c_code(self, filename): 

687 from .recompiler import recompile 

688 # 

689 if not hasattr(self, '_assigned_source'): 

690 raise ValueError("set_source() must be called before emit_c_code()") 

691 module_name, source, source_extension, kwds = self._assigned_source 

692 if source is None: 

693 raise TypeError("emit_c_code() is only for C extension modules, " 

694 "not for dlopen()-style pure Python modules") 

695 recompile(self, module_name, source, 

696 c_file=filename, call_c_compiler=False, **kwds) 

697 

698 def emit_python_code(self, filename): 

699 from .recompiler import recompile 

700 # 

701 if not hasattr(self, '_assigned_source'): 

702 raise ValueError("set_source() must be called before emit_c_code()") 

703 module_name, source, source_extension, kwds = self._assigned_source 

704 if source is not None: 

705 raise TypeError("emit_python_code() is only for dlopen()-style " 

706 "pure Python modules, not for C extension modules") 

707 recompile(self, module_name, source, 

708 c_file=filename, call_c_compiler=False, **kwds) 

709 

710 def compile(self, tmpdir='.', verbose=0, target=None, debug=None): 

711 """The 'target' argument gives the final file name of the 

712 compiled DLL. Use '*' to force distutils' choice, suitable for 

713 regular CPython C API modules. Use a file name ending in '.*' 

714 to ask for the system's default extension for dynamic libraries 

715 (.so/.dll/.dylib). 

716 

717 The default is '*' when building a non-embedded C API extension, 

718 and (module_name + '.*') when building an embedded library. 

719 """ 

720 from .recompiler import recompile 

721 # 

722 if not hasattr(self, '_assigned_source'): 

723 raise ValueError("set_source() must be called before compile()") 

724 module_name, source, source_extension, kwds = self._assigned_source 

725 return recompile(self, module_name, source, tmpdir=tmpdir, 

726 target=target, source_extension=source_extension, 

727 compiler_verbose=verbose, debug=debug, **kwds) 

728 

729 def init_once(self, func, tag): 

730 # Read _init_once_cache[tag], which is either (False, lock) if 

731 # we're calling the function now in some thread, or (True, result). 

732 # Don't call setdefault() in most cases, to avoid allocating and 

733 # immediately freeing a lock; but still use setdefaut() to avoid 

734 # races. 

735 try: 

736 x = self._init_once_cache[tag] 

737 except KeyError: 

738 x = self._init_once_cache.setdefault(tag, (False, allocate_lock())) 

739 # Common case: we got (True, result), so we return the result. 

740 if x[0]: 

741 return x[1] 

742 # Else, it's a lock. Acquire it to serialize the following tests. 

743 with x[1]: 

744 # Read again from _init_once_cache the current status. 

745 x = self._init_once_cache[tag] 

746 if x[0]: 

747 return x[1] 

748 # Call the function and store the result back. 

749 result = func() 

750 self._init_once_cache[tag] = (True, result) 

751 return result 

752 

753 def embedding_init_code(self, pysource): 

754 if self._embedding: 

755 raise ValueError("embedding_init_code() can only be called once") 

756 # fix 'pysource' before it gets dumped into the C file: 

757 # - remove empty lines at the beginning, so it starts at "line 1" 

758 # - dedent, if all non-empty lines are indented 

759 # - check for SyntaxErrors 

760 import re 

761 match = re.match(r'\s*\n', pysource) 

762 if match: 

763 pysource = pysource[match.end():] 

764 lines = pysource.splitlines() or [''] 

765 prefix = re.match(r'\s*', lines[0]).group() 

766 for i in range(1, len(lines)): 

767 line = lines[i] 

768 if line.rstrip(): 

769 while not line.startswith(prefix): 

770 prefix = prefix[:-1] 

771 i = len(prefix) 

772 lines = [line[i:]+'\n' for line in lines] 

773 pysource = ''.join(lines) 

774 # 

775 compile(pysource, "cffi_init", "exec") 

776 # 

777 self._embedding = pysource 

778 

779 def def_extern(self, *args, **kwds): 

780 raise ValueError("ffi.def_extern() is only available on API-mode FFI " 

781 "objects") 

782 

783 def list_types(self): 

784 """Returns the user type names known to this FFI instance. 

785 This returns a tuple containing three lists of names: 

786 (typedef_names, names_of_structs, names_of_unions) 

787 """ 

788 typedefs = [] 

789 structs = [] 

790 unions = [] 

791 for key in self._parser._declarations: 

792 if key.startswith('typedef '): 

793 typedefs.append(key[8:]) 

794 elif key.startswith('struct '): 

795 structs.append(key[7:]) 

796 elif key.startswith('union '): 

797 unions.append(key[6:]) 

798 typedefs.sort() 

799 structs.sort() 

800 unions.sort() 

801 return (typedefs, structs, unions) 

802 

803 

804def _load_backend_lib(backend, name, flags): 

805 import os 

806 if not isinstance(name, basestring): 

807 if sys.platform != "win32" or name is not None: 

808 return backend.load_library(name, flags) 

809 name = "c" # Windows: load_library(None) fails, but this works 

810 # on Python 2 (backward compatibility hack only) 

811 first_error = None 

812 if '.' in name or '/' in name or os.sep in name: 

813 try: 

814 return backend.load_library(name, flags) 

815 except OSError as e: 

816 first_error = e 

817 import ctypes.util 

818 path = ctypes.util.find_library(name) 

819 if path is None: 

820 if name == "c" and sys.platform == "win32" and sys.version_info >= (3,): 

821 raise OSError("dlopen(None) cannot work on Windows for Python 3 " 

822 "(see http://bugs.python.org/issue23606)") 

823 msg = ("ctypes.util.find_library() did not manage " 

824 "to locate a library called %r" % (name,)) 

825 if first_error is not None: 

826 msg = "%s. Additionally, %s" % (first_error, msg) 

827 raise OSError(msg) 

828 return backend.load_library(path, flags) 

829 

830def _make_ffi_library(ffi, libname, flags): 

831 backend = ffi._backend