Extend parsing of documentation

.github/workflows/format.yml

@@ -18,8 +18,8 @@ jobs:
       - uses: actions/checkout@v2
       - name: Install JuliaFormatter and format
         run: |
-          julia  -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter", version="0.21.1"))'
-          julia  -e 'using JuliaFormatter; format(["./src", "./test", "./parse"], verbose=true)'
+          julia  -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter", version="0.22.10"))'
+          julia  -e 'using JuliaFormatter; format(["./src", "./test"], verbose=true)'
       - name: Format check
         run: |
           julia -e '

Project.toml

@@ -1,7 +1,7 @@
 name = "Arblib"
 uuid = "fb37089c-8514-4489-9461-98f9c8763369"
 authors = ["Marek Kaluba <kalmar@amu.edu.pl>", "Sascha Timme <Sascha Timme <timme@math.tu-berlin.de>", "Joel Dahne <joel@dahne.eu>"]
-version = "0.6.4"
+version = "0.7.0"
 
 [deps]
 Arb_jll = "d9960996-1013-53c9-9ba4-74a4155039c3"

src/ArbCall/ArbArgTypes.jl

@@ -0,0 +1,84 @@
+struct UnsupportedArgumentType <: Exception
+    key::String
+end
+
+"""
+    ArbArgTypes(supported, unsupported, supported_reversed)
+
+Struct for conversion between C argument types in the Arb
+documentation and Julia types.
+"""
+struct ArbArgTypes
+    supported::Dict{String,DataType}
+    unsupported::Set{String}
+    supported_reversed::Dict{DataType,String}
+end
+
+function Base.getindex(arbargtypes::ArbArgTypes, key::AbstractString)
+    haskey(arbargtypes.supported, key) && return arbargtypes.supported[key]
+    key in arbargtypes.unsupported && throw(UnsupportedArgumentType(key))
+    throw(KeyError(key))
+end
+
+# Define the conversions we use for the rest of the code
+const arbargtypes = ArbArgTypes(
+    Dict{String,DataType}(
+        "void" => Cvoid,
+        "void *" => Ptr{Cvoid},
+        "int" => Cint,
+        "slong" => Int,
+        "ulong" => UInt,
+        "double" => Cdouble,
+        "double *" => Vector{Float64},
+        "complex_double" => ComplexF64,
+        "complex_double *" => Vector{ComplexF64},
+        "arf_t" => Arf,
+        "arb_t" => Arb,
+        "acb_t" => Acb,
+        "mag_t" => Mag,
+        "arb_srcptr" => ArbVector,
+        "arb_ptr" => ArbVector,
+        "acb_srcptr" => AcbVector,
+        "acb_ptr" => AcbVector,
+        "arb_poly_t" => ArbPoly,
+        "acb_poly_t" => AcbPoly,
+        "arb_mat_t" => ArbMatrix,
+        "acb_mat_t" => AcbMatrix,
+        "arf_rnd_t" => arb_rnd,
+        "mpfr_t" => BigFloat,
+        "mpfr_rnd_t" => Base.MPFR.MPFRRoundingMode,
+        "mpz_t" => BigInt,
+        "char *" => Cstring,
+        "slong *" => Vector{Int},
+        "ulong *" => Vector{UInt},
+    ),
+    Set(["FILE *", "fmpr_t", "fmpr_rnd_t", "flint_rand_t", "bool_mat_t"]),
+    Dict{DataType,String}(
+        Cvoid => "void",
+        Ptr{Cvoid} => "void *",
+        Cint => "int",
+        Int => "slong",
+        UInt => "ulong",
+        Cdouble => "double",
+        Vector{Float64} => "double *",
+        ComplexF64 => "complex_double",
+        Vector{ComplexF64} => "complex_double *",
+        Arf => "arf_t",
+        Arb => "arb_t",
+        Acb => "acb_t",
+        Mag => "mag_t",
+        ArbVector => "arb_ptr",
+        AcbVector => "acb_ptr",
+        ArbPoly => "arb_poly_t",
+        AcbPoly => "acb_poly_t",
+        ArbMatrix => "arb_mat_t",
+        AcbMatrix => "acb_mat_t",
+        arb_rnd => "arf_rnd_t",
+        BigFloat => "mpfr_t",
+        Base.MPFR.MPFRRoundingMode => "mpfr_rnd_t",
+        BigInt => "mpz_t",
+        Cstring => "char *",
+        Vector{Int} => "slong *",
+        Vector{UInt} => "ulong *",
+    ),
+)

src/ArbCall/ArbCall.jl

@@ -0,0 +1,37 @@
+module ArbCall
+
+using ..Arblib
+
+import ..Arblib:
+    cstructtype,
+    arb_rnd,
+    mag_struct,
+    arf_struct,
+    arb_struct,
+    acb_struct,
+    arb_vec_struct,
+    acb_vec_struct,
+    arb_poly_struct,
+    acb_poly_struct,
+    arb_mat_struct,
+    acb_mat_struct,
+    MagLike,
+    ArfLike,
+    ArbLike,
+    AcbLike,
+    ArbVectorLike,
+    AcbVectorLike,
+    ArbMatrixLike,
+    AcbMatrixLike,
+    ArbPolyLike,
+    AcbPolyLike,
+    ArbTypes
+
+include("ArbArgTypes.jl")
+include("Carg.jl")
+include("ArbFunction.jl")
+include("ArbFPWrapFunction.jl")
+
+include("parse.jl")
+
+end

src/ArbCall/ArbFPWrapFunction.jl

@@ -0,0 +1,177 @@
+"""
+    ArbFPWrapFunction{T}(fname, args)
+    ArbFPWrapFunction(str)
+
+Struct representing an Arb function from the `arb_fpwrap.h` module.
+"""
+struct ArbFPWrapFunction{T<:Union{Float64,ComplexF64}}
+    fname::String
+    args::Vector{Carg}
+end
+
+function ArbFPWrapFunction(str::AbstractString)
+    m = match(r"(?<returnflag>\w+(\s\*)?)\s+(?<arbfunction>[\w_]+)\((?<args>.*)\)", str)
+    isnothing(m) &&
+        throw(ArgumentError("string doesn't match arblib function signature pattern"))
+
+    # Check that it has the correct return type
+    m[:returnflag] == "int" ||
+        throw(ArgumentError("expected function to return int, got $(m[:returnflag])"))
+
+    # Determine if it returns double or cdouble
+    type_str = split(m[:arbfunction], "_", limit = 4)[3]
+    if type_str == "double"
+        T = Float64
+    elseif type_str == "cdouble"
+        T = ComplexF64
+    else
+        throw(ArgumentError("type is not double or cdouble, got $type_str"))
+    end
+
+    args = Carg.(strip.(split(m[:args], ",")))
+
+    # Check that at least the first argument is a result argument
+    is_fpwrap_res_argument(first(args), T) || throw(
+        ArgumentError(
+            "expected first argument to be a result argument, got $(first(args))",
+        ),
+    )
+
+    return ArbFPWrapFunction{T}(m[:arbfunction], args)
+end
+
+basetype(::ArbFPWrapFunction{T}) where {T} = T
+arbfname(af::ArbFPWrapFunction) = af.fname
+arguments(af::ArbFPWrapFunction) = af.args
+
+function count_res_arguments(af::ArbFPWrapFunction{T}) where {T}
+    i = findfirst(ca -> !is_fpwrap_res_argument(ca, T), arguments(af))
+    return i - 1
+end
+
+function returntype(af::ArbFPWrapFunction{T}) where {T}
+    n = count_res_arguments(af)
+    if n == 1
+        return basetype(af)
+    else
+        return NTuple{n,basetype(af)}
+    end
+end
+
+function arbsignature(af::ArbFPWrapFunction)
+    c_args = join(arbsignature.(arguments(af)), ", ")
+
+    return "int $(arbfname(af))($c_args)"
+end
+
+jlfname(af::ArbFPWrapFunction) = Symbol(:fpwrap_, split(arbfname(af), "_", limit = 4)[4])
+
+# See https://github.com/kalmarek/Arblib.jl/issues/138 for some
+# discussions related to this approach for default arguments
+"""
+    fpwrap_error_on_failure_default()
+
+Function giving the default value for the argument `error_on_failure`.
+See also [`fpwrap_error_on_failure_default_set`](@ref).
+"""
+fpwrap_error_on_failure_default() = false
+
+"""
+    fpwrap_error_on_failure_default_set(value::Bool)
+
+Set the default value for the argument `error_on_failure` for `fpwrap`
+methods. See also [`fpwrap_error_on_failure_default`](@ref).
+"""
+function fpwrap_error_on_failure_default_set(value::Bool)
+    if fpwrap_error_on_failure_default() != value
+        @eval fpwrap_error_on_failure_default() = $value
+    end
+end
+
+# TODO: Improve support for vector arguments
+function jlargs(af::ArbFPWrapFunction)
+    cargs = arguments(af)
+
+    # Skip return arguments
+
+    # Count res arguments
+    n = count_res_arguments(af)
+    n >= 1 || throw(ArgumentError("expected at least one result argument"))
+    # last argument is flag, skip this
+    cargs[end] == Carg{Cint}(:flags, false) ||
+        throw(ArgumentError("expected last argument to be flags::Cint, got $(cargs[end])"))
+
+    args = [:($(name(carg))::$(jltype(carg))) for carg in cargs[n+1:end-1]]
+
+    if basetype(af) == Float64
+        kwargs = [
+            Expr(
+                :kw,
+                :(error_on_failure::Bool),
+                :(Arblib.ArbCall.fpwrap_error_on_failure_default()),
+            ),
+            Expr(:kw, :(correct_rounding::Bool), :(false)),
+            Expr(:kw, :(work_limit::Integer), :(8)),
+        ]
+    else
+        kwargs = [
+            Expr(
+                :kw,
+                :(error_on_failure::Bool),
+                :(Arblib.ArbCall.fpwrap_error_on_failure_default()),
+            ),
+            Expr(:kw, :(accurate_parts::Bool), :(false)),
+            Expr(:kw, :(correct_rounding::Bool), :(false)),
+            Expr(:kw, :(work_limit::Integer), :(8)),
+        ]
+    end
+
+    return args, kwargs
+end
+
+function jlcode(af::ArbFPWrapFunction, jl_fname = jlfname(af))
+    T = basetype(af)
+    cargs = arguments(af)
+    n = count_res_arguments(af)
+    jl_args, jl_kwargs = jlargs(af)
+
+    return_variables = Expr(:block, [:($(name(ca)) = Ref{$T}()) for ca in cargs[1:n]]...)
+    if n == 1
+        return_expr = :($(name(cargs[1]))[])
+    else
+        return_expr = Expr(:tuple, [:($(name(ca))[]) for ca in cargs[1:n]]...)
+    end
+
+    func = :(
+        function $jl_fname($(jl_args...); $(jl_kwargs...))
+            $return_variables
+
+            # Set accurate_parts if it is not included as a kwarg
+            $(ifelse(T == Float64, :(accurate_parts = false), :nothing))
+
+            flags::Cint = accurate_parts + correct_rounding * 2 + work_limit * 65536
+
+            return_flag = ccall(
+                Arblib.@libarb($(arbfname(af))),
+                Cint,
+                $(Expr(:tuple, ctype.(cargs)...)),
+                $(name.(cargs)...),
+            )
+
+            if iszero(return_flag) || !error_on_failure
+                return $return_expr
+            elseif isone(return_flag)
+                error("unable to evaluate accurately")
+            else
+                error("unknown return flag $return_flag")
+            end
+        end
+    )
+
+    return func
+end
+
+macro arbfpwrapcall_str(str)
+    af = ArbFPWrapFunction(str)
+    return esc(jlcode(af))
+end