def register(self, cname, lname, lib):
self.name = "{0}::{1}".format(lname, cname)
if self.__class__.lib is None:
self.__class__.lib = ffi.open(lib)
# if DBG:
# print("loading Cni lib %s" % lib)
return self
def open(name, maxver=10, extra=()):
if not ffi:
return None
try:
return _cache[name]
except KeyError:
pass
def libs():
if sys.platform == "linux":
yield '%s.so' % name
for i in range(maxver, -1, -1):
yield '%s.so.%u' % (name, i)
else:
for ext in ('dylib', 'dll'):
yield '%s.%s' % (name, ext)
for n in extra:
yield n
err = None
for n in libs():
try:
l = ffi.open(n)
_cache[name] = l
return l
except OSError as e:
err = e
raise err
def open(name, maxver=10, extra=()):
if not ffi:
return None
try:
return _cache[name]
except KeyError:
pass
def libs():
if sys.platform == "linux":
yield '%s.so' % name
for i in range(maxver, -1, -1):
yield '%s.so.%u' % (name, i)
else:
for ext in ('dylib', 'dll'):
yield '%s.%s' % (name, ext)
for n in extra:
yield n
err = None
for n in libs():
try:
l = ffi.open(n)
_cache[name] = l
return l
except OSError as e:
err = e
raise err
def ffi_open(names):
err = None
for n in names:
try:
mod = ffi.open(n)
return mod
except OSError as e:
err = e
raise err
class FFI:
libc = ffi.open('libc.so.6')
IN_CREATE = 0x00000100
IN_DELETE = 0x00000200
inotify_init = libc.func('i', 'inotify_init', '')
inotify_add_watch = libc.func('i', 'inotify_add_watch', 'isI')
inotify_rm_watch = libc.func('i', 'inotify_rm_watch', 'ii')
def ffi_open(names):
err = None
for n in names:
try:
mod = ffi.open(n)
return mod
except OSError as e:
err = e
raise err
def get():
global _h
if _h:
return _h
err = None
try:
_h = ffi.open('libmd5.so')
return _h
except OSError as e:
err = e
raise err
def get():
global _h
if _h:
return _h
err = None
try:
_h = ffi.open('libmd5.so')
return _h
except OSError as e:
err = e
raise err
def get():
global _h
if _h:
return _h
err = None
for n in names:
try:
_h = ffi.open(n)
return _h
except OSError as e:
err = e
raise err
def get():
global _h
if _h:
return _h
err = None
for n in names:
try:
_h = ffi.open(n)
return _h
except OSError as e:
err = e
raise err
def _get_library_with_ffi(name, maxver, extra=()):
"""MicroPython Unix port may miss some required functions. This function can load them
from elsewhere.
Inspired by:
https://github.com/micropython/micropython-lib/blob/master/ffilib/ffilib.py
https://github.com/micropython/micropython-lib/blob/master/os/os/__init__.py
"""
if name in _ffi_library_cache:
return _ffi_library_cache[name]
import ffi # @UnresolvedImport
def libs():
if sys.platform == "linux":
yield "%s.so" % name
for i in range(maxver, -1, -1):
yield "%s.so.%u" % (name, i)
elif sys.platform == "darwin":
for ext in ("dylib", "dll"):
yield "%s.%s" % (name, ext)
else:
raise RuntimeError(sys.platform + " not supported")
for n in extra:
yield n
err = None
for n in libs():
try:
l = ffi.open(n)
_ffi_library_cache[name] = l
return l
except OSError as e:
err = e
raise err
#
# This module is part of the Pycopy https://github.com/pfalcon/pycopy
# project.
#
# Copyright (c) 2018-2021 Paul Sokolovsky
#
# The MIT License
import ffi
from uarray import array
import ullvm_c_conf
assert ullvm_c_conf.dynlib
L = ffi.open(ullvm_c_conf.dynlib)
def F(ret, name, params):
globals()[name] = L.func(ret, name, params)
# Initializer for functions which need Python wrappers.
def F_(ret, name, params):
globals()[name + "_"] = L.func(ret, name, params)
LLVMAbortProcessAction = 0
LLVMPrintMessageAction = 1
LLVMReturnStatusAction = 2
# LLVMCodeGenOptLevel;
# (c) 2015-2018 Paul Sokolovsky. MIT license.
import uarray as array
import ffi
import uctypes
from ubinascii import hexlify
py = ffi.open(None)
def D(ret, name, args):
globals()[name] = py.func(ret, name, args)
D("v", "mp_unix_alloc_exec", "Lpp")
def alloc_exec(sz):
ptr = array.array("L", [0])
size = array.array("L", [0])
#print(ptr, size)
mp_unix_alloc_exec(sz, ptr, size)
#print(ptr, size)
b = uctypes.bytearray_at(ptr[0], sz)
#print(b)
return b
def dlopen(lib):
with open(f"build/{lib}.json", 'r') as jsonf:
code = json.loads(jsonf.read())
# platform dependant
if CNI:
clib = f"lib{lib}_cni.so"
else:
clib = f"lib{lib}_c.so"
def ffimap(ffi_name):
global RETURN_TYPE_FIRST
if RETURN_TYPE_FIRST:
func, ret, args = ffi_name.rsplit('_', 2)
else:
func, args, ret = ffi_name.rsplit('_', 2)
return func, ret, args
# FIXME: use readelf tools and wasm tools
# for func in os.popen(f"nm --demangle --defined-only --dynamic {clib} |grep '. T .*_._.*$'|cut -d' ' -f3"):
for func in os.popen(
f"nm -C build/{clib} |grep '. T .*_*_.*$'|cut -d' ' -f3"):
ffi_name = func.strip()
if ffi_name.find(FFI_MARK) < 1:
if DBG:
print("N/I: globals", func, end='')
continue
try:
func, ret, args = ffimap(ffi_name)
cls, func = func.split(FFI_MARK, 1)
code.setdefault(cls, {})
code[cls].setdefault(func, [])
code[cls][func].append(
(code['callmap'].get(ffi_name, 'd'), ret, args, ffi_name))
if DBG:
print(cls, '.', func, args, '->', ret)
except:
if DBG:
print("N/I:", func, end='')
print("Loading native lib", clib, file=sys.stderr)
try:
lib = ffi.open(clib)
except Exception as e:
sys.print_exception(e)
print(f'dlopen failed on {clib}')
raise SystemExit
code['lib'] = clib
del code['btypes']
forward_decl = []
cls = code['classes']
ck = list(cls.keys())
ck.sort()
mx = 0
for cn in ck:
mx = max(mx, len(cls[cn]['bases']))
print('MAX PARENTS =', mx)
for p in range(mx + 1):
lot = []
for cn in ck:
if p == len(cls[cn]['bases']):
lot.append(cn)
lot.sort()
forward_decl.extend(lot)
print(forward_decl)
forward_decl = sort_inheritance(code, forward_decl)
forward_decl = sort_inheritance(code, forward_decl)
code['forward_decl'] = sort_inheritance(code, forward_decl)
return code
def dlopen(name, mode):
print("dlopen(%s, %x)" % (name, mode))
return ffi.open(name)
def alignment():
raise NotImplementedError
def resize():
raise NotImplementedError
def get_errno():
raise NotImplementedError
def set_errno():
raise NotImplementedError
def POINTER(type):
raise NotImplementedError
def pointer(obj):
raise NotImplementedError
_libc = ffi.open("libc.so.6")
_memmove_addr = _libc.addr("memmove")
_memset_addr = _libc.addr("memset")
_pointer_type_cache = {}
import ffi
libc = ffi.open("libc.so.6")
fcntl_l = libc.func("i", "fcntl", "iil")
fcntl_s = libc.func("i", "fcntl", "iis")
ioctl_l = libc.func("i", "ioctl", "iil")
ioctl_s = libc.func("i", "ioctl", "iis")
def fcntl(fd, op, arg):
if type(arg) is int:
return fcntl_l(fd, op, arg)
else:
raise NotImplementedError
def ioctl(fd, op, arg):
if type(arg) is int:
return ioctl_l(fd, op, arg)
else:
raise NotImplementedError
import uos, usys
try:
import ffi
except ImportError:
print("SKIP")
raise SystemExit
ffi_lib_filename = "./" + usys.argv[0].rsplit("/", 1)[0] + "/ffi_lib.so"
try:
uos.stat(ffi_lib_filename)
except OSError:
print("SKIP")
raise SystemExit
ffi_lib = ffi.open(ffi_lib_filename)
f8i = ffi_lib.func("b", "f8i", "b")
f8u = ffi_lib.func("B", "f8u", "B")
f16i = ffi_lib.func("h", "f16i", "h")
f16u = ffi_lib.func("H", "f16u", "H")
f32i = ffi_lib.func("i", "f32i", "i")
f32u = ffi_lib.func("I", "f32u", "I")
f64i = ffi_lib.func("q", "f64i", "q")
f64u = ffi_lib.func("Q", "f64u", "Q")
for func_name in ("f8i", "f8u", "f16i", "f16u", "f32i", "f32u", "f64i",
"f64u"):
func = globals()[func_name]
for val in (
0,
# (c) 2018 Paul Sokolovsky. Either zlib or MIT license at your choice.
import ffi
import ustruct
_lib = ffi.open("libSDL2_image-2.0.so.0")
IMG_Load = _lib.func("P", "IMG_Load", "s")
IMG_Load_RW = _lib.func("P", "IMG_Load_RW", "Pi")
import ffi
sq3 = ffi.open("libsqlite3.so.0")
sqlite3_open = sq3.func("i", "sqlite3_open", "sp")
#int sqlite3_prepare(
# sqlite3 *db, /* Database handle */
# const char *zSql, /* SQL statement, UTF-8 encoded */
# int nByte, /* Maximum length of zSql in bytes. */
# sqlite3_stmt **ppStmt, /* OUT: Statement handle */
# const char **pzTail /* OUT: Pointer to unused portion of zSql */
#);
sqlite3_prepare = sq3.func("i", "sqlite3_prepare", "psipp")
#int sqlite3_step(sqlite3_stmt*);
sqlite3_step = sq3.func("i", "sqlite3_step", "p")
#int sqlite3_column_count(sqlite3_stmt *pStmt);
sqlite3_column_count = sq3.func("i", "sqlite3_column_count", "p")
#int sqlite3_column_type(sqlite3_stmt*, int iCol);
sqlite3_column_type = sq3.func("i", "sqlite3_column_type", "pi")
sqlite3_column_int = sq3.func("i", "sqlite3_column_int", "pi")
# using "d" return type gives wrong results
sqlite3_column_double = sq3.func("f", "sqlite3_column_double", "pi")
sqlite3_column_text = sq3.func("s", "sqlite3_column_text", "pi")
SQLITE_ERROR = 1
SQLITE_BUSY = 5
SQLITE_MISUSE = 21
SQLITE_ROW = 100
SQLITE_DONE = 101
SDL_PACKEDLAYOUT_5551 = 4
SDL_PACKEDLAYOUT_565 = 5
SDL_PACKEDLAYOUT_8888 = 6
SDL_PACKEDLAYOUT_2101010 = 7
SDL_PACKEDLAYOUT_1010102 = 8
SDL_PIXELFORMAT_ARGB8888 = \
SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ARGB,
SDL_PACKEDLAYOUT_8888, 32, 4)
SDL_PIXELFORMAT_RGB24 = \
SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_ARRAYU8, SDL_ARRAYORDER_RGB, 0,
24, 3)
_sdl = ffi.open("libSDL2-2.0.so.0")
SDL_Init = _sdl.func("i", "SDL_Init", "I")
SDL_Quit = _sdl.func("v", "SDL_Quit", "")
SDL_CreateWindow = _sdl.func("P", "SDL_CreateWindow", "siiiii")
SDL_CreateRenderer = _sdl.func("P", "SDL_CreateRenderer", "PiI")
SDL_RenderSetLogicalSize = _sdl.func("i", "SDL_RenderSetLogicalSize", "Pii")
SDL_SetRenderDrawColor = _sdl.func("i", "SDL_SetRenderDrawColor", "PBBBB")
SDL_RenderClear = _sdl.func("v", "SDL_RenderClear", "P")
SDL_RenderCopy = _sdl.func("v", "SDL_RenderCopy", "PPPP")
SDL_RenderPresent = _sdl.func("v", "SDL_RenderPresent", "P")
SDL_RenderDrawPoint = _sdl.func("i", "SDL_RenderDrawPoint", "Pii")
SDL_RenderDrawLine = _sdl.func("i", "SDL_RenderDrawLine", "Piiii")
# Implementation of native Android "pm list packages"
# command in MicroPython.
import ffi
import jni
# Bootstrap JVM
jni.cls("java/lang/Object")
rt = ffi.open("/system/lib/libandroid_runtime.so")
# Note in 5.x, function may be called: jint registerFrameworkNatives(JNIEnv* env)
# https://android-review.googlesource.com/#/c/157981/1/core/jni/AndroidRuntime.cpp
registerNatives = rt.func("p", "Java_LoadClass_registerNatives", "pp")
registerNatives(jni.env(), None)
# This is older, Java-level way to register framework natives, but
# "registerNatives" method may be absent in 4.x devices, and class
# itself is removed in 5.x.
#fw = jni.cls("com.android.internal.util.WithFramework")
#fw.registerNatives()
ServiceManager = jni.cls("android/os/ServiceManager")
pm = ServiceManager.getService("package")
#print("Service:", pm)
IPackageManager = jni.cls("android/content/pm/IPackageManager")
#print("IPackageManager", IPackageManager)
IPackageManager_Stub = jni.cls("android/content/pm/IPackageManager$Stub")
#print(IPackageManager_Stub)
mPm = IPackageManager_Stub.asInterface(pm)
#print("mPm:", mPm, mPm.toString())
#print("=================")
res = mPm.getInstalledPackages(0, 0)
#res = pm.getInstalledPackages(0)
import ffi
sq3 = ffi.open("libsqlite3.so.0")
sqlite3_open = sq3.func("i", "sqlite3_open", "sp")
#int sqlite3_close(sqlite3*);
sqlite3_close = sq3.func("i", "sqlite3_close", "p")
#int sqlite3_prepare(
# sqlite3 *db, /* Database handle */
# const char *zSql, /* SQL statement, UTF-8 encoded */
# int nByte, /* Maximum length of zSql in bytes. */
# sqlite3_stmt **ppStmt, /* OUT: Statement handle */
# const char **pzTail /* OUT: Pointer to unused portion of zSql */
#);
sqlite3_prepare = sq3.func("i", "sqlite3_prepare", "psipp")
#int sqlite3_finalize(sqlite3_stmt *pStmt);
sqlite3_finalize = sq3.func("i", "sqlite3_finalize", "p")
#int sqlite3_step(sqlite3_stmt*);
sqlite3_step = sq3.func("i", "sqlite3_step", "p")
#int sqlite3_column_count(sqlite3_stmt *pStmt);
sqlite3_column_count = sq3.func("i", "sqlite3_column_count", "p")
#int sqlite3_column_type(sqlite3_stmt*, int iCol);
sqlite3_column_type = sq3.func("i", "sqlite3_column_type", "pi")
sqlite3_column_int = sq3.func("i", "sqlite3_column_int", "pi")
# using "d" return type gives wrong results
sqlite3_column_double = sq3.func("f", "sqlite3_column_double", "pi")
sqlite3_column_text = sq3.func("s", "sqlite3_column_text", "pi")
#sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
# TODO: should return long int
sqlite3_last_insert_rowid = sq3.func("i", "sqlite3_last_insert_rowid", "p")
#const char *sqlite3_errmsg(sqlite3*);
import ffi
l = ffi.open("libusb-1.0.so.0")
#int libusb_init(libusb_context **context)
libusb_init = l.func("i", "libusb_init", "p")
#const char *libusb_error_name(int errcode);
libusb_error_name = l.func("s", "libusb_error_name", "i")
#libusb_device_handle *libusb_open_device_with_vid_pid (libusb_context *ctx, uint16_t vendor_id, uint16_t product_id)
libusb_open_device_with_vid_pid = l.func("P", "libusb_open_device_with_vid_pid", "PHH")
#void libusb_close (libusb_device_handle *dev_handle)
libusb_close = l.func("v", "libusb_close", "P")
#int libusb_control_transfer(libusb_device_handle *dev_handle, uint8_t bmRequestType, uint8_t bRequest,
# uint16_t wValue, uint16_t wIndex, unsigned char *data, uint16_t wLength, unsigned int timeout)
libusb_control_transfer = l.func("i", "libusb_control_transfer", "PBBHHpHI")
#int libusb_get_string_descriptor_ascii(libusb_device_handle *dev,
# uint8_t desc_index, unsigned char *data, int length);
libusb_get_string_descriptor_ascii = l.func("i", "libusb_get_string_descriptor_ascii", "PBpi")
#/** In: device-to-host */
LIBUSB_ENDPOINT_IN = 0x80
#/** Out: host-to-device */
LIBUSB_ENDPOINT_OUT = 0x00
# Request type bits of the "bmRequestType" field in control transfers.
LIBUSB_REQUEST_TYPE_STANDARD = (0x00 << 5)
LIBUSB_REQUEST_TYPE_CLASS = (0x01 << 5)
LIBUSB_REQUEST_TYPE_VENDOR = (0x02 << 5)
LIBUSB_REQUEST_TYPE_RESERVED = (0x03 << 5)
try:
from ._fasttimer import timeit
except:
import ffi
path = __file__.split('/')[:-1]
if not path: path = '.'
else: path = '/'.join(path)
lib = ffi.open(path + '/_mpytimer.so')
_timeit = lib.func('d','timeit','Ci')
def timeit(callback,number=1000000):
cb = ffi.callback('v',callback,'')
return _timeit(cb,number)
def dlopen(name, mode):
log.debug("dlopen(%s, %x)" % (name, mode))
return ffi.open(name)
# Timer that matches machine.Timer (https://docs.micropython.org/en/latest/library/machine.Timer.html)
# for the unix port.
#
# MIT license; Copyright (c) 2021 Amir Gonnen
#
# Based on timer.py from micropython-lib (https://github.com/micropython/micropython-lib/blob/master/unix-ffi/machine/machine/timer.py)
import ffi
import uctypes
import array
import os
import sys
# FFI libraries
libc = ffi.open("libc.so.6")
librt = ffi.open("librt.so")
# C constants
CLOCK_REALTIME = 0
CLOCK_MONOTONIC = 1
SIGEV_SIGNAL = 0
# C structs
sigaction_t = {
"sa_handler": (0 | uctypes.UINT64),
"sa_mask": (8 | uctypes.ARRAY, 16 | uctypes.UINT64),
"sa_flags": (136 | uctypes.INT32),
"sa_restorer": (144 | uctypes.PTR, uctypes.UINT8),
import ffi
import array
pcre = ffi.open("libpcre.so.3")
# pcre *pcre_compile(const char *pattern, int options,
# const char **errptr, int *erroffset,
# const unsigned char *tableptr);
pcre_compile = pcre.func("p", "pcre_compile", "sipps")
# int pcre_exec(const pcre *code, const pcre_extra *extra,
# const char *subject, int length, int startoffset,
# int options, int *ovector, int ovecsize);
pcre_exec = pcre.func("i", "pcre_exec", "PPsiiipi")
# int pcre_fullinfo(const pcre *code, const pcre_extra *extra,
# int what, void *where);
pcre_fullinfo = pcre.func("i", "pcre_fullinfo", "PPip")
IGNORECASE = I = 1
MULTILINE = M = 2
DOTALL = S = 4
VERBOSE = X = 8
PCRE_ANCHORED = 0x10
# TODO. Note that Python3 has unicode by default
ASCII = A = 0
UNICODE = U = 0
AV_PIX_FMT_YUYV422 = 1
AV_PIX_FMT_RGB24 = 2
def AVERROR(e):
assert e > 0
return -e
def FFERRTAG(a, b, c, d):
return -(ord(a) | ord(b) << 8 | ord(c) << 16 | ord(d) << 24)
AVERROR_EOF = FFERRTAG('E', 'O', 'F', ' ')
_avcodec = ffi.open("libavcodec.so.57")
avcodec_register_all = _avcodec.func("i", "avcodec_register_all", "")
av_packet_alloc = _avcodec.func("P", "av_packet_alloc", "")
avcodec_find_decoder = _avcodec.func("P", "avcodec_find_decoder", "i")
av_parser_init = _avcodec.func("P", "av_parser_init", "i")
avcodec_alloc_context3 = _avcodec.func("P", "avcodec_alloc_context3", "P")
avcodec_open2 = _avcodec.func("i", "avcodec_open2", "PPP")
av_frame_alloc = _avcodec.func("P", "av_frame_alloc", "")
AVPacket_layout = OrderedDict({
"buf": (uctypes.PTR, uctypes.VOID),
"pts": uctypes.INT64,
"dts": uctypes.INT64,
"data": (uctypes.PTR, uctypes.UINT8),
"size": uctypes.INT32,