diff --git a/REQUIRE b/REQUIRE
index f914573..8de90c9 100644
--- a/REQUIRE
+++ b/REQUIRE
@@ -1,4 +1,4 @@
 julia 0.4-
 BinDeps
-@osx Homebrew
-Compat
\ No newline at end of file
+Conda
+Compat
diff --git a/deps/build.jl b/deps/build.jl
index cbe13c7..f61770c 100644
--- a/deps/build.jl
+++ b/deps/build.jl
@@ -1,27 +1,17 @@
 using BinDeps
 
 @BinDeps.setup
+netcdf = library_dependency("libnetcdf", aliases = ["libnetcdf4","libnetcdf-7"])
 
+using Conda
+provides(Conda.Manager, "libnetcdf", netcdf)
 
 @osx_only begin
     using Homebrew
-    netcdf = library_dependency("libnetcdf", aliases = ["libnetcdf.7"])
-    provides( Homebrew.HB, "netcdf", netcdf, os = :Darwin )
+		provides(Homebrew.HB, "netcdf", netcdf, os = :Darwin )
 end
 
-@linux_only begin
-    netcdf = library_dependency("libnetcdf", aliases = ["libnetcdf-7"])
-    provides(AptGet, Dict("libnetcdf-dev"=>netcdf))
-    provides(Yum, Dict("netcdf-devel"=>netcdf))
-end
-
-@windows_only begin
-    netcdf = library_dependency("netcdf")
-    provides (Binaries,URI("http://www.paratools.com/Azure/NetCDF/paratools-netcdf-4.1.3.tar.gz"),netcdf,os=:Windows)
-    push!(DL_LOAD_PATH, joinpath(Pkg.dir(),"NetCDF","deps","netcdf-4.1.3","bin"))
-end
-
-provides(Sources, URI("ftp://ftp.unidata.ucar.edu/pub/netcdf/netcdf-4.3.0.tar.gz"),netcdf)
-
+provides(AptGet, Dict("libnetcdf-dev"=>netcdf), os = :Linux)
+provides(Yum, Dict("netcdf-devel"=>netcdf), os = :Linux)
 
 @BinDeps.install
diff --git a/src/NetCDF.jl b/src/NetCDF.jl
index 7aee743..714ca5b 100644
--- a/src/NetCDF.jl
+++ b/src/NetCDF.jl
@@ -15,7 +15,7 @@ function __init__()
                    Int64=>NC_INT64,
                    Float32=>NC_FLOAT,
                    Float64=>NC_DOUBLE,
-                   Uint8=>NC_CHAR)
+                   UInt8=>NC_CHAR)
 
   global const nctype2jltype=@Compat.Dict(NC_BYTE=>Int8,
                     NC_SHORT=>Int16, 
@@ -23,8 +23,8 @@ function __init__()
                     NC_LONG=>Int64,
                     NC_FLOAT=>Float32,
                     NC_DOUBLE=>Float64,
-                    NC_CHAR=>Uint8,
-                    NC_STRING=>Ptr{Uint8})
+                    NC_CHAR=>UInt8,
+                    NC_STRING=>Ptr{UInt8})
 
   global const nctype2string=@Compat.Dict(NC_BYTE=>"BYTE",
                    NC_SHORT=>"SHORT",
@@ -42,7 +42,7 @@ type NcDim
   dimid::Int32
   varid::Int32
   name::ASCIIString
-  dimlen::Uint
+  dimlen::UInt
   vals::AbstractArray
   atts::Dict
 end
@@ -53,20 +53,20 @@ end
     NcDim(name::String,dimlength::Integer;values::Union(AbstractArray,Number)=[],atts::Dict{Any,Any}=Dict{Any,Any}())`
 This constructor creates an NcDim object with the name `name` and length `dimlength`.
 """ 
-function NcDim(name::String,dimlength::Integer;values::Union(AbstractArray,Number)=[],atts::Dict{Any,Any}=Dict{Any,Any}())
+function NcDim(name::AbstractString,dimlength::Integer;values::Union(AbstractArray,Number)=[],atts::Dict{Any,Any}=Dict{Any,Any}())
     (length(values)>0 && length(values)!=dimlength) ? error("Dimension value vector must have the same length as dimlength!") : nothing
     NcDim(-1,-1,-1,ascii(name),dimlength,values,atts)
   end
 
 
 """
-    NcDim(name::String,dimlength::Integer;values::Union(AbstractArray,Number)=[],atts::Dict{Any,Any}=Dict{Any,Any}())
+    NcDim(name::AbstractString,dimlength::Integer;values::Union(AbstractArray,Number)=[],atts::Dict{Any,Any}=Dict{Any,Any}())
 This constructor creates an NcDim object with the name `name` and and associated values `values`. Upon creation of the NetCDF file a 
 dimension variable will be generated and the values be written to this variable. Optionally a Dict of attributes can be supplied. 
 """ 
-NcDim(name::String,values::AbstractArray;atts::Dict=Dict{Any,Any}())=
+NcDim(name::AbstractString,values::AbstractArray;atts::Dict=Dict{Any,Any}())=
   NcDim(name,length(values),values=values,atts=atts)
-NcDim(name::String,values::AbstractArray,atts::Dict)=
+NcDim(name::AbstractString,values::AbstractArray,atts::Dict)=
   NcDim(name,length(values),values=values,atts=atts)
 
 """
@@ -90,18 +90,18 @@ end
 Base.convert{S,T,N}(::Type{NcVar{T,N}},v::NcVar{S,N})=NcVar{T,N}(v.ncid,v.varid,v.ndim,v.natts,v.nctype,v.name,v.dimids,v.dim,v.atts,v.compress)
 
 """
-    NcVar(name::String,dimin::Union(NcDim,Array{NcDim,1});atts::Dict{Any,Any}=Dict{Any,Any}(),t::Union(DataType,Integer)=Float64,compress::Integer=-1)
+    NcVar(name::AbstractString,dimin::Union(NcDim,Array{NcDim,1});atts::Dict{Any,Any}=Dict{Any,Any}(),t::Union(DataType,Integer)=Float64,compress::Integer=-1)
 Here varname is the name of the variable, dimlist an array of type NcDim holding the dimensions associated to the variable, varattributes is a Dict 
 holding pairs of attribute names and values. t is the data type that should be used for storing the variable. You can either specify a julia type 
 (Int16, Int32, Float32, Float64) which will be translated to (NC_SHORT, NC_INT, NC_FLOAT, NC_DOUBLE) or directly specify one of the latter list. 
 You can also set the compression level of the variable by setting compress to a number in the range 1..9 This has only an effect in NetCDF4 files.   
 """
 #Some additional constructors
-function NcVar(name::String,dimin::Union(NcDim,Array{NcDim,1});atts::Dict{Any,Any}=Dict{Any,Any}(),t::Union(DataType,Integer)=Float64,compress::Integer=-1)
+function NcVar(name::AbstractString,dimin::Union(NcDim,Array{NcDim,1});atts::Dict{Any,Any}=Dict{Any,Any}(),t::Union(DataType,Integer)=Float64,compress::Integer=-1)
   dim = isa(dimin,NcDim) ? NcDim[dimin] : dimin
   return NcVar{typeof(t)==DataType ? t : nctype2jltype[t],length(dim)}(-1,-1,length(dim),length(atts), typeof(t)==DataType ? jltype2nctype[t] : t,name,Array(Int32,length(dim)),dim,atts,compress)
 end
-NcVar(name::String,dimin::Union(NcDim,Array{NcDim,1}),atts::Dict{Any,Any},t::Union(DataType,Integer)=Float64)=NcVar{typeof(t)==DataType ? t : nctype2jltype[t],length(dimin)}(-1,-1,length(dimin),length(atts), typeof(t)==DataType ? jltype2nctype[t] : t,name,Array(Int,length(dimin)),dimin,atts,-1)
+NcVar(name::AbstractString,dimin::Union(NcDim,Array{NcDim,1}),atts::Dict{Any,Any},t::Union(DataType,Integer)=Float64)=NcVar{typeof(t)==DataType ? t : nctype2jltype[t],length(dimin)}(-1,-1,length(dimin),length(atts), typeof(t)==DataType ? jltype2nctype[t] : t,name,Array(Int,length(dimin)),dimin,atts,-1)
 
 #Array methods
 @generated function Base.size{T,N}(a::NcVar{T,N})
@@ -139,7 +139,7 @@ type NcFile
   gatts::Dict
   nunlimdimid::Int32
   name::ASCIIString
-  omode::Uint16
+  omode::UInt16
   in_def_mode::Bool
 end
 #Define getindex method to retrieve a variable
@@ -150,11 +150,11 @@ include("netcdf_helpers.jl")
 const currentNcFiles=Dict{ASCIIString,NcFile}()
 
 
-readvar!(nc::NcFile, varname::String, retvalsa::Array;start::Vector=defaultstart(nc[varname]),count::Vector=defaultcount(nc[varname]))=readvar!(nc[varname],retvalsa,start=start,count=count)
+readvar!(nc::NcFile, varname::AbstractString, retvalsa::Array;start::Vector=defaultstart(nc[varname]),count::Vector=defaultcount(nc[varname]))=readvar!(nc[varname],retvalsa,start=start,count=count)
 
 
 """
-readvar!(v::NcVar, d::Array;start::Vector=ones(Uint,ndims(d)),count::Vector=size(d))
+readvar!(v::NcVar, d::Array;start::Vector=ones(UInt,ndims(d)),count::Vector=size(d))
 is the mutating form of `readvar` which expects a pre-allocated array d, where the data are written to. It reads the values of the NcVar object `v`
 writing the values to the preallocated array `d`. 
 If only parts of the variable are to be read, you can provide optionally `start` and `count`, which enable you to read blocks of data. `start` and `count` have the same 
@@ -177,7 +177,7 @@ end
 #readvar{T<:Integer}(nc::NcFile,varname::AbstractString,start::Array{T,1},count::Array{T,1})=readvar(nc,varname,start=start,count=count)
 
 
-readvar(nc::NcFile, varname::String;start::Vector=defaultstart(nc[varname]),count::Vector=defaultcount(nc[varname]))=readvar(nc[varname],start=start,count=count)
+readvar(nc::NcFile, varname::AbstractString;start::Vector=defaultstart(nc[varname]),count::Vector=defaultcount(nc[varname]))=readvar(nc[varname],start=start,count=count)
 
 """
 readvar{T,N}(v::NcVar{T,N};start::Vector=ones(Int,v.ndim),count::Vector=zeros(Int,v.ndim))
@@ -243,8 +243,8 @@ for (t,ending,arname) in funext
     fname = symbol("nc_get_vara_$ending")
     fname1 = symbol("nc_get_var1_$ending")
     arsym=symbol(arname)
-    @eval nc_get_vara_x!(ncid::Integer,varid::Integer,start::Vector{Uint},count::Vector{Uint},retvalsa::Array{$t})=$fname(ncid,varid,start,count,retvalsa)
-    @eval nc_get_var1_x(ncid::Integer,varid::Integer,start::Vector{Uint},::Type{$t})=begin $fname1(ncid,varid,start,$(arsym)); $(arsym)[1] end
+    @eval nc_get_vara_x!(ncid::Integer,varid::Integer,start::Vector{UInt},count::Vector{UInt},retvalsa::Array{$t})=$fname(ncid,varid,start,count,retvalsa)
+    @eval nc_get_var1_x(ncid::Integer,varid::Integer,start::Vector{UInt},::Type{$t})=begin $fname1(ncid,varid,start,$(arsym)); $(arsym)[1] end
 end
 
 
@@ -273,7 +273,7 @@ end
 Writes name-value pairs of attributes given in `atts` to the file `nc`. If `varname` is a valid variable indentifier, the attribute(s) will be written to this variable. 
 Otherwise, global attributes will be generated. This function automatically overwrites existing attributes.  
 """
-function ncputatt(nc::String,varname::String,atts::Dict)
+function ncputatt(nc::AbstractString,varname::AbstractString,atts::Dict)
   nc = haskey(currentNcFiles,abspath(nc)) ? currentNcFiles[abspath(nc)] : open(nc,mode=NC_WRITE)
   if (nc.omode==NC_NOWRITE)
     fil=nc.name
@@ -284,7 +284,7 @@ function ncputatt(nc::String,varname::String,atts::Dict)
   putatt(nc,varname,atts)
 end
 
-putvar(nc::NcFile,varname::String,vals::Array;start=ones(Int,length(size(vals))),count=[size(vals)...])=putvar(nc[varname],vals,start=start,count=count)
+putvar(nc::NcFile,varname::AbstractString,vals::Array;start=ones(Int,length(size(vals))),count=[size(vals)...])=putvar(nc[varname],vals,start=start,count=count)
 
 """
     putvar(v::NcVar,vals::Array;start::Vector=ones(Int,length(size(vals))),count::Vector=[size(vals)...])
@@ -330,7 +330,7 @@ for (t,ending,arname) in funext
     fname1= symbol("nc_put_var1_$ending")
     arsym=symbol(arname)
     @eval nc_put_vara_x(ncid::Integer, varid::Integer, start, count, vals::Array{$t})=$fname(ncid,varid,start,count,vals)
-    @eval nc_put_var1_x(ncid::Integer,varid::Integer,start::Vector{Uint},val::$t)=begin $(arsym)[1]=val; $fname1(ncid,varid,start,$(arsym)) end
+    @eval nc_put_var1_x(ncid::Integer,varid::Integer,start::Vector{UInt},val::$t)=begin $(arsym)[1]=val; $fname1(ncid,varid,start,$(arsym)) end
 end
 
 
@@ -348,7 +348,7 @@ end
 
 #Function to close netcdf files
 "Closes the file and writes changes to the disk. If argument is omitted, all open files are closed.   "
-function ncclose(fil::String)
+function ncclose(fil::AbstractString)
   if (haskey(currentNcFiles,abspath(fil)))
     close(currentNcFiles[abspath(fil)])
   else
@@ -375,12 +375,12 @@ function setcompression(v::NcVar,mode)
     end
 end
 """
-    NetCDF.create(name::String,varlist::Array{NcVar};gatts::Dict{Any,Any}=Dict{Any,Any}(),mode::Uint16=NC_NETCDF4)
+    NetCDF.create(name::String,varlist::Array{NcVar};gatts::Dict{Any,Any}=Dict{Any,Any}(),mode::UInt16=NC_NETCDF4)
 This creates a new NetCDF file. Here, `filename`
  is the name of the file to be created and `varlist` an array of `NcVar` holding the variables that should appear in the file. In the optional 
 argument `gatts` you can specify a Dict containing global attributes and `mode` is the file type you want to create (NC_NETCDF4, NC_CLASSIC_MODEL or NC_64BIT_OFFSET). 
 """
-function create(name::String,varlist::Array{NcVar};gatts::Dict{Any,Any}=Dict{Any,Any}(),mode::Uint16=NC_NETCDF4)
+function create(name::AbstractString,varlist::Array{NcVar};gatts::Dict{Any,Any}=Dict{Any,Any}(),mode::UInt16=NC_NETCDF4)
   
   #Create the file
   id = nc_create(name,mode)
@@ -436,7 +436,7 @@ function create(name::String,varlist::Array{NcVar};gatts::Dict{Any,Any}=Dict{Any
   return(nc)
 end
 
-create(name::String,varlist::NcVar...;gatts::Dict{Any,Any}=Dict{Any,Any}(),mode::Uint16=NC_NETCDF4)=create(name,NcVar[varlist[i] for i=1:length(varlist)];gatts=gatts,mode=mode)
+create(name::AbstractString,varlist::NcVar...;gatts::Dict{Any,Any}=Dict{Any,Any}(),mode::UInt16=NC_NETCDF4)=create(name,NcVar[varlist[i] for i=1:length(varlist)];gatts=gatts,mode=mode)
 
 """
     NetCDF.close(nc::NcFile)
@@ -450,20 +450,20 @@ function close(nco::NcFile)
 end
 
 """
-    NetCDF.open(fil::String,v::String; mode::Integer=NC_NOWRITE, readdimvar::Bool=false)
+    NetCDF.open(fil::AbstractString,v::AbstractString; mode::Integer=NC_NOWRITE, readdimvar::Bool=false)
 opens a NetCDF variable `v` in the NetCDF file `fil` and returns an `NcVar` handle that implements the AbstractArray interface for reading and writing. 
 """
-function open(fil::String,v::String; mode::Integer=NC_NOWRITE, readdimvar::Bool=false)
+function open(fil::AbstractString,v::AbstractString; mode::Integer=NC_NOWRITE, readdimvar::Bool=false)
     nc=open(fil,mode=mode,readdimvar=readdimvar)
     nc.vars[v]
 end
 
 """
-    open(fil::String; mode::Integer=NC_NOWRITE, readdimvar::Bool=false)
+    open(fil::AbstractString; mode::Integer=NC_NOWRITE, readdimvar::Bool=false)
 opens the NetCDF file `fil` and returns a `NcFile` handle. The optional argument mode determines the `mode` in which the files is opened (`NC_NOWRITE` or `NC_WRITE`). 
 If you set `readdimvar=true`, then the dimension variables will be read when opening the file and added to the NcFIle object.  
 """
-function open(fil::String; mode::Integer=NC_NOWRITE, readdimvar::Bool=false)
+function open(fil::AbstractString; mode::Integer=NC_NOWRITE, readdimvar::Bool=false)
   # Open netcdf file
   ncid=nc_open(fil,mode)
   
@@ -510,14 +510,14 @@ If only parts of the variable are to be read, you can provide optionally `start`
 length as the number of variable dimensions. start gives the initial index for each dimension, while count gives the number of indices to be read along each dimension. 
 As a special case, setting a value in count to -1 will cause the function to read all values along this dimension. 
 """
-function ncread{T<:Integer}(fil::String,vname::String;start::Array{T}=Array(Int,0),count::Array{T}=Array(Int,0))
+function ncread{T<:Integer}(fil::AbstractString,vname::AbstractString;start::Array{T}=Array(Int,0),count::Array{T}=Array(Int,0))
   nc = haskey(currentNcFiles,abspath(fil)) ? currentNcFiles[abspath(fil)] : open(fil)
   length(start)==0 && (start=defaultstart(nc[vname]))
   length(count)==0 && (count=defaultcount(nc[vname]))
   x  = readvar(nc[vname],start=start,count=count)
   return x
 end
-ncread{T<:Integer}(fil::String,vname::String,start::Array{T,1},count::Array{T,1})=ncread(fil,vname,start=start,count=count)
+ncread{T<:Integer}(fil::AbstractString,vname::AbstractString,start::Array{T,1},count::Array{T,1})=ncread(fil,vname,start=start,count=count)
 
 """
 ncread! ( filename, varname, d, start=[1,1,...], count=[-1,-1,...] )
@@ -527,14 +527,14 @@ If only parts of the variable are to be read, you can provide optionally `start`
 length as the number of variable dimensions. start gives the initial index for each dimension, while count gives the number of indices to be read along each dimension. 
 As a special case, setting a value in count to -1 will cause the function to read all values along this dimension. 
 """
-function ncread!{T<:Integer}(fil::String,vname::String,vals::Array;start::Array{T}=ones(Int,ndims(vals)),count::Array{T}=Array(Int,size(vals)))
+function ncread!{T<:Integer}(fil::AbstractString,vname::AbstractString,vals::Array;start::Array{T}=ones(Int,ndims(vals)),count::Array{T}=Array(Int,size(vals)))
   nc = haskey(currentNcFiles,abspath(fil)) ? currentNcFiles[abspath(fil)] : open(fil)
   x  = readvar!(nc,vname,vals,start=start,count=count)
   return x
 end
 
 "prints information on the variables, dimension and attributes conatained in the file"
-function ncinfo(fil::String)
+function ncinfo(fil::AbstractString)
   nc = haskey(currentNcFiles,abspath(fil)) ? currentNcFiles[abspath(fil)] : open(fil)
   return(nc)
 end
@@ -543,13 +543,13 @@ iswritable(nc::NcFile)=(nc.omode & NC_WRITE) != zero(UInt16)
 
 #High-level functions for writing data to a file
 """
-    ncwrite{T<:Integer}(x::Array,fil::String,vname::String;start::Array{T,1}=ones(Int,length(size(x))),count::Array{T,1}=[size(x)...])
+    ncwrite{T<:Integer}(x::Array,fil::AbstractString,vname::AbstractString;start::Array{T,1}=ones(Int,length(size(x))),count::Array{T,1}=[size(x)...])
 Writes the array `x` to the file `fil` and variable `vname`. If no `start` argument is supplied, writing starts at index 1 in each dimension. 
 You can supply the argument `start`, a vector that has the same number as the number of variable dimensions, that provides the indices where to start writing the data. 
 As default the number of values written along each dimension equals the dimension of the input array. However you can specify the along which dimension the data will be 
 written by setting a `count` argument, an integer vector indicating the number of values written along each dimension.
 """
-function ncwrite{T<:Integer}(x::Array,fil::String,vname::String;start::Array{T,1}=ones(Int,length(size(x))),count::Array{T,1}=[size(x)...])
+function ncwrite{T<:Integer}(x::Array,fil::AbstractString,vname::AbstractString;start::Array{T,1}=ones(Int,length(size(x))),count::Array{T,1}=[size(x)...])
   nc = haskey(currentNcFiles,abspath(fil)) ? currentNcFiles[abspath(fil)] : open(fil,mode=NC_WRITE)
   if (nc.omode==NC_NOWRITE)
     close(nc)
@@ -558,10 +558,10 @@ function ncwrite{T<:Integer}(x::Array,fil::String,vname::String;start::Array{T,1
   end
   putvar(nc,vname,x,start=start,count=count)
 end
-ncwrite(x::Array,fil::String,vname::String,start::Array)=ncwrite(x,fil,vname,start=start)
+ncwrite(x::Array,fil::AbstractString,vname::AbstractString,start::Array)=ncwrite(x,fil,vname,start=start)
 
 "This reads an attribute from the specified file and variable. To read global attributes, set varname to `Global`."
-function ncgetatt(fil::String,vname::String,att::String)
+function ncgetatt(fil::AbstractString,vname::AbstractString,att::AbstractString)
   nc= haskey(currentNcFiles,abspath(fil)) ? currentNcFiles[abspath(fil)] : open(fil,NC_WRITE)
   return ( haskey(nc.vars,vname) ? get(nc.vars[vname].atts,att,nothing) : get(nc.gatts,att,nothing) )
 end
@@ -614,7 +614,7 @@ Possible optional arguments are:
 - **t** variable type, currently supported types are: const NC_BYTE, NC_CHAR, NC_SHORT, NC_INT, NC_FLOAT, NC_LONG, NC_DOUBLE
 - **mode** file creation mode, only valid when new file is created, choose one of: NC_NETCDF4, NC_CLASSIC_MODEL, NC_64BIT_OFFSET
 """
-function nccreate(fil::String,varname::String,dims...;atts::Dict=Dict{Any,Any}(),gatts::Dict=Dict{Any,Any}(),compress::Integer=-1,t::Union(Integer,Type)=NC_DOUBLE,mode::Uint16=NC_NETCDF4)
+function nccreate(fil::AbstractString,varname::AbstractString,dims...;atts::Dict=Dict{Any,Any}(),gatts::Dict=Dict{Any,Any}(),compress::Integer=-1,t::Union(Integer,Type)=NC_DOUBLE,mode::UInt16=NC_NETCDF4)
     # Checking dims argument for correctness
     dim=parsedimargs(dims)
     # open the file
diff --git a/src/netcdf_c.jl b/src/netcdf_c.jl
index 33c35d4..21d216a 100644
--- a/src/netcdf_c.jl
+++ b/src/netcdf_c.jl
@@ -3,25 +3,25 @@
 macro c(ret_type, func, arg_types, lib)
     local args_in = Any[ symbol(string('a',x)) for x in 1:length(arg_types.args) ]
     quote
-        function $(esc(func))($(args_in...))  
-            retval=ccall( ($(string(func)), $(Expr(:quote, lib)) ), $ret_type, $arg_types, $(args_in...) )
-            if retval!=NC_NOERR 
+        function $(esc(func))($(args_in...))
+            retval=ccall( Libdl.dlsym(libnc,$(Expr(:quote,func))), $ret_type, $arg_types, $(args_in...) )
+            if retval!=NC_NOERR
                 haskey(error_description,retval) ? error("NetCDF library error: $(error_description[retval])") : error("NetCDF library error: $(retval)")
             end
         end
     end
 end
 
-@osx_only begin
-    import Homebrew
-end
+using BinDeps
+@BinDeps.load_dependencies [:libnetcdf]
+const libnc = Libdl.dlopen(libnetcdf[1][2])
 
 const NC_NAT = 0
 const NC_BYTE = 1
 const NC_CHAR = 2
 const NC_SHORT = 3
 const NC_INT = 4
-const NC_LONG = 
+const NC_LONG =
 const NC_FLOAT = 5
 const NC_DOUBLE = 6
 const NC_UBYTE = 7
@@ -30,7 +30,7 @@ const NC_UINT = 9
 const NC_INT64 = 10
 const NC_UINT64 = 11
 const NC_STRING = 12
-const NC_MAX_ATOMIC_TYPE = 
+const NC_MAX_ATOMIC_TYPE =
 const NC_VLEN = 13
 const NC_OPAQUE = 14
 const NC_ENUM = 15
@@ -168,60 +168,60 @@ const NC_COLLECTIVE = 1
 typealias nc_type Cint
 typealias nclong Cint
 
-@c Ptr{Uint8} nc_inq_libvers () libnetcdf
-@c Ptr{Uint8} nc_strerror (Cint,) libnetcdf
-@c Cint nc__create (Ptr{Uint8}, Cint, Csize_t, Ptr{Csize_t}, Ptr{Cint}) libnetcdf
-@c Cint nc_create (Ptr{Uint8}, Cint, Ptr{Cint}) libnetcdf
-@c Cint nc__open (Ptr{Uint8}, Cint, Ptr{Csize_t}, Ptr{Cint}) libnetcdf
-@c Cint nc_open (Ptr{Uint8}, Cint, Ptr{Cint}) libnetcdf
-@c Cint nc_inq_path (Cint, Ptr{Csize_t}, Ptr{Uint8}) libnetcdf
+@c Ptr{UInt8} nc_inq_libvers () libnetcdf
+@c Ptr{UInt8} nc_strerror (Cint,) libnetcdf
+@c Cint nc__create (Ptr{UInt8}, Cint, Csize_t, Ptr{Csize_t}, Ptr{Cint}) libnetcdf
+@c Cint nc_create (Ptr{UInt8}, Cint, Ptr{Cint}) libnetcdf
+@c Cint nc__open (Ptr{UInt8}, Cint, Ptr{Csize_t}, Ptr{Cint}) libnetcdf
+@c Cint nc_open (Ptr{UInt8}, Cint, Ptr{Cint}) libnetcdf
+@c Cint nc_inq_path (Cint, Ptr{Csize_t}, Ptr{UInt8}) libnetcdf
 @c Cint nc_var_par_access (Cint, Cint, Cint) libnetcdf
-@c Cint nc_inq_ncid (Cint, Ptr{Uint8}, Ptr{Cint}) libnetcdf
+@c Cint nc_inq_ncid (Cint, Ptr{UInt8}, Ptr{Cint}) libnetcdf
 @c Cint nc_inq_grps (Cint, Ptr{Cint}, Ptr{Cint}) libnetcdf
-@c Cint nc_inq_grpname (Cint, Ptr{Uint8}) libnetcdf
-@c Cint nc_inq_grpname_full (Cint, Ptr{Csize_t}, Ptr{Uint8}) libnetcdf
+@c Cint nc_inq_grpname (Cint, Ptr{UInt8}) libnetcdf
+@c Cint nc_inq_grpname_full (Cint, Ptr{Csize_t}, Ptr{UInt8}) libnetcdf
 @c Cint nc_inq_grpname_len (Cint, Ptr{Csize_t}) libnetcdf
 @c Cint nc_inq_grp_parent (Cint, Ptr{Cint}) libnetcdf
-@c Cint nc_inq_grp_ncid (Cint, Ptr{Uint8}, Ptr{Cint}) libnetcdf
-@c Cint nc_inq_grp_full_ncid (Cint, Ptr{Uint8}, Ptr{Cint}) libnetcdf
+@c Cint nc_inq_grp_ncid (Cint, Ptr{UInt8}, Ptr{Cint}) libnetcdf
+@c Cint nc_inq_grp_full_ncid (Cint, Ptr{UInt8}, Ptr{Cint}) libnetcdf
 @c Cint nc_inq_varids (Cint, Ptr{Cint}, Ptr{Cint}) libnetcdf
 @c Cint nc_inq_dimids (Cint, Ptr{Cint}, Ptr{Cint}, Cint) libnetcdf
 @c Cint nc_inq_typeids (Cint, Ptr{Cint}, Ptr{Cint}) libnetcdf
 @c Cint nc_inq_type_equal (Cint, nc_type, Cint, nc_type, Ptr{Cint}) libnetcdf
-@c Cint nc_def_grp (Cint, Ptr{Uint8}, Ptr{Cint}) libnetcdf
-@c Cint nc_def_compound (Cint, Csize_t, Ptr{Uint8}, Ptr{nc_type}) libnetcdf
-@c Cint nc_insert_compound (Cint, nc_type, Ptr{Uint8}, Csize_t, nc_type) libnetcdf
-@c Cint nc_insert_array_compound (Cint, nc_type, Ptr{Uint8}, Csize_t, nc_type, Cint, Ptr{Cint}) libnetcdf
-@c Cint nc_inq_type (Cint, nc_type, Ptr{Uint8}, Ptr{Csize_t}) libnetcdf
-@c Cint nc_inq_typeid (Cint, Ptr{Uint8}, Ptr{nc_type}) libnetcdf
-@c Cint nc_inq_compound (Cint, nc_type, Ptr{Uint8}, Ptr{Csize_t}, Ptr{Csize_t}) libnetcdf
-@c Cint nc_inq_compound_name (Cint, nc_type, Ptr{Uint8}) libnetcdf
+@c Cint nc_def_grp (Cint, Ptr{UInt8}, Ptr{Cint}) libnetcdf
+@c Cint nc_def_compound (Cint, Csize_t, Ptr{UInt8}, Ptr{nc_type}) libnetcdf
+@c Cint nc_insert_compound (Cint, nc_type, Ptr{UInt8}, Csize_t, nc_type) libnetcdf
+@c Cint nc_insert_array_compound (Cint, nc_type, Ptr{UInt8}, Csize_t, nc_type, Cint, Ptr{Cint}) libnetcdf
+@c Cint nc_inq_type (Cint, nc_type, Ptr{UInt8}, Ptr{Csize_t}) libnetcdf
+@c Cint nc_inq_typeid (Cint, Ptr{UInt8}, Ptr{nc_type}) libnetcdf
+@c Cint nc_inq_compound (Cint, nc_type, Ptr{UInt8}, Ptr{Csize_t}, Ptr{Csize_t}) libnetcdf
+@c Cint nc_inq_compound_name (Cint, nc_type, Ptr{UInt8}) libnetcdf
 @c Cint nc_inq_compound_size (Cint, nc_type, Ptr{Csize_t}) libnetcdf
 @c Cint nc_inq_compound_nfields (Cint, nc_type, Ptr{Csize_t}) libnetcdf
-@c Cint nc_inq_compound_field (Cint, nc_type, Cint, Ptr{Uint8}, Ptr{Csize_t}, Ptr{nc_type}, Ptr{Cint}, Ptr{Cint}) libnetcdf
-@c Cint nc_inq_compound_fieldname (Cint, nc_type, Cint, Ptr{Uint8}) libnetcdf
-@c Cint nc_inq_compound_fieldindex (Cint, nc_type, Ptr{Uint8}, Ptr{Cint}) libnetcdf
+@c Cint nc_inq_compound_field (Cint, nc_type, Cint, Ptr{UInt8}, Ptr{Csize_t}, Ptr{nc_type}, Ptr{Cint}, Ptr{Cint}) libnetcdf
+@c Cint nc_inq_compound_fieldname (Cint, nc_type, Cint, Ptr{UInt8}) libnetcdf
+@c Cint nc_inq_compound_fieldindex (Cint, nc_type, Ptr{UInt8}, Ptr{Cint}) libnetcdf
 @c Cint nc_inq_compound_fieldoffset (Cint, nc_type, Cint, Ptr{Csize_t}) libnetcdf
 @c Cint nc_inq_compound_fieldtype (Cint, nc_type, Cint, Ptr{nc_type}) libnetcdf
 @c Cint nc_inq_compound_fieldndims (Cint, nc_type, Cint, Ptr{Cint}) libnetcdf
 @c Cint nc_inq_compound_fielddim_sizes (Cint, nc_type, Cint, Ptr{Cint}) libnetcdf
-@c Cint nc_def_vlen (Cint, Ptr{Uint8}, nc_type, Ptr{nc_type}) libnetcdf
-@c Cint nc_inq_vlen (Cint, nc_type, Ptr{Uint8}, Ptr{Csize_t}, Ptr{nc_type}) libnetcdf
+@c Cint nc_def_vlen (Cint, Ptr{UInt8}, nc_type, Ptr{nc_type}) libnetcdf
+@c Cint nc_inq_vlen (Cint, nc_type, Ptr{UInt8}, Ptr{Csize_t}, Ptr{nc_type}) libnetcdf
 @c Cint nc_free_vlen (Ptr{nc_vlen_t},) libnetcdf
 @c Cint nc_free_vlens (Csize_t, Ptr{nc_vlen_t}) libnetcdf
 @c Cint nc_put_vlen_element (Cint, Cint, Ptr{Void}, Csize_t, Ptr{Void}) libnetcdf
 @c Cint nc_get_vlen_element (Cint, Cint, Ptr{Void}, Ptr{Csize_t}, Ptr{Void}) libnetcdf
-@c Cint nc_free_string (Csize_t, Ptr{Ptr{Uint8}}) libnetcdf
-@c Cint nc_inq_user_type (Cint, nc_type, Ptr{Uint8}, Ptr{Csize_t}, Ptr{nc_type}, Ptr{Csize_t}, Ptr{Cint}) libnetcdf
-@c Cint nc_put_att (Cint, Cint, Ptr{Uint8}, nc_type, Csize_t, Ptr{Void}) libnetcdf
-@c Cint nc_get_att (Cint, Cint, Ptr{Uint8}, Ptr{Void}) libnetcdf
-@c Cint nc_def_enum (Cint, nc_type, Ptr{Uint8}, Ptr{nc_type}) libnetcdf
-@c Cint nc_insert_enum (Cint, nc_type, Ptr{Uint8}, Ptr{Void}) libnetcdf
-@c Cint nc_inq_enum (Cint, nc_type, Ptr{Uint8}, Ptr{nc_type}, Ptr{Csize_t}, Ptr{Csize_t}) libnetcdf
-@c Cint nc_inq_enum_member (Cint, nc_type, Cint, Ptr{Uint8}, Ptr{Void}) libnetcdf
-@c Cint nc_inq_enum_ident (Cint, nc_type, Clonglong, Ptr{Uint8}) libnetcdf
-@c Cint nc_def_opaque (Cint, Csize_t, Ptr{Uint8}, Ptr{nc_type}) libnetcdf
-@c Cint nc_inq_opaque (Cint, nc_type, Ptr{Uint8}, Ptr{Csize_t}) libnetcdf
+@c Cint nc_free_string (Csize_t, Ptr{Ptr{UInt8}}) libnetcdf
+@c Cint nc_inq_user_type (Cint, nc_type, Ptr{UInt8}, Ptr{Csize_t}, Ptr{nc_type}, Ptr{Csize_t}, Ptr{Cint}) libnetcdf
+@c Cint nc_put_att (Cint, Cint, Ptr{UInt8}, nc_type, Csize_t, Ptr{Void}) libnetcdf
+@c Cint nc_get_att (Cint, Cint, Ptr{UInt8}, Ptr{Void}) libnetcdf
+@c Cint nc_def_enum (Cint, nc_type, Ptr{UInt8}, Ptr{nc_type}) libnetcdf
+@c Cint nc_insert_enum (Cint, nc_type, Ptr{UInt8}, Ptr{Void}) libnetcdf
+@c Cint nc_inq_enum (Cint, nc_type, Ptr{UInt8}, Ptr{nc_type}, Ptr{Csize_t}, Ptr{Csize_t}) libnetcdf
+@c Cint nc_inq_enum_member (Cint, nc_type, Cint, Ptr{UInt8}, Ptr{Void}) libnetcdf
+@c Cint nc_inq_enum_ident (Cint, nc_type, Clonglong, Ptr{UInt8}) libnetcdf
+@c Cint nc_def_opaque (Cint, Csize_t, Ptr{UInt8}, Ptr{nc_type}) libnetcdf
+@c Cint nc_inq_opaque (Cint, nc_type, Ptr{UInt8}, Ptr{Csize_t}) libnetcdf
 @c Cint nc_put_var (Cint, Cint, Ptr{Void}) libnetcdf
 @c Cint nc_get_var (Cint, Cint, Ptr{Void}) libnetcdf
 @c Cint nc_put_var1 (Cint, Cint, Ptr{Csize_t}, Ptr{Void}) libnetcdf
@@ -262,62 +262,62 @@ typealias nclong Cint
 @c Cint nc_inq_unlimdim (Cint, Ptr{Cint}) libnetcdf
 @c Cint nc_inq_unlimdims (Cint, Ptr{Cint}, Ptr{Cint}) libnetcdf
 @c Cint nc_inq_format (Cint, Ptr{Cint}) libnetcdf
-@c Cint nc_def_dim (Cint, Ptr{Uint8}, Csize_t, Ptr{Cint}) libnetcdf
-@c Cint nc_inq_dimid (Cint, Ptr{Uint8}, Ptr{Cint}) libnetcdf
-@c Cint nc_inq_dim (Cint, Cint, Ptr{Uint8}, Ptr{Csize_t}) libnetcdf
-@c Cint nc_inq_dimname (Cint, Cint, Ptr{Uint8}) libnetcdf
+@c Cint nc_def_dim (Cint, Ptr{UInt8}, Csize_t, Ptr{Cint}) libnetcdf
+@c Cint nc_inq_dimid (Cint, Ptr{UInt8}, Ptr{Cint}) libnetcdf
+@c Cint nc_inq_dim (Cint, Cint, Ptr{UInt8}, Ptr{Csize_t}) libnetcdf
+@c Cint nc_inq_dimname (Cint, Cint, Ptr{UInt8}) libnetcdf
 @c Cint nc_inq_dimlen (Cint, Cint, Ptr{Csize_t}) libnetcdf
-@c Cint nc_rename_dim (Cint, Cint, Ptr{Uint8}) libnetcdf
-@c Cint nc_inq_att (Cint, Cint, Ptr{Uint8}, Ptr{nc_type}, Ptr{Csize_t}) libnetcdf
-@c Cint nc_inq_attid (Cint, Cint, Ptr{Uint8}, Ptr{Cint}) libnetcdf
-@c Cint nc_inq_atttype (Cint, Cint, Ptr{Uint8}, Ptr{nc_type}) libnetcdf
-@c Cint nc_inq_attlen (Cint, Cint, Ptr{Uint8}, Ptr{Csize_t}) libnetcdf
-@c Cint nc_inq_attname (Cint, Cint, Cint, Ptr{Uint8}) libnetcdf
-@c Cint nc_copy_att (Cint, Cint, Ptr{Uint8}, Cint, Cint) libnetcdf
-@c Cint nc_rename_att (Cint, Cint, Ptr{Uint8}, Ptr{Uint8}) libnetcdf
-@c Cint nc_del_att (Cint, Cint, Ptr{Uint8}) libnetcdf
-@c Cint nc_put_att_text (Cint, Cint, Ptr{Uint8}, Csize_t, Ptr{Uint8}) libnetcdf
-@c Cint nc_get_att_text (Cint, Cint, Ptr{Uint8}, Ptr{Uint8}) libnetcdf
-@c Cint nc_put_att_uchar (Cint, Cint, Ptr{Uint8}, nc_type, Csize_t, Ptr{Cuchar}) libnetcdf
-@c Cint nc_get_att_uchar (Cint, Cint, Ptr{Uint8}, Ptr{Cuchar}) libnetcdf
-@c Cint nc_put_att_schar (Cint, Cint, Ptr{Uint8}, nc_type, Csize_t, Ptr{Int8}) libnetcdf
-@c Cint nc_get_att_schar (Cint, Cint, Ptr{Uint8}, Ptr{Int8}) libnetcdf
-@c Cint nc_put_att_short (Cint, Cint, Ptr{Uint8}, nc_type, Csize_t, Ptr{Int16}) libnetcdf
-@c Cint nc_get_att_short (Cint, Cint, Ptr{Uint8}, Ptr{Int16}) libnetcdf
-@c Cint nc_put_att_int (Cint, Cint, Ptr{Uint8}, nc_type, Csize_t, Ptr{Cint}) libnetcdf
-@c Cint nc_get_att_int (Cint, Cint, Ptr{Uint8}, Ptr{Cint}) libnetcdf
-@c Cint nc_put_att_long (Cint, Cint, Ptr{Uint8}, nc_type, Csize_t, Ptr{Clong}) libnetcdf
-@c Cint nc_get_att_long (Cint, Cint, Ptr{Uint8}, Ptr{Clong}) libnetcdf
-@c Cint nc_put_att_float (Cint, Cint, Ptr{Uint8}, nc_type, Csize_t, Ptr{Cfloat}) libnetcdf
-@c Cint nc_get_att_float (Cint, Cint, Ptr{Uint8}, Ptr{Cfloat}) libnetcdf
-@c Cint nc_put_att_double (Cint, Cint, Ptr{Uint8}, nc_type, Csize_t, Ptr{Cdouble}) libnetcdf
-@c Cint nc_get_att_double (Cint, Cint, Ptr{Uint8}, Ptr{Cdouble}) libnetcdf
-@c Cint nc_put_att_ushort (Cint, Cint, Ptr{Uint8}, nc_type, Csize_t, Ptr{Uint16}) libnetcdf
-@c Cint nc_get_att_ushort (Cint, Cint, Ptr{Uint8}, Ptr{Uint16}) libnetcdf
-@c Cint nc_put_att_uint (Cint, Cint, Ptr{Uint8}, nc_type, Csize_t, Ptr{Uint32}) libnetcdf
-@c Cint nc_get_att_uint (Cint, Cint, Ptr{Uint8}, Ptr{Uint32}) libnetcdf
-@c Cint nc_put_att_longlong (Cint, Cint, Ptr{Uint8}, nc_type, Csize_t, Ptr{Clonglong}) libnetcdf
-@c Cint nc_get_att_longlong (Cint, Cint, Ptr{Uint8}, Ptr{Clonglong}) libnetcdf
-@c Cint nc_put_att_ulonglong (Cint, Cint, Ptr{Uint8}, nc_type, Csize_t, Ptr{Culonglong}) libnetcdf
-@c Cint nc_get_att_ulonglong (Cint, Cint, Ptr{Uint8}, Ptr{Culonglong}) libnetcdf
-@c Cint nc_put_att_string (Cint, Cint, Ptr{Uint8}, Csize_t, Ptr{Ptr{Uint8}}) libnetcdf
-@c Cint nc_get_att_string (Cint, Cint, Ptr{Uint8}, Ptr{Ptr{Uint8}}) libnetcdf
-@c Cint nc_def_var (Cint, Ptr{Uint8}, nc_type, Cint, Ptr{Cint}, Ptr{Cint}) libnetcdf
-@c Cint nc_inq_var (Cint, Cint, Ptr{Uint8}, Ptr{nc_type}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}) libnetcdf
-@c Cint nc_inq_varid (Cint, Ptr{Uint8}, Ptr{Cint}) libnetcdf
-@c Cint nc_inq_varname (Cint, Cint, Ptr{Uint8}) libnetcdf
+@c Cint nc_rename_dim (Cint, Cint, Ptr{UInt8}) libnetcdf
+@c Cint nc_inq_att (Cint, Cint, Ptr{UInt8}, Ptr{nc_type}, Ptr{Csize_t}) libnetcdf
+@c Cint nc_inq_attid (Cint, Cint, Ptr{UInt8}, Ptr{Cint}) libnetcdf
+@c Cint nc_inq_atttype (Cint, Cint, Ptr{UInt8}, Ptr{nc_type}) libnetcdf
+@c Cint nc_inq_attlen (Cint, Cint, Ptr{UInt8}, Ptr{Csize_t}) libnetcdf
+@c Cint nc_inq_attname (Cint, Cint, Cint, Ptr{UInt8}) libnetcdf
+@c Cint nc_copy_att (Cint, Cint, Ptr{UInt8}, Cint, Cint) libnetcdf
+@c Cint nc_rename_att (Cint, Cint, Ptr{UInt8}, Ptr{UInt8}) libnetcdf
+@c Cint nc_del_att (Cint, Cint, Ptr{UInt8}) libnetcdf
+@c Cint nc_put_att_text (Cint, Cint, Ptr{UInt8}, Csize_t, Ptr{UInt8}) libnetcdf
+@c Cint nc_get_att_text (Cint, Cint, Ptr{UInt8}, Ptr{UInt8}) libnetcdf
+@c Cint nc_put_att_uchar (Cint, Cint, Ptr{UInt8}, nc_type, Csize_t, Ptr{Cuchar}) libnetcdf
+@c Cint nc_get_att_uchar (Cint, Cint, Ptr{UInt8}, Ptr{Cuchar}) libnetcdf
+@c Cint nc_put_att_schar (Cint, Cint, Ptr{UInt8}, nc_type, Csize_t, Ptr{Int8}) libnetcdf
+@c Cint nc_get_att_schar (Cint, Cint, Ptr{UInt8}, Ptr{Int8}) libnetcdf
+@c Cint nc_put_att_short (Cint, Cint, Ptr{UInt8}, nc_type, Csize_t, Ptr{Int16}) libnetcdf
+@c Cint nc_get_att_short (Cint, Cint, Ptr{UInt8}, Ptr{Int16}) libnetcdf
+@c Cint nc_put_att_int (Cint, Cint, Ptr{UInt8}, nc_type, Csize_t, Ptr{Cint}) libnetcdf
+@c Cint nc_get_att_int (Cint, Cint, Ptr{UInt8}, Ptr{Cint}) libnetcdf
+@c Cint nc_put_att_long (Cint, Cint, Ptr{UInt8}, nc_type, Csize_t, Ptr{Clong}) libnetcdf
+@c Cint nc_get_att_long (Cint, Cint, Ptr{UInt8}, Ptr{Clong}) libnetcdf
+@c Cint nc_put_att_float (Cint, Cint, Ptr{UInt8}, nc_type, Csize_t, Ptr{Cfloat}) libnetcdf
+@c Cint nc_get_att_float (Cint, Cint, Ptr{UInt8}, Ptr{Cfloat}) libnetcdf
+@c Cint nc_put_att_double (Cint, Cint, Ptr{UInt8}, nc_type, Csize_t, Ptr{Cdouble}) libnetcdf
+@c Cint nc_get_att_double (Cint, Cint, Ptr{UInt8}, Ptr{Cdouble}) libnetcdf
+@c Cint nc_put_att_ushort (Cint, Cint, Ptr{UInt8}, nc_type, Csize_t, Ptr{UInt16}) libnetcdf
+@c Cint nc_get_att_ushort (Cint, Cint, Ptr{UInt8}, Ptr{UInt16}) libnetcdf
+@c Cint nc_put_att_uint (Cint, Cint, Ptr{UInt8}, nc_type, Csize_t, Ptr{UInt32}) libnetcdf
+@c Cint nc_get_att_uint (Cint, Cint, Ptr{UInt8}, Ptr{UInt32}) libnetcdf
+@c Cint nc_put_att_longlong (Cint, Cint, Ptr{UInt8}, nc_type, Csize_t, Ptr{Clonglong}) libnetcdf
+@c Cint nc_get_att_longlong (Cint, Cint, Ptr{UInt8}, Ptr{Clonglong}) libnetcdf
+@c Cint nc_put_att_ulonglong (Cint, Cint, Ptr{UInt8}, nc_type, Csize_t, Ptr{Culonglong}) libnetcdf
+@c Cint nc_get_att_ulonglong (Cint, Cint, Ptr{UInt8}, Ptr{Culonglong}) libnetcdf
+@c Cint nc_put_att_string (Cint, Cint, Ptr{UInt8}, Csize_t, Ptr{Ptr{UInt8}}) libnetcdf
+@c Cint nc_get_att_string (Cint, Cint, Ptr{UInt8}, Ptr{Ptr{UInt8}}) libnetcdf
+@c Cint nc_def_var (Cint, Ptr{UInt8}, nc_type, Cint, Ptr{Cint}, Ptr{Cint}) libnetcdf
+@c Cint nc_inq_var (Cint, Cint, Ptr{UInt8}, Ptr{nc_type}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}) libnetcdf
+@c Cint nc_inq_varid (Cint, Ptr{UInt8}, Ptr{Cint}) libnetcdf
+@c Cint nc_inq_varname (Cint, Cint, Ptr{UInt8}) libnetcdf
 @c Cint nc_inq_vartype (Cint, Cint, Ptr{nc_type}) libnetcdf
 @c Cint nc_inq_varndims (Cint, Cint, Ptr{Cint}) libnetcdf
 @c Cint nc_inq_vardimid (Cint, Cint, Ptr{Cint}) libnetcdf
 @c Cint nc_inq_varnatts (Cint, Cint, Ptr{Cint}) libnetcdf
-@c Cint nc_rename_var (Cint, Cint, Ptr{Uint8}) libnetcdf
+@c Cint nc_rename_var (Cint, Cint, Ptr{UInt8}) libnetcdf
 @c Cint nc_copy_var (Cint, Cint, Cint) libnetcdf
-@c Cint nc_put_var1_text (Cint, Cint, Ptr{Csize_t}, Ptr{Uint8}) libnetcdf
-@c Cint nc_get_var1_text (Cint, Cint, Ptr{Csize_t}, Ptr{Uint8}) libnetcdf
+@c Cint nc_put_var1_text (Cint, Cint, Ptr{Csize_t}, Ptr{UInt8}) libnetcdf
+@c Cint nc_get_var1_text (Cint, Cint, Ptr{Csize_t}, Ptr{UInt8}) libnetcdf
 @c Cint nc_put_var1_uchar (Cint, Cint, Ptr{Csize_t}, Ptr{Cuchar}) libnetcdf
 @c Cint nc_get_var1_uchar (Cint, Cint, Ptr{Csize_t}, Ptr{Cuchar}) libnetcdf
-@c Cint nc_put_var1_schar (Cint, Cint, Ptr{Csize_t}, Ptr{Uint8}) libnetcdf
-@c Cint nc_get_var1_schar (Cint, Cint, Ptr{Csize_t}, Ptr{Uint8}) libnetcdf
+@c Cint nc_put_var1_schar (Cint, Cint, Ptr{Csize_t}, Ptr{UInt8}) libnetcdf
+@c Cint nc_get_var1_schar (Cint, Cint, Ptr{Csize_t}, Ptr{UInt8}) libnetcdf
 @c Cint nc_put_var1_short (Cint, Cint, Ptr{Csize_t}, Ptr{Int16}) libnetcdf
 @c Cint nc_get_var1_short (Cint, Cint, Ptr{Csize_t}, Ptr{Int16}) libnetcdf
 @c Cint nc_put_var1_int (Cint, Cint, Ptr{Csize_t}, Ptr{Cint}) libnetcdf
@@ -328,18 +328,18 @@ typealias nclong Cint
 @c Cint nc_get_var1_float (Cint, Cint, Ptr{Csize_t}, Ptr{Cfloat}) libnetcdf
 @c Cint nc_put_var1_double (Cint, Cint, Ptr{Csize_t}, Ptr{Cdouble}) libnetcdf
 @c Cint nc_get_var1_double (Cint, Cint, Ptr{Csize_t}, Ptr{Cdouble}) libnetcdf
-@c Cint nc_put_var1_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{Uint16}) libnetcdf
-@c Cint nc_get_var1_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{Uint16}) libnetcdf
-@c Cint nc_put_var1_uint (Cint, Cint, Ptr{Csize_t}, Ptr{Uint32}) libnetcdf
-@c Cint nc_get_var1_uint (Cint, Cint, Ptr{Csize_t}, Ptr{Uint32}) libnetcdf
+@c Cint nc_put_var1_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{UInt16}) libnetcdf
+@c Cint nc_get_var1_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{UInt16}) libnetcdf
+@c Cint nc_put_var1_uint (Cint, Cint, Ptr{Csize_t}, Ptr{UInt32}) libnetcdf
+@c Cint nc_get_var1_uint (Cint, Cint, Ptr{Csize_t}, Ptr{UInt32}) libnetcdf
 @c Cint nc_put_var1_longlong (Cint, Cint, Ptr{Csize_t}, Ptr{Clonglong}) libnetcdf
 @c Cint nc_get_var1_longlong (Cint, Cint, Ptr{Csize_t}, Ptr{Clonglong}) libnetcdf
 @c Cint nc_put_var1_ulonglong (Cint, Cint, Ptr{Csize_t}, Ptr{Culonglong}) libnetcdf
 @c Cint nc_get_var1_ulonglong (Cint, Cint, Ptr{Csize_t}, Ptr{Culonglong}) libnetcdf
-@c Cint nc_put_var1_string (Cint, Cint, Ptr{Csize_t}, Ptr{Ptr{Uint8}}) libnetcdf
-@c Cint nc_get_var1_string (Cint, Cint, Ptr{Csize_t}, Ptr{Ptr{Uint8}}) libnetcdf
-@c Cint nc_put_vara_text (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Uint8}) libnetcdf
-@c Cint nc_get_vara_text (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Uint8}) libnetcdf
+@c Cint nc_put_var1_string (Cint, Cint, Ptr{Csize_t}, Ptr{Ptr{UInt8}}) libnetcdf
+@c Cint nc_get_var1_string (Cint, Cint, Ptr{Csize_t}, Ptr{Ptr{UInt8}}) libnetcdf
+@c Cint nc_put_vara_text (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{UInt8}) libnetcdf
+@c Cint nc_get_vara_text (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{UInt8}) libnetcdf
 @c Cint nc_put_vara_uchar (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Cuchar}) libnetcdf
 @c Cint nc_get_vara_uchar (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Cuchar}) libnetcdf
 @c Cint nc_put_vara_schar (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Int8}) libnetcdf
@@ -354,22 +354,22 @@ typealias nclong Cint
 @c Cint nc_get_vara_float (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Cfloat}) libnetcdf
 @c Cint nc_put_vara_double (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Cdouble}) libnetcdf
 @c Cint nc_get_vara_double (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Cdouble}) libnetcdf
-@c Cint nc_put_vara_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Uint16}) libnetcdf
-@c Cint nc_get_vara_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Uint16}) libnetcdf
-@c Cint nc_put_vara_uint (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Uint32}) libnetcdf
-@c Cint nc_get_vara_uint (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Uint32}) libnetcdf
+@c Cint nc_put_vara_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{UInt16}) libnetcdf
+@c Cint nc_get_vara_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{UInt16}) libnetcdf
+@c Cint nc_put_vara_uint (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{UInt32}) libnetcdf
+@c Cint nc_get_vara_uint (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{UInt32}) libnetcdf
 @c Cint nc_put_vara_longlong (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Clonglong}) libnetcdf
 @c Cint nc_get_vara_longlong (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Clonglong}) libnetcdf
 @c Cint nc_put_vara_ulonglong (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Culonglong}) libnetcdf
 @c Cint nc_get_vara_ulonglong (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Culonglong}) libnetcdf
-@c Cint nc_put_vara_string (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Ptr{Uint8}}) libnetcdf
-@c Cint nc_get_vara_string (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Ptr{Uint8}}) libnetcdf
-@c Cint nc_put_vars_text (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Uint8}) libnetcdf
-@c Cint nc_get_vars_text (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Uint8}) libnetcdf
+@c Cint nc_put_vara_string (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Ptr{UInt8}}) libnetcdf
+@c Cint nc_get_vara_string (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Ptr{UInt8}}) libnetcdf
+@c Cint nc_put_vars_text (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{UInt8}) libnetcdf
+@c Cint nc_get_vars_text (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{UInt8}) libnetcdf
 @c Cint nc_put_vars_uchar (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Cuchar}) libnetcdf
 @c Cint nc_get_vars_uchar (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Cuchar}) libnetcdf
-@c Cint nc_put_vars_schar (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Uint8}) libnetcdf
-@c Cint nc_get_vars_schar (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Uint8}) libnetcdf
+@c Cint nc_put_vars_schar (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{UInt8}) libnetcdf
+@c Cint nc_get_vars_schar (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{UInt8}) libnetcdf
 @c Cint nc_put_vars_short (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Int16}) libnetcdf
 @c Cint nc_get_vars_short (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Int16}) libnetcdf
 @c Cint nc_put_vars_int (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Cint}) libnetcdf
@@ -380,22 +380,22 @@ typealias nclong Cint
 @c Cint nc_get_vars_float (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Cfloat}) libnetcdf
 @c Cint nc_put_vars_double (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Cdouble}) libnetcdf
 @c Cint nc_get_vars_double (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Cdouble}) libnetcdf
-@c Cint nc_put_vars_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Uint16}) libnetcdf
-@c Cint nc_get_vars_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Uint16}) libnetcdf
-@c Cint nc_put_vars_uint (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Uint32}) libnetcdf
-@c Cint nc_get_vars_uint (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Uint32}) libnetcdf
+@c Cint nc_put_vars_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{UInt16}) libnetcdf
+@c Cint nc_get_vars_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{UInt16}) libnetcdf
+@c Cint nc_put_vars_uint (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{UInt32}) libnetcdf
+@c Cint nc_get_vars_uint (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{UInt32}) libnetcdf
 @c Cint nc_put_vars_longlong (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Clonglong}) libnetcdf
 @c Cint nc_get_vars_longlong (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Clonglong}) libnetcdf
 @c Cint nc_put_vars_ulonglong (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Culonglong}) libnetcdf
 @c Cint nc_get_vars_ulonglong (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Culonglong}) libnetcdf
-@c Cint nc_put_vars_string (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Ptr{Uint8}}) libnetcdf
-@c Cint nc_get_vars_string (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Ptr{Uint8}}) libnetcdf
-@c Cint nc_put_varm_text (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Uint8}) libnetcdf
-@c Cint nc_get_varm_text (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Uint8}) libnetcdf
+@c Cint nc_put_vars_string (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Ptr{UInt8}}) libnetcdf
+@c Cint nc_get_vars_string (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{Ptr{UInt8}}) libnetcdf
+@c Cint nc_put_varm_text (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{UInt8}) libnetcdf
+@c Cint nc_get_varm_text (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{UInt8}) libnetcdf
 @c Cint nc_put_varm_uchar (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Cuchar}) libnetcdf
 @c Cint nc_get_varm_uchar (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Cuchar}) libnetcdf
-@c Cint nc_put_varm_schar (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Uint8}) libnetcdf
-@c Cint nc_get_varm_schar (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Uint8}) libnetcdf
+@c Cint nc_put_varm_schar (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{UInt8}) libnetcdf
+@c Cint nc_get_varm_schar (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{UInt8}) libnetcdf
 @c Cint nc_put_varm_short (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Int16}) libnetcdf
 @c Cint nc_get_varm_short (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Int16}) libnetcdf
 @c Cint nc_put_varm_int (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Cint}) libnetcdf
@@ -406,22 +406,22 @@ typealias nclong Cint
 @c Cint nc_get_varm_float (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Cfloat}) libnetcdf
 @c Cint nc_put_varm_double (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Cdouble}) libnetcdf
 @c Cint nc_get_varm_double (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Cdouble}) libnetcdf
-@c Cint nc_put_varm_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Uint16}) libnetcdf
-@c Cint nc_get_varm_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Uint16}) libnetcdf
-@c Cint nc_put_varm_uint (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Uint32}) libnetcdf
-@c Cint nc_get_varm_uint (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Uint32}) libnetcdf
+@c Cint nc_put_varm_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{UInt16}) libnetcdf
+@c Cint nc_get_varm_ushort (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{UInt16}) libnetcdf
+@c Cint nc_put_varm_uint (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{UInt32}) libnetcdf
+@c Cint nc_get_varm_uint (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{UInt32}) libnetcdf
 @c Cint nc_put_varm_longlong (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Clonglong}) libnetcdf
 @c Cint nc_get_varm_longlong (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Clonglong}) libnetcdf
 @c Cint nc_put_varm_ulonglong (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Culonglong}) libnetcdf
 @c Cint nc_get_varm_ulonglong (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Culonglong}) libnetcdf
-@c Cint nc_put_varm_string (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Ptr{Uint8}}) libnetcdf
-@c Cint nc_get_varm_string (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Ptr{Uint8}}) libnetcdf
-@c Cint nc_put_var_text (Cint, Cint, Ptr{Uint8}) libnetcdf
-@c Cint nc_get_var_text (Cint, Cint, Ptr{Uint8}) libnetcdf
+@c Cint nc_put_varm_string (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Ptr{UInt8}}) libnetcdf
+@c Cint nc_get_varm_string (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{ptrdiff_t}, Ptr{ptrdiff_t}, Ptr{Ptr{UInt8}}) libnetcdf
+@c Cint nc_put_var_text (Cint, Cint, Ptr{UInt8}) libnetcdf
+@c Cint nc_get_var_text (Cint, Cint, Ptr{UInt8}) libnetcdf
 @c Cint nc_put_var_uchar (Cint, Cint, Ptr{Cuchar}) libnetcdf
 @c Cint nc_get_var_uchar (Cint, Cint, Ptr{Cuchar}) libnetcdf
-@c Cint nc_put_var_schar (Cint, Cint, Ptr{Uint8}) libnetcdf
-@c Cint nc_get_var_schar (Cint, Cint, Ptr{Uint8}) libnetcdf
+@c Cint nc_put_var_schar (Cint, Cint, Ptr{UInt8}) libnetcdf
+@c Cint nc_get_var_schar (Cint, Cint, Ptr{UInt8}) libnetcdf
 @c Cint nc_put_var_short (Cint, Cint, Ptr{Int16}) libnetcdf
 @c Cint nc_get_var_short (Cint, Cint, Ptr{Int16}) libnetcdf
 @c Cint nc_put_var_int (Cint, Cint, Ptr{Cint}) libnetcdf
@@ -432,18 +432,18 @@ typealias nclong Cint
 @c Cint nc_get_var_float (Cint, Cint, Ptr{Cfloat}) libnetcdf
 @c Cint nc_put_var_double (Cint, Cint, Ptr{Cdouble}) libnetcdf
 @c Cint nc_get_var_double (Cint, Cint, Ptr{Cdouble}) libnetcdf
-@c Cint nc_put_var_ushort (Cint, Cint, Ptr{Uint16}) libnetcdf
-@c Cint nc_get_var_ushort (Cint, Cint, Ptr{Uint16}) libnetcdf
-@c Cint nc_put_var_uint (Cint, Cint, Ptr{Uint32}) libnetcdf
-@c Cint nc_get_var_uint (Cint, Cint, Ptr{Uint32}) libnetcdf
+@c Cint nc_put_var_ushort (Cint, Cint, Ptr{UInt16}) libnetcdf
+@c Cint nc_get_var_ushort (Cint, Cint, Ptr{UInt16}) libnetcdf
+@c Cint nc_put_var_uint (Cint, Cint, Ptr{UInt32}) libnetcdf
+@c Cint nc_get_var_uint (Cint, Cint, Ptr{UInt32}) libnetcdf
 @c Cint nc_put_var_longlong (Cint, Cint, Ptr{Clonglong}) libnetcdf
 @c Cint nc_get_var_longlong (Cint, Cint, Ptr{Clonglong}) libnetcdf
 @c Cint nc_put_var_ulonglong (Cint, Cint, Ptr{Culonglong}) libnetcdf
 @c Cint nc_get_var_ulonglong (Cint, Cint, Ptr{Culonglong}) libnetcdf
-@c Cint nc_put_var_string (Cint, Cint, Ptr{Ptr{Uint8}}) libnetcdf
-@c Cint nc_get_var_string (Cint, Cint, Ptr{Ptr{Uint8}}) libnetcdf
-@c Cint nc_put_att_ubyte (Cint, Cint, Ptr{Uint8}, nc_type, Csize_t, Ptr{Cuchar}) libnetcdf
-@c Cint nc_get_att_ubyte (Cint, Cint, Ptr{Uint8}, Ptr{Cuchar}) libnetcdf
+@c Cint nc_put_var_string (Cint, Cint, Ptr{Ptr{UInt8}}) libnetcdf
+@c Cint nc_get_var_string (Cint, Cint, Ptr{Ptr{UInt8}}) libnetcdf
+@c Cint nc_put_att_ubyte (Cint, Cint, Ptr{UInt8}, nc_type, Csize_t, Ptr{Cuchar}) libnetcdf
+@c Cint nc_get_att_ubyte (Cint, Cint, Ptr{UInt8}, Ptr{Cuchar}) libnetcdf
 @c Cint nc_put_var1_ubyte (Cint, Cint, Ptr{Csize_t}, Ptr{Cuchar}) libnetcdf
 @c Cint nc_get_var1_ubyte (Cint, Cint, Ptr{Csize_t}, Ptr{Cuchar}) libnetcdf
 @c Cint nc_put_vara_ubyte (Cint, Cint, Ptr{Csize_t}, Ptr{Csize_t}, Ptr{Cuchar}) libnetcdf
@@ -455,16 +455,16 @@ typealias nclong Cint
 @c Cint nc_put_var_ubyte (Cint, Cint, Ptr{Cuchar}) libnetcdf
 @c Cint nc_get_var_ubyte (Cint, Cint, Ptr{Cuchar}) libnetcdf
 @c Cint nc_show_metadata (Cint,) libnetcdf
-@c Cint nc__create_mp (Ptr{Uint8}, Cint, Csize_t, Cint, Ptr{Csize_t}, Ptr{Cint}) libnetcdf
-@c Cint nc__open_mp (Ptr{Uint8}, Cint, Cint, Ptr{Csize_t}, Ptr{Cint}) libnetcdf
-@c Cint nc_delete (Ptr{Uint8},) libnetcdf
-@c Cint nc_delete_mp (Ptr{Uint8}, Cint) libnetcdf
+@c Cint nc__create_mp (Ptr{UInt8}, Cint, Csize_t, Cint, Ptr{Csize_t}, Ptr{Cint}) libnetcdf
+@c Cint nc__open_mp (Ptr{UInt8}, Cint, Cint, Ptr{Csize_t}, Ptr{Cint}) libnetcdf
+@c Cint nc_delete (Ptr{UInt8},) libnetcdf
+@c Cint nc_delete_mp (Ptr{UInt8}, Cint) libnetcdf
 @c Cint nc_set_base_pe (Cint, Cint) libnetcdf
 @c Cint nc_inq_base_pe (Cint, Ptr{Cint}) libnetcdf
 @c Cint nctypelen (nc_type,) libnetcdf
-@c None nc_advise (Ptr{Uint8}, Cint, Ptr{Uint8}) libnetcdf
-@c Cint nccreate (Ptr{Uint8}, Cint) libnetcdf
-@c Cint ncopen (Ptr{Uint8}, Cint) libnetcdf
+@c None nc_advise (Ptr{UInt8}, Cint, Ptr{UInt8}) libnetcdf
+@c Cint nccreate (Ptr{UInt8}, Cint) libnetcdf
+@c Cint ncopen (Ptr{UInt8}, Cint) libnetcdf
 @c Cint ncsetfill (Cint, Cint) libnetcdf
 @c Cint ncredef (Cint,) libnetcdf
 @c Cint ncendef (Cint,) libnetcdf
@@ -472,20 +472,20 @@ typealias nclong Cint
 @c Cint ncabort (Cint,) libnetcdf
 @c Cint ncclose (Cint,) libnetcdf
 @c Cint ncinquire (Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}) libnetcdf
-@c Cint ncdimdef (Cint, Ptr{Uint8}, Clong) libnetcdf
-@c Cint ncdimid (Cint, Ptr{Uint8}) libnetcdf
-@c Cint ncdiminq (Cint, Cint, Ptr{Uint8}, Ptr{Clong}) libnetcdf
-@c Cint ncdimrename (Cint, Cint, Ptr{Uint8}) libnetcdf
-@c Cint ncattput (Cint, Cint, Ptr{Uint8}, nc_type, Cint, Ptr{Void}) libnetcdf
-@c Cint ncattinq (Cint, Cint, Ptr{Uint8}, Ptr{nc_type}, Ptr{Cint}) libnetcdf
-@c Cint ncattget (Cint, Cint, Ptr{Uint8}, Ptr{Void}) libnetcdf
-@c Cint ncattcopy (Cint, Cint, Ptr{Uint8}, Cint, Cint) libnetcdf
-@c Cint ncattname (Cint, Cint, Cint, Ptr{Uint8}) libnetcdf
-@c Cint ncattrename (Cint, Cint, Ptr{Uint8}, Ptr{Uint8}) libnetcdf
-@c Cint ncattdel (Cint, Cint, Ptr{Uint8}) libnetcdf
-@c Cint ncvardef (Cint, Ptr{Uint8}, nc_type, Cint, Ptr{Cint}) libnetcdf
-@c Cint ncvarid (Cint, Ptr{Uint8}) libnetcdf
-@c Cint ncvarinq (Cint, Cint, Ptr{Uint8}, Ptr{nc_type}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}) libnetcdf
+@c Cint ncdimdef (Cint, Ptr{UInt8}, Clong) libnetcdf
+@c Cint ncdimid (Cint, Ptr{UInt8}) libnetcdf
+@c Cint ncdiminq (Cint, Cint, Ptr{UInt8}, Ptr{Clong}) libnetcdf
+@c Cint ncdimrename (Cint, Cint, Ptr{UInt8}) libnetcdf
+@c Cint ncattput (Cint, Cint, Ptr{UInt8}, nc_type, Cint, Ptr{Void}) libnetcdf
+@c Cint ncattinq (Cint, Cint, Ptr{UInt8}, Ptr{nc_type}, Ptr{Cint}) libnetcdf
+@c Cint ncattget (Cint, Cint, Ptr{UInt8}, Ptr{Void}) libnetcdf
+@c Cint ncattcopy (Cint, Cint, Ptr{UInt8}, Cint, Cint) libnetcdf
+@c Cint ncattname (Cint, Cint, Cint, Ptr{UInt8}) libnetcdf
+@c Cint ncattrename (Cint, Cint, Ptr{UInt8}, Ptr{UInt8}) libnetcdf
+@c Cint ncattdel (Cint, Cint, Ptr{UInt8}) libnetcdf
+@c Cint ncvardef (Cint, Ptr{UInt8}, nc_type, Cint, Ptr{Cint}) libnetcdf
+@c Cint ncvarid (Cint, Ptr{UInt8}) libnetcdf
+@c Cint ncvarinq (Cint, Cint, Ptr{UInt8}, Ptr{nc_type}, Ptr{Cint}, Ptr{Cint}, Ptr{Cint}) libnetcdf
 @c Cint ncvarput1 (Cint, Cint, Ptr{Clong}, Ptr{Void}) libnetcdf
 @c Cint ncvarget1 (Cint, Cint, Ptr{Clong}, Ptr{Void}) libnetcdf
 @c Cint ncvarput (Cint, Cint, Ptr{Clong}, Ptr{Clong}, Ptr{Void}) libnetcdf
@@ -494,8 +494,7 @@ typealias nclong Cint
 @c Cint ncvargets (Cint, Cint, Ptr{Clong}, Ptr{Clong}, Ptr{Clong}, Ptr{Void}) libnetcdf
 @c Cint ncvarputg (Cint, Cint, Ptr{Clong}, Ptr{Clong}, Ptr{Clong}, Ptr{Clong}, Ptr{Void}) libnetcdf
 @c Cint ncvargetg (Cint, Cint, Ptr{Clong}, Ptr{Clong}, Ptr{Clong}, Ptr{Clong}, Ptr{Void}) libnetcdf
-@c Cint ncvarrename (Cint, Cint, Ptr{Uint8}) libnetcdf
+@c Cint ncvarrename (Cint, Cint, Ptr{UInt8}) libnetcdf
 @c Cint ncrecinq (Cint, Ptr{Cint}, Ptr{Cint}, Ptr{Clong}) libnetcdf
 @c Cint ncrecget (Cint, Clong, Ptr{Ptr{Void}}) libnetcdf
 @c Cint ncrecput (Cint, Clong, Ptr{Ptr{Void}}) libnetcdf
-
diff --git a/src/netcdf_helpers.jl b/src/netcdf_helpers.jl
index b3ef2d2..9b3f159 100644
--- a/src/netcdf_helpers.jl
+++ b/src/netcdf_helpers.jl
@@ -35,13 +35,13 @@ const error_description=
 const funext = [  (Float64, "double","float64a"),
             (Float32, "float","float32a"),
             (Int32  , "int","int32a"),
-            (Uint8  , "text","uint8a"),
+            (UInt8  , "text","uint8a"),
             (Int8   , "schar","int8a"),
             (Int16  , "short","int16a"),
             (Int64  , "longlong","int64a")]
 
 const ida          = zeros(Int32,1)
-const namea        = zeros(Uint8,NC_MAX_NAME+1)
+const namea        = zeros(UInt8,NC_MAX_NAME+1)
 const lengtha      = zeros(Csize_t,1)
 const dimida       = zeros(Int32,NC_MAX_VAR_DIMS)
 const ndima        = zeros(Int32,1)
@@ -55,14 +55,14 @@ const dima         = zeros(Int32,1)
 const varida       = zeros(Int32,1)
 const vara         = zeros(Int32,1);
 const dumids       = zeros(Int32,NC_MAX_DIMS)
-const gstart       = zeros(Uint,NC_MAX_DIMS)
-const gcount       = zeros(Uint,NC_MAX_DIMS)
+const gstart       = zeros(UInt,NC_MAX_DIMS)
+const gcount       = zeros(UInt,NC_MAX_DIMS)
 
 for (t,ending,aname) in funext 
     @eval const $(symbol(aname)) = zeros($t,1)
 end
 
-function nc_open(fname::String,omode::Uint16)
+function nc_open(fname::AbstractString,omode::UInt16)
     # Function to open file fname, returns a NetCDF file ID
     nc_open(fname,omode,ida)
     return ida[1]
@@ -80,7 +80,7 @@ function nc_inq_dim(id::Integer,idim::Integer)
     return (name,lengtha[1])
 end
 
-function nc_inq_dimid(id::Integer,name::String)
+function nc_inq_dimid(id::Integer,name::AbstractString)
     # Function to read dimension id for a given function name
     NetCDF.nc_inq_dimid(id,name,dimida)
     return dimida[1]
@@ -124,38 +124,38 @@ function nc_get_att(ncid::Integer,varid::Integer,attnum::Integer)
 end
 
 #Define methods for writing attributes
-nc_put_att(ncid::Integer,varid::Integer,name::String,val::Array{Int8})    = nc_put_att_schar(ncid,varid,name,NC_BYTE,length(val),val)
-nc_put_att(ncid::Integer,varid::Integer,name::String,val::Array{Int16})   = nc_put_att_short(ncid,varid,name,NC_SHORT,length(val),val)
-nc_put_att(ncid::Integer,varid::Integer,name::String,val::Array{Int32})   = nc_put_att_int(ncid,varid,name,NC_INT,length(val),val)
-nc_put_att(ncid::Integer,varid::Integer,name::String,val::Array{Int64})   = nc_put_att_long(ncid,varid,name,NC_LONG,length(val),val)
-nc_put_att(ncid::Integer,varid::Integer,name::String,val::Array{Float32}) = nc_put_att_float(ncid,varid,name,NC_FLOAT,length(val),val)
-nc_put_att(ncid::Integer,varid::Integer,name::String,val::Array{Float64}) = nc_put_att_double(ncid,varid,name,NC_DOUBLE,length(val),val)
-nc_put_att(ncid::Integer,varid::Integer,name::String,val::String)         = nc_put_att_text(ncid,varid,name,length(val)+1,val)
-nc_put_att(ncid::Integer,varid::Integer,name::String,val::Array{Any})     = error("Writing attribute array of type Any is not possible") 
-
-nc_put_att(ncid::Integer,varid::Integer,name::String,val::Int8) = begin int8a[1] = val; nc_put_att(ncid,varid,name,int8a) end
-nc_put_att(ncid::Integer,varid::Integer,name::String,val::Int16) = begin int16a[1] = val; nc_put_att(ncid,varid,name,int16a) end
-nc_put_att(ncid::Integer,varid::Integer,name::String,val::Int32) = begin int32a[1] = val; nc_put_att(ncid,varid,name,int32a) end
-nc_put_att(ncid::Integer,varid::Integer,name::String,val::Int64) = begin int64a[1] = val; nc_put_att(ncid,varid,name,int64a) end
-nc_put_att(ncid::Integer,varid::Integer,name::String,val::Float32) = begin float32a[1] = val; nc_put_att(ncid,varid,name,float32a) end
-nc_put_att(ncid::Integer,varid::Integer,name::String,val::Float64) = begin float64a[1] = val; nc_put_att(ncid,varid,name,float64a) end
-nc_put_att(ncid::Integer,varid::Integer,name::String,val) = error("Writing attribute of type $(typeof(val)) is currently not possible.") 
-
-
-
-function nc_get_att(ncid::Integer,varid::Integer,name::String,attype::Integer,attlen::Integer)
+nc_put_att(ncid::Integer,varid::Integer,name::AbstractString,val::Array{Int8})    = nc_put_att_schar(ncid,varid,name,NC_BYTE,length(val),val)
+nc_put_att(ncid::Integer,varid::Integer,name::AbstractString,val::Array{Int16})   = nc_put_att_short(ncid,varid,name,NC_SHORT,length(val),val)
+nc_put_att(ncid::Integer,varid::Integer,name::AbstractString,val::Array{Int32})   = nc_put_att_int(ncid,varid,name,NC_INT,length(val),val)
+nc_put_att(ncid::Integer,varid::Integer,name::AbstractString,val::Array{Int64})   = nc_put_att_long(ncid,varid,name,NC_LONG,length(val),val)
+nc_put_att(ncid::Integer,varid::Integer,name::AbstractString,val::Array{Float32}) = nc_put_att_float(ncid,varid,name,NC_FLOAT,length(val),val)
+nc_put_att(ncid::Integer,varid::Integer,name::AbstractString,val::Array{Float64}) = nc_put_att_double(ncid,varid,name,NC_DOUBLE,length(val),val)
+nc_put_att(ncid::Integer,varid::Integer,name::AbstractString,val::AbstractString)         = nc_put_att_text(ncid,varid,name,length(val)+1,val)
+nc_put_att(ncid::Integer,varid::Integer,name::AbstractString,val::Array{Any})     = error("Writing attribute array of type Any is not possible") 
+
+nc_put_att(ncid::Integer,varid::Integer,name::AbstractString,val::Int8) = begin int8a[1] = val; nc_put_att(ncid,varid,name,int8a) end
+nc_put_att(ncid::Integer,varid::Integer,name::AbstractString,val::Int16) = begin int16a[1] = val; nc_put_att(ncid,varid,name,int16a) end
+nc_put_att(ncid::Integer,varid::Integer,name::AbstractString,val::Int32) = begin int32a[1] = val; nc_put_att(ncid,varid,name,int32a) end
+nc_put_att(ncid::Integer,varid::Integer,name::AbstractString,val::Int64) = begin int64a[1] = val; nc_put_att(ncid,varid,name,int64a) end
+nc_put_att(ncid::Integer,varid::Integer,name::AbstractString,val::Float32) = begin float32a[1] = val; nc_put_att(ncid,varid,name,float32a) end
+nc_put_att(ncid::Integer,varid::Integer,name::AbstractString,val::Float64) = begin float64a[1] = val; nc_put_att(ncid,varid,name,float64a) end
+nc_put_att(ncid::Integer,varid::Integer,name::AbstractString,val) = error("Writing attribute of type $(typeof(val)) is currently not possible.") 
+
+
+
+function nc_get_att(ncid::Integer,varid::Integer,name::AbstractString,attype::Integer,attlen::Integer)
     valsa=Array(nctype2jltype[attype],attlen)
     nc_get_att!(ncid,varid,name,valsa)
 end
 
-nc_get_att!(ncid::Integer,varid::Integer,name::String,valsa::Array{Uint8}) = begin nc_get_att_text(ncid,varid,name,valsa); ascii(valsa) end
-nc_get_att!(ncid::Integer,varid::Integer,name::String,valsa::Array{Ptr{Uint8}}) = begin nc_get_att_string(ncid,varid,name,valsa); [bytestring(pointer(valsa[i])) for i=1:length(valsa)] end
-nc_get_att!(ncid::Integer,varid::Integer,name::String,valsa::Array{Int8})  = begin nc_get_att_schar(ncid,varid,name,valsa); valsa end
-nc_get_att!(ncid::Integer,varid::Integer,name::String,valsa::Array{Int16})  = begin nc_get_att_short(ncid,varid,name,valsa); valsa end
-nc_get_att!(ncid::Integer,varid::Integer,name::String,valsa::Array{Int32})  = begin nc_get_att_int(ncid,varid,name,valsa); valsa end
-nc_get_att!(ncid::Integer,varid::Integer,name::String,valsa::Array{Int64})  = begin nc_get_att_long(ncid,varid,name,valsa); valsa end
-nc_get_att!(ncid::Integer,varid::Integer,name::String,valsa::Array{Float32})  = begin nc_get_att_float(ncid,varid,name,valsa); valsa end
-nc_get_att!(ncid::Integer,varid::Integer,name::String,valsa::Array{Float64})  = begin nc_get_att_double(ncid,varid,name,valsa); valsa end
+nc_get_att!(ncid::Integer,varid::Integer,name::AbstractString,valsa::Array{UInt8}) = begin nc_get_att_text(ncid,varid,name,valsa); ascii(valsa) end
+nc_get_att!(ncid::Integer,varid::Integer,name::AbstractString,valsa::Array{Ptr{UInt8}}) = begin nc_get_att_string(ncid,varid,name,valsa); [bytestring(pointer(valsa[i])) for i=1:length(valsa)] end
+nc_get_att!(ncid::Integer,varid::Integer,name::AbstractString,valsa::Array{Int8})  = begin nc_get_att_schar(ncid,varid,name,valsa); valsa end
+nc_get_att!(ncid::Integer,varid::Integer,name::AbstractString,valsa::Array{Int16})  = begin nc_get_att_short(ncid,varid,name,valsa); valsa end
+nc_get_att!(ncid::Integer,varid::Integer,name::AbstractString,valsa::Array{Int32})  = begin nc_get_att_int(ncid,varid,name,valsa); valsa end
+nc_get_att!(ncid::Integer,varid::Integer,name::AbstractString,valsa::Array{Int64})  = begin nc_get_att_long(ncid,varid,name,valsa); valsa end
+nc_get_att!(ncid::Integer,varid::Integer,name::AbstractString,valsa::Array{Float32})  = begin nc_get_att_float(ncid,varid,name,valsa); valsa end
+nc_get_att!(ncid::Integer,varid::Integer,name::AbstractString,valsa::Array{Float64})  = begin nc_get_att_double(ncid,varid,name,valsa); valsa end
 
 
 function nc_inq_var(nc::NcFile,varid::Integer)
@@ -192,7 +192,7 @@ function getatts_all(ncid::Integer,varid::Integer,natts::Integer)
   atts=Dict{Any,Any}()
   for attnum=0:natts-1
     attname,attval=nc_get_att(ncid,varid,attnum)
-    if ((length(attval)==1) & !(typeof(attval)<:String))
+    if ((length(attval)==1) & !(typeof(attval)<:AbstractString))
       attval=attval[1]
     end
     atts[attname]=attval
@@ -242,7 +242,7 @@ function parsedimargs(dim)
   #Determine number of dimensions
   ndim=0
   for a in dim
-    if (typeof(a)<:String)
+    if (typeof(a)<:AbstractString)
       ndim=ndim+1
     end
     NC_VERBOSE ? println(a) : nothing
@@ -251,7 +251,7 @@ function parsedimargs(dim)
   idim=1
   for a in dim
     NC_VERBOSE ? println(a,idim) : nothing
-    if (typeof(a)<:String)
+    if (typeof(a)<:AbstractString)
       #Assume a name is given
       #first create an NcDim object from the last dim
       if (name!=nothing)