Working version of parselog

Author: timholy

.github/workflows/CI.yml

@@ -23,9 +23,9 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - '1.10'
-          - '1.6'
+          - 'min'
           - 'pre'
+          - 'nightly'
         os:
           - ubuntu-latest
         arch:

.gitignore

@@ -3,3 +3,4 @@
 *.jl.mem
 /docs/Manifest*.toml
 /docs/build/
+Manifest.toml

Manifest.toml

@@ -3,8 +3,12 @@ uuid = "d61f35a8-f6af-436f-bc10-cee6b101f7bd"
 authors = ["Tim Holy <[email protected]> and contributors"]
 version = "1.0.0-DEV"
 
+[deps]
+Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
+
 [compat]
-julia = "1.6.7"
+Graphs = "1"
+julia = "1.12"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

Project.toml

@@ -1,5 +1,9 @@
 module JuliaLibWrapping
 
-# Write your package code here.
+using Graphs
+
+export parselog
+
+include("parselog.jl")
 
 end

src/JuliaLibWrapping.jl

@@ -0,0 +1,104 @@
+struct FieldDesc
+    name::String
+    type::String
+    offset::Int
+end
+function Base.show(io::IO, field::FieldDesc)
+    print(io, field.name, "::", field.type, "[", field.offset, "]")
+end
+
+struct TypeDesc
+    name::String
+    fields::Vector{FieldDesc}
+    size::Int
+end
+function Base.show(io::IO, type::TypeDesc)
+    print(io, type.name, "(", join(type.fields, ", "), ") (", type.size, " bytes)")
+end
+
+struct ArgDesc
+    name::String
+    type::String
+    isva::Bool  # is this a varargs argument?
+end
+function Base.show(io::IO, arg::ArgDesc)
+    print(io, arg.name, "::", arg.type)
+    if arg.isva
+        print(io, "...")
+    end
+end
+
+struct MethodDesc
+    name::String
+    return_type::String
+    args::Vector{ArgDesc}
+end
+
+function Base.show(io::IO, method::MethodDesc)
+    print(io, method.name, "(", join(method.args, ", "), ")::", method.return_type)
+end
+
+const rexsize = r"^(\d+) bytes$"
+const rexfield = r"^  (.+)::(.+)\[(\d+)\]$"
+const rexmethod = r"^(.+)\((.*)\)::(.+)$"
+const rexarg = r"^(.+)::(.+)(\.\.\.)?$"
+
+"""
+    entrypoints, typedescs = parselog(filename::String)
+
+Extract the signatures of the entrypoints and nonstandard types from a log file.
+"""
+function parselog(filename::String)
+    entrypoints = MethodDesc[]
+    typedescs = Dict{String, TypeDesc}()
+
+    open(filename) do f
+        handling_types = false
+        while !eof(f)
+            line = rstrip(readline(f))
+            if isempty(line)
+                handling_types = true
+                continue
+            elseif handling_types
+                current_type = line
+                fields = FieldDesc[]
+                line = rstrip(readline(f))  # Read the next line for type details
+                m = match(rexsize, line)
+                while m === nothing
+                    m = match(rexfield, line)
+                    field_name = m.captures[1]
+                    field_type = m.captures[2]
+                    field_offset = parse(Int, m.captures[3])
+                    push!(fields, FieldDesc(field_name, field_type, field_offset))
+                    line = rstrip(readline(f))
+                    m = match(rexsize, line)
+                end
+                type_size = parse(Int, m.captures[1])
+                typedescs[current_type] = TypeDesc(current_type, fields, type_size)
+            else   # methods
+                m = match(rexmethod, line)
+                method_name = m.captures[1]
+                args_str = m.captures[2]
+                return_type = m.captures[3]
+
+                args = ArgDesc[]
+                for arg_str in split(args_str, ",")
+                    arg_str = strip(arg_str)
+                    if isempty(arg_str)
+                        continue
+                    end
+                    m = match(rexarg, arg_str)
+                    arg_name = m.captures[1]
+                    arg_type = m.captures[2]
+                    isva = length(m.captures) > 2 && m.captures[3] !== nothing  # Check for varargs
+                    push!(args, ArgDesc(arg_name, arg_type, isva))
+                end
+
+                push!(entrypoints, MethodDesc(method_name, return_type, args))
+            end
+        end
+    end
+
+    return entrypoints, typedescs
+end
+parselog(filename::AbstractString) = parselog(String(filename)::String)

src/parselog.jl

@@ -0,0 +1,10 @@
+copyto_and_sum(fromto::CVectorPair{Float32})::Float32
+
+CVectorPair{Float32}
+  from::CVector{Float32}[0]
+  to::CVector{Float32}[16]
+32 bytes
+CVector{Float32}
+  length::Int32[0]
+  data::Ptr{Float32}[8]
+16 bytes

test/bindinginfo_simplelib.log

@@ -2,5 +2,42 @@ using JuliaLibWrapping
 using Test
 
 @testset "JuliaLibWrapping.jl" begin
-    # Write your tests here.
+    @testset "parselog" begin
+        entrypoints, typedescs = parselog("bindinginfo_simplelib.log")
+        methdesc = only(entrypoints)
+        @test methdesc.name == "copyto_and_sum"
+        @test methdesc.return_type == "Float32"
+        @test length(methdesc.args) == 1
+        argdesc = only(methdesc.args)
+        @test argdesc.name == "fromto"
+        @test argdesc.type == "CVectorPair{Float32}"
+        @test argdesc.isva == false
+        @test length(typedescs) == 2
+        tdesc = typedescs["CVectorPair{Float32}"]
+        @test tdesc.name == "CVectorPair{Float32}"
+        @test length(tdesc.fields) == 2
+        @test tdesc.fields[1].name == "from"
+        @test tdesc.fields[1].type == "CVector{Float32}"
+        @test tdesc.fields[1].offset == 0
+        @test tdesc.fields[2].name == "to"
+        @test tdesc.fields[2].type == "CVector{Float32}"
+        @test tdesc.fields[2].offset == 16
+        @test tdesc.size == 32
+        tdesc = typedescs["CVector{Float32}"]
+        @test tdesc.name == "CVector{Float32}"
+        @test length(tdesc.fields) == 2
+        @test tdesc.fields[1].name == "length"
+        @test tdesc.fields[1].type == "Int32"
+        @test tdesc.fields[1].offset == 0
+        @test tdesc.fields[2].name == "data"
+        @test tdesc.fields[2].type == "Ptr{Float32}"
+        @test tdesc.fields[2].offset == 8
+        @test tdesc.size == 16
+        @test haskey(typedescs, "CVectorPair{Float32}")
+        @test haskey(typedescs, "CVector{Float32}")
+        @test sprint(show, only(entrypoints)) == "copyto_and_sum(fromto::CVectorPair{Float32})::Float32"
+        str = sprint(show, typedescs)
+        @test occursin("CVectorPair{Float32}(from::CVector{Float32}[0], to::CVector{Float32}[16]) (32 bytes)", str)
+        @test occursin("CVector{Float32}(length::Int32[0], data::Ptr{Float32}[8]) (16 bytes)", str)
+    end
 end