micropython-ffigen

#!/usr/bin/env python3.5
import sys
import json
import re
import os
import glob

MODULE = sys.stdout


def py_ffi_out(*code):
    global MODULE
    print( ' '.join(code), file=MODULE )


comment_level = 0

# https://github.com/ffi/ffi/wiki/Types
#
# nm --dynamic --demangle libNAME.so
# nm -g libNAME.a
#
FFI_TYPE_MAP = {
    ":void": "v",
    ":int": "i",
    ":signed-char": "b",
    ":unsigned-char": "B",
    ":short": "h",
    ":unsigned-short": "H",
    ":int": "i",
    ":unsigned-int": "I",
    ":long": "l",
    ":unsigned-long": "L",
    ":long-long": "q",
    ":unsigned-long-long": "Q",
    ":enum": "i",

    ":float": "f",
    ":double": "d",

    "uint8_t": "B",
    "uint16_t": "H",
    "uint32_t": "I",
    "ssize_t": "l",

    ":_Bool" : "B",
}

UCTYPES_TYPE_MAP = {
    ":void": "uctypes.VOID",
    ":char": "uctypes.INT8",
    ":signed-char": "uctypes.INT8",
    ":unsigned-char": "uctypes.UINT8",
    ":short": "uctypes.INT16",
    ":unsigned-short": "uctypes.UINT16",
    ":int": "uctypes.INT32",
    ":unsigned-int": "uctypes.UINT32",
    ":long": "uctypes.INT32",
    ":unsigned-long": "uctypes.UINT32",
    ":long-long": "uctypes.INT64",
    ":unsigned-long-long": "uctypes.UINT64",
    ":enum": "uctypes.INT32",

    ":float": "uctypes.FLOAT",
    ":double": "uctypes.DOUBLE",

    "uint8_t": "uctypes.UINT8",
    "uint16_t": "uctypes.UINT16",
    "uint32_t": "uctypes.UINT32",

    ":_Bool" : "uctypes.UINT8",

}


def matches_filters(loc, proj):
    process = False
    if "include" in proj:
        for pat in proj["include"]:
            if re.search(pat, loc):
                process = True
                break
    return process


def conv_ffi_type(rec):
    tag = rec["tag"]

    if tag == ":pointer":
        return "p"

    if tag == ":array":
        return "p"

    if tag in FFI_TYPE_MAP:
        return FFI_TYPE_MAP[rec["tag"]]

    assert 0, rec["tag"]



def conv_uctypes_type(rec, offset):
    tag = rec["tag"]

    if tag in UCTYPES_TYPE_MAP:
        v = UCTYPES_TYPE_MAP[rec["tag"]]
        if "%d" in v:
            return v % offset

        return "%s | %d" % (v, offset)

    if tag == ":pointer":
        if rec["type"]["tag"] == ":struct":
            return "(uctypes.PTR | %d, %s)" % (offset, rec["type"]["name"])
        elif rec["type"]["tag"] == ":pointer":
            return "(uctypes.PTR | %d, %s)" % (offset, "uctypes.VOID")

        if rec["type"]["tag"] not in UCTYPES_TYPE_MAP:
            assert 0, rec
        return "(uctypes.PTR | %d, %s)" % (offset, UCTYPES_TYPE_MAP[rec["type"]["tag"]])



    if tag == ":array":
        if rec["type"]["tag"] == ":function-pointer":
            return "(uctypes.ARRAY | %d, %d, (uctypes.PTR,))  # TODO: array of func-ptr" % \
                (offset, rec["size"])
        return "(uctypes.ARRAY | %d, %d, %s)" % (offset, rec["size"], UCTYPES_TYPE_MAP[rec["type"]["tag"]])

    if tag == ":function-pointer":
            return "(uctypes.PTR | %d, %s)  # TODO: func-ptr" % (offset, "uctypes.VOID")

    if tag == "union":
        return "# TODO: union"

    assert 0, rec["tag"]


def handle_typedef(desc, should_output=False):
    tag = desc["type"]["tag"]

    if tag in (":struct", "struct"):
        FFI_TYPE_MAP[desc["name"]] = desc["type"]["name"]
        UCTYPES_TYPE_MAP[desc["name"]] = desc["type"]["name"]
        if comment_level > 1:
            py_ffi_out("# typedef struct %s" % desc["name"])
        return

    if tag in (":union", "union"):
        FFI_TYPE_MAP[desc["name"]] = desc["type"]["name"]
        UCTYPES_TYPE_MAP[desc["name"]] = desc["type"]["name"]
        if comment_level > 1:
            py_ffi_out("# typedef union %s" % desc["name"])
        return

    if tag == ":pointer":
        FFI_TYPE_MAP[desc["name"]] = "p"
        # TODO
        UCTYPES_TYPE_MAP[desc["name"]] = "(uctypes.PTR | %d, uctypes.VOID)"
        if comment_level > 1:
            py_ffi_out("# typedef ptr %s" % desc["name"])
        return

    if tag == ":function-pointer":
        FFI_TYPE_MAP[desc["name"]] = "C"
        UCTYPES_TYPE_MAP[desc["name"]] = "(uctypes.PTR | %d, uctypes.VOID)"
        if comment_level > 1:
            py_ffi_out("# typedef func-ptr %s" % desc["name"])
        return

    FFI_TYPE_MAP[desc["name"]] = FFI_TYPE_MAP[desc["type"]["tag"]]
    UCTYPES_TYPE_MAP[desc["name"]] = UCTYPES_TYPE_MAP[desc["type"]["tag"]]
    if comment_level > 1:
        py_ffi_out("# typedef %s" % desc["name"])


#======================== auto builder ==========================================================

TREE='src'
HOME = os.getcwd()

site_packages='%s/site-packages' % os.getenv('MICROPYHOME','.')
lib_dynload = '%s/lib-dynload' % os.getenv('MICROPYHOME','.')

if os.access('/system/bin/linker64',0):
    ARCH = 'android-armv8'
elif os.access('/system/bin/linker',0):
    ARCH = 'android-armv7'


os.system('mkdir -p %s'% site_packages)
os.system('mkdir -p %s'% lib_dynload)


for module_file in glob.glob('%s/mod_*.py' % TREE):

    if os.path.exists('%s.skip' % module_file ):
        print('Skipping %s' % module_file)
        continue
    print()
    print()

    module_name = module_file.rsplit('/mod_',1)[-1][:-3]
    print('[%s]'%  module_name)

    module_dest ='%s/%s' % ( site_packages, module_name)
    os.system('mkdir -p %s' % module_dest)


    soname = '%s/_%s-%s.so' % (lib_dynload,module_name, ARCH )

    print('\tBuilding shared (bin)',soname)

    cbuild = 'mod_%s.build' % module_name
    if os.path.isfile('%s/%s' %(TREE, cbuild )):
        #custom build will take soname as $1
        print("\tCustom build for :", module_name)
        os.chdir( TREE )
        os.system('./%s %s' %( cbuild , soname) )
        comment_level = 1
    else:
        os.chdir('%s/%s' % (TREE, module_name ) )
        objs=[]
        for c_file in glob.glob('*.c'):
            build_obj = 'gcc -O3 -c -fsanitize=bool -Wall -Werror -fpic -o %s.o %s' % (c_file[:-2],c_file)
            print('\t', build_obj)
            os.system(build_obj)
            objs.append(c_file[:-2]+'.o')
        for c_file in glob.glob('*.cpp'):
            build_obj = 'gcc -O3 -c -fsanitize=bool -Wall -Werror -fpic -o %s.o %s' % (c_file[:-2],c_file)
            print('\t', build_obj)
            os.system(build_obj)
            objs.append(c_file[:-2]+'.o')


        build_so = 'gcc -O3 -shared -o %s %s' %( soname , ' '.join( objs ) )

        print("\t",build_so)
        os.system(build_so)
        #os.system('rm *.o')
        os.system('cat *.h > ../%s.h' % module_name )
        os.chdir('..')

    os.system('c2ffi %s.h > %s.c2ffi' % (module_name,module_name) )

    with open( '%s.c2ffi' % module_name ) as f:
        data = json.load(f)
        proj = { 'lib' : """ '%s/lib-dynload/_%s.so' % ( os.getenv('MICROPYHOME','.'), '"""+ module_name + "')" }

    os.unlink('%s.c2ffi' % module_name )
    os.chdir(HOME)

    print('\tBuilding loader (source)',module_dest )

    MODULE = open('%s/%s/__init__.py' % (site_packages,module_name) ,'w')

    py_ffi_out("""import os
import sys
import ffi
import uctypes
if os.access("/system/bin/linker64",0):l="android-armv8"
elif os.access("/system/bin/linker",0):l="android-armv7"
else: l= "linux-%s" % os.popen('arch').read().strip()
l = "_""" + module_name +"""-%s.so" % l
l = "%s/%s" %( '%s/lib-dynload' % os.getenv('MICROPYHOME','.') , l )
print("Loading native lib",l,file=sys.stderr)
l = ffi.open(l)
""" )


    for desc in data:
        loc = desc["location"]
        process = matches_filters(loc, proj)

        # We need to collect all types for future references
        if desc["tag"] == "typedef":
            handle_typedef(desc, process)
            continue

        if not process:
            if comment_level > 0:
                py_ffi_out("# Ignoring %s" % loc)
            #continue

        if comment_level > 0:
            py_ffi_out("# Processing %s" % loc)

        if desc["tag"] == "function":
            params = [conv_ffi_type(x["type"]) for x in desc["parameters"]]
            s = '%s = l.func("%s", "%s", "%s")' % (desc["name"], conv_ffi_type(desc["return-type"]), desc["name"], "".join(params))
            if desc.get("inline", False):
                py_ffi_out("#%s" % s)
            else:
                py_ffi_out(s)
        elif desc["tag"] == "enum":
            py_ffi_out("# %s" % desc["name"])
            for f in desc["fields"]:
                py_ffi_out("%s = %s" % (f["name"], f["value"]))
        elif desc["tag"] == "struct":
            py_ffi_out("%s = {" % desc["name"])
            for f in desc["fields"]:
                py_ffi_out('    "%s": %s,' % (f["name"], conv_uctypes_type(f["type"], f["bit-offset"] / 8)))

            if desc["bit-size"] != 0:
                # This doesn't have to be true due to alignment
                #assert desc["bit-size"] == f["bit-offset"] + f["bit-size"]
                pass

            py_ffi_out("}")
        else:
            py_ffi_out(desc)
            assert 0, desc["tag"]
            pass

    py_ffi_out("\ndel l")
    py_ffi_out("#","="*79)
    py_ffi_out("\n"*2)
    MODULE.close()


    os.system('cat %s >> %s/__init__.py' % ( module_file, module_dest ) )





#
#if len(sys.argv) < 3 or len(sys.argv) > 4:
#    py_ffi_out("usage: %s <proj>.json <c2ffi>.json [<c2ffi-macro>.h]" % sys.argv[0])
#    sys.exit(1)
#
#
#if len(sys.argv) > 3:
#    with open(sys.argv[3]) as f:
#        py_ffi_out("\n# Constants\n")
#        items = []
#        for l in f:
#            if l.startswith("/* "):
#                loc = l[3:-4]
#            elif l.startswith("#define "):
#                if matches_filters(loc, proj):
#                    _, name, val = l.rstrip().split(" ", 2)
#                    loc = loc.split(":")
#                    items.append((loc[0], int(loc[1]), name, val))
#        items.sort()
#        for fname, line, name, val in items:
#            #py_ffi_out("#%s:%s" % (fname, line))
#            py_ffi_out("%s = %s" % (name, val))












#