micropython-ffigen

#!/usr/bin/env python3
import sys
import json
import re


comment_level = 0

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",
}

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",
}


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):
    if rec["tag"] == ":pointer":
        return "p"
    if rec["tag"] == ":array":
        return "p"
    if rec["tag"] in FFI_TYPE_MAP:
        return FFI_TYPE_MAP[rec["tag"]]
    assert 0, rec["tag"]

def conv_uctypes_type(rec, offset):
    if rec["tag"] in UCTYPES_TYPE_MAP:
        v = UCTYPES_TYPE_MAP[rec["tag"]]
        if "%d" in v:
            return v % offset
        else:
            return "%s | %d" % (v, offset)
    if rec["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")
        else:
            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 rec["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 rec["tag"] == ":function-pointer":
            return "(uctypes.PTR | %d, %s)  # TODO: func-ptr" % (offset, "uctypes.VOID")
    if rec["tag"] == "union":
        return "# TODO: union"
    assert 0, rec["tag"]


def handle_typedef(desc, should_output=False):
    if desc["type"]["tag"] in (":struct", "struct"):
        FFI_TYPE_MAP[desc["name"]] = desc["type"]["name"]
        UCTYPES_TYPE_MAP[desc["name"]] = desc["type"]["name"]
        if comment_level > 1:
            print("# typedef struct %s" % desc["name"])
    elif desc["type"]["tag"] in (":union", "union"):
        FFI_TYPE_MAP[desc["name"]] = desc["type"]["name"]
        UCTYPES_TYPE_MAP[desc["name"]] = desc["type"]["name"]
        if comment_level > 1:
            print("# typedef union %s" % desc["name"])
    elif desc["type"]["tag"] == ":pointer":
        FFI_TYPE_MAP[desc["name"]] = "p"
        # TODO
        UCTYPES_TYPE_MAP[desc["name"]] = "(uctypes.PTR | %d, uctypes.VOID)"
        if comment_level > 1:
            print("# typedef ptr %s" % desc["name"])
    elif desc["type"]["tag"] == ":function-pointer":
        FFI_TYPE_MAP[desc["name"]] = "C"
        UCTYPES_TYPE_MAP[desc["name"]] = "(uctypes.PTR | %d, uctypes.VOID)"
        if comment_level > 1:
            print("# typedef func-ptr %s" % desc["name"])
    else:
        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:
            print("# typedef %s" % desc["name"])


if len(sys.argv) < 3 or len(sys.argv) > 4:
    print("usage: %s <proj>.json <c2ffi>.json [<c2ffi-macro>.h]" % sys.argv[0])
    sys.exit(1)


with open(sys.argv[1]) as f:
    proj = json.load(f)

with open(sys.argv[2]) as f:
    data = json.load(f)

print("import ffi")
print("import uctypes")
print()
print('l = ffi.open("%s")' % proj["lib"])
print()


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":
#        print("Processing %s" % loc)
        handle_typedef(desc, process)
        continue

    if not process:
        if comment_level > 0:
            print("# Ignoring %s" % loc)
        continue
    if comment_level > 0:
        print("# 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):
            print("#%s" % s)
        else:
            print(s)
    elif desc["tag"] == "enum":
        print("# %s" % desc["name"])
        for f in desc["fields"]:
            print("%s = %s" % (f["name"], f["value"]))
    elif desc["tag"] == "struct":
        print("%s = {" % desc["name"])
        for f in desc["fields"]:
            print('    "%s": %s,' % (f["name"], conv_uctypes_type(f["type"], f["bit-offset"] / 8)))
#            print(f)
        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
#        print(desc)
        print("}")
    else:
        print(desc)
        assert 0, desc["tag"]
        pass


if len(sys.argv) > 3:
    with open(sys.argv[3]) as f:
        print("\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:
            #print("#%s:%s" % (fname, line))
            print("%s = %s" % (name, val))