ccall improvements for issue #132

- conversions are inserted for the arguments, to the ccall argument types
- syntax &x is used to pass a pointer to a scalar

Author: JeffBezanson

examples/bitvector.j

@@ -125,5 +125,5 @@ end
 length(s::IntSet) = numel(s)
 numel(s::IntSet) =
     int32(ccall(:bitvector_count, Uint64, (Ptr{Uint32}, Uint64, Uint64),
-                s.bits, uint64(0), uint64(s.limit)))
+                s.bits, 0, s.limit))
 

j/array.j

@@ -19,7 +19,7 @@ numel(a::Array) = arraylen(a)
 ## copy ##
 
 copy_to{T}(dest::Ptr{T}, src::Ptr{T}, n::Integer) =
-    ccall(:memcpy, Ptr{Void}, (Ptr{Void}, Ptr{Void}, Uint), dest, src, uint(n*sizeof(T)))
+    ccall(:memcpy, Ptr{Void}, (Ptr{Void}, Ptr{Void}, Uint), dest, src, n*sizeof(T))
 
 function copy_to{T}(dest::Array{T}, do, src::Array{T}, so, N)
     if so+N-1 > numel(src) || do+N-1 > numel(dest) || do < 1 || so < 1
@@ -40,7 +40,7 @@ copy_to{T}(dest::Array{T}, src::Array{T}) = copy_to(dest, 1, src, 1, numel(src))
 function reinterpret{T,S}(::Type{T}, a::Array{S})
     b = Array(T, div(numel(a)*sizeof(S),sizeof(T)))
     ccall(:memcpy, Ptr{T}, (Ptr{T}, Ptr{S}, Uint),
-          b, a, uint(length(b)*sizeof(T)))
+          b, a, length(b)*sizeof(T))
     return b
 end
 reinterpret(t,x) = reinterpret(t,[x])[1]
@@ -81,12 +81,12 @@ ref{T}(::Type{T}) = Array(T,0)
 ref{T}(::Type{T}, x) = (a=Array(T,1); a[1]=x; a)
 
 function fill!{T<:Union(Int8,Uint8)}(a::Array{T}, x::Integer)
-    ccall(:memset, Void, (Ptr{T}, Int32, Int), a, int32(x), int(length(a)))
+    ccall(:memset, Void, (Ptr{T}, Int32, Int), a, x, length(a))
     return a
 end
 function fill!{T<:Union(Integer,Float)}(a::Array{T}, x)
     if convert(T,x) == 0
-        ccall(:bzero, Void, (Ptr{T}, Int), a, int(length(a)*sizeof(T)))
+        ccall(:bzero, Void, (Ptr{T}, Int), a, length(a)*sizeof(T))
     else
         for i = 1:numel(a)
             a[i] = x
@@ -417,13 +417,13 @@ function push{T}(a::Array{T,1}, item)
     end
     # convert first so we don't grow the array if the assignment won't work
     item = convert(T, item)
-    ccall(:jl_array_grow_end, Void, (Any, Uint), a, uint(1))
+    ccall(:jl_array_grow_end, Void, (Any, Uint), a, 1)
     a[end] = item
     return a
 end
 
 function push(a::Array{Any,1}, item::ANY)
-    ccall(:jl_array_grow_end, Void, (Any, Uint), a, uint(1))
+    ccall(:jl_array_grow_end, Void, (Any, Uint), a, 1)
     a[end] = item
     return a
 end
@@ -433,13 +433,13 @@ function append!{T}(a::Array{T,1}, items::Array{T,1})
         error("[] cannot grow. Instead, initialize the array with \"T[]\".")
     end
     n = length(items)
-    ccall(:jl_array_grow_end, Void, (Any, Uint), a, uint(n))
+    ccall(:jl_array_grow_end, Void, (Any, Uint), a, n)
     a[end-n+1:end] = items
     return a
 end
 
 function grow(a::Vector, n::Integer)
-    ccall(:jl_array_grow_end, Void, (Any, Uint), a, uint(n))
+    ccall(:jl_array_grow_end, Void, (Any, Uint), a, n)
     return a
 end
 
@@ -448,7 +448,7 @@ function pop(a::Vector)
         error("pop: array is empty")
     end
     item = a[end]
-    ccall(:jl_array_del_end, Void, (Any, Uint), a, uint(1))
+    ccall(:jl_array_del_end, Void, (Any, Uint), a, 1)
     return item
 end
 
@@ -457,7 +457,7 @@ function enqueue{T}(a::Array{T,1}, item)
         error("[] cannot grow. Instead, initialize the array with \"T[]\".")
     end
     item = convert(T, item)
-    ccall(:jl_array_grow_beg, Void, (Any, Uint), a, uint(1))
+    ccall(:jl_array_grow_beg, Void, (Any, Uint), a, 1)
     a[1] = item
     return a
 end
@@ -468,7 +468,7 @@ function shift(a::Vector)
         error("shift: array is empty")
     end
     item = a[1]
-    ccall(:jl_array_del_beg, Void, (Any, Uint), a, uint(1))
+    ccall(:jl_array_del_beg, Void, (Any, Uint), a, 1)
     return item
 end
 
@@ -479,14 +479,14 @@ function insert{T}(a::Array{T,1}, i::Integer, item)
     item = convert(T, item)
     n = length(a)
     if i > n
-        ccall(:jl_array_grow_end, Void, (Any, Uint), a, uint(i-n))
+        ccall(:jl_array_grow_end, Void, (Any, Uint), a, i-n)
     elseif i > div(n,2)
-        ccall(:jl_array_grow_end, Void, (Any, Uint), a, uint(1))
+        ccall(:jl_array_grow_end, Void, (Any, Uint), a, 1)
         for k=n+1:-1:i+1
             a[k] = a[k-1]
         end
     else
-        ccall(:jl_array_grow_beg, Void, (Any, Uint), a, uint(1))
+        ccall(:jl_array_grow_beg, Void, (Any, Uint), a, 1)
         for k=1:(i-1)
             a[k] = a[k+1]
         end
@@ -503,12 +503,12 @@ function del(a::Vector, i::Integer)
         for k = i:-1:2
             a[k] = a[k-1]
         end
-        ccall(:jl_array_del_beg, Void, (Any, Uint), a, uint(1))
+        ccall(:jl_array_del_beg, Void, (Any, Uint), a, 1)
     else
         for k = i:n-1
             a[k] = a[k+1]
         end
-        ccall(:jl_array_del_end, Void, (Any, Uint), a, uint(1))
+        ccall(:jl_array_del_end, Void, (Any, Uint), a, 1)
     end
     return a
 end
@@ -528,18 +528,18 @@ function del{T<:Integer}(a::Vector, r::Range1{T})
         for k = l:-1:1+d
             a[k] = a[k-d]
         end
-        ccall(:jl_array_del_beg, Void, (Any, Uint), a, uint(d))
+        ccall(:jl_array_del_beg, Void, (Any, Uint), a, d)
     else
         for k = f:n-d
             a[k] = a[k+d]
         end
-        ccall(:jl_array_del_end, Void, (Any, Uint), a, uint(d))
+        ccall(:jl_array_del_end, Void, (Any, Uint), a, d)
     end
     return a
 end
 
 function del_all(a::Vector)
-    ccall(:jl_array_del_end, Void, (Any, Uint), a, uint(length(a)))
+    ccall(:jl_array_del_end, Void, (Any, Uint), a, length(a))
     return a
 end
 

j/base.j

@@ -91,8 +91,7 @@ dlsym(hnd, s::String) =
     ccall(:jl_dlsym, Ptr{Void}, (Ptr{Void}, Ptr{Uint8}), hnd, cstring(s))
 
 dlsym(hnd, s::Symbol) =
-    ccall(:jl_dlsym, Ptr{Void}, (Ptr{Void}, Ptr{Uint8}),
-          hnd, convert(Ptr{Uint8}, s))
+    ccall(:jl_dlsym, Ptr{Void}, (Ptr{Void}, Ptr{Uint8}), hnd, s)
 
 dlopen(fname::String) =
     ccall(:jl_load_dynamic_library, Ptr{Void}, (Ptr{Uint8},), cstring(fname))
@@ -152,10 +151,10 @@ Array(T, d::Int...) = Array(T, d)
 
 Array{T}(::Type{T}, m::Integer) =
     ccall(:jl_alloc_array_1d, Array{T,1}, (Any,Int), Array{T,1},
-          int(m))
+          m)
 Array{T}(::Type{T}, m::Integer,n::Integer) =
     ccall(:jl_alloc_array_2d, Array{T,2}, (Any,Int,Int), Array{T,2},
-          int(m), int(n))
+          m, n)
 Array{T}(::Type{T}, m::Integer,n::Integer,o::Integer) =
     ccall(:jl_alloc_array_3d, Array{T,3}, (Any,Int,Int,Int), Array{T,3},
-          int(m), int(n), int(o))
+          m, n, o)

j/env.j

@@ -13,7 +13,7 @@ end
 
 function setenv(var::String, val::String, overwrite::Bool)
     ret = ccall(:setenv, Int32, (Ptr{Uint8}, Ptr{Uint8}, Int32),
-                cstring(var), cstring(val), int32(overwrite))
+                cstring(var), cstring(val), overwrite)
     system_error(:setenv, ret != 0)
 end
 
@@ -51,9 +51,9 @@ del(::EnvHash, k::String) = unsetenv(k)
 assign(::EnvHash, v::String, k::String) = (setenv(k,v); v)
 
 start(::EnvHash) = 0
-done(::EnvHash, i) = (ccall(:jl_environ, Any, (Int32,), int32(i)) == nothing)
+done(::EnvHash, i) = (ccall(:jl_environ, Any, (Int32,), i) == nothing)
 function next(::EnvHash, i)
-    env = ccall(:jl_environ, Any, (Int32,), int32(i))
+    env = ccall(:jl_environ, Any, (Int32,), i)
     if env == nothing
         error("environ: index out of range")
     end

j/error.j

@@ -11,7 +11,7 @@ end
 ## system error handling ##
 
 errno() = ccall(:jl_errno, Int32, ())
-strerror(e::Integer) = ccall(:jl_strerror, Any, (Int32,), int32(e))::ByteString
+strerror(e::Integer) = ccall(:jl_strerror, Any, (Int32,), e)::ByteString
 strerror() = strerror(errno())
 system_error(p, b::Bool) = b ? error(SystemError(string(p))) : nothing
 

j/expr.j

@@ -3,7 +3,7 @@
 symbol(s::ASCIIString) = symbol(s.data)
 symbol(s::UTF8String) = symbol(s.data)
 symbol(a::Array{Uint8,1}) =
-    ccall(:jl_symbol_n, Any, (Ptr{Uint8}, Int32), a, int32(length(a)))::Symbol
+    ccall(:jl_symbol_n, Any, (Ptr{Uint8}, Int32), a, length(a))::Symbol
 
 gensym() = ccall(:jl_gensym, Any, ())::Symbol
 gensym(n::Integer) = ntuple(n, i->gensym())

j/grisu.j

@@ -11,7 +11,7 @@ macro grisu_ccall(value, mode, ndigits)
         ccall(dlsym(_jl_libgrisu, :grisu), Void,
               (Float64, Int32, Int32, Ptr{Uint8}, Int32,
                Ptr{Bool}, Ptr{Int32}, Ptr{Int32}),
-              float64($value), int32($mode), int32($ndigits),
+              $value, $mode, $ndigits,
               _jl_digits, _jl_buflen, _jl_neg, _jl_length, _jl_point)
     end
 end

j/inference.j

@@ -31,7 +31,7 @@ tmatch(a::ANY,b::ANY) = ccall(:jl_type_match, Any, (Any,Any), a, b)
 
 getmethods(f,t) = getmethods(f,t,-1)::Array{Any,1}
 getmethods(f,t,lim) = ccall(:jl_matching_methods, Any, (Any,Any,Int32),
-                            f, t, int32(lim))
+                            f, t, lim)
 
 typeseq(a,b) = subtype(a,b)&&subtype(b,a)
 

j/intset.j

@@ -99,13 +99,13 @@ start(s::IntSet) = int64(0)
 done(s::IntSet, i) = (next(s,i)[1] >= s.limit)
 function next(s::IntSet, i)
     n = ccall(:bitvector_next, Int64, (Ptr{Uint32}, Uint64, Uint64),
-              s.bits, uint64(i), uint64(s.limit))
+              s.bits, i, s.limit)
     (n, n+1)
 end
 
 isempty(s::IntSet) =
     ccall(:bitvector_any1, Uint32, (Ptr{Uint32}, Uint64, Uint64),
-          s.bits, uint64(0), uint64(s.limit))==0
+          s.bits, 0, s.limit)==0
 
 function choose(s::IntSet)
     n = next(s,0)[1]
@@ -123,7 +123,7 @@ end
 
 numel(s::IntSet) =
     int(ccall(:bitvector_count, Uint64, (Ptr{Uint32}, Uint64, Uint64),
-              s.bits, uint64(0), uint64(s.limit)))
+              s.bits, 0, s.limit))
 
 function show(s::IntSet)
     print("intset(")

j/io.j

@@ -27,7 +27,7 @@ close(s::IOStream) = ccall(:ios_close, Void, (Ptr{Void},), s.ios)
 function fdio(fd::Integer, own::Bool)
     s = IOStream()
     ccall(:ios_fd, Void, (Ptr{Uint8}, Int, Int32, Int32),
-          s.ios, int(fd), int32(0), int32(own));
+          s.ios, fd, 0, own);
     return s
 end
 fdio(fd::Integer) = fdio(fd, false)
@@ -36,8 +36,7 @@ function open(fname::String, rd::Bool, wr::Bool, cr::Bool, tr::Bool, ff::Bool)
     s = IOStream()
     if ccall(:ios_file, Ptr{Void},
              (Ptr{Uint8}, Ptr{Uint8}, Int32, Int32, Int32, Int32),
-             s.ios, cstring(fname),
-             int32(rd), int32(wr), int32(cr), int32(tr)) == C_NULL
+             s.ios, cstring(fname), rd, wr, cr, tr) == C_NULL
         error("could not open file ", fname)
     end
     if ff && ccall(:ios_seek_end, Uint, (Ptr{Void},), s.ios) != 0
@@ -59,7 +58,7 @@ end
 
 function memio(x::Integer, finalize::Bool)
     s = IOStream(finalize)
-    ccall(:jl_ios_mem, Ptr{Void}, (Ptr{Uint8}, Uint), s.ios, uint(x))
+    ccall(:jl_ios_mem, Ptr{Void}, (Ptr{Uint8}, Uint), s.ios, x)
     s
 end
 memio(x::Integer) = memio(x, true)
@@ -166,7 +165,7 @@ end
 ## low-level calls ##
 
 write(s::IOStream, b::Uint8) =
-    ccall(:ios_putc, Int32, (Int32, Ptr{Void}), int32(b), s.ios)
+    ccall(:ios_putc, Int32, (Int32, Ptr{Void}), b, s.ios)
 
 write(s::IOStream, c::Char) =
     ccall(:ios_pututf8, Int32, (Ptr{Void}, Char), s.ios, c)
@@ -175,16 +174,15 @@ function write{T}(s::IOStream, a::Array{T})
     if isa(T,BitsKind)
         ccall(:ios_write, Uint,
               (Ptr{Void}, Ptr{Void}, Uint),
-              s.ios, a, uint(numel(a)*sizeof(T)))
+              s.ios, a, numel(a)*sizeof(T))
     else
         invoke(write, (Any, Array), s, a)
     end
 end
 
 function write(s::IOStream, p::Ptr, nb::Integer)
     ccall(:ios_write, Uint,
-          (Ptr{Void}, Ptr{Void}, Uint),
-          s.ios, p, uint(nb))
+          (Ptr{Void}, Ptr{Void}, Uint), s.ios, p, nb)
 end
 
 function write{T,N}(s::IOStream, a::SubArray{T,N,Array})
@@ -219,7 +217,7 @@ function read{T}(s::IOStream, a::Array{T})
     if isa(T,BitsKind)
         nb = numel(a)*sizeof(T)
         if ccall(:ios_readall, Uint,
-                 (Ptr{Void}, Ptr{Void}, Uint), s.ios, a, uint(nb)) < nb
+                 (Ptr{Void}, Ptr{Void}, Uint), s.ios, a, nb) < nb
             throw(EOFError())
         end
         a
@@ -246,14 +244,14 @@ readline(s::IOStream) = readuntil(s, uint8('\n'))
 flush(s::IOStream) = ccall(:ios_flush, Void, (Ptr{Void},), s.ios)
 
 truncate(s::IOStream, n::Integer) =
-    ccall(:ios_trunc, Uint, (Ptr{Void}, Uint), s.ios, uint(n))
+    ccall(:ios_trunc, Uint, (Ptr{Void}, Uint), s.ios, n)
 
 seek(s::IOStream, n::Integer) =
-    (ccall(:ios_seek, Int, (Ptr{Void}, Int), s.ios, int(n))==0 ||
+    (ccall(:ios_seek, Int, (Ptr{Void}, Int), s.ios, n)==0 ||
      error("seek failed"))
 
 skip(s::IOStream, delta::Integer) =
-    (ccall(:ios_skip, Int, (Ptr{Void}, Int), s.ios, int(delta))==0 ||
+    (ccall(:ios_skip, Int, (Ptr{Void}, Int), s.ios, delta)==0 ||
      error("skip failed"))
 
 position(s::IOStream) = ccall(:ios_pos, Int, (Ptr{Void},), s.ios)
@@ -285,7 +283,7 @@ function add(s::FDSet, i::Integer)
     if !(0 <= i < sizeof_fd_set*8)
         error("invalid descriptor ", i)
     end
-    ccall(:jl_fd_set, Void, (Ptr{Void}, Int32), s.data, int32(i))
+    ccall(:jl_fd_set, Void, (Ptr{Void}, Int32), s.data, i)
     if i >= s.nfds
         s.nfds = i+1
     end
@@ -295,14 +293,14 @@ end
 function has(s::FDSet, i::Integer)
     if 0 <= i < sizeof_fd_set*8
         return ccall(:jl_fd_isset, Int32,
-                     (Ptr{Void}, Int32), s.data, int32(i))!=0
+                     (Ptr{Void}, Int32), s.data, i)!=0
     end
     return false
 end
 
 function del(s::FDSet, i::Integer)
     if 0 <= i < sizeof_fd_set*8
-        ccall(:jl_fd_clr, Void, (Ptr{Void}, Int32), s.data, int32(i))
+        ccall(:jl_fd_clr, Void, (Ptr{Void}, Int32), s.data, i)
         if i == s.nfds-1
             s.nfds -= 1
             while s.nfds>0 && !has(s, s.nfds-1)
@@ -327,7 +325,7 @@ begin
             tout = C_NULL
         else
             ccall(:jl_set_timeval, Void, (Ptr{Void}, Float64),
-                  tv, float64(timeout))
+                  tv, timeout)
             tout = convert(Ptr{Void}, tv)
         end
         ccall(:select, Int32,