Removed need for eval() in xgboost_ccall

Author: Allardvm

src/xgboost_wrapper_h.jl

@@ -3,150 +3,140 @@ include("../deps/deps.jl")
 # xgboost_wrapper.h
 
 "Calls an xgboost API function and correctly reports errors."
-macro xgboost_ccall(f, argTypes, args...)
-    argTypes = eval(argTypes)
+macro xgboost(f, params...)
+    args = [param.args[1] for param in params]
+    types = [param.args[2] for param in params]
+
     return quote
-        err = ccall(($f, _xgboost), Int64, ($(argTypes...),), $(args...))
+        err = ccall(($f, _xgboost), Int64, ($(types...),), $(args...))
         if err != 0
-            errMsg = unsafe_string(ccall((:XGBGetLastError, _xgboost), Ptr{UInt8}, ()))
-            error("Call to XGBoost C function "*string($f)*" failed: $errMsg")
+            err_msg = unsafe_string(ccall((:XGBGetLastError, _xgboost), Cstring, ()))
+            error("Call to XGBoost C function ", string($f), " failed: ", err_msg)
         end
     end
 end
 
-function XGDMatrixCreateFromFile(fname::String, slient::Int32)
+function XGDMatrixCreateFromFile(fname::String, silent::Int32)
     handle = Ref{Ptr{Void}}()
-    @xgboost_ccall(
-        :XGDMatrixCreateFromFile,
-        (Ptr{UInt8}, Int32, Ref{Ptr{Void}}),
-        fname, slient, handle
-    )
+    @xgboost(:XGDMatrixCreateFromFile,
+             fname => Ptr{UInt8},
+             silent => Int32,
+             handle => Ref{Ptr{Void}})
     return handle[]
 end
 
 function XGDMatrixCreateFromCSC(data::SparseMatrixCSC)
     handle = Ref{Ptr{Void}}()
-    @xgboost_ccall(
-        :XGDMatrixCreateFromCSC,
-        (Ptr{UInt64}, Ptr{UInt32}, Ptr{Float32}, UInt64, UInt64, Ref{Ptr{Void}}),
-        convert(Array{UInt64, 1}, data.colptr - 1),
-        convert(Array{UInt32, 1}, data.rowval - 1), convert(Array{Float32, 1}, data.nzval),
-        convert(UInt64, size(data.colptr)[1]),
-        convert(UInt64, nnz(data)),
-        handle
-    )
+    @xgboost(:XGDMatrixCreateFromCSC,
+             convert(Array{UInt64, 1}, data.colptr - 1) => Ptr{UInt64},
+             convert(Array{UInt32, 1}, data.rowval - 1) => Ptr{UInt32},
+             convert(Array{Float32, 1}, data.nzval) => Ptr{Float32},
+             convert(UInt64, size(data.colptr)[1]) => UInt64,
+             convert(UInt64, nnz(data)) => UInt64,
+             handle => Ref{Ptr{Void}})
     return handle[]
 end
 
 function XGDMatrixCreateFromCSCT(data::SparseMatrixCSC)
     handle = Ref{Ptr{Void}}()
-    @xgboost_ccall(
-        :XGDMatrixCreateFromCSR,
-        (Ptr{UInt64}, Ptr{UInt32}, Ptr{Float32}, UInt64, UInt64, Ref{Ptr{Void}}),
-        convert(Array{UInt64, 1}, data.colptr - 1),
-        convert(Array{UInt32, 1}, data.rowval - 1), convert(Array{Float32, 1}, data.nzval),
-        convert(UInt64, size(data.colptr)[1]),
-        convert(UInt64, nnz(data)),
-        handle
-    )
+    @xgboost(:XGDMatrixCreateFromCSR,
+             convert(Array{UInt64, 1}, data.colptr - 1) => Ptr{UInt64},
+             convert(Array{UInt32, 1}, data.rowval - 1) => Ptr{UInt32},
+             convert(Array{Float32, 1}, data.nzval) => Ptr{Float32},
+             convert(UInt64, size(data.colptr)[1]) => UInt64,
+             convert(UInt64, nnz(data)) => UInt64,
+             handle => Ref{Ptr{Void}})
     return handle[]
 end
 
-function XGDMatrixCreateFromMat(data::Array{Float32, 2}, missing::Float32)
+function XGDMatrixCreateFromMat(data::Array{Float32,2}, missing::Float32)
     XGDMatrixCreateFromMatT(transpose(data), missing)
 end
 
-function XGDMatrixCreateFromMatT(data::Array{Float32, 2}, missing::Float32)
-    nrow = size(data)[2]
-    ncol = size(data)[1]
+function XGDMatrixCreateFromMatT(data::Array{Float32,2}, missing::Float32)
+    ncol, nrow = size(data)
     handle = Ref{Ptr{Void}}()
-    @xgboost_ccall(
-        :XGDMatrixCreateFromMat,
-        (Ptr{Float32}, UInt64, UInt64, Float32, Ref{Ptr{Void}}),
-        data, nrow, ncol, missing, handle
-    )
+    @xgboost(:XGDMatrixCreateFromMat,
+             data => Ptr{Float32},
+             nrow => UInt64,
+             ncol => UInt64,
+             missing => Float32,
+             handle => Ref{Ptr{Void}})
     return handle[]
 end
 
-function XGDMatrixSliceDMatrix(handle::Ptr{Void}, idxset::Array{Int32, 1}, len::UInt64)
+function XGDMatrixSliceDMatrix(handle::Ptr{Void}, idxset::Array{Int32,1}, len::UInt64)
     ret = Ref{Ptr{Void}}()
-    @xgboost_ccall(
-        :XGDMatrixSliceDMatrix,
-        (Ptr{Void}, Ptr{Int32}, UInt64, Ref{Ptr{Void}}),
-        handle, idxset, len, ret
-    )
+    @xgboost(:XGDMatrixSliceDMatrix,
+             handle => Ptr{Void},
+             idxset => Ptr{Int32},
+             len => UInt64,
+             ret => Ref{Ptr{Void}})
     return ret[]
 end
 
 function XGDMatrixFree(handle::Ptr{Void})
-    @xgboost_ccall(
-        :XGDMatrixFree,
-        (Ptr{Void},),
-        handle
-    )
+    @xgboost(:XGDMatrixFree,
+             handle => Ptr{Void})
 end
 
-function XGDMatrixSaveBinary(handle::Ptr{Void}, fname::String, slient::Int32)
-    @xgboost_ccall(
-        :XGDMatrixSaveBinary,
-        (Ptr{Void}, Ptr{UInt8}, Int32),
-        handle, fname, slient
-    )
+function XGDMatrixSaveBinary(handle::Ptr{Void}, fname::String, silent::Int32)
+    @xgboost(:XGDMatrixSaveBinary,
+             handle => Ptr{Void},
+             fname => Ptr{UInt8},
+             silent => Int32)
 end
 
-function XGDMatrixSetFloatInfo(handle::Ptr{Void}, field::String,
-                               array::Array{Float32, 1}, len::UInt64)
-    @xgboost_ccall(
-        :XGDMatrixSetFloatInfo,
-        (Ptr{Void}, Ptr{UInt8}, Ptr{Float32}, UInt64),
-        handle, field, array, len
-    )
+function XGDMatrixSetFloatInfo(handle::Ptr{Void}, field::String, array::Array{Float32,1},
+                               len::UInt64)
+    @xgboost(:XGDMatrixSetFloatInfo,
+             handle => Ptr{Void},
+             field => Ptr{UInt8},
+             array => Ptr{Float32},
+             len => UInt64)
 end
 
-function XGDMatrixSetUIntInfo(handle::Ptr{Void}, field::String,
-                              array::Array{UInt32, 1}, len::UInt64)
-    @xgboost_ccall(
-        :XGDMatrixSetUIntInfo,
-        (Ptr{Void}, Ptr{UInt8}, Ptr{UInt32}, UInt64),
-        handle, field, array, len
-    )
+function XGDMatrixSetUIntInfo(handle::Ptr{Void}, field::String, array::Array{UInt32,1},
+                              len::UInt64)
+    @xgboost(:XGDMatrixSetUIntInfo,
+             handle => Ptr{Void},
+             field => Ptr{UInt8},
+             array => Ptr{UInt32},
+             len => UInt64)
 end
 
-function XGDMatrixSetGroup(handle::Ptr{Void}, array::Array{UInt32, 1}, len::UInt64)
-    @xgboost_ccall(
-        :XGDMatrixSetGroup,
-        (Ptr{Void}, Ptr{UInt32}, UInt64),
-         handle, array, len
-    )
+function XGDMatrixSetGroup(handle::Ptr{Void}, array::Array{UInt32,1}, len::UInt64)
+    @xgboost(:XGDMatrixSetGroup,
+             handle => Ptr{Void},
+             array => Ptr{UInt32},
+             len => UInt64)
 end
 
-function XGDMatrixGetFloatInfo(handle::Ptr{Void}, field::String, outlen::Array{UInt64, 1})
+function XGDMatrixGetFloatInfo(handle::Ptr{Void}, field::String, outlen::Array{UInt64,1})
     ret = Ref{Ptr{Float32}}()
-    @xgboost_ccall(
-        :XGDMatrixGetFloatInfo,
-        (Ptr{Void}, Ptr{UInt8}, Ptr{UInt64}, Ref{Ptr{Float32}}),
-         handle, field, outlen, ret
-    )
+    @xgboost(:XGDMatrixGetFloatInfo,
+             handle => Ptr{Void},
+             field => Ptr{UInt8},
+             outlen => Ptr{UInt64},
+             ret =>  Ref{Ptr{Float32}})
     return ret[]
 end
 
-function XGDMatrixGetUIntInfo(handle::Ptr{Void}, field::String, outlen::Array{UInt64, 1})
+function XGDMatrixGetUIntInfo(handle::Ptr{Void}, field::String, outlen::Array{UInt64,1})
     ret = Ref{Ptr{UInt32}}()
-    @xgboost_ccall(
-        :XGDMatrixGetUIntInfo,
-        (Ptr{Void}, Ptr{UInt8}, Ptr{UInt64}, Ref{Ptr{UInt32}}),
-         handle, field, outlen, ret
-    )
+    @xgboost(:XGDMatrixGetUIntInfo,
+             handle => Ptr{Void},
+             field => Ptr{UInt8},
+             outlen => Ptr{UInt64},
+             ret => Ref{Ptr{UInt32}})
     return ret[]
 end
 
 function XGDMatrixNumRow(handle::Ptr{Void})
     ret = Ref{UInt64}()
-    @xgboost_ccall(
-        :XGDMatrixNumRow,
-        (Ptr{Void}, Ref{UInt64}),
-         handle, ret
-    )
+    @xgboost(:XGDMatrixNumRow,
+             handle => Ptr{Void},
+             ret => Ref{UInt64})
     return ret[]
 end
 
@@ -162,100 +152,90 @@ function JLGetUintInfo(handle::Ptr{Void}, field::String)
     return unsafe_wrap(Array, ptr, len[1])
 end
 
-function XGBoosterCreate(cachelist::Array{Ptr{Void}, 1}, len::Int64)
+function XGBoosterCreate(cachelist::Array{Ptr{Void},1}, len::Int64)
     handle = Ref{Ptr{Void}}()
-    @xgboost_ccall(
-        :XGBoosterCreate,
-        (Ptr{Ptr{Void}}, UInt64, Ref{Ptr{Void}}),
-        cachelist, len, handle
-    )
+    @xgboost(:XGBoosterCreate,
+             cachelist => Ptr{Ptr{Void}},
+             len => UInt64,
+             handle => Ref{Ptr{Void}})
     return handle[]
 end
 
 function XGBoosterFree(handle::Ptr{Void})
-    @xgboost_ccall(
-        :XGBoosterFree,
-        (Ptr{Void}, ),
-        handle
-    )
+    @xgboost(:XGBoosterFree,
+             handle => Ptr{Void})
 end
 
 function XGBoosterSetParam(handle::Ptr{Void}, key::String, value::String)
-    @xgboost_ccall(
-        :XGBoosterSetParam,
-        (Ptr{Void}, Ptr{UInt8}, Ptr{UInt8}),
-        handle, key, value
-    )
+    @xgboost(:XGBoosterSetParam,
+             handle => Ptr{Void},
+             key => Ptr{UInt8},
+             value => Ptr{UInt8})
 end
 
 function XGBoosterUpdateOneIter(handle::Ptr{Void}, iter::Int32, dtrain::Ptr{Void})
-    @xgboost_ccall(
-        :XGBoosterUpdateOneIter,
-        (Ptr{Void}, Int32, Ptr{Void}),
-        handle, iter, dtrain
-    )
+    @xgboost(:XGBoosterUpdateOneIter,
+             handle => Ptr{Void},
+             iter => Int32,
+             dtrain => Ptr{Void})
 end
 
-function XGBoosterBoostOneIter(handle::Ptr{Void}, dtrain::Ptr{Void},
-                               grad::Array{Float32, 1},
-                               hess::Array{Float32, 1},
-                               len::UInt64)
-    @xgboost_ccall(
-        :XGBoosterBoostOneIter,
-        (Ptr{Void}, Ptr{Void}, Ptr{Float32}, Ptr{Float32}, UInt64),
-        handle, dtrain, grad, hess, len
-    )
+function XGBoosterBoostOneIter(handle::Ptr{Void}, dtrain::Ptr{Void}, grad::Array{Float32,1},
+                               hess::Array{Float32,1}, len::UInt64)
+    @xgboost(:XGBoosterBoostOneIter,
+             handle => Ptr{Void},
+             dtrain => Ptr{Void},
+             grad => Ptr{Float32},
+             hess => Ptr{Float32},
+             len => UInt64)
 end
 
-function XGBoosterEvalOneIter(handle::Ptr{Void}, iter::Int32,
-                              dmats::Array{Ptr{Void}, 1},
-                              evnames::Array{String, 1}, len::UInt64)
+function XGBoosterEvalOneIter(handle::Ptr{Void}, iter::Int32, dmats::Array{Ptr{Void},1},
+                              evnames::Array{String,1}, len::UInt64)
     msg = Ref{Ptr{UInt8}}()
-    @xgboost_ccall(
-        :XGBoosterEvalOneIter,
-        (Ptr{Void}, Int32, Ptr{Ptr{Void}}, Ptr{Ptr{UInt8}}, UInt64, Ref{Ptr{UInt8}}),
-        handle, iter, dmats, evnames, len, msg
-    )
+    @xgboost(:XGBoosterEvalOneIter,
+             handle => Ptr{Void},
+             iter => Int32,
+             dmats => Ptr{Ptr{Void}},
+             evnames => Ptr{Ptr{UInt8}},
+             len => UInt64,
+             msg => Ref{Ptr{UInt8}})
     return unsafe_string(msg[])
 end
 
-
 function XGBoosterPredict(handle::Ptr{Void}, dmat::Ptr{Void}, output_margin::Int32,
-                          ntree_limit::UInt32, len::Array{UInt64, 1})
+                          ntree_limit::UInt32, len::Array{UInt64,1})
     ret = Ref{Ptr{Float32}}()
-    @xgboost_ccall(
-        :XGBoosterPredict,
-        (Ptr{Void}, Ptr{Void}, Int32, UInt32, Ptr{UInt64}, Ref{Ptr{Float32}}),
-        handle, dmat, output_margin, ntree_limit, len, ret
-    )
+    @xgboost(:XGBoosterPredict,
+             handle => Ptr{Void},
+             dmat => Ptr{Void},
+             output_margin => Int32,
+             ntree_limit => UInt32,
+             len => Ptr{UInt64},
+             ret => Ref{Ptr{Float32}})
     return ret[]
 end
 
-
 function XGBoosterLoadModel(handle::Ptr{Void}, fname::String)
-    @xgboost_ccall(
-        :XGBoosterLoadModel,
-        (Ptr{Void}, Ptr{UInt8}),
-        handle, fname
-    )
+    @xgboost(:XGBoosterLoadModel,
+             handle => Ptr{Void},
+             fname => Ptr{UInt8})
 end
 
 function XGBoosterSaveModel(handle::Ptr{Void}, fname::String)
-    @xgboost_ccall(
-        :XGBoosterSaveModel,
-        (Ptr{Void}, Ptr{UInt8}),
-        handle, fname
-    )
+    @xgboost(:XGBoosterSaveModel,
+             handle => Ptr{Void},
+             fname => Ptr{UInt8})
 end
 
-
 function XGBoosterDumpModel(handle::Ptr{Void}, fmap::String, with_stats::Int64)
     data = Ref{Ptr{Ptr{UInt8}}}()
     out_len = Ref{UInt64}(0)
-    @xgboost_ccall(
-        :XGBoosterDumpModel,
-        (Ptr{Void}, Ptr{UInt8}, Int64, Ref{UInt64}, Ref{Ptr{Ptr{UInt8}}}),
-        handle, fmap, with_stats, out_len, data
-    )
+    @xgboost(:XGBoosterDumpModel,
+             handle => Ptr{Void},
+             fmap => Ptr{UInt8},
+             with_stats => Int64,
+             out_len => Ref{UInt64},
+             data => Ref{Ptr{Ptr{UInt8}}})
     return unsafe_wrap(Array, data[], out_len[])
 end