carray-netcdf 1.0.4 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19f1abb99ae79c059426a1323e0fb028dd669f556b993cd6b5823263fa19e281
-  data.tar.gz: cc84704439ad231e340dc5a2bb4e3fae86496037008102458bf3634ec8dcd10b
+  metadata.gz: 6d15da63f025da8ee09c9ad58b7d62ad8c7864fbeb88dde9baa35610154d419a
+  data.tar.gz: f049d0e22dd10c6d68b5b1292be3c22ecff4427397acd405945daa720ee425f6
 SHA512:
-  metadata.gz: fd1842a3d39729174629d8912ead0714b64c917dc99c888d750419edf5cf6c1e15e33d6f1b6ec8ce0557565bffa8588186ca9b2b07b6b27ceef54d8d2be14495
-  data.tar.gz: fea6389e64aa7728dfa71bc88ad8267af0749d2e419085f50c22cdc47b64bdf806c6b6e0109d71f3907e4f582dd73a8ab26093e6d69e5c92a5eeeaa234802224
+  metadata.gz: 6db9c2ae9e3e1236c0f5a1fa54397df2d843017467d9c1507e09487889b3290bf422273852529211f48e1cc8cc6177c3666afc7f561914c1fdc4c235c9068071
+  data.tar.gz: 73756a1b34dc1445825c6bc9b69f0a64e979c55c754d6cbf6791374f2fd8dd23503be29143c140292626d2c0a4151b7396e43320f815536ca25c0eb87198686a

data/bin/ncdef2yaml

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+require "carray-netcdf"
+require "yaml"
+
+NC_DATA_TYPES = ["char","byte","short","int","float","double"]
+
+module Psych
+  module Visitors
+    class YAMLTree < Psych::Visitors::Visitor
+      alias_method :emit_coder_orig, :emit_coder
+      def emit_coder c, o
+        case c.type
+        when :seq
+          @emitter.start_sequence nil, c.tag, c.tag.nil?, c.style
+          c.seq.each do |thing|
+            accept thing
+          end
+          @emitter.end_sequence
+        else
+          emit_coder_orig c, o
+        end
+      end
+    end
+  end
+end
+
+class Hash
+  def encode_with(coder)
+    if NC_DATA_TYPES.include?(self.first[0]) 
+      coder.style = Psych::Nodes::Mapping::FLOW
+    end
+    coder.tag = nil
+    coder.map = self
+  end
+end
+
+class Array
+
+  def encode_with (coder)
+    if self.all?{|v| Numeric===v or String===v}
+      coder.style = Psych::Nodes::Mapping::FLOW
+    end
+    coder.tag = nil
+    coder.seq = self
+  end
+  
+end
+
+class String
+  
+  def to_yaml
+    return self
+  end
+
+end
+
+nc = NCFile.open(ARGV[0])
+
+puts nc.definition.to_yaml

data/carray-netcdf.gemspec

@@ -1,6 +1,6 @@
 
 Gem::Specification::new do |s|
-  version = "1.0.4"
+  version = "1.0.7"
 
   files = Dir.glob("**/*") - [ 
                                Dir.glob("carray-*.gem"), 
@@ -18,5 +18,6 @@ Gem::Specification::new do |s|
   s.homepage    = 'https://github.com/himotoyoshi/carray-netcdf'
   s.files       = files
   s.extensions  = [ "extconf.rb" ]
+  s.executables << 'ncdef2yaml'
   s.required_ruby_version = ">= 1.8.1"
 end

data/lib/io/netcdf.rb

@@ -346,7 +346,7 @@ class NCDim < NCObject
   end
   
   def to_i
-    return @len
+    return @dim_id
   end
 
   def to_ca
@@ -419,7 +419,7 @@ class NCFile < NCObject
         case value.data_type
         when CA_UINT8
           value = { "char" => value[0] }
-        when CA_BYTE
+        when CA_INT8
           value = { "byte" => value[0] }
         when CA_SHORT
           value = { "short" => value[0] }
@@ -434,7 +434,7 @@ class NCFile < NCObject
         case value.data_type
         when CA_UINT8
           value = { "char" => value.to_a }
-        when CA_BYTE
+        when CA_INT8
           value = { "byte" => value.to_a }
         when CA_SHORT
           value = { "short" => value.to_a }
@@ -511,8 +511,8 @@ class NCFileWriter
       end
       @dims    = definition["dim"]
       if @dims
-        @shape   = @dims.map{|key| @ncfile.dim(key).to_i }
-        dim_ids  = @dims.map{|key| @ncfile.dim(key).dim_id }
+        @shape   = @dims.map{|key| @ncfile.dim(key).len }
+        dim_ids  = @dims.map{|key| @ncfile.dim(key).to_i }
       else
         dim_ids  = []
       end
@@ -542,6 +542,10 @@ class NCFileWriter
     
     attr_reader :name, :type, :attributes
     
+    def to_i
+      return @var_id
+    end
+    
     def []= (*argv)
       put(*argv)      
     end
@@ -610,7 +614,6 @@ class NCFileWriter
       return nc_put_varm(@file_id, @var_id, start, count, stride, imap, value)
     end
 
-  
   end
   
   class Dim
@@ -629,10 +632,10 @@ class NCFileWriter
       end
     end
     
-    attr_reader :name, :dim_id
+    attr_reader :name, :len
     
     def to_i
-      return @len
+      return @dim_id
     end
     
   end
@@ -736,7 +739,7 @@ class NCFileWriter
       when "char"
         value = CA_UINT8(value)
       when "byte"
-        value = CA_BYTE(value)
+        value = CA_INT8(value)
       when "short"
         value = CA_SHORT(value)
       when "int"

data/rb_netcdflib.c

@@ -49,13 +49,23 @@ rb_nc_typemap (nc_type nc_type)
 {
   switch ( nc_type ) {
   case NC_CHAR:
-    return CA_INT8;
+    return CA_UINT8;
   case NC_BYTE: 
+    return CA_INT8;
+  case NC_UBYTE: 
     return CA_UINT8;
   case NC_SHORT:
     return CA_INT16;
+  case NC_USHORT:
+    return CA_UINT16;
   case NC_INT:
     return CA_INT32;
+  case NC_UINT:
+    return CA_UINT32;
+  case NC_INT64:
+    return CA_INT64;
+  case NC_UINT64:
+    return CA_UINT64;
   case NC_FLOAT:
     return CA_FLOAT32;
   case NC_DOUBLE:
@@ -72,15 +82,25 @@ rb_nc_rtypemap (int ca_type)
   case CA_INT8:
     return NC_BYTE;
   case CA_UINT8:
-    return NC_BYTE;
+    return NC_UBYTE;
   case CA_INT16:
     return NC_SHORT;
+  case CA_UINT16:
+    return NC_USHORT;
   case CA_INT32:
     return NC_INT;
+  case CA_UINT32:
+    return NC_UINT;
+  case CA_INT64:
+    return NC_INT64;
+  case CA_UINT64:
+    return NC_UINT64;
   case CA_FLOAT32:
     return NC_FLOAT;
   case CA_FLOAT64:
     return NC_DOUBLE;
+  case CA_FIXLEN:
+    return NC_STRING;
   default:
     rb_raise(rb_eRuntimeError, "invalid CA_TYPE");
   }
@@ -94,7 +114,7 @@ rb_nc_ca_type (int argc, VALUE *argv, VALUE mod)
   CHECK_ARGC(1);
   CHECK_TYPE_INT(argv[0]);
   
-  type = rb_nc_typemap(NUM2LONG(argv[0]));
+  type = rb_nc_typemap(NUM2INT(argv[0]));
 
   return LONG2NUM(type);
 }
@@ -107,7 +127,7 @@ rb_nc_nc_type (int argc, VALUE *argv, VALUE mod)
   CHECK_ARGC(1);
   CHECK_TYPE_INT(argv[0]);
   
-  type = rb_nc_rtypemap(NUM2LONG(argv[0]));
+  type = rb_nc_rtypemap(NUM2INT(argv[0]));
 
   return LONG2NUM(type);
 }
@@ -126,15 +146,57 @@ rb_nc_create (int argc, VALUE *argv, VALUE mod)
   if ( argc == 1 ) {
     status = nc_create(StringValuePtr(argv[0]), NC_CLOBBER, &nc_id);
   }
+  else if ( argc == 2 ) {
+    CHECK_TYPE_INT(argv[1]);
+    status = nc_create(StringValuePtr(argv[0]), NUM2INT(argv[1]), &nc_id);
+  }
   else {
+    rb_raise(rb_eArgError, "too many argument");
+  }
+
+  CHECK_STATUS(status);
+
+  return LONG2NUM(nc_id);
+}
+
+/*
+static VALUE
+rb_nc_create_mem (int argc, VALUE *argv, VALUE mod)
+{
+  int status, nc_id;
+  if ( argc < 1 ) {
+    rb_raise(rb_eArgError, "invalid # of arguments");
+  }
+
+  CHECK_TYPE_STRING(argv[0]);
+
+  if ( argc == 1 ) {
+    status = nc_create_mem(StringValuePtr(argv[0]), NC_CLOBBER, NC_SIZEHINT_DEFAULT, &nc_id);
+  }
+  else if ( argc == 2 ) {
+    CHECK_TYPE_INT(argv[1]);
+    status = nc_create_mem(StringValuePtr(argv[0]), 
+                           NUM2INT(argv[1]), 
+                           NC_SIZEHINT_DEFAULT,                            
+                           &nc_id);
+  }
+  else if ( argc == 3 ) {
     CHECK_TYPE_INT(argv[1]);
-    status = nc_create(StringValuePtr(argv[0]), NUM2LONG(argv[1]), &nc_id);
+    CHECK_TYPE_INT(argv[2]);
+    status = nc_create_mem(StringValuePtr(argv[0]), 
+                           NUM2INT(argv[1]), 
+                           NUM2INT(argv[2]),                            
+                           &nc_id);
+  }
+  else {
+    rb_raise(rb_eArgError, "too many argument");
   }
 
   CHECK_STATUS(status);
 
   return LONG2NUM(nc_id);
 }
+*/
 
 static VALUE
 rb_nc_open (int argc, VALUE *argv, VALUE mod)
@@ -150,9 +212,12 @@ rb_nc_open (int argc, VALUE *argv, VALUE mod)
   if ( argc == 1 ) {
     status = nc_open(StringValuePtr(argv[0]), NC_NOWRITE, &nc_id);
   }
-  else {
+  else if ( argc == 2 ) {
     CHECK_TYPE_INT(argv[1]);
-    status = nc_open(StringValuePtr(argv[0]), NUM2LONG(argv[1]), &nc_id);
+    status = nc_open(StringValuePtr(argv[0]), NUM2INT(argv[1]), &nc_id);
+  }
+  else {
+    rb_raise(rb_eArgError, "too many argument");
   }
 
   CHECK_STATUS(status);
@@ -168,7 +233,7 @@ rb_nc_close (int argc, VALUE *argv, VALUE mod)
   CHECK_ARGC(1);
   CHECK_TYPE_ID(argv[0]);
   
-  status = nc_close(NUM2LONG(argv[0]));
+  status = nc_close(NUM2INT(argv[0]));
 
   CHECK_STATUS(status);
 
@@ -183,7 +248,7 @@ rb_nc_redef (int argc, VALUE *argv, VALUE mod)
   CHECK_ARGC(1);
   CHECK_TYPE_ID(argv[0]);
   
-  status = nc_redef(NUM2LONG(argv[0]));
+  status = nc_redef(NUM2INT(argv[0]));
 
   CHECK_STATUS(status);
 
@@ -198,7 +263,7 @@ rb_nc_enddef (int argc, VALUE *argv, VALUE mod)
   CHECK_ARGC(1);
   CHECK_TYPE_ID(argv[0]);
   
-  status = nc_enddef(NUM2LONG(argv[0]));
+  status = nc_enddef(NUM2INT(argv[0]));
 
   CHECK_STATUS(status);
 
@@ -213,7 +278,7 @@ rb_nc_sync (int argc, VALUE *argv, VALUE mod)
   CHECK_ARGC(1);
   CHECK_TYPE_ID(argv[0]);
   
-  status = nc_sync(NUM2LONG(argv[0]));
+  status = nc_sync(NUM2INT(argv[0]));
 
   CHECK_STATUS(status);
 
@@ -228,7 +293,7 @@ rb_nc_inq_ndims (int argc, VALUE *argv, VALUE mod)
   CHECK_ARGC(1);
   CHECK_TYPE_ID(argv[0]);
   
-  status = nc_inq_ndims(NUM2LONG(argv[0]), &ndims);
+  status = nc_inq_ndims(NUM2INT(argv[0]), &ndims);
 
   CHECK_STATUS(status);
 
@@ -243,7 +308,7 @@ rb_nc_inq_nvars (int argc, VALUE *argv, VALUE mod)
   CHECK_ARGC(1);
   CHECK_TYPE_ID(argv[0]);
   
-  status = nc_inq_nvars(NUM2LONG(argv[0]), &nvars);
+  status = nc_inq_nvars(NUM2INT(argv[0]), &nvars);
 
   CHECK_STATUS(status);
 
@@ -258,7 +323,7 @@ rb_nc_inq_natts (int argc, VALUE *argv, VALUE mod)
   CHECK_ARGC(1);
   CHECK_TYPE_ID(argv[0]);
   
-  status = nc_inq_natts(NUM2LONG(argv[0]), &natts);
+  status = nc_inq_natts(NUM2INT(argv[0]), &natts);
 
   CHECK_STATUS(status);
 
@@ -273,7 +338,7 @@ rb_nc_inq_unlimdim (int argc, VALUE *argv, VALUE mod)
   CHECK_ARGC(1);
   CHECK_TYPE_ID(argv[0]);
   
-  status = nc_inq_unlimdim(NUM2LONG(argv[0]), &uldim);
+  status = nc_inq_unlimdim(NUM2INT(argv[0]), &uldim);
 
   CHECK_STATUS(status);
 
@@ -289,7 +354,7 @@ rb_nc_inq_dimid (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[0]);
   CHECK_TYPE_STRING(argv[1]);
   
-  status = nc_inq_dimid(NUM2LONG(argv[0]), StringValuePtr(argv[1]), &dimid);
+  status = nc_inq_dimid(NUM2INT(argv[0]), StringValuePtr(argv[1]), &dimid);
 
   return ( status != NC_NOERR ) ? Qnil : LONG2NUM(dimid);
 }
@@ -303,7 +368,7 @@ rb_nc_inq_varid (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[0]);
   CHECK_TYPE_STRING(argv[1]);
   
-  status = nc_inq_varid(NUM2LONG(argv[0]), StringValuePtr(argv[1]), &varid);
+  status = nc_inq_varid(NUM2INT(argv[0]), StringValuePtr(argv[1]), &varid);
 
   return ( status != NC_NOERR ) ? Qnil : LONG2NUM(varid);
 }
@@ -318,7 +383,7 @@ rb_nc_inq_attid (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[1]);
   CHECK_TYPE_STRING(argv[2]);
   
-  status = nc_inq_attid(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+  status = nc_inq_attid(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 		                    StringValuePtr(argv[2]), &attid);
 
   return ( status != NC_NOERR ) ? Qnil : LONG2NUM(attid);
@@ -334,7 +399,7 @@ rb_nc_inq_dimlen (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[0]);
   CHECK_TYPE_ID(argv[1]);
   
-  status = nc_inq_dimlen(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &dimlen);
+  status = nc_inq_dimlen(NUM2INT(argv[0]), NUM2INT(argv[1]), &dimlen);
 
   CHECK_STATUS(status);
 
@@ -351,7 +416,7 @@ rb_nc_inq_dimname (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[0]);
   CHECK_TYPE_ID(argv[1]);
   
-  status = nc_inq_dimname(NUM2LONG(argv[0]), NUM2LONG(argv[1]), dimname);
+  status = nc_inq_dimname(NUM2INT(argv[0]), NUM2INT(argv[1]), dimname);
 
   CHECK_STATUS(status);
 
@@ -368,7 +433,7 @@ rb_nc_inq_varname (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[0]);
   CHECK_TYPE_ID(argv[1]);
   
-  status = nc_inq_varname(NUM2LONG(argv[0]), NUM2LONG(argv[1]), varname);
+  status = nc_inq_varname(NUM2INT(argv[0]), NUM2INT(argv[1]), varname);
 
   CHECK_STATUS(status);
 
@@ -385,7 +450,7 @@ rb_nc_inq_vartype (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[0]);
   CHECK_TYPE_ID(argv[1]);
   
-  status = nc_inq_vartype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &type);
+  status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
 
   CHECK_STATUS(status);
 
@@ -401,7 +466,7 @@ rb_nc_inq_varndims (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[0]);
   CHECK_TYPE_ID(argv[1]);
   
-  status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
+  status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
 
   CHECK_STATUS(status);
 
@@ -421,11 +486,11 @@ rb_nc_inq_vardimid (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[0]); /* nc_id */
   CHECK_TYPE_ID(argv[1]); /* var_id */
 
-  status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
+  status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
 
   CHECK_STATUS(status);
 
-  status = nc_inq_vardimid(NUM2LONG(argv[0]), NUM2LONG(argv[1]), dimid);
+  status = nc_inq_vardimid(NUM2INT(argv[0]), NUM2INT(argv[1]), dimid);
 
   CHECK_STATUS(status);
 
@@ -446,7 +511,7 @@ rb_nc_inq_varnatts (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[0]);
   CHECK_TYPE_ID(argv[1]);
   
-  status = nc_inq_varnatts(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &natts);
+  status = nc_inq_varnatts(NUM2INT(argv[0]), NUM2INT(argv[1]), &natts);
 
   CHECK_STATUS(status);
 
@@ -465,8 +530,8 @@ rb_nc_inq_attname (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[1]);
   CHECK_TYPE_ID(argv[2]);
   
-  status = nc_inq_attname(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
-			  NUM2LONG(argv[2]), attname);
+  status = nc_inq_attname(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+			  NUM2INT(argv[2]), attname);
 
   CHECK_STATUS(status);
 
@@ -484,7 +549,7 @@ rb_nc_inq_atttype (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[1]);
   CHECK_TYPE_STRING(argv[2]);
   
-  status = nc_inq_atttype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+  status = nc_inq_atttype(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			  StringValuePtr(argv[2]), &type);
 
   CHECK_STATUS(status);
@@ -503,7 +568,7 @@ rb_nc_inq_attlen (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[1]);
   CHECK_TYPE_STRING(argv[2]);
   
-  status = nc_inq_attlen(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+  status = nc_inq_attlen(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			 StringValuePtr(argv[2]), &len);
 
   CHECK_STATUS(status);
@@ -521,14 +586,268 @@ rb_nc_def_dim (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_STRING(argv[1]);
   CHECK_TYPE_INT(argv[2]);
   
-  status = nc_def_dim(NUM2LONG(argv[0]), StringValuePtr(argv[1]), 
-		      NUM2LONG(argv[2]), &dimid);
+  status = nc_def_dim(NUM2INT(argv[0]), StringValuePtr(argv[1]), 
+		      NUM2INT(argv[2]), &dimid);
 
   CHECK_STATUS(status);
 
   return LONG2NUM(dimid);
 }
 
+static VALUE
+rb_nc_def_grp (int argc, VALUE *argv, VALUE mod)
+{
+  int status, grpid;
+
+  CHECK_ARGC(2);
+  CHECK_TYPE_ID(argv[0]);
+  CHECK_TYPE_STRING(argv[1]);
+
+  status = nc_def_grp(NUM2INT(argv[0]), StringValuePtr(argv[1]), 
+           		        &grpid);
+
+  CHECK_STATUS(status);
+
+  return LONG2NUM(grpid);
+}
+
+static VALUE
+rb_nc_inq_ncid (int argc, VALUE *argv, VALUE mod)
+{
+  int status, ncid;
+
+  CHECK_ARGC(2);
+  CHECK_TYPE_ID(argv[0]);
+  CHECK_TYPE_STRING(argv[1]);
+
+  status = nc_inq_ncid(NUM2INT(argv[0]), StringValuePtr(argv[1]), 
+           		         &ncid);
+
+  CHECK_STATUS(status);
+
+  return LONG2NUM(ncid);
+}
+
+
+static VALUE
+rb_nc_inq_grp_full_ncid (int argc, VALUE *argv, VALUE mod)
+{
+  int status, ncid;
+
+  CHECK_ARGC(2);
+  CHECK_TYPE_ID(argv[0]);
+  CHECK_TYPE_STRING(argv[1]);
+
+  status = nc_inq_grp_full_ncid(NUM2INT(argv[0]), StringValuePtr(argv[1]), 
+           		         &ncid);
+
+  CHECK_STATUS(status);
+
+  return LONG2NUM(ncid);
+}
+
+
+static VALUE
+rb_nc_inq_grp_ncid (int argc, VALUE *argv, VALUE mod)
+{
+  int status, ncid;
+
+  CHECK_ARGC(2);
+  CHECK_TYPE_ID(argv[0]);
+  CHECK_TYPE_STRING(argv[1]);
+
+  status = nc_inq_grp_ncid(NUM2INT(argv[0]), StringValuePtr(argv[1]), 
+           		         &ncid);
+
+  CHECK_STATUS(status);
+
+  return LONG2NUM(ncid);
+}
+
+static VALUE
+rb_nc_inq_grp_parent (int argc, VALUE *argv, VALUE mod)
+{
+  int parent;
+  int status;
+
+  CHECK_ARGC(1);
+  CHECK_TYPE_ID(argv[0]);
+  
+  status = nc_inq_grp_parent(NUM2INT(argv[0]), &parent);
+
+  CHECK_STATUS(status);
+
+  return ULONG2NUM(parent);
+}
+
+static VALUE
+rb_nc_inq_grpname (int argc, VALUE *argv, VALUE mod)
+{
+  int status;
+  char grpname[NC_MAX_NAME];
+
+  CHECK_ARGC(1);
+  CHECK_TYPE_ID(argv[0]);
+  
+  status = nc_inq_grpname(NUM2INT(argv[0]), grpname);
+
+  CHECK_STATUS(status);
+
+  return rb_str_new2(grpname);
+}
+
+static VALUE
+rb_nc_inq_grpname_full (int argc, VALUE *argv, VALUE mod)
+{
+  int status;
+  size_t len;
+  char grpname[NC_MAX_NAME];
+
+  CHECK_ARGC(1);
+  CHECK_TYPE_ID(argv[0]);
+  
+  status = nc_inq_grpname_full(NUM2INT(argv[0]), &len, grpname);
+
+  CHECK_STATUS(status);
+  
+  return rb_str_new2(grpname);
+}
+
+static VALUE
+rb_nc_inq_grpname_len (int argc, VALUE *argv, VALUE mod)
+{
+  int status;
+  size_t len;
+
+  CHECK_ARGC(2);
+  CHECK_TYPE_ID(argv[0]);
+  CHECK_TYPE_STRING(argv[1]);
+
+  status = nc_inq_grpname_len(NUM2INT(argv[0]), &len);
+
+  CHECK_STATUS(status);
+
+  return LONG2NUM(len);
+}
+
+static VALUE
+rb_nc_inq_grps (int argc, VALUE *argv, VALUE mod)
+{
+  volatile VALUE rgrps;
+  int grps[NC_MAX_DIMS];
+  int i, ngrps;
+  int status;
+
+  CHECK_ARGC(1);
+  CHECK_TYPE_ID(argv[0]); /* nc_id */
+
+  status = nc_inq_grps(NUM2INT(argv[0]), 
+                       &ngrps,
+                       grps);
+
+  CHECK_STATUS(status);
+
+  rgrps = rb_ary_new();
+  for (i=0; i<ngrps; i++) {
+    rb_ary_store(rgrps, i, ULONG2NUM(grps[i]));
+  }
+
+  return rgrps;
+}
+
+
+static VALUE
+rb_nc_inq_dimids (int argc, VALUE *argv, VALUE mod)
+{
+  volatile VALUE rdimids;
+  int dimids[NC_MAX_DIMS];
+  int i, ndims;
+  int status;
+
+  CHECK_ARGC(2);
+  CHECK_TYPE_ID(argv[0]); /* nc_id */
+  CHECK_TYPE_ID(argv[1]); /* nc_id */
+
+  status = nc_inq_dimids(NUM2INT(argv[0]), 
+                         &ndims,
+                         dimids, 
+                         NUM2INT(argv[1]));
+
+  CHECK_STATUS(status);
+
+  rdimids = rb_ary_new();
+  for (i=0; i<ndims; i++) {
+    rb_ary_store(rdimids, i, ULONG2NUM(dimids[i]));
+  }
+
+  return rdimids;
+}
+
+static VALUE
+rb_nc_inq_varids (int argc, VALUE *argv, VALUE mod)
+{
+  volatile VALUE rvarids;
+  int varids[NC_MAX_DIMS];
+  int i, nvars;
+  int status;
+
+  CHECK_ARGC(1);
+  CHECK_TYPE_ID(argv[0]); /* nc_id */
+
+  status = nc_inq_varids(NUM2INT(argv[0]), 
+                         &nvars,
+                         varids);
+
+  CHECK_STATUS(status);
+
+  rvarids = rb_ary_new();
+  for (i=0; i<nvars; i++) {
+    rb_ary_store(rvarids, i, ULONG2NUM(varids[i]));
+  }
+
+  return rvarids;
+}
+
+static VALUE
+rb_nc_inq_typeids (int argc, VALUE *argv, VALUE mod)
+{
+  volatile VALUE rtypeids;
+  int typeids[NC_MAX_DIMS];
+  int i, ntypes;
+  int status;
+
+  CHECK_ARGC(1);
+  CHECK_TYPE_ID(argv[0]); /* nc_id */
+
+  status = nc_inq_typeids(NUM2INT(argv[0]), 
+                         &ntypes,
+                         typeids);
+
+  CHECK_STATUS(status);
+
+  rtypeids = rb_ary_new();
+  for (i=0; i<ntypes; i++) {
+    rb_ary_store(rtypeids, i, ULONG2NUM(typeids[i]));
+  }
+
+  return rtypeids;
+}
+
+static VALUE
+rb_nc_show_metadata (int argc, VALUE *argv, VALUE mod)
+{
+  int status;
+
+  CHECK_ARGC(1);
+  CHECK_TYPE_ID(argv[0]); /* nc_id */
+
+  status = nc_show_metadata(NUM2INT(argv[0]));
+
+  CHECK_STATUS(status);
+
+  return Qnil;
+}
+
 static VALUE
 rb_nc_def_var (int argc, VALUE *argv, VALUE mod)
 {
@@ -546,19 +865,88 @@ rb_nc_def_var (int argc, VALUE *argv, VALUE mod)
 
   vdim = argv[3];
 
-  ndims = RARRAY_LEN(vdim);
+  ndims = (int) RARRAY_LEN(vdim);
   for (i=0; i<ndims; i++) {
-    dimids[i] = NUM2LONG(RARRAY_PTR(vdim)[i]);
+    dimids[i] = NUM2INT(RARRAY_PTR(vdim)[i]);
   }
 
-  status = nc_def_var(NUM2LONG(argv[0]), StringValuePtr(argv[1]), 
-		      NUM2LONG(argv[2]), ndims, dimids, &varid);
+  status = nc_def_var(NUM2INT(argv[0]), StringValuePtr(argv[1]), 
+		      NUM2INT(argv[2]), ndims, dimids, &varid);
 
   CHECK_STATUS(status);
 
   return LONG2NUM(varid);
 }
 
+static VALUE
+rb_nc_def_var_chunking (int argc, VALUE *argv, VALUE mod)
+{
+  volatile VALUE vdim;
+  int status;
+  int ndims;
+  size_t chunksizes[NC_MAX_DIMS];
+  int i;
+
+  CHECK_ARGC(4);
+  CHECK_TYPE_ID(argv[0]);
+  CHECK_TYPE_ID(argv[1]);
+  CHECK_TYPE_INT(argv[2]);
+  CHECK_TYPE_ARRAY(argv[3]);
+
+  vdim = argv[3];
+
+  ndims = (int) RARRAY_LEN(vdim);
+  for (i=0; i<ndims; i++) {
+    chunksizes[i] = NUM2INT(RARRAY_PTR(vdim)[i]);
+  }
+
+  status = nc_def_var_chunking(NUM2INT(argv[0]), 
+                               NUM2INT(argv[1]), 
+                               NUM2INT(argv[2]), 
+                               chunksizes);
+
+  CHECK_STATUS(status);
+
+  return Qnil;
+}
+
+static VALUE
+rb_nc_inq_var_chunking (int argc, VALUE *argv, VALUE mod)
+{
+  volatile VALUE retval;
+  volatile VALUE rchunksize;
+  int storage;
+  size_t chunksizes[NC_MAX_DIMS];
+  int i, ndims;
+  int status;
+
+  CHECK_ARGC(2);
+  CHECK_TYPE_ID(argv[0]); /* nc_id */
+  CHECK_TYPE_ID(argv[1]); /* var_id */
+
+  status = nc_inq_var_chunking(NUM2INT(argv[0]), 
+                               NUM2INT(argv[1]),
+                               &storage, 
+                               chunksizes);
+
+  CHECK_STATUS(status);
+
+  status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
+
+  CHECK_STATUS(status);
+
+  rchunksize = rb_ary_new();
+  for (i=0; i<ndims; i++) {
+    rb_ary_store(rchunksize, i, ULONG2NUM(chunksizes[i]));
+  }
+
+  retval = rb_ary_new();
+  rb_ary_store(retval, 0, ULONG2NUM(storage));
+  rb_ary_store(retval, 1, rchunksize);
+
+  return retval;
+}
+
 static VALUE
 rb_nc_def_var_deflate (int argc, VALUE *argv, VALUE mod)
 {
@@ -571,8 +959,8 @@ rb_nc_def_var_deflate (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_INT(argv[3]);
   CHECK_TYPE_INT(argv[4]);
   
-  status = nc_def_var_deflate(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
-                              NUM2LONG(argv[2]), NUM2LONG(argv[3]), NUM2LONG(argv[4]));
+  status = nc_def_var_deflate(NUM2INT(argv[0]), NUM2INT(argv[1]),
+                              NUM2INT(argv[2]), NUM2INT(argv[3]), NUM2INT(argv[4]));
 
 
   CHECK_STATUS(status);
@@ -591,7 +979,7 @@ rb_nc_inq_var_deflate (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[0]); /* nc_id */
   CHECK_TYPE_ID(argv[1]); /* var_id */
 
-  status = nc_inq_var_deflate(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
+  status = nc_inq_var_deflate(NUM2INT(argv[0]), NUM2INT(argv[1]),
                               &shuffle, &deflate, &deflate_level);
 
   CHECK_STATUS(status);
@@ -615,7 +1003,7 @@ rb_nc_del_att (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[1]);
   CHECK_TYPE_STRING(argv[2]);
 
-  status = nc_del_att(NUM2LONG(argv[0]), NUM2LONG(argv[1]), StringValuePtr(argv[2]));
+  status = nc_del_att(NUM2INT(argv[0]), NUM2INT(argv[1]), StringValuePtr(argv[2]));
 
   CHECK_STATUS(status);
 
@@ -628,13 +1016,23 @@ nc_get_att_numeric (int ncid, int varid, const char name[],
 {
   switch (type) {
   case NC_BYTE:
-    return nc_get_att_uchar(ncid, varid, name, value);
-  case NC_CHAR:
     return nc_get_att_schar(ncid, varid, name, value);
+  case NC_UBYTE:
+    return nc_get_att_ubyte(ncid, varid, name, value);
+  case NC_CHAR:
+    return nc_get_att_uchar(ncid, varid, name, value);
   case NC_SHORT:
     return nc_get_att_short(ncid, varid, name, value);
+  case NC_USHORT:
+    return nc_get_att_ushort(ncid, varid, name, value);
   case NC_INT:
     return nc_get_att_int(ncid, varid, name, value);
+  case NC_UINT:
+    return nc_get_att_uint(ncid, varid, name, value);
+  case NC_INT64:
+    return nc_get_att_longlong(ncid, varid, name, value);
+  case NC_UINT64:
+    return nc_get_att_ulonglong(ncid, varid, name, value);
   case NC_FLOAT:
     return nc_get_att_float(ncid, varid, name, value);
   case NC_DOUBLE:
@@ -650,13 +1048,23 @@ nc_put_att_numeric (int ncid, int varid, const char name[],
 {
   switch (type) {
   case NC_BYTE:
-    return nc_put_att_uchar(ncid, varid, name, xtype, len, value);
-  case NC_CHAR:
     return nc_put_att_schar(ncid, varid, name, xtype, len, value);
+  case NC_UBYTE:
+    return nc_put_att_ubyte(ncid, varid, name, xtype, len, value);
+  case NC_CHAR:
+    return nc_put_att_uchar(ncid, varid, name, xtype, len, value);
   case NC_SHORT:
     return nc_put_att_short(ncid, varid, name, xtype, len, value);
+  case NC_USHORT:
+    return nc_put_att_ushort(ncid, varid, name, xtype, len, value);
   case NC_INT:
     return nc_put_att_int(ncid, varid, name, xtype, len, value);
+  case NC_UINT:
+    return nc_put_att_uint(ncid, varid, name, xtype, len, value);
+  case NC_INT64:
+    return nc_put_att_longlong(ncid, varid, name, xtype, len, value);
+  case NC_UINT64:
+    return nc_put_att_longlong(ncid, varid, name, xtype, len, value);
   case NC_FLOAT:
     return nc_put_att_float(ncid, varid, name, xtype, len, value);
   case NC_DOUBLE:
@@ -677,14 +1085,14 @@ rb_nc_get_att (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[1]);
   CHECK_TYPE_STRING(argv[2]);
 
-  status = nc_inq_atttype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+  status = nc_inq_atttype(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			  StringValuePtr(argv[2]), &type);
 
   if ( status != NC_NOERR) {
     return Qnil;
   }
 
-  status = nc_inq_attlen(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+  status = nc_inq_attlen(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			 StringValuePtr(argv[2]), &len);
   CHECK_STATUS(status);
 
@@ -692,7 +1100,7 @@ rb_nc_get_att (int argc, VALUE *argv, VALUE mod)
 
     if ( type == NC_CHAR ) {
       volatile VALUE text = rb_str_new(NULL, len);
-      status = nc_get_att_text(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+      status = nc_get_att_text(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			       StringValuePtr(argv[2]), 
 			       StringValuePtr(text));
       return text;
@@ -700,42 +1108,77 @@ rb_nc_get_att (int argc, VALUE *argv, VALUE mod)
     else if ( len == 1 ) {
       switch ( type ) {
       case NC_BYTE: {
-	uint8_t val;
-	status = nc_get_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
-				  StringValuePtr(argv[2]), type, &val);
-	CHECK_STATUS(status);
-	return INT2NUM(val);
+      	int8_t val;
+      	status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+      				  StringValuePtr(argv[2]), type, &val);
+      	CHECK_STATUS(status);
+      	return INT2NUM(val);
+      }
+      case NC_UBYTE: {
+      	uint8_t val;
+      	status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+      				  StringValuePtr(argv[2]), type, &val);
+      	CHECK_STATUS(status);
+      	return INT2NUM(val);
       }
       case NC_SHORT: {
-	int16_t val;
-	status = nc_get_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
-				    StringValuePtr(argv[2]), type, &val);
-	CHECK_STATUS(status);
-	return INT2NUM(val);
+      	int16_t val;
+      	status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+      				    StringValuePtr(argv[2]), type, &val);
+      	CHECK_STATUS(status);
+      	return INT2NUM(val);
+      }
+      case NC_USHORT: {
+      	uint16_t val;
+      	status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+      				    StringValuePtr(argv[2]), type, &val);
+      	CHECK_STATUS(status);
+      	return INT2NUM(val);
       }
       case NC_INT: {
-	int32_t val;
-	status = nc_get_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
-				    StringValuePtr(argv[2]), type, &val);
-	CHECK_STATUS(status);
-	return INT2NUM(val);
+      	int32_t val;
+      	status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+      				    StringValuePtr(argv[2]), type, &val);
+      	CHECK_STATUS(status);
+      	return INT2NUM(val);
+      }
+      case NC_UINT: {
+      	uint32_t val;
+      	status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+      				    StringValuePtr(argv[2]), type, &val);
+      	CHECK_STATUS(status);
+      	return INT2NUM(val);
+      }
+      case NC_INT64: {
+      	int64_t val;
+      	status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+      				    StringValuePtr(argv[2]), type, &val);
+      	CHECK_STATUS(status);
+      	return INT2NUM(val);
+      }
+      case NC_UINT64: {
+      	uint64_t val;
+      	status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+      				    StringValuePtr(argv[2]), type, &val);
+      	CHECK_STATUS(status);
+      	return INT2NUM(val);
       }
       case NC_FLOAT: {
-	float32_t val;
-	status = nc_get_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
-				    StringValuePtr(argv[2]), type, &val);
-	CHECK_STATUS(status);
-	return rb_float_new(val);
+      	float32_t val;
+      	status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+      				    StringValuePtr(argv[2]), type, &val);
+      	CHECK_STATUS(status);
+      	return rb_float_new(val);
       }
       case NC_DOUBLE: {
-	float64_t val;
-	status = nc_get_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
-				    StringValuePtr(argv[2]), type, &val);
-	CHECK_STATUS(status);
-	return rb_float_new(val);
+      	float64_t val;
+      	status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+      				    StringValuePtr(argv[2]), type, &val);
+      	CHECK_STATUS(status);
+      	return rb_float_new(val);
       }
       default: 
-	rb_raise(rb_eRuntimeError, "unknown att nc_type");
+      	rb_raise(rb_eRuntimeError, "unknown att nc_type");
       }
     }
     else {
@@ -749,7 +1192,7 @@ rb_nc_get_att (int argc, VALUE *argv, VALUE mod)
 
       Data_Get_Struct(out, CArray, ca);
 
-      status = nc_get_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+      status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 				  StringValuePtr(argv[2]), type, ca->ptr);
 
       CHECK_STATUS(status);
@@ -764,7 +1207,7 @@ rb_nc_get_att (int argc, VALUE *argv, VALUE mod)
     if ( type == NC_CHAR ) {
       volatile VALUE text = argv[3];
       rb_str_resize(text, len);
-      status = nc_get_att_text(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+      status = nc_get_att_text(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			       StringValuePtr(argv[2]), 
 			       StringValuePtr(text));
     }  
@@ -772,12 +1215,12 @@ rb_nc_get_att (int argc, VALUE *argv, VALUE mod)
       CArray *ca;
       nc_type xtype;
       if ( ! rb_obj_is_kind_of(argv[3], rb_cCArray) ) {
-	rb_raise(rb_eTypeError, "arg4 must be a CArray object");
+      	rb_raise(rb_eTypeError, "arg4 must be a CArray object");
       }
       Data_Get_Struct(argv[3], CArray, ca);
       xtype = rb_nc_rtypemap(ca->data_type);
       ca_attach(ca);
-      status = nc_get_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+      status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 				  StringValuePtr(argv[2]), type, ca->ptr);
       ca_sync(ca);
       ca_detach(ca);
@@ -798,19 +1241,19 @@ rb_nc_put_att (int argc, VALUE *argv, VALUE mod)
 
   if ( TYPE(argv[3]) == T_STRING ) {
     volatile VALUE text = argv[3];
-    status = nc_put_att_text(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+    status = nc_put_att_text(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			     StringValuePtr(argv[2]), 
 			     strlen(StringValuePtr(text)), StringValuePtr(text));
   }
   else if ( rb_obj_is_kind_of(argv[3], rb_cInteger) ) {
     int32_t val = NUM2INT(argv[3]);
-    status = nc_put_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+    status = nc_put_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 				StringValuePtr(argv[2]), 
 				NC_INT, NC_INT, 1, &val);
   }
   else if ( rb_obj_is_kind_of(argv[3], rb_cFloat) ) {
     float64_t val = NUM2DBL(argv[3]);
-    status = nc_put_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+    status = nc_put_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 				StringValuePtr(argv[2]), 
 				NC_DOUBLE, NC_DOUBLE, 1, &val);
   }
@@ -823,7 +1266,7 @@ rb_nc_put_att (int argc, VALUE *argv, VALUE mod)
     Data_Get_Struct(argv[3], CArray, ca);
     xtype = rb_nc_rtypemap(ca->data_type);
     ca_attach(ca);
-    status = nc_put_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+    status = nc_put_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 				StringValuePtr(argv[2]), 
 				xtype, xtype, ca->elements, ca->ptr);
     ca_detach(ca);
@@ -841,13 +1284,23 @@ nc_get_var1_numeric (int ncid, int varid,
 {
   switch (type) {
   case NC_BYTE:
-    return nc_get_var1_uchar(ncid, varid, index, value);
-  case NC_CHAR:
     return nc_get_var1_schar(ncid, varid, index, value);
+  case NC_UBYTE:
+    return nc_get_var1_ubyte(ncid, varid, index, value);
+  case NC_CHAR:
+    return nc_get_var1_uchar(ncid, varid, index, value);
   case NC_SHORT:
     return nc_get_var1_short(ncid, varid, index, value);
+  case NC_USHORT:
+    return nc_get_var1_ushort(ncid, varid, index, value);
   case NC_INT:
     return nc_get_var1_int(ncid, varid, index, value);
+  case NC_UINT:
+    return nc_get_var1_uint(ncid, varid, index, value);
+  case NC_INT64:
+    return nc_get_var1_longlong(ncid, varid, index, value);
+  case NC_UINT64:
+    return nc_get_var1_ulonglong(ncid, varid, index, value);
   case NC_FLOAT:
     return nc_get_var1_float(ncid, varid, index, value);
   case NC_DOUBLE:
@@ -863,13 +1316,23 @@ nc_put_var1_numeric (int ncid, int varid,
 {
   switch (type) {
   case NC_BYTE:
-    return nc_put_var1_uchar(ncid, varid, index, value);
-  case NC_CHAR:
     return nc_put_var1_schar(ncid, varid, index, value);
+  case NC_UBYTE:
+    return nc_put_var1_ubyte(ncid, varid, index, value);
+  case NC_CHAR:
+    return nc_put_var1_uchar(ncid, varid, index, value);
   case NC_SHORT:
     return nc_put_var1_short(ncid, varid, index, value);
+  case NC_USHORT:
+    return nc_put_var1_ushort(ncid, varid, index, value);
   case NC_INT:
     return nc_put_var1_int(ncid, varid, index, value);
+  case NC_UINT:
+    return nc_put_var1_uint(ncid, varid, index, value);
+  case NC_INT64:
+    return nc_put_var1_longlong(ncid, varid, index, value);
+  case NC_UINT64:
+    return nc_put_var1_ulonglong(ncid, varid, index, value);
   case NC_FLOAT:
     return nc_put_var1_float(ncid, varid, index, value);
   case NC_DOUBLE:
@@ -884,13 +1347,23 @@ nc_get_var_numeric (int ncid, int varid, nc_type type, void *value)
 {
   switch (type) {
   case NC_BYTE:
-    return nc_get_var_uchar(ncid, varid, value);
-  case NC_CHAR:
     return nc_get_var_schar(ncid, varid, value);
+  case NC_UBYTE:
+    return nc_get_var_ubyte(ncid, varid, value);
+  case NC_CHAR:
+    return nc_get_var_uchar(ncid, varid, value);
   case NC_SHORT:
     return nc_get_var_short(ncid, varid, value);
+  case NC_USHORT:
+    return nc_get_var_ushort(ncid, varid, value);
   case NC_INT:
     return nc_get_var_int(ncid, varid, value);
+  case NC_UINT:
+    return nc_get_var_uint(ncid, varid, value);
+  case NC_INT64:
+    return nc_get_var_longlong(ncid, varid, value);
+  case NC_UINT64:
+    return nc_get_var_ulonglong(ncid, varid, value);
   case NC_FLOAT:
     return nc_get_var_float(ncid, varid, value);
   case NC_DOUBLE:
@@ -905,13 +1378,23 @@ nc_put_var_numeric (int ncid, int varid, nc_type type, void *value)
 {
   switch (type) {
   case NC_BYTE:
-    return nc_put_var_uchar(ncid, varid, value);
-  case NC_CHAR:
     return nc_put_var_schar(ncid, varid, value);
+  case NC_UBYTE:
+    return nc_put_var_ubyte(ncid, varid, value);
+  case NC_CHAR:
+    return nc_put_var_uchar(ncid, varid, value);
   case NC_SHORT:
     return nc_put_var_short(ncid, varid, value);
+  case NC_USHORT:
+    return nc_put_var_ushort(ncid, varid, value);
   case NC_INT:
     return nc_put_var_int(ncid, varid, value);
+  case NC_UINT:
+    return nc_put_var_uint(ncid, varid, value);
+  case NC_INT64:
+    return nc_put_var_longlong(ncid, varid, value);
+  case NC_UINT64:
+    return nc_put_var_ulonglong(ncid, varid, value);
   case NC_FLOAT:
     return nc_put_var_float(ncid, varid, value);
   case NC_DOUBLE:
@@ -928,13 +1411,23 @@ nc_get_vara_numeric (int ncid, int varid, nc_type type,
 {
   switch (type) {
   case NC_BYTE:
-    return nc_get_vara_uchar(ncid, varid, start, count, value);
-  case NC_CHAR:
     return nc_get_vara_schar(ncid, varid, start, count, value);
+  case NC_UBYTE:
+    return nc_get_vara_ubyte(ncid, varid, start, count, value);
+  case NC_CHAR:
+    return nc_get_vara_uchar(ncid, varid, start, count, value);
   case NC_SHORT:
     return nc_get_vara_short(ncid, varid, start, count, value);
+  case NC_USHORT:
+    return nc_get_vara_ushort(ncid, varid, start, count, value);
   case NC_INT:
     return nc_get_vara_int(ncid, varid, start, count, value);
+  case NC_UINT:
+    return nc_get_vara_uint(ncid, varid, start, count, value);
+  case NC_INT64:
+    return nc_get_vara_longlong(ncid, varid, start, count, value);
+  case NC_UINT64:
+    return nc_get_vara_ulonglong(ncid, varid, start, count, value);
   case NC_FLOAT:
     return nc_get_vara_float(ncid, varid, start, count, value);
   case NC_DOUBLE:
@@ -951,13 +1444,23 @@ nc_put_vara_numeric (int ncid, int varid, nc_type type,
 {
   switch (type) {
   case NC_BYTE:
-    return nc_put_vara_uchar(ncid, varid, start, count, value);
-  case NC_CHAR:
     return nc_put_vara_schar(ncid, varid, start, count, value);
+  case NC_UBYTE:
+    return nc_put_vara_ubyte(ncid, varid, start, count, value);
+  case NC_CHAR:
+    return nc_put_vara_uchar(ncid, varid, start, count, value);
   case NC_SHORT:
     return nc_put_vara_short(ncid, varid, start, count, value);
+  case NC_USHORT:
+    return nc_put_vara_ushort(ncid, varid, start, count, value);
   case NC_INT:
     return nc_put_vara_int(ncid, varid, start, count, value);
+  case NC_UINT:
+    return nc_put_vara_uint(ncid, varid, start, count, value);
+  case NC_INT64:
+    return nc_put_vara_longlong(ncid, varid, start, count, value);
+  case NC_UINT64:
+    return nc_put_vara_ulonglong(ncid, varid, start, count, value);
   case NC_FLOAT:
     return nc_put_vara_float(ncid, varid, start, count, value);
   case NC_DOUBLE:
@@ -975,13 +1478,23 @@ nc_get_vars_numeric (int ncid, int varid, nc_type type,
 {
   switch (type) {
   case NC_BYTE:
-    return nc_get_vars_uchar(ncid, varid, start, count, stride, value);
-  case NC_CHAR:
     return nc_get_vars_schar(ncid, varid, start, count, stride, value);
+  case NC_UBYTE:
+    return nc_get_vars_ubyte(ncid, varid, start, count, stride, value);
+  case NC_CHAR:
+    return nc_get_vars_uchar(ncid, varid, start, count, stride, value);
   case NC_SHORT:
     return nc_get_vars_short(ncid, varid, start, count, stride, value);
+  case NC_USHORT:
+    return nc_get_vars_ushort(ncid, varid, start, count, stride, value);
   case NC_INT:
     return nc_get_vars_int(ncid, varid, start, count, stride, value);
+  case NC_UINT:
+    return nc_get_vars_uint(ncid, varid, start, count, stride, value);
+  case NC_INT64:
+    return nc_get_vars_longlong(ncid, varid, start, count, stride, value);
+  case NC_UINT64:
+    return nc_get_vars_ulonglong(ncid, varid, start, count, stride, value);
   case NC_FLOAT:
     return nc_get_vars_float(ncid, varid, start, count, stride, value);
   case NC_DOUBLE:
@@ -999,13 +1512,23 @@ nc_put_vars_numeric (int ncid, int varid, nc_type type,
 {
   switch (type) {
   case NC_BYTE:
-    return nc_put_vars_uchar(ncid, varid, start, count, stride, value);
-  case NC_CHAR:
     return nc_put_vars_schar(ncid, varid, start, count, stride, value);
+  case NC_UBYTE:
+    return nc_put_vars_ubyte(ncid, varid, start, count, stride, value);
+  case NC_CHAR:
+    return nc_put_vars_uchar(ncid, varid, start, count, stride, value);
   case NC_SHORT:
     return nc_put_vars_short(ncid, varid, start, count, stride, value);
+  case NC_USHORT:
+    return nc_put_vars_ushort(ncid, varid, start, count, stride, value);
   case NC_INT:
     return nc_put_vars_int(ncid, varid, start, count, stride, value);
+  case NC_UINT:
+    return nc_put_vars_uint(ncid, varid, start, count, stride, value);
+  case NC_INT64:
+    return nc_put_vars_longlong(ncid, varid, start, count, stride, value);
+  case NC_UINT64:
+    return nc_put_vars_ulonglong(ncid, varid, start, count, stride, value);
   case NC_FLOAT:
     return nc_put_vars_float(ncid, varid, start, count, stride, value);
   case NC_DOUBLE:
@@ -1023,13 +1546,23 @@ nc_get_varm_numeric (int ncid, int varid, nc_type type,
 {
   switch (type) {
   case NC_BYTE:
-    return nc_get_varm_uchar(ncid, varid, start, count, stride, imap, value);
-  case NC_CHAR:
     return nc_get_varm_schar(ncid, varid, start, count, stride, imap, value);
+  case NC_UBYTE:
+    return nc_get_varm_ubyte(ncid, varid, start, count, stride, imap, value);
+  case NC_CHAR:
+    return nc_get_varm_uchar(ncid, varid, start, count, stride, imap, value);
   case NC_SHORT:
     return nc_get_varm_short(ncid, varid, start, count, stride, imap, value);
+  case NC_USHORT:
+    return nc_get_varm_ushort(ncid, varid, start, count, stride, imap, value);
   case NC_INT:
     return nc_get_varm_int(ncid, varid, start, count, stride, imap, value);
+  case NC_UINT:
+    return nc_get_varm_uint(ncid, varid, start, count, stride, imap, value);
+  case NC_INT64:
+    return nc_get_varm_longlong(ncid, varid, start, count, stride, imap, value);
+  case NC_UINT64:
+    return nc_get_varm_ulonglong(ncid, varid, start, count, stride, imap, value);
   case NC_FLOAT:
     return nc_get_varm_float(ncid, varid, start, count, stride, imap, value);
   case NC_DOUBLE:
@@ -1047,13 +1580,23 @@ nc_put_varm_numeric (int ncid, int varid, nc_type type,
 {
   switch (type) {
   case NC_BYTE:
-    return nc_put_varm_uchar(ncid, varid, start, count, stride, imap, value);
-  case NC_CHAR:
     return nc_put_varm_schar(ncid, varid, start, count, stride, imap, value);
+  case NC_UBYTE:
+    return nc_put_varm_ubyte(ncid, varid, start, count, stride, imap, value);
+  case NC_CHAR:
+    return nc_put_varm_uchar(ncid, varid, start, count, stride, imap, value);
   case NC_SHORT:
     return nc_put_varm_short(ncid, varid, start, count, stride, imap, value);
+  case NC_USHORT:
+    return nc_put_varm_ushort(ncid, varid, start, count, stride, imap, value);
   case NC_INT:
     return nc_put_varm_int(ncid, varid, start, count, stride, imap, value);
+  case NC_UINT:
+    return nc_put_varm_uint(ncid, varid, start, count, stride, imap, value);
+  case NC_INT64:
+    return nc_put_varm_longlong(ncid, varid, start, count, stride, imap, value);
+  case NC_UINT64:
+    return nc_put_varm_ulonglong(ncid, varid, start, count, stride, imap, value);
   case NC_FLOAT:
     return nc_put_varm_float(ncid, varid, start, count, stride, imap, value);
   case NC_DOUBLE:
@@ -1076,11 +1619,11 @@ rb_nc_get_var1 (int argc, VALUE *argv, VALUE mod)
     rb_raise(rb_eArgError, "invalid # of arguments");
   }
 
-  status = nc_inq_vartype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &type);
+  status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
 
   CHECK_STATUS(status);
 
-  status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
+  status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
 
   CHECK_STATUS(status);
 
@@ -1092,36 +1635,71 @@ rb_nc_get_var1 (int argc, VALUE *argv, VALUE mod)
   if ( argc == 3 ) {
     switch ( type ) {
     case NC_BYTE: {
+      int8_t val;
+      status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+				   type, index, &val);
+      CHECK_STATUS(status);
+      return INT2NUM(val);
+    }
+    case NC_UBYTE: {
       uint8_t val;
-      status = nc_get_var1_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+      status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 				   type, index, &val);
       CHECK_STATUS(status);
       return INT2NUM(val);
     }
     case NC_SHORT: {
       int16_t val;
-      status = nc_get_var1_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+      status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+				   type, index, &val);
+      CHECK_STATUS(status);
+      return INT2NUM(val);
+    }
+    case NC_USHORT: {
+      uint16_t val;
+      status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 				   type, index, &val);
       CHECK_STATUS(status);
       return INT2NUM(val);
     }
     case NC_INT: {
       int32_t val;
-      status = nc_get_var1_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+      status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+				   type, index, &val);
+      CHECK_STATUS(status);
+      return INT2NUM(val);
+    }
+    case NC_UINT: {
+      uint32_t val;
+      status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+				   type, index, &val);
+      CHECK_STATUS(status);
+      return INT2NUM(val);
+    }
+    case NC_INT64: {
+      int64_t val;
+      status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+				   type, index, &val);
+      CHECK_STATUS(status);
+      return INT2NUM(val);
+    }
+    case NC_UINT64: {
+      uint64_t val;
+      status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 				   type, index, &val);
       CHECK_STATUS(status);
       return INT2NUM(val);
     }
     case NC_FLOAT: {
       float32_t val;
-      status = nc_get_var1_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+      status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 				   type, index, &val);
       CHECK_STATUS(status);
       return rb_float_new(val);
     }
     case NC_DOUBLE: {
       float64_t val;
-      status = nc_get_var1_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+      status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 				   type, index, &val);
       CHECK_STATUS(status);
       return rb_float_new(val);
@@ -1143,7 +1721,7 @@ rb_nc_get_var1 (int argc, VALUE *argv, VALUE mod)
     type = rb_nc_rtypemap(ca->data_type);
 
     ca_attach(ca);
-    status = nc_get_var1_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+    status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			       type, index, ca->ptr);
 
     ca_sync(ca);
@@ -1169,7 +1747,7 @@ rb_nc_put_var1 (int argc, VALUE *argv, VALUE mod)
 
   CHECK_ARGC(4);
 
-  status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
+  status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
 
   CHECK_STATUS(status);
 
@@ -1190,7 +1768,7 @@ rb_nc_put_var1 (int argc, VALUE *argv, VALUE mod)
   type = rb_nc_rtypemap(ca->data_type);
 
   ca_attach(ca);
-  status = nc_put_var1_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+  status = nc_put_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			       type, index, ca->ptr);
   ca_detach(ca);
 
@@ -1211,15 +1789,15 @@ rb_nc_get_var (int argc, VALUE *argv, VALUE mod)
     rb_raise(rb_eArgError, "invalid # of arguments");
   }
   
-  status = nc_inq_vartype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &type);
+  status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
 
   CHECK_STATUS(status);
 
-  status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
+  status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
 
   CHECK_STATUS(status);
 
-  status = nc_inq_vardimid(NUM2LONG(argv[0]), NUM2LONG(argv[1]), dimid);
+  status = nc_inq_vardimid(NUM2INT(argv[0]), NUM2INT(argv[1]), dimid);
 
   CHECK_STATUS(status);
 
@@ -1234,7 +1812,7 @@ rb_nc_get_var (int argc, VALUE *argv, VALUE mod)
     data_type = rb_nc_typemap (type);
     rank = ndims;
     for (i=0; i<rank; i++) {
-      status = nc_inq_dimlen(NUM2LONG(argv[0]), dimid[i], &len);
+      status = nc_inq_dimlen(NUM2INT(argv[0]), dimid[i], &len);
       CHECK_STATUS(status);
       dim[i] = len;
     }
@@ -1242,7 +1820,7 @@ rb_nc_get_var (int argc, VALUE *argv, VALUE mod)
     out = rb_carray_new(data_type, rank, dim, 0, NULL);
     Data_Get_Struct(out, CArray, ca);
 
-    status = nc_get_var_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+    status = nc_get_var_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 				type, ca->ptr);
 
     CHECK_STATUS(status);
@@ -1262,7 +1840,7 @@ rb_nc_get_var (int argc, VALUE *argv, VALUE mod)
     type = rb_nc_rtypemap(ca->data_type);
 
     ca_attach(ca);
-    status = nc_get_var_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+    status = nc_get_var_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 				type, ca->ptr);
     ca_sync(ca);
     ca_detach(ca);
@@ -1283,7 +1861,7 @@ rb_nc_put_var (int argc, VALUE *argv, VALUE mod)
 
   CHECK_ARGC(3);
   
-  status = nc_inq_vartype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &type);
+  status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
 
   CHECK_STATUS(status);
 
@@ -1297,7 +1875,7 @@ rb_nc_put_var (int argc, VALUE *argv, VALUE mod)
 
   type = rb_nc_rtypemap(ca->data_type);
   ca_attach(ca);
-  status = nc_put_var_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+  status = nc_put_var_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			      type, ca->ptr);
   ca_detach(ca);
 
@@ -1320,15 +1898,15 @@ rb_nc_get_vara (int argc, VALUE *argv, VALUE mod)
     rb_raise(rb_eArgError, "invalid # of arguments");
   }
   
-  status = nc_inq_vartype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &type);
+  status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
 
   CHECK_STATUS(status);
 
-  status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
+  status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
 
   CHECK_STATUS(status);
 
-  status = nc_inq_vardimid(NUM2LONG(argv[0]), NUM2LONG(argv[1]), dimid);
+  status = nc_inq_vardimid(NUM2INT(argv[0]), NUM2INT(argv[1]), dimid);
 
   CHECK_STATUS(status);
 
@@ -1356,7 +1934,7 @@ rb_nc_get_vara (int argc, VALUE *argv, VALUE mod)
     out = rb_carray_new(data_type, rank, dim, 0, NULL);
     Data_Get_Struct(out, CArray, ca);
 
-    status = nc_get_vara_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+    status = nc_get_vara_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 				 type, start, count, ca->ptr);
 
     CHECK_STATUS(status);
@@ -1377,15 +1955,15 @@ rb_nc_get_vara (int argc, VALUE *argv, VALUE mod)
     }
 
     for (i=0; i<ca->rank; i++) {
-      if ( ca->dim[i] != count[i] ) {
-	rb_raise(rb_eRuntimeError, "dim[%i] mismatch", i);
+      if ( ca->dim[i] != (ca_size_t) count[i] ) {
+      	rb_raise(rb_eRuntimeError, "dim[%i] mismatch", i);
       }
     }
 
     type = rb_nc_rtypemap(ca->data_type);
 
     ca_attach(ca);
-    status = nc_get_vara_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+    status = nc_get_vara_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			       type, start, count, ca->ptr);
     ca_sync(ca);
     ca_detach(ca);
@@ -1409,7 +1987,7 @@ rb_nc_put_vara (int argc, VALUE *argv, VALUE mod)
 
   CHECK_ARGC(5);
 
-  status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
+  status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
 
   CHECK_STATUS(status);
 
@@ -1432,7 +2010,7 @@ rb_nc_put_vara (int argc, VALUE *argv, VALUE mod)
   type = rb_nc_rtypemap(ca->data_type);
 
   ca_attach(ca);
-  status = nc_put_vara_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+  status = nc_put_vara_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			       type, start, count, ca->ptr);
   ca_detach(ca);
 
@@ -1457,15 +2035,15 @@ rb_nc_get_vars (int argc, VALUE *argv, VALUE mod)
     rb_raise(rb_eArgError, "invalid # of arguments");
   }
   
-  status = nc_inq_vartype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &type);
+  status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
 
   CHECK_STATUS(status);
 
-  status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
+  status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
 
   CHECK_STATUS(status);
 
-  status = nc_inq_vardimid(NUM2LONG(argv[0]), NUM2LONG(argv[1]), dimid);
+  status = nc_inq_vardimid(NUM2INT(argv[0]), NUM2INT(argv[1]), dimid);
 
   CHECK_STATUS(status);
 
@@ -1495,7 +2073,7 @@ rb_nc_get_vars (int argc, VALUE *argv, VALUE mod)
     out = rb_carray_new(data_type, rank, dim, 0, NULL);
     Data_Get_Struct(out, CArray, ca);
 
-    status = nc_get_vars_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+    status = nc_get_vars_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 				 type, start, count, stride, ca->ptr);
 
     CHECK_STATUS(status);
@@ -1517,15 +2095,15 @@ rb_nc_get_vars (int argc, VALUE *argv, VALUE mod)
     }
 
     for (i=0; i<ca->rank; i++) {
-      if ( ca->dim[i] != count[i] ) {
-	rb_raise(rb_eRuntimeError, "dim[%i] mismatch", i);
+      if ( ca->dim[i] != (ca_size_t) count[i] ) {
+      	rb_raise(rb_eRuntimeError, "dim[%i] mismatch", i);
       }
     }
 
     type = rb_nc_rtypemap(ca->data_type);
 
     ca_attach(ca);
-    status = nc_get_vars_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+    status = nc_get_vars_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			       type, start, count, stride, ca->ptr);
     ca_sync(ca);
     ca_detach(ca);
@@ -1550,7 +2128,7 @@ rb_nc_put_vars (int argc, VALUE *argv, VALUE mod)
 
   CHECK_ARGC(6);
 
-  status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
+  status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
 
   CHECK_STATUS(status);
 
@@ -1575,7 +2153,7 @@ rb_nc_put_vars (int argc, VALUE *argv, VALUE mod)
   type = rb_nc_rtypemap(ca->data_type);
 
   ca_attach(ca);
-  status = nc_put_vars_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+  status = nc_put_vars_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			       type, start, count, stride, ca->ptr);
   ca_detach(ca);
 
@@ -1600,15 +2178,15 @@ rb_nc_get_varm (int argc, VALUE *argv, VALUE mod)
     rb_raise(rb_eArgError, "invalid # of arguments");
   }
   
-  status = nc_inq_vartype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &type);
+  status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
 
   CHECK_STATUS(status);
 
-  status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
+  status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
 
   CHECK_STATUS(status);
 
-  status = nc_inq_vardimid(NUM2LONG(argv[0]), NUM2LONG(argv[1]), dimid);
+  status = nc_inq_vardimid(NUM2INT(argv[0]), NUM2INT(argv[1]), dimid);
 
   CHECK_STATUS(status);
 
@@ -1640,7 +2218,7 @@ rb_nc_get_varm (int argc, VALUE *argv, VALUE mod)
     out = rb_carray_new(data_type, rank, dim, 0, NULL);
     Data_Get_Struct(out, CArray, ca);
 
-    status = nc_get_varm_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+    status = nc_get_varm_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			       type, start, count, stride, imap, ca->ptr);
 
     CHECK_STATUS(status);
@@ -1662,15 +2240,15 @@ rb_nc_get_varm (int argc, VALUE *argv, VALUE mod)
     }
 
     for (i=0; i<ca->rank; i++) {
-      if ( ca->dim[i] != count[i] ) {
-	rb_raise(rb_eRuntimeError, "dim[%i] mismatch", i);
+      if ( ca->dim[i] != (ca_size_t) count[i] ) {
+      	rb_raise(rb_eRuntimeError, "dim[%i] mismatch", i);
       }
     }
 
     type = rb_nc_rtypemap(ca->data_type);
 
     ca_attach(ca);
-    status = nc_get_varm_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+    status = nc_get_varm_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			       type, start, count, stride, imap, ca->ptr);
     ca_sync(ca);
     ca_detach(ca);
@@ -1695,7 +2273,7 @@ rb_nc_put_varm (int argc, VALUE *argv, VALUE mod)
 
   CHECK_ARGC(7);
 
-  status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
+  status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
 
   CHECK_STATUS(status);
 
@@ -1722,7 +2300,7 @@ rb_nc_put_varm (int argc, VALUE *argv, VALUE mod)
   type = rb_nc_rtypemap(ca->data_type);
 
   ca_attach(ca);
-  status = nc_put_varm_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+  status = nc_put_varm_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			       type, start, count, stride, imap, ca->ptr);
   ca_detach(ca);
 
@@ -1741,7 +2319,7 @@ rb_nc_rename_dim (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[1]);
   CHECK_TYPE_STRING(argv[2]);
 
-  status = nc_rename_dim(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+  status = nc_rename_dim(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			 StringValuePtr(argv[2]));
 
   CHECK_STATUS(status);
@@ -1749,6 +2327,22 @@ rb_nc_rename_dim (int argc, VALUE *argv, VALUE mod)
   return LONG2NUM(status);
 }
 
+static VALUE
+rb_nc_rename_grp (int argc, VALUE *argv, VALUE mod)
+{
+  int status;
+
+  CHECK_ARGC(2);
+  CHECK_TYPE_ID(argv[0]);
+  CHECK_TYPE_STRING(argv[1]);
+  
+  status = nc_rename_grp(NUM2INT(argv[0]), StringValuePtr(argv[1]));
+
+  CHECK_STATUS(status);
+
+  return LONG2NUM(status);
+}
+
 static VALUE
 rb_nc_rename_var (int argc, VALUE *argv, VALUE mod)
 {
@@ -1759,7 +2353,7 @@ rb_nc_rename_var (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[1]);
   CHECK_TYPE_STRING(argv[2]);
   
-  status = nc_rename_var(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+  status = nc_rename_var(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			 StringValuePtr(argv[2]));
 
   CHECK_STATUS(status);
@@ -1778,7 +2372,7 @@ rb_nc_rename_att (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_STRING(argv[2]);
   CHECK_TYPE_STRING(argv[3]);
   
-  status = nc_rename_att(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
+  status = nc_rename_att(NUM2INT(argv[0]), NUM2INT(argv[1]), 
 			 StringValuePtr(argv[2]), StringValuePtr(argv[3]));
 
   CHECK_STATUS(status);
@@ -1786,10 +2380,8 @@ rb_nc_rename_att (int argc, VALUE *argv, VALUE mod)
   return LONG2NUM(status);
 }
 
-int nc_setfill(int ncid, int fillmode, int* old_fillemode);
-
 static VALUE
-rb_nc_setfill (int argc, VALUE *argv, VALUE mod)
+rb_nc_set_fill (int argc, VALUE *argv, VALUE mod)
 {
   int status;
   int old_fillmode;
@@ -1798,7 +2390,7 @@ rb_nc_setfill (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[0]);
   CHECK_TYPE_INT(argv[1]);
 
-  status = nc_setfill(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &old_fillmode);
+  status = nc_set_fill(NUM2INT(argv[0]), NUM2INT(argv[1]), &old_fillmode);
 
   CHECK_STATUS(status);
 
@@ -1817,8 +2409,8 @@ rb_nc_copy_att (int argc, VALUE *argv, VALUE mod)
   CHECK_TYPE_ID(argv[3]);
   CHECK_TYPE_ID(argv[4]);
   
-  status = nc_copy_att(NUM2LONG(argv[0]), NUM2LONG(argv[1]), 
-		      StringValuePtr(argv[2]), NUM2LONG(argv[3]), NUM2LONG(argv[4]));
+  status = nc_copy_att(NUM2INT(argv[0]), NUM2INT(argv[1]), 
+		      StringValuePtr(argv[2]), NUM2INT(argv[3]), NUM2INT(argv[4]));
 
   CHECK_STATUS(status);
 
@@ -1846,122 +2438,226 @@ Init_netcdflib ()
   rb_define_singleton_method(mNetCDF,   "enddef", rb_nc_enddef, -1);
   rb_define_module_function(mNetCDF, "nc_sync",   rb_nc_sync, -1);
   rb_define_singleton_method(mNetCDF,   "sync",   rb_nc_sync, -1);
+  rb_define_module_function(mNetCDF, "nc_set_fill",  rb_nc_set_fill, -1);
+  rb_define_singleton_method(mNetCDF,   "set_fill",  rb_nc_set_fill, -1);
 
-  rb_define_module_function(mNetCDF, "nc_inq_ndims",   rb_nc_inq_ndims, -1);
-  rb_define_singleton_method(mNetCDF,   "inq_ndims",   rb_nc_inq_ndims, -1);
-  rb_define_module_function(mNetCDF, "nc_inq_nvars",   rb_nc_inq_nvars, -1);
-  rb_define_singleton_method(mNetCDF,   "inq_nvars",   rb_nc_inq_nvars, -1);
-  rb_define_module_function(mNetCDF, "nc_inq_natts",   rb_nc_inq_natts, -1);
-  rb_define_singleton_method(mNetCDF,   "inq_natts",   rb_nc_inq_natts, -1);
-  rb_define_module_function(mNetCDF, "nc_inq_unlimdim",   rb_nc_inq_unlimdim, -1);
-  rb_define_singleton_method(mNetCDF,   "inq_unlimdim",   rb_nc_inq_unlimdim, -1);
-
+  rb_define_module_function(mNetCDF, "nc_def_dim",  rb_nc_def_dim, -1);
+  rb_define_singleton_method(mNetCDF,   "def_dim",  rb_nc_def_dim, -1);
+  // nc_inq_dim is not defined
   rb_define_module_function(mNetCDF, "nc_inq_dimid",   rb_nc_inq_dimid, -1);
   rb_define_singleton_method(mNetCDF,   "inq_dimid",   rb_nc_inq_dimid, -1);
-  rb_define_module_function(mNetCDF, "nc_inq_varid",   rb_nc_inq_varid, -1);
-  rb_define_singleton_method(mNetCDF,   "inq_varid",   rb_nc_inq_varid, -1);
-  rb_define_module_function(mNetCDF, "nc_inq_attid",   rb_nc_inq_attid, -1);
-  rb_define_singleton_method(mNetCDF,   "inq_attid",   rb_nc_inq_attid, -1);
-
   rb_define_module_function(mNetCDF, "nc_inq_dimlen",  rb_nc_inq_dimlen, -1);
   rb_define_singleton_method(mNetCDF,   "inq_dimlen",  rb_nc_inq_dimlen, -1);
   rb_define_module_function(mNetCDF, "nc_inq_dimname", rb_nc_inq_dimname, -1);
   rb_define_singleton_method(mNetCDF,   "inq_dimname", rb_nc_inq_dimname, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_ndims",   rb_nc_inq_ndims, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_ndims",   rb_nc_inq_ndims, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_unlimdim",   rb_nc_inq_unlimdim, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_unlimdim",   rb_nc_inq_unlimdim, -1);
+  rb_define_module_function(mNetCDF, "nc_rename_dim",  rb_nc_rename_dim, -1);
+  rb_define_singleton_method(mNetCDF,   "rename_dim",  rb_nc_rename_dim, -1);
 
-  rb_define_module_function(mNetCDF, "nc_inq_varname",    rb_nc_inq_varname, -1);
-  rb_define_singleton_method(mNetCDF,   "inq_varname",    rb_nc_inq_varname, -1);
-  rb_define_module_function(mNetCDF, "nc_inq_vartype",    rb_nc_inq_vartype, -1);
-  rb_define_singleton_method(mNetCDF,   "inq_vartype",    rb_nc_inq_vartype, -1);
-  rb_define_module_function(mNetCDF, "nc_inq_varndims",   rb_nc_inq_varndims, -1);
-  rb_define_singleton_method(mNetCDF,   "inq_varndims",   rb_nc_inq_varndims, -1);
-  rb_define_module_function(mNetCDF, "nc_inq_vardimid",  rb_nc_inq_vardimid, -1);
-  rb_define_singleton_method(mNetCDF,    "inq_vardimid",  rb_nc_inq_vardimid, -1);
-  rb_define_module_function(mNetCDF, "nc_inq_varnatts",   rb_nc_inq_varnatts, -1);
-  rb_define_singleton_method(mNetCDF,    "inq_varnatts",  rb_nc_inq_varnatts, -1);
-
-  rb_define_module_function(mNetCDF, "nc_inq_attname", rb_nc_inq_attname, -1);
-  rb_define_singleton_method(mNetCDF,   "inq_attname", rb_nc_inq_attname, -1);
-  rb_define_module_function(mNetCDF, "nc_inq_atttype", rb_nc_inq_atttype, -1);
-  rb_define_singleton_method(mNetCDF,   "inq_atttype", rb_nc_inq_atttype, -1);
-  rb_define_module_function(mNetCDF, "nc_inq_attlen",  rb_nc_inq_attlen, -1);
-  rb_define_singleton_method(mNetCDF,   "inq_attlen",  rb_nc_inq_attlen, -1);
-  rb_define_module_function(mNetCDF, "nc_inq_attid",   rb_nc_inq_attid, -1);
-  rb_define_singleton_method(mNetCDF,   "inq_attid",   rb_nc_inq_attid, -1);
-
-  rb_define_module_function(mNetCDF, "nc_def_dim",  rb_nc_def_dim, -1);
-  rb_define_singleton_method(mNetCDF,   "def_dim",  rb_nc_def_dim, -1);
   rb_define_module_function(mNetCDF, "nc_def_var",  rb_nc_def_var, -1);
   rb_define_singleton_method(mNetCDF,   "def_var",  rb_nc_def_var, -1);
-
+  rb_define_module_function(mNetCDF, "nc_def_var_chunking",  rb_nc_def_var_chunking, -1);
+  rb_define_singleton_method(mNetCDF,   "def_var_chunking",  rb_nc_def_var_chunking, -1);
   rb_define_module_function(mNetCDF, "nc_def_var_deflate",  rb_nc_def_var_deflate, -1);
   rb_define_singleton_method(mNetCDF,   "def_var_deflate",  rb_nc_def_var_deflate, -1);
-  rb_define_module_function(mNetCDF, "nc_inq_var_deflate",  rb_nc_inq_var_deflate, -1);
-  rb_define_singleton_method(mNetCDF,   "inq_var_deflate",  rb_nc_inq_var_deflate, -1);
-
-  rb_define_module_function(mNetCDF, "nc_rename_dim",  rb_nc_rename_dim, -1);
-  rb_define_singleton_method(mNetCDF,   "rename_dim",  rb_nc_rename_dim, -1);
-  rb_define_module_function(mNetCDF, "nc_rename_var",  rb_nc_rename_var, -1);
-  rb_define_singleton_method(mNetCDF,   "rename_var",  rb_nc_rename_var, -1);
-  rb_define_module_function(mNetCDF, "nc_rename_att",  rb_nc_rename_att, -1);
-  rb_define_singleton_method(mNetCDF,   "rename_att",  rb_nc_rename_att, -1);
-  rb_define_module_function(mNetCDF, "nc_del_att",  rb_nc_del_att, -1);
-  rb_define_singleton_method(mNetCDF,   "del_att",  rb_nc_del_att, -1);
-  rb_define_module_function(mNetCDF, "nc_setfill",  rb_nc_setfill, -1);
-  rb_define_singleton_method(mNetCDF,   "setfill",  rb_nc_setfill, -1);
-
-  rb_define_module_function(mNetCDF, "nc_put_att",  rb_nc_put_att, -1);
-  rb_define_singleton_method(mNetCDF,   "put_att",  rb_nc_put_att, -1);
-  rb_define_module_function(mNetCDF, "nc_get_att",  rb_nc_get_att, -1);
-  rb_define_singleton_method(mNetCDF,   "get_att",  rb_nc_get_att, -1);
-  rb_define_module_function(mNetCDF, "nc_copy_att", rb_nc_copy_att, -1);
-  rb_define_singleton_method(mNetCDF,   "copy_att", rb_nc_copy_att, -1);
-
+  // nc_def_var_endian
+  // nc_def_var_fill
+  // nc_def_var_fletcher32
+  // nc_free_string
   rb_define_module_function(mNetCDF, "nc_get_var1", rb_nc_get_var1, -1);
   rb_define_singleton_method(mNetCDF,   "get_var1", rb_nc_get_var1, -1);
-  rb_define_module_function(mNetCDF, "nc_put_var1", rb_nc_put_var1, -1);
-  rb_define_singleton_method(mNetCDF,   "put_var1", rb_nc_put_var1, -1);
   rb_define_module_function(mNetCDF, "nc_get_var",  rb_nc_get_var, -1);
   rb_define_singleton_method(mNetCDF,   "get_var",  rb_nc_get_var, -1);
-  rb_define_module_function(mNetCDF, "nc_put_var",  rb_nc_put_var, -1);
-  rb_define_singleton_method(mNetCDF,   "put_var",  rb_nc_put_var, -1);
   rb_define_module_function(mNetCDF, "nc_get_vara", rb_nc_get_vara, -1);
   rb_define_singleton_method(mNetCDF,   "get_vara", rb_nc_get_vara, -1);
-  rb_define_module_function(mNetCDF, "nc_put_vara", rb_nc_put_vara, -1);
-  rb_define_singleton_method(mNetCDF,   "put_vara", rb_nc_put_vara, -1);
   rb_define_module_function(mNetCDF, "nc_get_vars", rb_nc_get_vars, -1);
   rb_define_singleton_method(mNetCDF,   "get_vars", rb_nc_get_vars, -1);
-  rb_define_module_function(mNetCDF, "nc_put_vars", rb_nc_put_vars, -1);
-  rb_define_singleton_method(mNetCDF,   "put_vars", rb_nc_put_vars, -1);
   rb_define_module_function(mNetCDF, "nc_get_varm", rb_nc_get_varm, -1);
   rb_define_singleton_method(mNetCDF,   "get_varm", rb_nc_get_varm, -1);
+  //nc_inq_var
+  rb_define_module_function(mNetCDF, "nc_inq_var_chunking",  rb_nc_inq_var_chunking, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_var_chunking",  rb_nc_inq_var_chunking, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_var_deflate",  rb_nc_inq_var_deflate, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_var_deflate",  rb_nc_inq_var_deflate, -1);
+  //nc_inq_var_endian
+  //nc_inq_var_fill
+  //nc_inq_var_filter
+  //nc_inq_var_fletcher32
+  //nc_inq_var_szip
+  rb_define_module_function(mNetCDF, "nc_inq_vardimid",  rb_nc_inq_vardimid, -1);
+  rb_define_singleton_method(mNetCDF,    "inq_vardimid",  rb_nc_inq_vardimid, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_varid",   rb_nc_inq_varid, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_varid",   rb_nc_inq_varid, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_varname",    rb_nc_inq_varname, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_varname",    rb_nc_inq_varname, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_varnatts",   rb_nc_inq_varnatts, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_varnatts",  rb_nc_inq_varnatts, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_varndims",   rb_nc_inq_varndims, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_varndims",   rb_nc_inq_varndims, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_vartype",    rb_nc_inq_vartype, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_vartype",    rb_nc_inq_vartype, -1);
+  rb_define_module_function(mNetCDF, "nc_put_var1", rb_nc_put_var1, -1);
+  rb_define_singleton_method(mNetCDF,   "put_var1", rb_nc_put_var1, -1);
+  rb_define_module_function(mNetCDF, "nc_put_var",  rb_nc_put_var, -1);
+  rb_define_singleton_method(mNetCDF,   "put_var",  rb_nc_put_var, -1);
+  rb_define_module_function(mNetCDF, "nc_put_vara", rb_nc_put_vara, -1);
+  rb_define_singleton_method(mNetCDF,   "put_vara", rb_nc_put_vara, -1);
+  rb_define_module_function(mNetCDF, "nc_put_vars", rb_nc_put_vars, -1);
+  rb_define_singleton_method(mNetCDF,   "put_vars", rb_nc_put_vars, -1);
   rb_define_module_function(mNetCDF, "nc_put_varm", rb_nc_put_varm, -1);
   rb_define_singleton_method(mNetCDF,   "put_varm", rb_nc_put_varm, -1);
+  rb_define_module_function(mNetCDF, "nc_rename_var",  rb_nc_rename_var, -1);
+  rb_define_singleton_method(mNetCDF,   "rename_var",  rb_nc_rename_var, -1);
+  // nc_set_var_chunk_cache
+  
+  rb_define_module_function(mNetCDF, "nc_del_att",  rb_nc_del_att, -1);
+  rb_define_singleton_method(mNetCDF,   "del_att",  rb_nc_del_att, -1);
+  rb_define_module_function(mNetCDF, "nc_get_att",  rb_nc_get_att, -1);
+  rb_define_singleton_method(mNetCDF,   "get_att",  rb_nc_get_att, -1);
+  // nc_inq_att
+  rb_define_module_function(mNetCDF, "nc_inq_attid",   rb_nc_inq_attid, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_attid",   rb_nc_inq_attid, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_attlen",  rb_nc_inq_attlen, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_attlen",  rb_nc_inq_attlen, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_attname", rb_nc_inq_attname, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_attname", rb_nc_inq_attname, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_atttype", rb_nc_inq_atttype, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_atttype", rb_nc_inq_atttype, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_natts",   rb_nc_inq_natts, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_natts",   rb_nc_inq_natts, -1);
+  rb_define_module_function(mNetCDF, "nc_put_att",  rb_nc_put_att, -1);
+  rb_define_singleton_method(mNetCDF,   "put_att",  rb_nc_put_att, -1);
+  rb_define_module_function(mNetCDF, "nc_rename_att",  rb_nc_rename_att, -1);
+  rb_define_singleton_method(mNetCDF,   "rename_att",  rb_nc_rename_att, -1);
+
+  rb_define_module_function(mNetCDF, "nc_def_grp",  rb_nc_def_grp, -1);
+  rb_define_singleton_method(mNetCDF,   "def_grp",  rb_nc_def_grp, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_dimids",  rb_nc_inq_dimids, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_dimids",  rb_nc_inq_dimids, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_grp_full_ncid",  rb_nc_inq_grp_full_ncid, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_grp_full_ncid",  rb_nc_inq_grp_full_ncid, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_grp_ncid",  rb_nc_inq_grp_ncid, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_grp_ncid",  rb_nc_inq_grp_ncid, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_grp_parent",  rb_nc_inq_grp_parent, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_grp_parent",  rb_nc_inq_grp_parent, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_grpname",  rb_nc_inq_grpname, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_grpname",  rb_nc_inq_grpname, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_grpname_full",  rb_nc_inq_grpname_full, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_grpname_full",  rb_nc_inq_grpname_full, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_grpname_len",  rb_nc_inq_grpname_len, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_grpname_len",  rb_nc_inq_grpname_len, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_grps",  rb_nc_inq_grps, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_grps",  rb_nc_inq_grps, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_ncid",  rb_nc_inq_ncid, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_ncid",  rb_nc_inq_ncid, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_typeids",  rb_nc_inq_typeids, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_typeids",  rb_nc_inq_typeids, -1);
+  rb_define_module_function(mNetCDF, "nc_inq_varids",  rb_nc_inq_varids, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_varids",  rb_nc_inq_varids, -1);
+  rb_define_module_function(mNetCDF, "nc_rename_grp",  rb_nc_rename_grp, -1);
+  rb_define_singleton_method(mNetCDF,   "rename_grp",  rb_nc_rename_grp, -1);
+  rb_define_module_function(mNetCDF, "nc_show_metadata",  rb_nc_show_metadata, -1);
+  rb_define_singleton_method(mNetCDF,   "show_metadata",  rb_nc_show_metadata, -1);
+
+
+  rb_define_module_function(mNetCDF, "nc_copy_att", rb_nc_copy_att, -1);
+  rb_define_singleton_method(mNetCDF,   "copy_att", rb_nc_copy_att, -1);
+
+  rb_define_module_function(mNetCDF, "nc_inq_nvars",   rb_nc_inq_nvars, -1);
+  rb_define_singleton_method(mNetCDF,   "inq_nvars",   rb_nc_inq_nvars, -1);
 
-  rb_define_const(mNetCDF, "NC_NOERR",     INT2FIX(NC_NOERR));
-
-  rb_define_const(mNetCDF, "NC_NOWRITE",   INT2FIX(NC_NOWRITE));
-  rb_define_const(mNetCDF, "NC_WRITE",     INT2FIX(NC_WRITE));
-  rb_define_const(mNetCDF, "NC_SHARE",     INT2FIX(NC_SHARE));
-  rb_define_const(mNetCDF, "NC_LOCK",      INT2FIX(NC_LOCK));
-  rb_define_const(mNetCDF, "NC_CLOBBER",   INT2FIX(NC_CLOBBER));
-  rb_define_const(mNetCDF, "NC_NOCLOBBER", INT2FIX(NC_NOCLOBBER));
-  rb_define_const(mNetCDF, "NC_NETCDF4", INT2FIX(NC_NETCDF4));
-  rb_define_const(mNetCDF, "NC_CLASSIC_MODEL", INT2FIX(NC_CLASSIC_MODEL));
-  rb_define_const(mNetCDF, "NC_SIZEHINT_DEFAULT", INT2FIX(NC_SIZEHINT_DEFAULT));
-
-  rb_define_const(mNetCDF, "NC_GLOBAL",       INT2FIX(NC_GLOBAL));
-  rb_define_const(mNetCDF, "NC_MAX_NAME",     INT2FIX(NC_MAX_NAME));
-  rb_define_const(mNetCDF, "NC_MAX_VAR_DIMS", INT2FIX(NC_MAX_VAR_DIMS));
-  rb_define_const(mNetCDF, "NC_MAX_DIMS",     INT2FIX(NC_MAX_DIMS));
-  rb_define_const(mNetCDF, "NC_NOFILL",       INT2FIX(NC_NOFILL));
-  rb_define_const(mNetCDF, "NC_FILL",         INT2FIX(NC_FILL));
-
-  rb_define_const(mNetCDF, "NC_NAT",     INT2FIX(NC_NAT));
-  rb_define_const(mNetCDF, "NC_BYTE",    INT2FIX(NC_BYTE));
-  rb_define_const(mNetCDF, "NC_CHAR",    INT2FIX(NC_CHAR));
-  rb_define_const(mNetCDF, "NC_SHORT",   INT2FIX(NC_SHORT));
-  rb_define_const(mNetCDF, "NC_INT",     INT2FIX(NC_INT));
-  rb_define_const(mNetCDF, "NC_FLOAT",   INT2FIX(NC_FLOAT));
-  rb_define_const(mNetCDF, "NC_DOUBLE",  INT2FIX(NC_DOUBLE));
+  rb_define_const(mNetCDF, "NC_NOERR",        INT2NUM(NC_NOERR));
+
+  rb_define_const(mNetCDF, "NC_NOWRITE",      INT2NUM(NC_NOWRITE));
+  rb_define_const(mNetCDF, "NC_WRITE",        INT2NUM(NC_WRITE));
+  rb_define_const(mNetCDF, "NC_CLOBBER",      INT2NUM(NC_CLOBBER));
+  rb_define_const(mNetCDF, "NC_NOCLOBBER",    INT2NUM(NC_NOCLOBBER));
+  rb_define_const(mNetCDF, "NC_DISKLESS",        INT2NUM(NC_DISKLESS));
+  rb_define_const(mNetCDF, "NC_MMAP",        INT2NUM(NC_MMAP));
+  rb_define_const(mNetCDF, "NC_64BIT_DATA",        INT2NUM(NC_64BIT_DATA));
+  rb_define_const(mNetCDF, "NC_CDF5",        INT2NUM(NC_CDF5));
+  rb_define_const(mNetCDF, "NC_CLASSIC_MODEL",    INT2NUM(NC_CLASSIC_MODEL));
+  rb_define_const(mNetCDF, "NC_LOCK",         INT2NUM(NC_LOCK));
+  rb_define_const(mNetCDF, "NC_SHARE",        INT2NUM(NC_SHARE));
+  rb_define_const(mNetCDF, "NC_NETCDF4",      INT2NUM(NC_NETCDF4));
+  rb_define_const(mNetCDF, "NC_MPIIO",      INT2NUM(NC_MPIIO));
+  rb_define_const(mNetCDF, "NC_INMEMORY",      INT2NUM(NC_INMEMORY));
+  rb_define_const(mNetCDF, "NC_PNETCDF",      INT2NUM(NC_PNETCDF));
+
+  rb_define_const(mNetCDF, "NC_FORMAT_CLASSIC",      INT2NUM(NC_FORMAT_CLASSIC));
+  rb_define_const(mNetCDF, "NC_FORMAT_64BIT_OFFSET",      INT2NUM(NC_FORMAT_64BIT_OFFSET));
+  rb_define_const(mNetCDF, "NC_FORMAT_64BIT",      INT2NUM(NC_FORMAT_64BIT));
+  rb_define_const(mNetCDF, "NC_FORMAT_NETCDF4",      INT2NUM(NC_FORMAT_NETCDF4));
+  rb_define_const(mNetCDF, "NC_FORMAT_NETCDF4_CLASSIC",      INT2NUM(NC_FORMAT_NETCDF4_CLASSIC));
+  rb_define_const(mNetCDF, "NC_FORMAT_64BIT_DATA",      INT2NUM(NC_FORMAT_64BIT_DATA));
+  rb_define_const(mNetCDF, "NC_FORMAT_CDF5",      INT2NUM(NC_FORMAT_CDF5));
+
+
+  rb_define_const(mNetCDF, "NC_SIZEHINT_DEFAULT", INT2NUM(NC_SIZEHINT_DEFAULT));
+
+  rb_define_const(mNetCDF, "NC_ALIGN_CHUNK",       INT2NUM(NC_ALIGN_CHUNK));
+  rb_define_const(mNetCDF, "NC_UNLIMITED",       INT2NUM(NC_UNLIMITED));
+
+  rb_define_const(mNetCDF, "NC_GLOBAL",       INT2NUM(NC_GLOBAL));
+  rb_define_const(mNetCDF, "NC_MAX_DIMS",     INT2NUM(NC_MAX_DIMS));
+  rb_define_const(mNetCDF, "NC_MAX_ATTRS",     INT2NUM(NC_MAX_ATTRS));
+  rb_define_const(mNetCDF, "NC_MAX_VARS",     INT2NUM(NC_MAX_VARS));
+  rb_define_const(mNetCDF, "NC_MAX_NAME",     INT2NUM(NC_MAX_NAME));
+  rb_define_const(mNetCDF, "NC_MAX_VAR_DIMS", INT2NUM(NC_MAX_VAR_DIMS));
+  rb_define_const(mNetCDF, "NC_FILL",         INT2NUM(NC_FILL));
+  rb_define_const(mNetCDF, "NC_NOFILL",       INT2NUM(NC_NOFILL));
+
+  rb_define_const(mNetCDF, "NC_ENDIAN_NATIVE",         INT2NUM(NC_ENDIAN_NATIVE));
+  rb_define_const(mNetCDF, "NC_ENDIAN_LITTLE",         INT2NUM(NC_ENDIAN_LITTLE));
+  rb_define_const(mNetCDF, "NC_ENDIAN_BIG",         INT2NUM(NC_ENDIAN_BIG));
+
+  rb_define_const(mNetCDF, "NC_CHUNKED",      INT2NUM(NC_CHUNKED));
+  rb_define_const(mNetCDF, "NC_CONTIGUOUS",   INT2NUM(NC_CONTIGUOUS));
+
+  rb_define_const(mNetCDF, "NC_NOCHECKSUM",      INT2NUM(NC_NOCHECKSUM));
+  rb_define_const(mNetCDF, "NC_FLETCHER32",      INT2NUM(NC_FLETCHER32));
+
+  rb_define_const(mNetCDF, "NC_NOSHUFFLE",      INT2NUM(NC_NOSHUFFLE));
+  rb_define_const(mNetCDF, "NC_SHUFFLE",      INT2NUM(NC_SHUFFLE));
+
+
+  rb_define_const(mNetCDF, "NC_NAT",     INT2NUM(NC_NAT));
+  rb_define_const(mNetCDF, "NC_BYTE",    INT2NUM(NC_BYTE));
+  rb_define_const(mNetCDF, "NC_UBYTE",   INT2NUM(NC_UBYTE));
+  rb_define_const(mNetCDF, "NC_CHAR",    INT2NUM(NC_CHAR));
+  rb_define_const(mNetCDF, "NC_SHORT",   INT2NUM(NC_SHORT));
+  rb_define_const(mNetCDF, "NC_USHORT",  INT2NUM(NC_USHORT));
+  rb_define_const(mNetCDF, "NC_INT",     INT2NUM(NC_INT));
+  rb_define_const(mNetCDF, "NC_LONG",    INT2NUM(NC_LONG));
+  rb_define_const(mNetCDF, "NC_UINT",    INT2NUM(NC_UINT));
+  rb_define_const(mNetCDF, "NC_INT64",   INT2NUM(NC_INT64));
+  rb_define_const(mNetCDF, "NC_UINT64",  INT2NUM(NC_UINT64));
+  rb_define_const(mNetCDF, "NC_FLOAT",   INT2NUM(NC_FLOAT));
+  rb_define_const(mNetCDF, "NC_DOUBLE",  INT2NUM(NC_DOUBLE));
+  rb_define_const(mNetCDF, "NC_STRING",  INT2NUM(NC_STRING));
+
+//  rb_define_const(mNetCDF, "NC_",     INT2NUM(NC_));
+
+  rb_define_const(mNetCDF, "NC_VLEN",     INT2NUM(NC_VLEN));
+  rb_define_const(mNetCDF, "NC_OPAQUE",     INT2NUM(NC_OPAQUE));
+  rb_define_const(mNetCDF, "NC_ENUM",     INT2NUM(NC_ENUM));
+  rb_define_const(mNetCDF, "NC_COMPOUND",     INT2NUM(NC_COMPOUND));
+
+
+  rb_define_const(mNetCDF, "NC_FILL_BYTE",     INT2NUM(NC_FILL_BYTE));
+  rb_define_const(mNetCDF, "NC_FILL_CHAR",     INT2NUM(NC_FILL_CHAR));
+  rb_define_const(mNetCDF, "NC_FILL_SHORT",     INT2NUM(NC_FILL_SHORT));
+  rb_define_const(mNetCDF, "NC_FILL_INT",     INT2NUM(NC_FILL_INT));
+  rb_define_const(mNetCDF, "NC_FILL_FLOAT",     rb_float_new(NC_FILL_FLOAT));
+  rb_define_const(mNetCDF, "NC_FILL_DOUBLE",     rb_float_new(NC_FILL_DOUBLE));
+  rb_define_const(mNetCDF, "NC_FILL_UBYTE",     UINT2NUM(NC_FILL_UBYTE));
+  rb_define_const(mNetCDF, "NC_FILL_USHORT",     UINT2NUM(NC_FILL_USHORT));
+  rb_define_const(mNetCDF, "NC_FILL_UINT",     UINT2NUM(NC_FILL_UINT));
+  rb_define_const(mNetCDF, "NC_FILL_IN64",     LL2NUM(NC_FILL_INT64));
+  rb_define_const(mNetCDF, "NC_FILL_UIN64",     ULL2NUM(NC_FILL_INT64));
+  rb_define_const(mNetCDF, "NC_FILL_STRING",     rb_str_new2(NC_FILL_STRING));
 
 }