Include ffi lib?

[gynt]

Options:
https://github.com/zhaojh329/lua-ffi
https://github.com/q66/cffi-lua

Or roll our own:

c11 = require("c11")
lpegrex = require("lpegrex")

node = c11([[

    struct A {
        int a;
        short b;
        char c;
        void * d;
        char field_0x100;
        char e[100];
        char * f;
    };
    
]], "struct_test")

type_size_lookup = {
    ["char"] = 1,
    ["byte"] = 1,
    ["short"] = 2,
    ["int"] = 4,
    ["void *"] = 4,
    ["char *"] = 4,
}

type_getter_lookup = {
    ["char"] = "readByte",
    ["byte"] = "readByte",
    ["short"] = "readSmallInteger",
    ["int"] = "readInteger",
    ["void *"] = "readInteger",
    ["char *"] = "readInteger",
    ["char[*]"] = "readString",
}

type_setter_lookup = {
    ["char"] = "writeByte",
    ["byte"] = "writeByte",
    ["short"] = "writeSmallInteger",
    ["int"] = "writeInteger",
    ["void *"] = "writeInteger",
    ["char *"] = "writeInteger",
    ["char[*]"] = "writeString",
}

-- todo implement this before c11 parsing
type_preprocessor = {
    ["undefined"] = "char",
    ["byte"] = "char",
    ["undefined2"] = "short",
    ["undefined4"] = "int",
}

function generate_struct(node, ignore_prefix)
    local ignoring = false
    if ignore_prefix ~= nil then
        ignoring = true
    end
    if node.tag ~= "struct-or-union-specifier" then error() end
    if node[1] ~= "struct" then error() end
    name = node[3]
    print(string.format("generate_struct: struct name: %s", name))
    
    sdl = node[4]
    
    offset = 0
    
    getters = {}
    setters = {}
    
    for k, sd in ipairs(sdl) do        
        type_size = nil
        
        sql = sd[1]
        tp = sql[1]
        type_string = tp[1]
        
        dl = sd[2]
        sdr = dl[1]
        d = sdr[1]
        
        pointer_string = nil
        
        if d[1].tag == "identifier" then
            id = d[1]        
            identifier_string = id[1]
            
            full_type_string = type_string
        elseif d[1].tag == "pointer" then
            p = d[1]
            id = p[3]
            identifier_string = id[1]
            pointer_string = (pointer_string or "") .. "*"
            
            full_type_string = type_string .. " " .. pointer_string
        elseif d[1].tag == "declarator-subscript" then
            node_to_solve = d[1]
            subscript = d[1]
            id = subscript[1]
            identifier_string = id[1]
            integer_constant = subscript[3]
            type_size = integer_constant[1] * type_size_lookup[type_string]
            -- error("node_to_solve")
            
            full_type_string = type_string .. "[*]"
        else
            error(d[1].tag)
        end    
        
        if ignoring and identifier_string:sub(1, ignore_prefix:len()) == ignore_prefix then
            -- continue
        else
        
            -- if identifier_string == "new" or identifier_string == "at" then
                -- error(string.format("reserved name: %s", identifier_string))
            -- end
            
            if type_size == nil then
                type_size = type_size_lookup[full_type_string]
            end
            
            if type_size == nil then error(full_type_string) end

            print(string.format("name: %s, type: %s, size: %s, offset: %s", identifier_string, full_type_string, type_size, offset))
            
            g = type_getter_lookup[full_type_string]
            if g == nil then error(full_type_string) end
            
            if full_type_string == "char[*]" then
                getter = string.format([[
                    if k == "%s" then
                        return %s(address + %s, %s)
                    end
                ]], identifier_string, g, offset, type_size)
                
                s = type_setter_lookup[full_type_string]
                if s == nil then error(full_type_string) end
                
                setter = string.format([[
                    if k == "%s" then
                        if v:len() >= %s then
                            error("string too large")
                        end
                        return %s(address + %s, v)
                    end
                ]], identifier_string, type_size, s, offset)
            else
                getter = string.format([[
                    if k == "%s" then
                        return %s(address + %s)
                    end
                ]], identifier_string, g, offset)
                
                s = type_setter_lookup[full_type_string]
                if s == nil then error(full_type_string) end
                
                setter = string.format([[
                    if k == "%s" then
                        return %s(address + %s, v)
                    end
                ]], identifier_string, s, offset)
            end

            
            table.insert(getters, getter)
            table.insert(setters, setter)
            
        end
        
        offset = offset + type_size
        
             
    end
    
    size = offset

    return string.format([[
return function(address)
    local allocated = false
    local deallocated = nil
    local size = %s
    if address == nil then
        print("allocating")
        allocated = true
        deallocated = false
        address = allocate(size)
    end
    if type(address) ~= "number" then
        error("not a valid address:" .. tostring(address))
    end
    
    local mt = {
        __index = function(t, k)
%s
        end,
        
        __newindex = function(t, k, v)
%s
        end,
        
        __gc = function(t)
            if allocated and deallocated == false then
                deallocate(address)
                deallocated = true
            end
        end,
        
        __len = function(t)
            return size
        end,
    }
    
    return setmetatable({}, mt)
end
    ]], size, table.concat(getters, "\n\n"), table.concat(setters, "\n\n"))
end

function translation_unit_to_struct_specifier(node)
    return node[1][1][1][1][1] -- todo: ignores possibility of multiple struct definitions
end

lua = generate_struct(translation_unit_to_struct_specifier(node))

compile = load(lua, "generator", 't', {
    error = error,
    tostring = tostring,
    print = print,
    type = type,
    table = table,
    string = string,
    setmetatable = setmetatable,
    allocate = function(size) fakeResult = 0x400000 + size; print(string.format("allocate %s => %X", size, fakeResult)); return fakeResult end,
    deallocate = function(address) print(string.format("deallocate %X", address)) end,
    readByte = function(address) print(string.format("readByte %X", address)) end,
    readSmallInteger = function(address) print(string.format("readSmallInteger %X", address)) end,
    readInteger = function(address) print(string.format("readInteger %X", address)) end,
    readString = function(address, size) print(string.format("readString %X %s", address, size)) end,
    writeByte = function(address) print(string.format("writeByte %X", address)) end,
    writeSmallInteger = function(address) print(string.format("writeSmallInteger %X", address)) end,
    writeInteger = function(address) print(string.format("writeInteger %X", address)) end,
    writeString = function(address, data) print(string.format("writeString %X %s", address, data)) end,
})

A = compile()
a = A(0x400000)
b = A() -- allocated

print(#b)

b = nil
collectgarbage()