Re-factor: Rename parselog to import_abi_info

Also add a struct definition to be able to conveniently document the
various bits of output data.

Author: topolarity

src/JuliaLibWrapping.jl

@@ -3,10 +3,10 @@ module JuliaLibWrapping
 using OrderedCollections
 using Graphs
 
-export parselog, wrapper
-export CProject
+export import_abi_info, wrapper
+export CProject, ABIInfo
 
-include("parselog.jl")
+include("abi_import.jl")
 include("c.jl")
 
 end

src/parselog.jl renamed to src/abi_import.jl

@@ -113,26 +113,16 @@ function build_type_graph(typedescs::OrderedDict{Int, TypeDesc};
 end
 
 """
-    entrypoints, typedescs = parselog(filename::String)
+    sort_declarations!(typedescs) -> forward_declarations
 
-Extract the signatures of the entrypoints and nonstandard types from a log file.
-"""
-function parselog(filename::String)
-    abi_info = JSON.Parser.parsefile(filename)
-
-    # Extract all the type descriptors
-    typedescs = OrderedDict{Int, TypeDesc}()
-    for type in abi_info["types"]
-        id = type["id"]::Int
-        typedescs[id] = from_json(TypeDesc, type)
-    end
-
-    # Then collect the methods
-    entrypoints = MethodDesc[]
-    for method in abi_info["functions"]
-        push!(entrypoints, from_json(MethodDesc, method))
-    end
+Sort `typedescs` w.r.t. type-dependencies (e.g. Type A using Type B in a field),
+so that a type-descriptor always appears after any dependencies. Sort is performed
+in-place.
 
+Returns indices of all types that could not be sorted (due to recursive types, e.g.
+a linked list in C). In C, these are the definitions that must be forward-declared.
+"""
+function sort_declarations!(typedescs::OrderedDict{Int, TypeDesc})
     # First we have to identify the parts of the graph where we have type-recursion and
     # therefore have to use forward-declarations instead of just sorting declarations.
     recursive_types = BitSet()
@@ -178,6 +168,42 @@ function parselog(filename::String)
         end
     end
 
-    return entrypoints, typedescs, forwarddecls
+    return forwarddecls
+end
+
+struct ABIInfo
+    # A map from `type_id` to `type_descriptor`, sorted by declaration order.
+    typeinfo::OrderedDict{Int, TypeDesc}
+    # Indexes into `types`, indicates which types must be forward-declared for C.
+    forward_declared::BitSet
+    # A vector of exposed functions from the imported ABI
+    entrypoints::Vector{MethodDesc}
+end
+
+"""
+    entrypoints, typedescs, forward_declarations = parselog(filename::String)
+
+Extract the signatures of the entrypoints and types from an exported ABI info (JSON) file.
+"""
+function import_abi_info(filename::String)
+    abi_info = JSON.Parser.parsefile(filename)
+
+    # Extract all the type descriptors
+    typedescs = OrderedDict{Int, TypeDesc}()
+    for type in abi_info["types"]
+        id = type["id"]::Int
+        typedescs[id] = from_json(TypeDesc, type)
+    end
+
+    # Then collect the methods
+    entrypoints = MethodDesc[]
+    for method in abi_info["functions"]
+        push!(entrypoints, from_json(MethodDesc, method))
+    end
+
+    forward_declared = sort_declarations!(typedescs)
+
+    return ABIInfo(typedescs, forward_declared, entrypoints)
 end
-parselog(filename::AbstractString) = parselog(String(filename)::String)
+
+import_abi_info(filename::AbstractString) = import_abi_info(String(filename)::String)

src/c.jl

@@ -3,7 +3,9 @@ struct CProject
     headerbase::String
 end
 
-function wrapper(dest::CProject, entrypoints, typedescs, forwarddecls)
+function wrapper(dest::CProject, abi_info::ABIInfo)
+    (; entrypoints, typeinfo, forward_declared) = abi_info
+
     # Write the header file for C
     headerfile = joinpath(dest.dir, dest.headerbase * ".h")
     libvar = "JULIALIB_" * uppercase(dest.headerbase) * "_H"
@@ -18,20 +20,20 @@ function wrapper(dest::CProject, entrypoints, typedescs, forwarddecls)
         typedict = Dict{Int, String}()
 
         # Print forward-declarations (if any, for recursive types)
-        for id in forwarddecls
-            type = typedescs[id]
+        for id in forward_declared
+            type = typeinfo[id]
             @assert type isa StructDesc "un-expected forward declaration type"
-            mangled_name = mangle_c!(typedict, id, typedescs)
+            mangled_name = mangle_c!(typedict, id, typeinfo)
             println(f, "struct ", mangled_name, ";")
         end
 
         # Print the struct definitions
-        for (id, type) in pairs(typedescs)
+        for (id, type) in pairs(typeinfo)
             if type isa StructDesc
-                mangled_name = mangle_c!(typedict, id, typedescs)
+                mangled_name = mangle_c!(typedict, id, typeinfo)
                 println(f, "typedef struct ", mangled_name, " {")
                 for field in type.fields
-                    ft = mangle_c!(typedict, field.type, typedescs)
+                    ft = mangle_c!(typedict, field.type, typeinfo)
                     println(f, "    ", ft, " ", sanitize_for_c(field.name), ";")
                 end
                 println(f, "} ", mangled_name, ";")
@@ -48,7 +50,7 @@ function wrapper(dest::CProject, entrypoints, typedescs, forwarddecls)
             if !isempty(args)
                 args = ", " * args
             end
-            mangled_rt = mangle_c!(typedict, method.return_type, typedescs)
+            mangled_rt = mangle_c!(typedict, method.return_type, typeinfo)
             print(f, mangled_rt, " ", method.symbol, "(")
             isfirst = true
             for arg in method.args
@@ -57,7 +59,7 @@ function wrapper(dest::CProject, entrypoints, typedescs, forwarddecls)
                 else
                     print(f, ", ")
                 end
-                ft = mangle_c!(typedict, arg.type, typedescs)
+                ft = mangle_c!(typedict, arg.type, typeinfo)
                 print(f, ft, " ", sanitize_for_c(arg.name))
                 if arg.isva
                     print(f, "...")
@@ -107,19 +109,19 @@ function sanitize_for_c(str::AbstractString)
     return replace(str, r"[^a-zA-Z0-9_]" => "_")
 end
 
-function mangle_c!(typedict::Dict{Int, String}, type_id::Int, typedescs::OrderedDict{Int,TypeDesc})
+function mangle_c!(typedict::Dict{Int, String}, type_id::Int, typeinfo::OrderedDict{Int,TypeDesc})
     if type_id in keys(typedict)
         return typedict[type_id]
     end
 
-    type = typedescs[type_id]
+    type = typeinfo[type_id]
     if type isa PrimitiveTypeDesc
         if !in(type.name, keys(ctypes))
             error("unsupported primitive type: '$(type.name)'")
         end
         return ctypes[type.name]
     elseif type isa PointerDesc
-        mangled = mangle_c!(typedict, type.pointee_type, typedescs) * "*"
+        mangled = mangle_c!(typedict, type.pointee_type, typeinfo) * "*"
     elseif type isa StructDesc
         mangled = sanitize_for_c(type.name)
     end

test/runtests.jl

@@ -10,71 +10,72 @@ function onlymatch(f, collection)
 end
 
 @testset "JuliaLibWrapping.jl" begin
-    @testset "parselog" begin
-        entrypoints, typedescs, forwarddecls = parselog("bindinginfo_libsimple.json")
+    @testset "import_abi_info" begin
+        abi_info = import_abi_info("bindinginfo_libsimple.json")
+        (; entrypoints, typeinfo) = abi_info
 
         methdesc = onlymatch(md -> md.symbol == "copyto_and_sum", entrypoints)
-        @test typedescs[methdesc.return_type].name == "Float32"
+        @test typeinfo[methdesc.return_type].name == "Float32"
         @test length(methdesc.args) == 1
         argdesc = only(methdesc.args)
         @test argdesc.name == "fromto"
-        @test typedescs[argdesc.type].name == "CVectorPair{Float32}"
+        @test typeinfo[argdesc.type].name == "CVectorPair{Float32}"
         @test argdesc.isva == false
 
         methdesc = onlymatch(md -> md.symbol == "countsame", entrypoints)
-        @test typedescs[methdesc.return_type].name == "Int32"
+        @test typeinfo[methdesc.return_type].name == "Int32"
         @test length(methdesc.args) == 2
         argdesc1, argdesc2 = methdesc.args
         @test argdesc1.name == "list"
-        @test typedescs[argdesc1.type].name == "Ptr{MyTwoVec}"
+        @test typeinfo[argdesc1.type].name == "Ptr{MyTwoVec}"
         @test argdesc1.isva == false
         @test argdesc2.name == "n"
-        @test typedescs[argdesc2.type].name == "Int32"
+        @test typeinfo[argdesc2.type].name == "Int32"
         @test argdesc2.isva == false
 
-        @test length(typedescs) >= 3
+        @test length(typeinfo) >= 3
         findtype(descs, name) = (k = collect(keys(descs)); k[findfirst((id)->descs[id].name === name, k)])
 
-        tdesc = typedescs[findtype(typedescs, "CVectorPair{Float32}")]
+        tdesc = typeinfo[findtype(typeinfo, "CVectorPair{Float32}")]
         @test tdesc.name == "CVectorPair{Float32}"
         @test length(tdesc.fields) == 2
         @test tdesc.fields[1].name == "from"
-        @test typedescs[tdesc.fields[1].type].name == "CVector{Float32}"
+        @test typeinfo[tdesc.fields[1].type].name == "CVector{Float32}"
         @test tdesc.fields[1].offset == 0
         @test tdesc.fields[2].name == "to"
-        @test typedescs[tdesc.fields[2].type].name == "CVector{Float32}"
+        @test typeinfo[tdesc.fields[2].type].name == "CVector{Float32}"
         @test tdesc.fields[2].offset == 16
         @test tdesc.size == 32
-        tdesc = typedescs[findtype(typedescs, "CVector{Float32}")]
+        tdesc = typeinfo[findtype(typeinfo, "CVector{Float32}")]
         @test tdesc.name == "CVector{Float32}"
         @test length(tdesc.fields) == 2
         @test tdesc.fields[1].name == "length"
-        @test typedescs[tdesc.fields[1].type].name == "Int32"
+        @test typeinfo[tdesc.fields[1].type].name == "Int32"
         @test tdesc.fields[1].offset == 0
         @test tdesc.fields[2].name == "data"
-        @test typedescs[tdesc.fields[2].type].name == "Ptr{Float32}"
+        @test typeinfo[tdesc.fields[2].type].name == "Ptr{Float32}"
         @test tdesc.fields[2].offset == 8
         @test tdesc.size == 16
-        tdesc = typedescs[findtype(typedescs, "MyTwoVec")]
+        tdesc = typeinfo[findtype(typeinfo, "MyTwoVec")]
         @test tdesc.name == "MyTwoVec"
         @test length(tdesc.fields) == 2
         @test tdesc.fields[1].name == "x"
-        @test typedescs[tdesc.fields[1].type].name == "Int32"
+        @test typeinfo[tdesc.fields[1].type].name == "Int32"
         @test tdesc.fields[1].offset == 0
         @test tdesc.fields[2].name == "y"
-        @test typedescs[tdesc.fields[2].type].name == "Int32"
+        @test typeinfo[tdesc.fields[2].type].name == "Int32"
         @test tdesc.fields[2].offset == 4
         @test tdesc.size == 8
-        name2idx = Dict(desc.name => i for (i, desc) in enumerate(values(typedescs)))
+        name2idx = Dict(desc.name => i for (i, desc) in enumerate(values(typeinfo)))
         @test name2idx["CVectorPair{Float32}"] > name2idx["CVector{Float32}"]
     end
 
     @testset "C wrapper" begin
         mktempdir() do path
             mkpath(path)
             dest = CProject(path, "libsimple")
-            entrypoints, typedescs, forwarddecls = parselog("bindinginfo_libsimple.json")
-            wrapper(dest, entrypoints, typedescs, forwarddecls)
+            abi_info = import_abi_info("bindinginfo_libsimple.json")
+            wrapper(dest, abi_info)
 
             headerfile = joinpath(dest.dir, dest.headerbase * ".h")
             @test isfile(headerfile)