carray-netcdf 1.0.4 → 1.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 19f1abb99ae79c059426a1323e0fb028dd669f556b993cd6b5823263fa19e281
4
- data.tar.gz: cc84704439ad231e340dc5a2bb4e3fae86496037008102458bf3634ec8dcd10b
3
+ metadata.gz: 6d15da63f025da8ee09c9ad58b7d62ad8c7864fbeb88dde9baa35610154d419a
4
+ data.tar.gz: f049d0e22dd10c6d68b5b1292be3c22ecff4427397acd405945daa720ee425f6
5
5
  SHA512:
6
- metadata.gz: fd1842a3d39729174629d8912ead0714b64c917dc99c888d750419edf5cf6c1e15e33d6f1b6ec8ce0557565bffa8588186ca9b2b07b6b27ceef54d8d2be14495
7
- data.tar.gz: fea6389e64aa7728dfa71bc88ad8267af0749d2e419085f50c22cdc47b64bdf806c6b6e0109d71f3907e4f582dd73a8ab26093e6d69e5c92a5eeeaa234802224
6
+ metadata.gz: 6db9c2ae9e3e1236c0f5a1fa54397df2d843017467d9c1507e09487889b3290bf422273852529211f48e1cc8cc6177c3666afc7f561914c1fdc4c235c9068071
7
+ data.tar.gz: 73756a1b34dc1445825c6bc9b69f0a64e979c55c754d6cbf6791374f2fd8dd23503be29143c140292626d2c0a4151b7396e43320f815536ca25c0eb87198686a
data/bin/ncdef2yaml ADDED
@@ -0,0 +1,60 @@
1
+ #!/usr/bin/env ruby
2
+
3
+ require "carray-netcdf"
4
+ require "yaml"
5
+
6
+ NC_DATA_TYPES = ["char","byte","short","int","float","double"]
7
+
8
+ module Psych
9
+ module Visitors
10
+ class YAMLTree < Psych::Visitors::Visitor
11
+ alias_method :emit_coder_orig, :emit_coder
12
+ def emit_coder c, o
13
+ case c.type
14
+ when :seq
15
+ @emitter.start_sequence nil, c.tag, c.tag.nil?, c.style
16
+ c.seq.each do |thing|
17
+ accept thing
18
+ end
19
+ @emitter.end_sequence
20
+ else
21
+ emit_coder_orig c, o
22
+ end
23
+ end
24
+ end
25
+ end
26
+ end
27
+
28
+ class Hash
29
+ def encode_with(coder)
30
+ if NC_DATA_TYPES.include?(self.first[0])
31
+ coder.style = Psych::Nodes::Mapping::FLOW
32
+ end
33
+ coder.tag = nil
34
+ coder.map = self
35
+ end
36
+ end
37
+
38
+ class Array
39
+
40
+ def encode_with (coder)
41
+ if self.all?{|v| Numeric===v or String===v}
42
+ coder.style = Psych::Nodes::Mapping::FLOW
43
+ end
44
+ coder.tag = nil
45
+ coder.seq = self
46
+ end
47
+
48
+ end
49
+
50
+ class String
51
+
52
+ def to_yaml
53
+ return self
54
+ end
55
+
56
+ end
57
+
58
+ nc = NCFile.open(ARGV[0])
59
+
60
+ puts nc.definition.to_yaml
@@ -1,6 +1,6 @@
1
1
 
2
2
  Gem::Specification::new do |s|
3
- version = "1.0.4"
3
+ version = "1.0.7"
4
4
 
5
5
  files = Dir.glob("**/*") - [
6
6
  Dir.glob("carray-*.gem"),
@@ -18,5 +18,6 @@ Gem::Specification::new do |s|
18
18
  s.homepage = 'https://github.com/himotoyoshi/carray-netcdf'
19
19
  s.files = files
20
20
  s.extensions = [ "extconf.rb" ]
21
+ s.executables << 'ncdef2yaml'
21
22
  s.required_ruby_version = ">= 1.8.1"
22
23
  end
data/lib/io/netcdf.rb CHANGED
@@ -346,7 +346,7 @@ class NCDim < NCObject
346
346
  end
347
347
 
348
348
  def to_i
349
- return @len
349
+ return @dim_id
350
350
  end
351
351
 
352
352
  def to_ca
@@ -419,7 +419,7 @@ class NCFile < NCObject
419
419
  case value.data_type
420
420
  when CA_UINT8
421
421
  value = { "char" => value[0] }
422
- when CA_BYTE
422
+ when CA_INT8
423
423
  value = { "byte" => value[0] }
424
424
  when CA_SHORT
425
425
  value = { "short" => value[0] }
@@ -434,7 +434,7 @@ class NCFile < NCObject
434
434
  case value.data_type
435
435
  when CA_UINT8
436
436
  value = { "char" => value.to_a }
437
- when CA_BYTE
437
+ when CA_INT8
438
438
  value = { "byte" => value.to_a }
439
439
  when CA_SHORT
440
440
  value = { "short" => value.to_a }
@@ -511,8 +511,8 @@ class NCFileWriter
511
511
  end
512
512
  @dims = definition["dim"]
513
513
  if @dims
514
- @shape = @dims.map{|key| @ncfile.dim(key).to_i }
515
- dim_ids = @dims.map{|key| @ncfile.dim(key).dim_id }
514
+ @shape = @dims.map{|key| @ncfile.dim(key).len }
515
+ dim_ids = @dims.map{|key| @ncfile.dim(key).to_i }
516
516
  else
517
517
  dim_ids = []
518
518
  end
@@ -542,6 +542,10 @@ class NCFileWriter
542
542
 
543
543
  attr_reader :name, :type, :attributes
544
544
 
545
+ def to_i
546
+ return @var_id
547
+ end
548
+
545
549
  def []= (*argv)
546
550
  put(*argv)
547
551
  end
@@ -610,7 +614,6 @@ class NCFileWriter
610
614
  return nc_put_varm(@file_id, @var_id, start, count, stride, imap, value)
611
615
  end
612
616
 
613
-
614
617
  end
615
618
 
616
619
  class Dim
@@ -629,10 +632,10 @@ class NCFileWriter
629
632
  end
630
633
  end
631
634
 
632
- attr_reader :name, :dim_id
635
+ attr_reader :name, :len
633
636
 
634
637
  def to_i
635
- return @len
638
+ return @dim_id
636
639
  end
637
640
 
638
641
  end
@@ -736,7 +739,7 @@ class NCFileWriter
736
739
  when "char"
737
740
  value = CA_UINT8(value)
738
741
  when "byte"
739
- value = CA_BYTE(value)
742
+ value = CA_INT8(value)
740
743
  when "short"
741
744
  value = CA_SHORT(value)
742
745
  when "int"
data/rb_netcdflib.c CHANGED
@@ -49,13 +49,23 @@ rb_nc_typemap (nc_type nc_type)
49
49
  {
50
50
  switch ( nc_type ) {
51
51
  case NC_CHAR:
52
- return CA_INT8;
52
+ return CA_UINT8;
53
53
  case NC_BYTE:
54
+ return CA_INT8;
55
+ case NC_UBYTE:
54
56
  return CA_UINT8;
55
57
  case NC_SHORT:
56
58
  return CA_INT16;
59
+ case NC_USHORT:
60
+ return CA_UINT16;
57
61
  case NC_INT:
58
62
  return CA_INT32;
63
+ case NC_UINT:
64
+ return CA_UINT32;
65
+ case NC_INT64:
66
+ return CA_INT64;
67
+ case NC_UINT64:
68
+ return CA_UINT64;
59
69
  case NC_FLOAT:
60
70
  return CA_FLOAT32;
61
71
  case NC_DOUBLE:
@@ -72,15 +82,25 @@ rb_nc_rtypemap (int ca_type)
72
82
  case CA_INT8:
73
83
  return NC_BYTE;
74
84
  case CA_UINT8:
75
- return NC_BYTE;
85
+ return NC_UBYTE;
76
86
  case CA_INT16:
77
87
  return NC_SHORT;
88
+ case CA_UINT16:
89
+ return NC_USHORT;
78
90
  case CA_INT32:
79
91
  return NC_INT;
92
+ case CA_UINT32:
93
+ return NC_UINT;
94
+ case CA_INT64:
95
+ return NC_INT64;
96
+ case CA_UINT64:
97
+ return NC_UINT64;
80
98
  case CA_FLOAT32:
81
99
  return NC_FLOAT;
82
100
  case CA_FLOAT64:
83
101
  return NC_DOUBLE;
102
+ case CA_FIXLEN:
103
+ return NC_STRING;
84
104
  default:
85
105
  rb_raise(rb_eRuntimeError, "invalid CA_TYPE");
86
106
  }
@@ -94,7 +114,7 @@ rb_nc_ca_type (int argc, VALUE *argv, VALUE mod)
94
114
  CHECK_ARGC(1);
95
115
  CHECK_TYPE_INT(argv[0]);
96
116
 
97
- type = rb_nc_typemap(NUM2LONG(argv[0]));
117
+ type = rb_nc_typemap(NUM2INT(argv[0]));
98
118
 
99
119
  return LONG2NUM(type);
100
120
  }
@@ -107,7 +127,7 @@ rb_nc_nc_type (int argc, VALUE *argv, VALUE mod)
107
127
  CHECK_ARGC(1);
108
128
  CHECK_TYPE_INT(argv[0]);
109
129
 
110
- type = rb_nc_rtypemap(NUM2LONG(argv[0]));
130
+ type = rb_nc_rtypemap(NUM2INT(argv[0]));
111
131
 
112
132
  return LONG2NUM(type);
113
133
  }
@@ -126,15 +146,57 @@ rb_nc_create (int argc, VALUE *argv, VALUE mod)
126
146
  if ( argc == 1 ) {
127
147
  status = nc_create(StringValuePtr(argv[0]), NC_CLOBBER, &nc_id);
128
148
  }
149
+ else if ( argc == 2 ) {
150
+ CHECK_TYPE_INT(argv[1]);
151
+ status = nc_create(StringValuePtr(argv[0]), NUM2INT(argv[1]), &nc_id);
152
+ }
129
153
  else {
154
+ rb_raise(rb_eArgError, "too many argument");
155
+ }
156
+
157
+ CHECK_STATUS(status);
158
+
159
+ return LONG2NUM(nc_id);
160
+ }
161
+
162
+ /*
163
+ static VALUE
164
+ rb_nc_create_mem (int argc, VALUE *argv, VALUE mod)
165
+ {
166
+ int status, nc_id;
167
+ if ( argc < 1 ) {
168
+ rb_raise(rb_eArgError, "invalid # of arguments");
169
+ }
170
+
171
+ CHECK_TYPE_STRING(argv[0]);
172
+
173
+ if ( argc == 1 ) {
174
+ status = nc_create_mem(StringValuePtr(argv[0]), NC_CLOBBER, NC_SIZEHINT_DEFAULT, &nc_id);
175
+ }
176
+ else if ( argc == 2 ) {
177
+ CHECK_TYPE_INT(argv[1]);
178
+ status = nc_create_mem(StringValuePtr(argv[0]),
179
+ NUM2INT(argv[1]),
180
+ NC_SIZEHINT_DEFAULT,
181
+ &nc_id);
182
+ }
183
+ else if ( argc == 3 ) {
130
184
  CHECK_TYPE_INT(argv[1]);
131
- status = nc_create(StringValuePtr(argv[0]), NUM2LONG(argv[1]), &nc_id);
185
+ CHECK_TYPE_INT(argv[2]);
186
+ status = nc_create_mem(StringValuePtr(argv[0]),
187
+ NUM2INT(argv[1]),
188
+ NUM2INT(argv[2]),
189
+ &nc_id);
190
+ }
191
+ else {
192
+ rb_raise(rb_eArgError, "too many argument");
132
193
  }
133
194
 
134
195
  CHECK_STATUS(status);
135
196
 
136
197
  return LONG2NUM(nc_id);
137
198
  }
199
+ */
138
200
 
139
201
  static VALUE
140
202
  rb_nc_open (int argc, VALUE *argv, VALUE mod)
@@ -150,9 +212,12 @@ rb_nc_open (int argc, VALUE *argv, VALUE mod)
150
212
  if ( argc == 1 ) {
151
213
  status = nc_open(StringValuePtr(argv[0]), NC_NOWRITE, &nc_id);
152
214
  }
153
- else {
215
+ else if ( argc == 2 ) {
154
216
  CHECK_TYPE_INT(argv[1]);
155
- status = nc_open(StringValuePtr(argv[0]), NUM2LONG(argv[1]), &nc_id);
217
+ status = nc_open(StringValuePtr(argv[0]), NUM2INT(argv[1]), &nc_id);
218
+ }
219
+ else {
220
+ rb_raise(rb_eArgError, "too many argument");
156
221
  }
157
222
 
158
223
  CHECK_STATUS(status);
@@ -168,7 +233,7 @@ rb_nc_close (int argc, VALUE *argv, VALUE mod)
168
233
  CHECK_ARGC(1);
169
234
  CHECK_TYPE_ID(argv[0]);
170
235
 
171
- status = nc_close(NUM2LONG(argv[0]));
236
+ status = nc_close(NUM2INT(argv[0]));
172
237
 
173
238
  CHECK_STATUS(status);
174
239
 
@@ -183,7 +248,7 @@ rb_nc_redef (int argc, VALUE *argv, VALUE mod)
183
248
  CHECK_ARGC(1);
184
249
  CHECK_TYPE_ID(argv[0]);
185
250
 
186
- status = nc_redef(NUM2LONG(argv[0]));
251
+ status = nc_redef(NUM2INT(argv[0]));
187
252
 
188
253
  CHECK_STATUS(status);
189
254
 
@@ -198,7 +263,7 @@ rb_nc_enddef (int argc, VALUE *argv, VALUE mod)
198
263
  CHECK_ARGC(1);
199
264
  CHECK_TYPE_ID(argv[0]);
200
265
 
201
- status = nc_enddef(NUM2LONG(argv[0]));
266
+ status = nc_enddef(NUM2INT(argv[0]));
202
267
 
203
268
  CHECK_STATUS(status);
204
269
 
@@ -213,7 +278,7 @@ rb_nc_sync (int argc, VALUE *argv, VALUE mod)
213
278
  CHECK_ARGC(1);
214
279
  CHECK_TYPE_ID(argv[0]);
215
280
 
216
- status = nc_sync(NUM2LONG(argv[0]));
281
+ status = nc_sync(NUM2INT(argv[0]));
217
282
 
218
283
  CHECK_STATUS(status);
219
284
 
@@ -228,7 +293,7 @@ rb_nc_inq_ndims (int argc, VALUE *argv, VALUE mod)
228
293
  CHECK_ARGC(1);
229
294
  CHECK_TYPE_ID(argv[0]);
230
295
 
231
- status = nc_inq_ndims(NUM2LONG(argv[0]), &ndims);
296
+ status = nc_inq_ndims(NUM2INT(argv[0]), &ndims);
232
297
 
233
298
  CHECK_STATUS(status);
234
299
 
@@ -243,7 +308,7 @@ rb_nc_inq_nvars (int argc, VALUE *argv, VALUE mod)
243
308
  CHECK_ARGC(1);
244
309
  CHECK_TYPE_ID(argv[0]);
245
310
 
246
- status = nc_inq_nvars(NUM2LONG(argv[0]), &nvars);
311
+ status = nc_inq_nvars(NUM2INT(argv[0]), &nvars);
247
312
 
248
313
  CHECK_STATUS(status);
249
314
 
@@ -258,7 +323,7 @@ rb_nc_inq_natts (int argc, VALUE *argv, VALUE mod)
258
323
  CHECK_ARGC(1);
259
324
  CHECK_TYPE_ID(argv[0]);
260
325
 
261
- status = nc_inq_natts(NUM2LONG(argv[0]), &natts);
326
+ status = nc_inq_natts(NUM2INT(argv[0]), &natts);
262
327
 
263
328
  CHECK_STATUS(status);
264
329
 
@@ -273,7 +338,7 @@ rb_nc_inq_unlimdim (int argc, VALUE *argv, VALUE mod)
273
338
  CHECK_ARGC(1);
274
339
  CHECK_TYPE_ID(argv[0]);
275
340
 
276
- status = nc_inq_unlimdim(NUM2LONG(argv[0]), &uldim);
341
+ status = nc_inq_unlimdim(NUM2INT(argv[0]), &uldim);
277
342
 
278
343
  CHECK_STATUS(status);
279
344
 
@@ -289,7 +354,7 @@ rb_nc_inq_dimid (int argc, VALUE *argv, VALUE mod)
289
354
  CHECK_TYPE_ID(argv[0]);
290
355
  CHECK_TYPE_STRING(argv[1]);
291
356
 
292
- status = nc_inq_dimid(NUM2LONG(argv[0]), StringValuePtr(argv[1]), &dimid);
357
+ status = nc_inq_dimid(NUM2INT(argv[0]), StringValuePtr(argv[1]), &dimid);
293
358
 
294
359
  return ( status != NC_NOERR ) ? Qnil : LONG2NUM(dimid);
295
360
  }
@@ -303,7 +368,7 @@ rb_nc_inq_varid (int argc, VALUE *argv, VALUE mod)
303
368
  CHECK_TYPE_ID(argv[0]);
304
369
  CHECK_TYPE_STRING(argv[1]);
305
370
 
306
- status = nc_inq_varid(NUM2LONG(argv[0]), StringValuePtr(argv[1]), &varid);
371
+ status = nc_inq_varid(NUM2INT(argv[0]), StringValuePtr(argv[1]), &varid);
307
372
 
308
373
  return ( status != NC_NOERR ) ? Qnil : LONG2NUM(varid);
309
374
  }
@@ -318,7 +383,7 @@ rb_nc_inq_attid (int argc, VALUE *argv, VALUE mod)
318
383
  CHECK_TYPE_ID(argv[1]);
319
384
  CHECK_TYPE_STRING(argv[2]);
320
385
 
321
- status = nc_inq_attid(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
386
+ status = nc_inq_attid(NUM2INT(argv[0]), NUM2INT(argv[1]),
322
387
  StringValuePtr(argv[2]), &attid);
323
388
 
324
389
  return ( status != NC_NOERR ) ? Qnil : LONG2NUM(attid);
@@ -334,7 +399,7 @@ rb_nc_inq_dimlen (int argc, VALUE *argv, VALUE mod)
334
399
  CHECK_TYPE_ID(argv[0]);
335
400
  CHECK_TYPE_ID(argv[1]);
336
401
 
337
- status = nc_inq_dimlen(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &dimlen);
402
+ status = nc_inq_dimlen(NUM2INT(argv[0]), NUM2INT(argv[1]), &dimlen);
338
403
 
339
404
  CHECK_STATUS(status);
340
405
 
@@ -351,7 +416,7 @@ rb_nc_inq_dimname (int argc, VALUE *argv, VALUE mod)
351
416
  CHECK_TYPE_ID(argv[0]);
352
417
  CHECK_TYPE_ID(argv[1]);
353
418
 
354
- status = nc_inq_dimname(NUM2LONG(argv[0]), NUM2LONG(argv[1]), dimname);
419
+ status = nc_inq_dimname(NUM2INT(argv[0]), NUM2INT(argv[1]), dimname);
355
420
 
356
421
  CHECK_STATUS(status);
357
422
 
@@ -368,7 +433,7 @@ rb_nc_inq_varname (int argc, VALUE *argv, VALUE mod)
368
433
  CHECK_TYPE_ID(argv[0]);
369
434
  CHECK_TYPE_ID(argv[1]);
370
435
 
371
- status = nc_inq_varname(NUM2LONG(argv[0]), NUM2LONG(argv[1]), varname);
436
+ status = nc_inq_varname(NUM2INT(argv[0]), NUM2INT(argv[1]), varname);
372
437
 
373
438
  CHECK_STATUS(status);
374
439
 
@@ -385,7 +450,7 @@ rb_nc_inq_vartype (int argc, VALUE *argv, VALUE mod)
385
450
  CHECK_TYPE_ID(argv[0]);
386
451
  CHECK_TYPE_ID(argv[1]);
387
452
 
388
- status = nc_inq_vartype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &type);
453
+ status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
389
454
 
390
455
  CHECK_STATUS(status);
391
456
 
@@ -401,7 +466,7 @@ rb_nc_inq_varndims (int argc, VALUE *argv, VALUE mod)
401
466
  CHECK_TYPE_ID(argv[0]);
402
467
  CHECK_TYPE_ID(argv[1]);
403
468
 
404
- status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
469
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
405
470
 
406
471
  CHECK_STATUS(status);
407
472
 
@@ -421,11 +486,11 @@ rb_nc_inq_vardimid (int argc, VALUE *argv, VALUE mod)
421
486
  CHECK_TYPE_ID(argv[0]); /* nc_id */
422
487
  CHECK_TYPE_ID(argv[1]); /* var_id */
423
488
 
424
- status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
489
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
425
490
 
426
491
  CHECK_STATUS(status);
427
492
 
428
- status = nc_inq_vardimid(NUM2LONG(argv[0]), NUM2LONG(argv[1]), dimid);
493
+ status = nc_inq_vardimid(NUM2INT(argv[0]), NUM2INT(argv[1]), dimid);
429
494
 
430
495
  CHECK_STATUS(status);
431
496
 
@@ -446,7 +511,7 @@ rb_nc_inq_varnatts (int argc, VALUE *argv, VALUE mod)
446
511
  CHECK_TYPE_ID(argv[0]);
447
512
  CHECK_TYPE_ID(argv[1]);
448
513
 
449
- status = nc_inq_varnatts(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &natts);
514
+ status = nc_inq_varnatts(NUM2INT(argv[0]), NUM2INT(argv[1]), &natts);
450
515
 
451
516
  CHECK_STATUS(status);
452
517
 
@@ -465,8 +530,8 @@ rb_nc_inq_attname (int argc, VALUE *argv, VALUE mod)
465
530
  CHECK_TYPE_ID(argv[1]);
466
531
  CHECK_TYPE_ID(argv[2]);
467
532
 
468
- status = nc_inq_attname(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
469
- NUM2LONG(argv[2]), attname);
533
+ status = nc_inq_attname(NUM2INT(argv[0]), NUM2INT(argv[1]),
534
+ NUM2INT(argv[2]), attname);
470
535
 
471
536
  CHECK_STATUS(status);
472
537
 
@@ -484,7 +549,7 @@ rb_nc_inq_atttype (int argc, VALUE *argv, VALUE mod)
484
549
  CHECK_TYPE_ID(argv[1]);
485
550
  CHECK_TYPE_STRING(argv[2]);
486
551
 
487
- status = nc_inq_atttype(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
552
+ status = nc_inq_atttype(NUM2INT(argv[0]), NUM2INT(argv[1]),
488
553
  StringValuePtr(argv[2]), &type);
489
554
 
490
555
  CHECK_STATUS(status);
@@ -503,7 +568,7 @@ rb_nc_inq_attlen (int argc, VALUE *argv, VALUE mod)
503
568
  CHECK_TYPE_ID(argv[1]);
504
569
  CHECK_TYPE_STRING(argv[2]);
505
570
 
506
- status = nc_inq_attlen(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
571
+ status = nc_inq_attlen(NUM2INT(argv[0]), NUM2INT(argv[1]),
507
572
  StringValuePtr(argv[2]), &len);
508
573
 
509
574
  CHECK_STATUS(status);
@@ -521,14 +586,268 @@ rb_nc_def_dim (int argc, VALUE *argv, VALUE mod)
521
586
  CHECK_TYPE_STRING(argv[1]);
522
587
  CHECK_TYPE_INT(argv[2]);
523
588
 
524
- status = nc_def_dim(NUM2LONG(argv[0]), StringValuePtr(argv[1]),
525
- NUM2LONG(argv[2]), &dimid);
589
+ status = nc_def_dim(NUM2INT(argv[0]), StringValuePtr(argv[1]),
590
+ NUM2INT(argv[2]), &dimid);
526
591
 
527
592
  CHECK_STATUS(status);
528
593
 
529
594
  return LONG2NUM(dimid);
530
595
  }
531
596
 
597
+ static VALUE
598
+ rb_nc_def_grp (int argc, VALUE *argv, VALUE mod)
599
+ {
600
+ int status, grpid;
601
+
602
+ CHECK_ARGC(2);
603
+ CHECK_TYPE_ID(argv[0]);
604
+ CHECK_TYPE_STRING(argv[1]);
605
+
606
+ status = nc_def_grp(NUM2INT(argv[0]), StringValuePtr(argv[1]),
607
+ &grpid);
608
+
609
+ CHECK_STATUS(status);
610
+
611
+ return LONG2NUM(grpid);
612
+ }
613
+
614
+ static VALUE
615
+ rb_nc_inq_ncid (int argc, VALUE *argv, VALUE mod)
616
+ {
617
+ int status, ncid;
618
+
619
+ CHECK_ARGC(2);
620
+ CHECK_TYPE_ID(argv[0]);
621
+ CHECK_TYPE_STRING(argv[1]);
622
+
623
+ status = nc_inq_ncid(NUM2INT(argv[0]), StringValuePtr(argv[1]),
624
+ &ncid);
625
+
626
+ CHECK_STATUS(status);
627
+
628
+ return LONG2NUM(ncid);
629
+ }
630
+
631
+
632
+ static VALUE
633
+ rb_nc_inq_grp_full_ncid (int argc, VALUE *argv, VALUE mod)
634
+ {
635
+ int status, ncid;
636
+
637
+ CHECK_ARGC(2);
638
+ CHECK_TYPE_ID(argv[0]);
639
+ CHECK_TYPE_STRING(argv[1]);
640
+
641
+ status = nc_inq_grp_full_ncid(NUM2INT(argv[0]), StringValuePtr(argv[1]),
642
+ &ncid);
643
+
644
+ CHECK_STATUS(status);
645
+
646
+ return LONG2NUM(ncid);
647
+ }
648
+
649
+
650
+ static VALUE
651
+ rb_nc_inq_grp_ncid (int argc, VALUE *argv, VALUE mod)
652
+ {
653
+ int status, ncid;
654
+
655
+ CHECK_ARGC(2);
656
+ CHECK_TYPE_ID(argv[0]);
657
+ CHECK_TYPE_STRING(argv[1]);
658
+
659
+ status = nc_inq_grp_ncid(NUM2INT(argv[0]), StringValuePtr(argv[1]),
660
+ &ncid);
661
+
662
+ CHECK_STATUS(status);
663
+
664
+ return LONG2NUM(ncid);
665
+ }
666
+
667
+ static VALUE
668
+ rb_nc_inq_grp_parent (int argc, VALUE *argv, VALUE mod)
669
+ {
670
+ int parent;
671
+ int status;
672
+
673
+ CHECK_ARGC(1);
674
+ CHECK_TYPE_ID(argv[0]);
675
+
676
+ status = nc_inq_grp_parent(NUM2INT(argv[0]), &parent);
677
+
678
+ CHECK_STATUS(status);
679
+
680
+ return ULONG2NUM(parent);
681
+ }
682
+
683
+ static VALUE
684
+ rb_nc_inq_grpname (int argc, VALUE *argv, VALUE mod)
685
+ {
686
+ int status;
687
+ char grpname[NC_MAX_NAME];
688
+
689
+ CHECK_ARGC(1);
690
+ CHECK_TYPE_ID(argv[0]);
691
+
692
+ status = nc_inq_grpname(NUM2INT(argv[0]), grpname);
693
+
694
+ CHECK_STATUS(status);
695
+
696
+ return rb_str_new2(grpname);
697
+ }
698
+
699
+ static VALUE
700
+ rb_nc_inq_grpname_full (int argc, VALUE *argv, VALUE mod)
701
+ {
702
+ int status;
703
+ size_t len;
704
+ char grpname[NC_MAX_NAME];
705
+
706
+ CHECK_ARGC(1);
707
+ CHECK_TYPE_ID(argv[0]);
708
+
709
+ status = nc_inq_grpname_full(NUM2INT(argv[0]), &len, grpname);
710
+
711
+ CHECK_STATUS(status);
712
+
713
+ return rb_str_new2(grpname);
714
+ }
715
+
716
+ static VALUE
717
+ rb_nc_inq_grpname_len (int argc, VALUE *argv, VALUE mod)
718
+ {
719
+ int status;
720
+ size_t len;
721
+
722
+ CHECK_ARGC(2);
723
+ CHECK_TYPE_ID(argv[0]);
724
+ CHECK_TYPE_STRING(argv[1]);
725
+
726
+ status = nc_inq_grpname_len(NUM2INT(argv[0]), &len);
727
+
728
+ CHECK_STATUS(status);
729
+
730
+ return LONG2NUM(len);
731
+ }
732
+
733
+ static VALUE
734
+ rb_nc_inq_grps (int argc, VALUE *argv, VALUE mod)
735
+ {
736
+ volatile VALUE rgrps;
737
+ int grps[NC_MAX_DIMS];
738
+ int i, ngrps;
739
+ int status;
740
+
741
+ CHECK_ARGC(1);
742
+ CHECK_TYPE_ID(argv[0]); /* nc_id */
743
+
744
+ status = nc_inq_grps(NUM2INT(argv[0]),
745
+ &ngrps,
746
+ grps);
747
+
748
+ CHECK_STATUS(status);
749
+
750
+ rgrps = rb_ary_new();
751
+ for (i=0; i<ngrps; i++) {
752
+ rb_ary_store(rgrps, i, ULONG2NUM(grps[i]));
753
+ }
754
+
755
+ return rgrps;
756
+ }
757
+
758
+
759
+ static VALUE
760
+ rb_nc_inq_dimids (int argc, VALUE *argv, VALUE mod)
761
+ {
762
+ volatile VALUE rdimids;
763
+ int dimids[NC_MAX_DIMS];
764
+ int i, ndims;
765
+ int status;
766
+
767
+ CHECK_ARGC(2);
768
+ CHECK_TYPE_ID(argv[0]); /* nc_id */
769
+ CHECK_TYPE_ID(argv[1]); /* nc_id */
770
+
771
+ status = nc_inq_dimids(NUM2INT(argv[0]),
772
+ &ndims,
773
+ dimids,
774
+ NUM2INT(argv[1]));
775
+
776
+ CHECK_STATUS(status);
777
+
778
+ rdimids = rb_ary_new();
779
+ for (i=0; i<ndims; i++) {
780
+ rb_ary_store(rdimids, i, ULONG2NUM(dimids[i]));
781
+ }
782
+
783
+ return rdimids;
784
+ }
785
+
786
+ static VALUE
787
+ rb_nc_inq_varids (int argc, VALUE *argv, VALUE mod)
788
+ {
789
+ volatile VALUE rvarids;
790
+ int varids[NC_MAX_DIMS];
791
+ int i, nvars;
792
+ int status;
793
+
794
+ CHECK_ARGC(1);
795
+ CHECK_TYPE_ID(argv[0]); /* nc_id */
796
+
797
+ status = nc_inq_varids(NUM2INT(argv[0]),
798
+ &nvars,
799
+ varids);
800
+
801
+ CHECK_STATUS(status);
802
+
803
+ rvarids = rb_ary_new();
804
+ for (i=0; i<nvars; i++) {
805
+ rb_ary_store(rvarids, i, ULONG2NUM(varids[i]));
806
+ }
807
+
808
+ return rvarids;
809
+ }
810
+
811
+ static VALUE
812
+ rb_nc_inq_typeids (int argc, VALUE *argv, VALUE mod)
813
+ {
814
+ volatile VALUE rtypeids;
815
+ int typeids[NC_MAX_DIMS];
816
+ int i, ntypes;
817
+ int status;
818
+
819
+ CHECK_ARGC(1);
820
+ CHECK_TYPE_ID(argv[0]); /* nc_id */
821
+
822
+ status = nc_inq_typeids(NUM2INT(argv[0]),
823
+ &ntypes,
824
+ typeids);
825
+
826
+ CHECK_STATUS(status);
827
+
828
+ rtypeids = rb_ary_new();
829
+ for (i=0; i<ntypes; i++) {
830
+ rb_ary_store(rtypeids, i, ULONG2NUM(typeids[i]));
831
+ }
832
+
833
+ return rtypeids;
834
+ }
835
+
836
+ static VALUE
837
+ rb_nc_show_metadata (int argc, VALUE *argv, VALUE mod)
838
+ {
839
+ int status;
840
+
841
+ CHECK_ARGC(1);
842
+ CHECK_TYPE_ID(argv[0]); /* nc_id */
843
+
844
+ status = nc_show_metadata(NUM2INT(argv[0]));
845
+
846
+ CHECK_STATUS(status);
847
+
848
+ return Qnil;
849
+ }
850
+
532
851
  static VALUE
533
852
  rb_nc_def_var (int argc, VALUE *argv, VALUE mod)
534
853
  {
@@ -546,19 +865,88 @@ rb_nc_def_var (int argc, VALUE *argv, VALUE mod)
546
865
 
547
866
  vdim = argv[3];
548
867
 
549
- ndims = RARRAY_LEN(vdim);
868
+ ndims = (int) RARRAY_LEN(vdim);
550
869
  for (i=0; i<ndims; i++) {
551
- dimids[i] = NUM2LONG(RARRAY_PTR(vdim)[i]);
870
+ dimids[i] = NUM2INT(RARRAY_PTR(vdim)[i]);
552
871
  }
553
872
 
554
- status = nc_def_var(NUM2LONG(argv[0]), StringValuePtr(argv[1]),
555
- NUM2LONG(argv[2]), ndims, dimids, &varid);
873
+ status = nc_def_var(NUM2INT(argv[0]), StringValuePtr(argv[1]),
874
+ NUM2INT(argv[2]), ndims, dimids, &varid);
556
875
 
557
876
  CHECK_STATUS(status);
558
877
 
559
878
  return LONG2NUM(varid);
560
879
  }
561
880
 
881
+ static VALUE
882
+ rb_nc_def_var_chunking (int argc, VALUE *argv, VALUE mod)
883
+ {
884
+ volatile VALUE vdim;
885
+ int status;
886
+ int ndims;
887
+ size_t chunksizes[NC_MAX_DIMS];
888
+ int i;
889
+
890
+ CHECK_ARGC(4);
891
+ CHECK_TYPE_ID(argv[0]);
892
+ CHECK_TYPE_ID(argv[1]);
893
+ CHECK_TYPE_INT(argv[2]);
894
+ CHECK_TYPE_ARRAY(argv[3]);
895
+
896
+ vdim = argv[3];
897
+
898
+ ndims = (int) RARRAY_LEN(vdim);
899
+ for (i=0; i<ndims; i++) {
900
+ chunksizes[i] = NUM2INT(RARRAY_PTR(vdim)[i]);
901
+ }
902
+
903
+ status = nc_def_var_chunking(NUM2INT(argv[0]),
904
+ NUM2INT(argv[1]),
905
+ NUM2INT(argv[2]),
906
+ chunksizes);
907
+
908
+ CHECK_STATUS(status);
909
+
910
+ return Qnil;
911
+ }
912
+
913
+ static VALUE
914
+ rb_nc_inq_var_chunking (int argc, VALUE *argv, VALUE mod)
915
+ {
916
+ volatile VALUE retval;
917
+ volatile VALUE rchunksize;
918
+ int storage;
919
+ size_t chunksizes[NC_MAX_DIMS];
920
+ int i, ndims;
921
+ int status;
922
+
923
+ CHECK_ARGC(2);
924
+ CHECK_TYPE_ID(argv[0]); /* nc_id */
925
+ CHECK_TYPE_ID(argv[1]); /* var_id */
926
+
927
+ status = nc_inq_var_chunking(NUM2INT(argv[0]),
928
+ NUM2INT(argv[1]),
929
+ &storage,
930
+ chunksizes);
931
+
932
+ CHECK_STATUS(status);
933
+
934
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
935
+
936
+ CHECK_STATUS(status);
937
+
938
+ rchunksize = rb_ary_new();
939
+ for (i=0; i<ndims; i++) {
940
+ rb_ary_store(rchunksize, i, ULONG2NUM(chunksizes[i]));
941
+ }
942
+
943
+ retval = rb_ary_new();
944
+ rb_ary_store(retval, 0, ULONG2NUM(storage));
945
+ rb_ary_store(retval, 1, rchunksize);
946
+
947
+ return retval;
948
+ }
949
+
562
950
  static VALUE
563
951
  rb_nc_def_var_deflate (int argc, VALUE *argv, VALUE mod)
564
952
  {
@@ -571,8 +959,8 @@ rb_nc_def_var_deflate (int argc, VALUE *argv, VALUE mod)
571
959
  CHECK_TYPE_INT(argv[3]);
572
960
  CHECK_TYPE_INT(argv[4]);
573
961
 
574
- status = nc_def_var_deflate(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
575
- NUM2LONG(argv[2]), NUM2LONG(argv[3]), NUM2LONG(argv[4]));
962
+ status = nc_def_var_deflate(NUM2INT(argv[0]), NUM2INT(argv[1]),
963
+ NUM2INT(argv[2]), NUM2INT(argv[3]), NUM2INT(argv[4]));
576
964
 
577
965
 
578
966
  CHECK_STATUS(status);
@@ -591,7 +979,7 @@ rb_nc_inq_var_deflate (int argc, VALUE *argv, VALUE mod)
591
979
  CHECK_TYPE_ID(argv[0]); /* nc_id */
592
980
  CHECK_TYPE_ID(argv[1]); /* var_id */
593
981
 
594
- status = nc_inq_var_deflate(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
982
+ status = nc_inq_var_deflate(NUM2INT(argv[0]), NUM2INT(argv[1]),
595
983
  &shuffle, &deflate, &deflate_level);
596
984
 
597
985
  CHECK_STATUS(status);
@@ -615,7 +1003,7 @@ rb_nc_del_att (int argc, VALUE *argv, VALUE mod)
615
1003
  CHECK_TYPE_ID(argv[1]);
616
1004
  CHECK_TYPE_STRING(argv[2]);
617
1005
 
618
- status = nc_del_att(NUM2LONG(argv[0]), NUM2LONG(argv[1]), StringValuePtr(argv[2]));
1006
+ status = nc_del_att(NUM2INT(argv[0]), NUM2INT(argv[1]), StringValuePtr(argv[2]));
619
1007
 
620
1008
  CHECK_STATUS(status);
621
1009
 
@@ -628,13 +1016,23 @@ nc_get_att_numeric (int ncid, int varid, const char name[],
628
1016
  {
629
1017
  switch (type) {
630
1018
  case NC_BYTE:
631
- return nc_get_att_uchar(ncid, varid, name, value);
632
- case NC_CHAR:
633
1019
  return nc_get_att_schar(ncid, varid, name, value);
1020
+ case NC_UBYTE:
1021
+ return nc_get_att_ubyte(ncid, varid, name, value);
1022
+ case NC_CHAR:
1023
+ return nc_get_att_uchar(ncid, varid, name, value);
634
1024
  case NC_SHORT:
635
1025
  return nc_get_att_short(ncid, varid, name, value);
1026
+ case NC_USHORT:
1027
+ return nc_get_att_ushort(ncid, varid, name, value);
636
1028
  case NC_INT:
637
1029
  return nc_get_att_int(ncid, varid, name, value);
1030
+ case NC_UINT:
1031
+ return nc_get_att_uint(ncid, varid, name, value);
1032
+ case NC_INT64:
1033
+ return nc_get_att_longlong(ncid, varid, name, value);
1034
+ case NC_UINT64:
1035
+ return nc_get_att_ulonglong(ncid, varid, name, value);
638
1036
  case NC_FLOAT:
639
1037
  return nc_get_att_float(ncid, varid, name, value);
640
1038
  case NC_DOUBLE:
@@ -650,13 +1048,23 @@ nc_put_att_numeric (int ncid, int varid, const char name[],
650
1048
  {
651
1049
  switch (type) {
652
1050
  case NC_BYTE:
653
- return nc_put_att_uchar(ncid, varid, name, xtype, len, value);
654
- case NC_CHAR:
655
1051
  return nc_put_att_schar(ncid, varid, name, xtype, len, value);
1052
+ case NC_UBYTE:
1053
+ return nc_put_att_ubyte(ncid, varid, name, xtype, len, value);
1054
+ case NC_CHAR:
1055
+ return nc_put_att_uchar(ncid, varid, name, xtype, len, value);
656
1056
  case NC_SHORT:
657
1057
  return nc_put_att_short(ncid, varid, name, xtype, len, value);
1058
+ case NC_USHORT:
1059
+ return nc_put_att_ushort(ncid, varid, name, xtype, len, value);
658
1060
  case NC_INT:
659
1061
  return nc_put_att_int(ncid, varid, name, xtype, len, value);
1062
+ case NC_UINT:
1063
+ return nc_put_att_uint(ncid, varid, name, xtype, len, value);
1064
+ case NC_INT64:
1065
+ return nc_put_att_longlong(ncid, varid, name, xtype, len, value);
1066
+ case NC_UINT64:
1067
+ return nc_put_att_longlong(ncid, varid, name, xtype, len, value);
660
1068
  case NC_FLOAT:
661
1069
  return nc_put_att_float(ncid, varid, name, xtype, len, value);
662
1070
  case NC_DOUBLE:
@@ -677,14 +1085,14 @@ rb_nc_get_att (int argc, VALUE *argv, VALUE mod)
677
1085
  CHECK_TYPE_ID(argv[1]);
678
1086
  CHECK_TYPE_STRING(argv[2]);
679
1087
 
680
- status = nc_inq_atttype(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1088
+ status = nc_inq_atttype(NUM2INT(argv[0]), NUM2INT(argv[1]),
681
1089
  StringValuePtr(argv[2]), &type);
682
1090
 
683
1091
  if ( status != NC_NOERR) {
684
1092
  return Qnil;
685
1093
  }
686
1094
 
687
- status = nc_inq_attlen(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1095
+ status = nc_inq_attlen(NUM2INT(argv[0]), NUM2INT(argv[1]),
688
1096
  StringValuePtr(argv[2]), &len);
689
1097
  CHECK_STATUS(status);
690
1098
 
@@ -692,7 +1100,7 @@ rb_nc_get_att (int argc, VALUE *argv, VALUE mod)
692
1100
 
693
1101
  if ( type == NC_CHAR ) {
694
1102
  volatile VALUE text = rb_str_new(NULL, len);
695
- status = nc_get_att_text(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1103
+ status = nc_get_att_text(NUM2INT(argv[0]), NUM2INT(argv[1]),
696
1104
  StringValuePtr(argv[2]),
697
1105
  StringValuePtr(text));
698
1106
  return text;
@@ -700,42 +1108,77 @@ rb_nc_get_att (int argc, VALUE *argv, VALUE mod)
700
1108
  else if ( len == 1 ) {
701
1109
  switch ( type ) {
702
1110
  case NC_BYTE: {
703
- uint8_t val;
704
- status = nc_get_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
705
- StringValuePtr(argv[2]), type, &val);
706
- CHECK_STATUS(status);
707
- return INT2NUM(val);
1111
+ int8_t val;
1112
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1113
+ StringValuePtr(argv[2]), type, &val);
1114
+ CHECK_STATUS(status);
1115
+ return INT2NUM(val);
1116
+ }
1117
+ case NC_UBYTE: {
1118
+ uint8_t val;
1119
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1120
+ StringValuePtr(argv[2]), type, &val);
1121
+ CHECK_STATUS(status);
1122
+ return INT2NUM(val);
708
1123
  }
709
1124
  case NC_SHORT: {
710
- int16_t val;
711
- status = nc_get_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
712
- StringValuePtr(argv[2]), type, &val);
713
- CHECK_STATUS(status);
714
- return INT2NUM(val);
1125
+ int16_t val;
1126
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1127
+ StringValuePtr(argv[2]), type, &val);
1128
+ CHECK_STATUS(status);
1129
+ return INT2NUM(val);
1130
+ }
1131
+ case NC_USHORT: {
1132
+ uint16_t val;
1133
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1134
+ StringValuePtr(argv[2]), type, &val);
1135
+ CHECK_STATUS(status);
1136
+ return INT2NUM(val);
715
1137
  }
716
1138
  case NC_INT: {
717
- int32_t val;
718
- status = nc_get_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
719
- StringValuePtr(argv[2]), type, &val);
720
- CHECK_STATUS(status);
721
- return INT2NUM(val);
1139
+ int32_t val;
1140
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1141
+ StringValuePtr(argv[2]), type, &val);
1142
+ CHECK_STATUS(status);
1143
+ return INT2NUM(val);
1144
+ }
1145
+ case NC_UINT: {
1146
+ uint32_t val;
1147
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1148
+ StringValuePtr(argv[2]), type, &val);
1149
+ CHECK_STATUS(status);
1150
+ return INT2NUM(val);
1151
+ }
1152
+ case NC_INT64: {
1153
+ int64_t val;
1154
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1155
+ StringValuePtr(argv[2]), type, &val);
1156
+ CHECK_STATUS(status);
1157
+ return INT2NUM(val);
1158
+ }
1159
+ case NC_UINT64: {
1160
+ uint64_t val;
1161
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1162
+ StringValuePtr(argv[2]), type, &val);
1163
+ CHECK_STATUS(status);
1164
+ return INT2NUM(val);
722
1165
  }
723
1166
  case NC_FLOAT: {
724
- float32_t val;
725
- status = nc_get_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
726
- StringValuePtr(argv[2]), type, &val);
727
- CHECK_STATUS(status);
728
- return rb_float_new(val);
1167
+ float32_t val;
1168
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1169
+ StringValuePtr(argv[2]), type, &val);
1170
+ CHECK_STATUS(status);
1171
+ return rb_float_new(val);
729
1172
  }
730
1173
  case NC_DOUBLE: {
731
- float64_t val;
732
- status = nc_get_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
733
- StringValuePtr(argv[2]), type, &val);
734
- CHECK_STATUS(status);
735
- return rb_float_new(val);
1174
+ float64_t val;
1175
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1176
+ StringValuePtr(argv[2]), type, &val);
1177
+ CHECK_STATUS(status);
1178
+ return rb_float_new(val);
736
1179
  }
737
1180
  default:
738
- rb_raise(rb_eRuntimeError, "unknown att nc_type");
1181
+ rb_raise(rb_eRuntimeError, "unknown att nc_type");
739
1182
  }
740
1183
  }
741
1184
  else {
@@ -749,7 +1192,7 @@ rb_nc_get_att (int argc, VALUE *argv, VALUE mod)
749
1192
 
750
1193
  Data_Get_Struct(out, CArray, ca);
751
1194
 
752
- status = nc_get_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1195
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
753
1196
  StringValuePtr(argv[2]), type, ca->ptr);
754
1197
 
755
1198
  CHECK_STATUS(status);
@@ -764,7 +1207,7 @@ rb_nc_get_att (int argc, VALUE *argv, VALUE mod)
764
1207
  if ( type == NC_CHAR ) {
765
1208
  volatile VALUE text = argv[3];
766
1209
  rb_str_resize(text, len);
767
- status = nc_get_att_text(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1210
+ status = nc_get_att_text(NUM2INT(argv[0]), NUM2INT(argv[1]),
768
1211
  StringValuePtr(argv[2]),
769
1212
  StringValuePtr(text));
770
1213
  }
@@ -772,12 +1215,12 @@ rb_nc_get_att (int argc, VALUE *argv, VALUE mod)
772
1215
  CArray *ca;
773
1216
  nc_type xtype;
774
1217
  if ( ! rb_obj_is_kind_of(argv[3], rb_cCArray) ) {
775
- rb_raise(rb_eTypeError, "arg4 must be a CArray object");
1218
+ rb_raise(rb_eTypeError, "arg4 must be a CArray object");
776
1219
  }
777
1220
  Data_Get_Struct(argv[3], CArray, ca);
778
1221
  xtype = rb_nc_rtypemap(ca->data_type);
779
1222
  ca_attach(ca);
780
- status = nc_get_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1223
+ status = nc_get_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
781
1224
  StringValuePtr(argv[2]), type, ca->ptr);
782
1225
  ca_sync(ca);
783
1226
  ca_detach(ca);
@@ -798,19 +1241,19 @@ rb_nc_put_att (int argc, VALUE *argv, VALUE mod)
798
1241
 
799
1242
  if ( TYPE(argv[3]) == T_STRING ) {
800
1243
  volatile VALUE text = argv[3];
801
- status = nc_put_att_text(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1244
+ status = nc_put_att_text(NUM2INT(argv[0]), NUM2INT(argv[1]),
802
1245
  StringValuePtr(argv[2]),
803
1246
  strlen(StringValuePtr(text)), StringValuePtr(text));
804
1247
  }
805
1248
  else if ( rb_obj_is_kind_of(argv[3], rb_cInteger) ) {
806
1249
  int32_t val = NUM2INT(argv[3]);
807
- status = nc_put_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1250
+ status = nc_put_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
808
1251
  StringValuePtr(argv[2]),
809
1252
  NC_INT, NC_INT, 1, &val);
810
1253
  }
811
1254
  else if ( rb_obj_is_kind_of(argv[3], rb_cFloat) ) {
812
1255
  float64_t val = NUM2DBL(argv[3]);
813
- status = nc_put_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1256
+ status = nc_put_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
814
1257
  StringValuePtr(argv[2]),
815
1258
  NC_DOUBLE, NC_DOUBLE, 1, &val);
816
1259
  }
@@ -823,7 +1266,7 @@ rb_nc_put_att (int argc, VALUE *argv, VALUE mod)
823
1266
  Data_Get_Struct(argv[3], CArray, ca);
824
1267
  xtype = rb_nc_rtypemap(ca->data_type);
825
1268
  ca_attach(ca);
826
- status = nc_put_att_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1269
+ status = nc_put_att_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
827
1270
  StringValuePtr(argv[2]),
828
1271
  xtype, xtype, ca->elements, ca->ptr);
829
1272
  ca_detach(ca);
@@ -841,13 +1284,23 @@ nc_get_var1_numeric (int ncid, int varid,
841
1284
  {
842
1285
  switch (type) {
843
1286
  case NC_BYTE:
844
- return nc_get_var1_uchar(ncid, varid, index, value);
845
- case NC_CHAR:
846
1287
  return nc_get_var1_schar(ncid, varid, index, value);
1288
+ case NC_UBYTE:
1289
+ return nc_get_var1_ubyte(ncid, varid, index, value);
1290
+ case NC_CHAR:
1291
+ return nc_get_var1_uchar(ncid, varid, index, value);
847
1292
  case NC_SHORT:
848
1293
  return nc_get_var1_short(ncid, varid, index, value);
1294
+ case NC_USHORT:
1295
+ return nc_get_var1_ushort(ncid, varid, index, value);
849
1296
  case NC_INT:
850
1297
  return nc_get_var1_int(ncid, varid, index, value);
1298
+ case NC_UINT:
1299
+ return nc_get_var1_uint(ncid, varid, index, value);
1300
+ case NC_INT64:
1301
+ return nc_get_var1_longlong(ncid, varid, index, value);
1302
+ case NC_UINT64:
1303
+ return nc_get_var1_ulonglong(ncid, varid, index, value);
851
1304
  case NC_FLOAT:
852
1305
  return nc_get_var1_float(ncid, varid, index, value);
853
1306
  case NC_DOUBLE:
@@ -863,13 +1316,23 @@ nc_put_var1_numeric (int ncid, int varid,
863
1316
  {
864
1317
  switch (type) {
865
1318
  case NC_BYTE:
866
- return nc_put_var1_uchar(ncid, varid, index, value);
867
- case NC_CHAR:
868
1319
  return nc_put_var1_schar(ncid, varid, index, value);
1320
+ case NC_UBYTE:
1321
+ return nc_put_var1_ubyte(ncid, varid, index, value);
1322
+ case NC_CHAR:
1323
+ return nc_put_var1_uchar(ncid, varid, index, value);
869
1324
  case NC_SHORT:
870
1325
  return nc_put_var1_short(ncid, varid, index, value);
1326
+ case NC_USHORT:
1327
+ return nc_put_var1_ushort(ncid, varid, index, value);
871
1328
  case NC_INT:
872
1329
  return nc_put_var1_int(ncid, varid, index, value);
1330
+ case NC_UINT:
1331
+ return nc_put_var1_uint(ncid, varid, index, value);
1332
+ case NC_INT64:
1333
+ return nc_put_var1_longlong(ncid, varid, index, value);
1334
+ case NC_UINT64:
1335
+ return nc_put_var1_ulonglong(ncid, varid, index, value);
873
1336
  case NC_FLOAT:
874
1337
  return nc_put_var1_float(ncid, varid, index, value);
875
1338
  case NC_DOUBLE:
@@ -884,13 +1347,23 @@ nc_get_var_numeric (int ncid, int varid, nc_type type, void *value)
884
1347
  {
885
1348
  switch (type) {
886
1349
  case NC_BYTE:
887
- return nc_get_var_uchar(ncid, varid, value);
888
- case NC_CHAR:
889
1350
  return nc_get_var_schar(ncid, varid, value);
1351
+ case NC_UBYTE:
1352
+ return nc_get_var_ubyte(ncid, varid, value);
1353
+ case NC_CHAR:
1354
+ return nc_get_var_uchar(ncid, varid, value);
890
1355
  case NC_SHORT:
891
1356
  return nc_get_var_short(ncid, varid, value);
1357
+ case NC_USHORT:
1358
+ return nc_get_var_ushort(ncid, varid, value);
892
1359
  case NC_INT:
893
1360
  return nc_get_var_int(ncid, varid, value);
1361
+ case NC_UINT:
1362
+ return nc_get_var_uint(ncid, varid, value);
1363
+ case NC_INT64:
1364
+ return nc_get_var_longlong(ncid, varid, value);
1365
+ case NC_UINT64:
1366
+ return nc_get_var_ulonglong(ncid, varid, value);
894
1367
  case NC_FLOAT:
895
1368
  return nc_get_var_float(ncid, varid, value);
896
1369
  case NC_DOUBLE:
@@ -905,13 +1378,23 @@ nc_put_var_numeric (int ncid, int varid, nc_type type, void *value)
905
1378
  {
906
1379
  switch (type) {
907
1380
  case NC_BYTE:
908
- return nc_put_var_uchar(ncid, varid, value);
909
- case NC_CHAR:
910
1381
  return nc_put_var_schar(ncid, varid, value);
1382
+ case NC_UBYTE:
1383
+ return nc_put_var_ubyte(ncid, varid, value);
1384
+ case NC_CHAR:
1385
+ return nc_put_var_uchar(ncid, varid, value);
911
1386
  case NC_SHORT:
912
1387
  return nc_put_var_short(ncid, varid, value);
1388
+ case NC_USHORT:
1389
+ return nc_put_var_ushort(ncid, varid, value);
913
1390
  case NC_INT:
914
1391
  return nc_put_var_int(ncid, varid, value);
1392
+ case NC_UINT:
1393
+ return nc_put_var_uint(ncid, varid, value);
1394
+ case NC_INT64:
1395
+ return nc_put_var_longlong(ncid, varid, value);
1396
+ case NC_UINT64:
1397
+ return nc_put_var_ulonglong(ncid, varid, value);
915
1398
  case NC_FLOAT:
916
1399
  return nc_put_var_float(ncid, varid, value);
917
1400
  case NC_DOUBLE:
@@ -928,13 +1411,23 @@ nc_get_vara_numeric (int ncid, int varid, nc_type type,
928
1411
  {
929
1412
  switch (type) {
930
1413
  case NC_BYTE:
931
- return nc_get_vara_uchar(ncid, varid, start, count, value);
932
- case NC_CHAR:
933
1414
  return nc_get_vara_schar(ncid, varid, start, count, value);
1415
+ case NC_UBYTE:
1416
+ return nc_get_vara_ubyte(ncid, varid, start, count, value);
1417
+ case NC_CHAR:
1418
+ return nc_get_vara_uchar(ncid, varid, start, count, value);
934
1419
  case NC_SHORT:
935
1420
  return nc_get_vara_short(ncid, varid, start, count, value);
1421
+ case NC_USHORT:
1422
+ return nc_get_vara_ushort(ncid, varid, start, count, value);
936
1423
  case NC_INT:
937
1424
  return nc_get_vara_int(ncid, varid, start, count, value);
1425
+ case NC_UINT:
1426
+ return nc_get_vara_uint(ncid, varid, start, count, value);
1427
+ case NC_INT64:
1428
+ return nc_get_vara_longlong(ncid, varid, start, count, value);
1429
+ case NC_UINT64:
1430
+ return nc_get_vara_ulonglong(ncid, varid, start, count, value);
938
1431
  case NC_FLOAT:
939
1432
  return nc_get_vara_float(ncid, varid, start, count, value);
940
1433
  case NC_DOUBLE:
@@ -951,13 +1444,23 @@ nc_put_vara_numeric (int ncid, int varid, nc_type type,
951
1444
  {
952
1445
  switch (type) {
953
1446
  case NC_BYTE:
954
- return nc_put_vara_uchar(ncid, varid, start, count, value);
955
- case NC_CHAR:
956
1447
  return nc_put_vara_schar(ncid, varid, start, count, value);
1448
+ case NC_UBYTE:
1449
+ return nc_put_vara_ubyte(ncid, varid, start, count, value);
1450
+ case NC_CHAR:
1451
+ return nc_put_vara_uchar(ncid, varid, start, count, value);
957
1452
  case NC_SHORT:
958
1453
  return nc_put_vara_short(ncid, varid, start, count, value);
1454
+ case NC_USHORT:
1455
+ return nc_put_vara_ushort(ncid, varid, start, count, value);
959
1456
  case NC_INT:
960
1457
  return nc_put_vara_int(ncid, varid, start, count, value);
1458
+ case NC_UINT:
1459
+ return nc_put_vara_uint(ncid, varid, start, count, value);
1460
+ case NC_INT64:
1461
+ return nc_put_vara_longlong(ncid, varid, start, count, value);
1462
+ case NC_UINT64:
1463
+ return nc_put_vara_ulonglong(ncid, varid, start, count, value);
961
1464
  case NC_FLOAT:
962
1465
  return nc_put_vara_float(ncid, varid, start, count, value);
963
1466
  case NC_DOUBLE:
@@ -975,13 +1478,23 @@ nc_get_vars_numeric (int ncid, int varid, nc_type type,
975
1478
  {
976
1479
  switch (type) {
977
1480
  case NC_BYTE:
978
- return nc_get_vars_uchar(ncid, varid, start, count, stride, value);
979
- case NC_CHAR:
980
1481
  return nc_get_vars_schar(ncid, varid, start, count, stride, value);
1482
+ case NC_UBYTE:
1483
+ return nc_get_vars_ubyte(ncid, varid, start, count, stride, value);
1484
+ case NC_CHAR:
1485
+ return nc_get_vars_uchar(ncid, varid, start, count, stride, value);
981
1486
  case NC_SHORT:
982
1487
  return nc_get_vars_short(ncid, varid, start, count, stride, value);
1488
+ case NC_USHORT:
1489
+ return nc_get_vars_ushort(ncid, varid, start, count, stride, value);
983
1490
  case NC_INT:
984
1491
  return nc_get_vars_int(ncid, varid, start, count, stride, value);
1492
+ case NC_UINT:
1493
+ return nc_get_vars_uint(ncid, varid, start, count, stride, value);
1494
+ case NC_INT64:
1495
+ return nc_get_vars_longlong(ncid, varid, start, count, stride, value);
1496
+ case NC_UINT64:
1497
+ return nc_get_vars_ulonglong(ncid, varid, start, count, stride, value);
985
1498
  case NC_FLOAT:
986
1499
  return nc_get_vars_float(ncid, varid, start, count, stride, value);
987
1500
  case NC_DOUBLE:
@@ -999,13 +1512,23 @@ nc_put_vars_numeric (int ncid, int varid, nc_type type,
999
1512
  {
1000
1513
  switch (type) {
1001
1514
  case NC_BYTE:
1002
- return nc_put_vars_uchar(ncid, varid, start, count, stride, value);
1003
- case NC_CHAR:
1004
1515
  return nc_put_vars_schar(ncid, varid, start, count, stride, value);
1516
+ case NC_UBYTE:
1517
+ return nc_put_vars_ubyte(ncid, varid, start, count, stride, value);
1518
+ case NC_CHAR:
1519
+ return nc_put_vars_uchar(ncid, varid, start, count, stride, value);
1005
1520
  case NC_SHORT:
1006
1521
  return nc_put_vars_short(ncid, varid, start, count, stride, value);
1522
+ case NC_USHORT:
1523
+ return nc_put_vars_ushort(ncid, varid, start, count, stride, value);
1007
1524
  case NC_INT:
1008
1525
  return nc_put_vars_int(ncid, varid, start, count, stride, value);
1526
+ case NC_UINT:
1527
+ return nc_put_vars_uint(ncid, varid, start, count, stride, value);
1528
+ case NC_INT64:
1529
+ return nc_put_vars_longlong(ncid, varid, start, count, stride, value);
1530
+ case NC_UINT64:
1531
+ return nc_put_vars_ulonglong(ncid, varid, start, count, stride, value);
1009
1532
  case NC_FLOAT:
1010
1533
  return nc_put_vars_float(ncid, varid, start, count, stride, value);
1011
1534
  case NC_DOUBLE:
@@ -1023,13 +1546,23 @@ nc_get_varm_numeric (int ncid, int varid, nc_type type,
1023
1546
  {
1024
1547
  switch (type) {
1025
1548
  case NC_BYTE:
1026
- return nc_get_varm_uchar(ncid, varid, start, count, stride, imap, value);
1027
- case NC_CHAR:
1028
1549
  return nc_get_varm_schar(ncid, varid, start, count, stride, imap, value);
1550
+ case NC_UBYTE:
1551
+ return nc_get_varm_ubyte(ncid, varid, start, count, stride, imap, value);
1552
+ case NC_CHAR:
1553
+ return nc_get_varm_uchar(ncid, varid, start, count, stride, imap, value);
1029
1554
  case NC_SHORT:
1030
1555
  return nc_get_varm_short(ncid, varid, start, count, stride, imap, value);
1556
+ case NC_USHORT:
1557
+ return nc_get_varm_ushort(ncid, varid, start, count, stride, imap, value);
1031
1558
  case NC_INT:
1032
1559
  return nc_get_varm_int(ncid, varid, start, count, stride, imap, value);
1560
+ case NC_UINT:
1561
+ return nc_get_varm_uint(ncid, varid, start, count, stride, imap, value);
1562
+ case NC_INT64:
1563
+ return nc_get_varm_longlong(ncid, varid, start, count, stride, imap, value);
1564
+ case NC_UINT64:
1565
+ return nc_get_varm_ulonglong(ncid, varid, start, count, stride, imap, value);
1033
1566
  case NC_FLOAT:
1034
1567
  return nc_get_varm_float(ncid, varid, start, count, stride, imap, value);
1035
1568
  case NC_DOUBLE:
@@ -1047,13 +1580,23 @@ nc_put_varm_numeric (int ncid, int varid, nc_type type,
1047
1580
  {
1048
1581
  switch (type) {
1049
1582
  case NC_BYTE:
1050
- return nc_put_varm_uchar(ncid, varid, start, count, stride, imap, value);
1051
- case NC_CHAR:
1052
1583
  return nc_put_varm_schar(ncid, varid, start, count, stride, imap, value);
1584
+ case NC_UBYTE:
1585
+ return nc_put_varm_ubyte(ncid, varid, start, count, stride, imap, value);
1586
+ case NC_CHAR:
1587
+ return nc_put_varm_uchar(ncid, varid, start, count, stride, imap, value);
1053
1588
  case NC_SHORT:
1054
1589
  return nc_put_varm_short(ncid, varid, start, count, stride, imap, value);
1590
+ case NC_USHORT:
1591
+ return nc_put_varm_ushort(ncid, varid, start, count, stride, imap, value);
1055
1592
  case NC_INT:
1056
1593
  return nc_put_varm_int(ncid, varid, start, count, stride, imap, value);
1594
+ case NC_UINT:
1595
+ return nc_put_varm_uint(ncid, varid, start, count, stride, imap, value);
1596
+ case NC_INT64:
1597
+ return nc_put_varm_longlong(ncid, varid, start, count, stride, imap, value);
1598
+ case NC_UINT64:
1599
+ return nc_put_varm_ulonglong(ncid, varid, start, count, stride, imap, value);
1057
1600
  case NC_FLOAT:
1058
1601
  return nc_put_varm_float(ncid, varid, start, count, stride, imap, value);
1059
1602
  case NC_DOUBLE:
@@ -1076,11 +1619,11 @@ rb_nc_get_var1 (int argc, VALUE *argv, VALUE mod)
1076
1619
  rb_raise(rb_eArgError, "invalid # of arguments");
1077
1620
  }
1078
1621
 
1079
- status = nc_inq_vartype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &type);
1622
+ status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
1080
1623
 
1081
1624
  CHECK_STATUS(status);
1082
1625
 
1083
- status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
1626
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
1084
1627
 
1085
1628
  CHECK_STATUS(status);
1086
1629
 
@@ -1092,36 +1635,71 @@ rb_nc_get_var1 (int argc, VALUE *argv, VALUE mod)
1092
1635
  if ( argc == 3 ) {
1093
1636
  switch ( type ) {
1094
1637
  case NC_BYTE: {
1638
+ int8_t val;
1639
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1640
+ type, index, &val);
1641
+ CHECK_STATUS(status);
1642
+ return INT2NUM(val);
1643
+ }
1644
+ case NC_UBYTE: {
1095
1645
  uint8_t val;
1096
- status = nc_get_var1_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1646
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1097
1647
  type, index, &val);
1098
1648
  CHECK_STATUS(status);
1099
1649
  return INT2NUM(val);
1100
1650
  }
1101
1651
  case NC_SHORT: {
1102
1652
  int16_t val;
1103
- status = nc_get_var1_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1653
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1654
+ type, index, &val);
1655
+ CHECK_STATUS(status);
1656
+ return INT2NUM(val);
1657
+ }
1658
+ case NC_USHORT: {
1659
+ uint16_t val;
1660
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1104
1661
  type, index, &val);
1105
1662
  CHECK_STATUS(status);
1106
1663
  return INT2NUM(val);
1107
1664
  }
1108
1665
  case NC_INT: {
1109
1666
  int32_t val;
1110
- status = nc_get_var1_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1667
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1668
+ type, index, &val);
1669
+ CHECK_STATUS(status);
1670
+ return INT2NUM(val);
1671
+ }
1672
+ case NC_UINT: {
1673
+ uint32_t val;
1674
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1675
+ type, index, &val);
1676
+ CHECK_STATUS(status);
1677
+ return INT2NUM(val);
1678
+ }
1679
+ case NC_INT64: {
1680
+ int64_t val;
1681
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1682
+ type, index, &val);
1683
+ CHECK_STATUS(status);
1684
+ return INT2NUM(val);
1685
+ }
1686
+ case NC_UINT64: {
1687
+ uint64_t val;
1688
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1111
1689
  type, index, &val);
1112
1690
  CHECK_STATUS(status);
1113
1691
  return INT2NUM(val);
1114
1692
  }
1115
1693
  case NC_FLOAT: {
1116
1694
  float32_t val;
1117
- status = nc_get_var1_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1695
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1118
1696
  type, index, &val);
1119
1697
  CHECK_STATUS(status);
1120
1698
  return rb_float_new(val);
1121
1699
  }
1122
1700
  case NC_DOUBLE: {
1123
1701
  float64_t val;
1124
- status = nc_get_var1_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1702
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1125
1703
  type, index, &val);
1126
1704
  CHECK_STATUS(status);
1127
1705
  return rb_float_new(val);
@@ -1143,7 +1721,7 @@ rb_nc_get_var1 (int argc, VALUE *argv, VALUE mod)
1143
1721
  type = rb_nc_rtypemap(ca->data_type);
1144
1722
 
1145
1723
  ca_attach(ca);
1146
- status = nc_get_var1_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1724
+ status = nc_get_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1147
1725
  type, index, ca->ptr);
1148
1726
 
1149
1727
  ca_sync(ca);
@@ -1169,7 +1747,7 @@ rb_nc_put_var1 (int argc, VALUE *argv, VALUE mod)
1169
1747
 
1170
1748
  CHECK_ARGC(4);
1171
1749
 
1172
- status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
1750
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
1173
1751
 
1174
1752
  CHECK_STATUS(status);
1175
1753
 
@@ -1190,7 +1768,7 @@ rb_nc_put_var1 (int argc, VALUE *argv, VALUE mod)
1190
1768
  type = rb_nc_rtypemap(ca->data_type);
1191
1769
 
1192
1770
  ca_attach(ca);
1193
- status = nc_put_var1_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1771
+ status = nc_put_var1_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1194
1772
  type, index, ca->ptr);
1195
1773
  ca_detach(ca);
1196
1774
 
@@ -1211,15 +1789,15 @@ rb_nc_get_var (int argc, VALUE *argv, VALUE mod)
1211
1789
  rb_raise(rb_eArgError, "invalid # of arguments");
1212
1790
  }
1213
1791
 
1214
- status = nc_inq_vartype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &type);
1792
+ status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
1215
1793
 
1216
1794
  CHECK_STATUS(status);
1217
1795
 
1218
- status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
1796
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
1219
1797
 
1220
1798
  CHECK_STATUS(status);
1221
1799
 
1222
- status = nc_inq_vardimid(NUM2LONG(argv[0]), NUM2LONG(argv[1]), dimid);
1800
+ status = nc_inq_vardimid(NUM2INT(argv[0]), NUM2INT(argv[1]), dimid);
1223
1801
 
1224
1802
  CHECK_STATUS(status);
1225
1803
 
@@ -1234,7 +1812,7 @@ rb_nc_get_var (int argc, VALUE *argv, VALUE mod)
1234
1812
  data_type = rb_nc_typemap (type);
1235
1813
  rank = ndims;
1236
1814
  for (i=0; i<rank; i++) {
1237
- status = nc_inq_dimlen(NUM2LONG(argv[0]), dimid[i], &len);
1815
+ status = nc_inq_dimlen(NUM2INT(argv[0]), dimid[i], &len);
1238
1816
  CHECK_STATUS(status);
1239
1817
  dim[i] = len;
1240
1818
  }
@@ -1242,7 +1820,7 @@ rb_nc_get_var (int argc, VALUE *argv, VALUE mod)
1242
1820
  out = rb_carray_new(data_type, rank, dim, 0, NULL);
1243
1821
  Data_Get_Struct(out, CArray, ca);
1244
1822
 
1245
- status = nc_get_var_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1823
+ status = nc_get_var_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1246
1824
  type, ca->ptr);
1247
1825
 
1248
1826
  CHECK_STATUS(status);
@@ -1262,7 +1840,7 @@ rb_nc_get_var (int argc, VALUE *argv, VALUE mod)
1262
1840
  type = rb_nc_rtypemap(ca->data_type);
1263
1841
 
1264
1842
  ca_attach(ca);
1265
- status = nc_get_var_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1843
+ status = nc_get_var_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1266
1844
  type, ca->ptr);
1267
1845
  ca_sync(ca);
1268
1846
  ca_detach(ca);
@@ -1283,7 +1861,7 @@ rb_nc_put_var (int argc, VALUE *argv, VALUE mod)
1283
1861
 
1284
1862
  CHECK_ARGC(3);
1285
1863
 
1286
- status = nc_inq_vartype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &type);
1864
+ status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
1287
1865
 
1288
1866
  CHECK_STATUS(status);
1289
1867
 
@@ -1297,7 +1875,7 @@ rb_nc_put_var (int argc, VALUE *argv, VALUE mod)
1297
1875
 
1298
1876
  type = rb_nc_rtypemap(ca->data_type);
1299
1877
  ca_attach(ca);
1300
- status = nc_put_var_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1878
+ status = nc_put_var_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1301
1879
  type, ca->ptr);
1302
1880
  ca_detach(ca);
1303
1881
 
@@ -1320,15 +1898,15 @@ rb_nc_get_vara (int argc, VALUE *argv, VALUE mod)
1320
1898
  rb_raise(rb_eArgError, "invalid # of arguments");
1321
1899
  }
1322
1900
 
1323
- status = nc_inq_vartype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &type);
1901
+ status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
1324
1902
 
1325
1903
  CHECK_STATUS(status);
1326
1904
 
1327
- status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
1905
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
1328
1906
 
1329
1907
  CHECK_STATUS(status);
1330
1908
 
1331
- status = nc_inq_vardimid(NUM2LONG(argv[0]), NUM2LONG(argv[1]), dimid);
1909
+ status = nc_inq_vardimid(NUM2INT(argv[0]), NUM2INT(argv[1]), dimid);
1332
1910
 
1333
1911
  CHECK_STATUS(status);
1334
1912
 
@@ -1356,7 +1934,7 @@ rb_nc_get_vara (int argc, VALUE *argv, VALUE mod)
1356
1934
  out = rb_carray_new(data_type, rank, dim, 0, NULL);
1357
1935
  Data_Get_Struct(out, CArray, ca);
1358
1936
 
1359
- status = nc_get_vara_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1937
+ status = nc_get_vara_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1360
1938
  type, start, count, ca->ptr);
1361
1939
 
1362
1940
  CHECK_STATUS(status);
@@ -1377,15 +1955,15 @@ rb_nc_get_vara (int argc, VALUE *argv, VALUE mod)
1377
1955
  }
1378
1956
 
1379
1957
  for (i=0; i<ca->rank; i++) {
1380
- if ( ca->dim[i] != count[i] ) {
1381
- rb_raise(rb_eRuntimeError, "dim[%i] mismatch", i);
1958
+ if ( ca->dim[i] != (ca_size_t) count[i] ) {
1959
+ rb_raise(rb_eRuntimeError, "dim[%i] mismatch", i);
1382
1960
  }
1383
1961
  }
1384
1962
 
1385
1963
  type = rb_nc_rtypemap(ca->data_type);
1386
1964
 
1387
1965
  ca_attach(ca);
1388
- status = nc_get_vara_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1966
+ status = nc_get_vara_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1389
1967
  type, start, count, ca->ptr);
1390
1968
  ca_sync(ca);
1391
1969
  ca_detach(ca);
@@ -1409,7 +1987,7 @@ rb_nc_put_vara (int argc, VALUE *argv, VALUE mod)
1409
1987
 
1410
1988
  CHECK_ARGC(5);
1411
1989
 
1412
- status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
1990
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
1413
1991
 
1414
1992
  CHECK_STATUS(status);
1415
1993
 
@@ -1432,7 +2010,7 @@ rb_nc_put_vara (int argc, VALUE *argv, VALUE mod)
1432
2010
  type = rb_nc_rtypemap(ca->data_type);
1433
2011
 
1434
2012
  ca_attach(ca);
1435
- status = nc_put_vara_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
2013
+ status = nc_put_vara_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1436
2014
  type, start, count, ca->ptr);
1437
2015
  ca_detach(ca);
1438
2016
 
@@ -1457,15 +2035,15 @@ rb_nc_get_vars (int argc, VALUE *argv, VALUE mod)
1457
2035
  rb_raise(rb_eArgError, "invalid # of arguments");
1458
2036
  }
1459
2037
 
1460
- status = nc_inq_vartype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &type);
2038
+ status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
1461
2039
 
1462
2040
  CHECK_STATUS(status);
1463
2041
 
1464
- status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
2042
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
1465
2043
 
1466
2044
  CHECK_STATUS(status);
1467
2045
 
1468
- status = nc_inq_vardimid(NUM2LONG(argv[0]), NUM2LONG(argv[1]), dimid);
2046
+ status = nc_inq_vardimid(NUM2INT(argv[0]), NUM2INT(argv[1]), dimid);
1469
2047
 
1470
2048
  CHECK_STATUS(status);
1471
2049
 
@@ -1495,7 +2073,7 @@ rb_nc_get_vars (int argc, VALUE *argv, VALUE mod)
1495
2073
  out = rb_carray_new(data_type, rank, dim, 0, NULL);
1496
2074
  Data_Get_Struct(out, CArray, ca);
1497
2075
 
1498
- status = nc_get_vars_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
2076
+ status = nc_get_vars_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1499
2077
  type, start, count, stride, ca->ptr);
1500
2078
 
1501
2079
  CHECK_STATUS(status);
@@ -1517,15 +2095,15 @@ rb_nc_get_vars (int argc, VALUE *argv, VALUE mod)
1517
2095
  }
1518
2096
 
1519
2097
  for (i=0; i<ca->rank; i++) {
1520
- if ( ca->dim[i] != count[i] ) {
1521
- rb_raise(rb_eRuntimeError, "dim[%i] mismatch", i);
2098
+ if ( ca->dim[i] != (ca_size_t) count[i] ) {
2099
+ rb_raise(rb_eRuntimeError, "dim[%i] mismatch", i);
1522
2100
  }
1523
2101
  }
1524
2102
 
1525
2103
  type = rb_nc_rtypemap(ca->data_type);
1526
2104
 
1527
2105
  ca_attach(ca);
1528
- status = nc_get_vars_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
2106
+ status = nc_get_vars_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1529
2107
  type, start, count, stride, ca->ptr);
1530
2108
  ca_sync(ca);
1531
2109
  ca_detach(ca);
@@ -1550,7 +2128,7 @@ rb_nc_put_vars (int argc, VALUE *argv, VALUE mod)
1550
2128
 
1551
2129
  CHECK_ARGC(6);
1552
2130
 
1553
- status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
2131
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
1554
2132
 
1555
2133
  CHECK_STATUS(status);
1556
2134
 
@@ -1575,7 +2153,7 @@ rb_nc_put_vars (int argc, VALUE *argv, VALUE mod)
1575
2153
  type = rb_nc_rtypemap(ca->data_type);
1576
2154
 
1577
2155
  ca_attach(ca);
1578
- status = nc_put_vars_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
2156
+ status = nc_put_vars_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1579
2157
  type, start, count, stride, ca->ptr);
1580
2158
  ca_detach(ca);
1581
2159
 
@@ -1600,15 +2178,15 @@ rb_nc_get_varm (int argc, VALUE *argv, VALUE mod)
1600
2178
  rb_raise(rb_eArgError, "invalid # of arguments");
1601
2179
  }
1602
2180
 
1603
- status = nc_inq_vartype(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &type);
2181
+ status = nc_inq_vartype(NUM2INT(argv[0]), NUM2INT(argv[1]), &type);
1604
2182
 
1605
2183
  CHECK_STATUS(status);
1606
2184
 
1607
- status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
2185
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
1608
2186
 
1609
2187
  CHECK_STATUS(status);
1610
2188
 
1611
- status = nc_inq_vardimid(NUM2LONG(argv[0]), NUM2LONG(argv[1]), dimid);
2189
+ status = nc_inq_vardimid(NUM2INT(argv[0]), NUM2INT(argv[1]), dimid);
1612
2190
 
1613
2191
  CHECK_STATUS(status);
1614
2192
 
@@ -1640,7 +2218,7 @@ rb_nc_get_varm (int argc, VALUE *argv, VALUE mod)
1640
2218
  out = rb_carray_new(data_type, rank, dim, 0, NULL);
1641
2219
  Data_Get_Struct(out, CArray, ca);
1642
2220
 
1643
- status = nc_get_varm_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
2221
+ status = nc_get_varm_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1644
2222
  type, start, count, stride, imap, ca->ptr);
1645
2223
 
1646
2224
  CHECK_STATUS(status);
@@ -1662,15 +2240,15 @@ rb_nc_get_varm (int argc, VALUE *argv, VALUE mod)
1662
2240
  }
1663
2241
 
1664
2242
  for (i=0; i<ca->rank; i++) {
1665
- if ( ca->dim[i] != count[i] ) {
1666
- rb_raise(rb_eRuntimeError, "dim[%i] mismatch", i);
2243
+ if ( ca->dim[i] != (ca_size_t) count[i] ) {
2244
+ rb_raise(rb_eRuntimeError, "dim[%i] mismatch", i);
1667
2245
  }
1668
2246
  }
1669
2247
 
1670
2248
  type = rb_nc_rtypemap(ca->data_type);
1671
2249
 
1672
2250
  ca_attach(ca);
1673
- status = nc_get_varm_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
2251
+ status = nc_get_varm_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1674
2252
  type, start, count, stride, imap, ca->ptr);
1675
2253
  ca_sync(ca);
1676
2254
  ca_detach(ca);
@@ -1695,7 +2273,7 @@ rb_nc_put_varm (int argc, VALUE *argv, VALUE mod)
1695
2273
 
1696
2274
  CHECK_ARGC(7);
1697
2275
 
1698
- status = nc_inq_varndims(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &ndims);
2276
+ status = nc_inq_varndims(NUM2INT(argv[0]), NUM2INT(argv[1]), &ndims);
1699
2277
 
1700
2278
  CHECK_STATUS(status);
1701
2279
 
@@ -1722,7 +2300,7 @@ rb_nc_put_varm (int argc, VALUE *argv, VALUE mod)
1722
2300
  type = rb_nc_rtypemap(ca->data_type);
1723
2301
 
1724
2302
  ca_attach(ca);
1725
- status = nc_put_varm_numeric(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
2303
+ status = nc_put_varm_numeric(NUM2INT(argv[0]), NUM2INT(argv[1]),
1726
2304
  type, start, count, stride, imap, ca->ptr);
1727
2305
  ca_detach(ca);
1728
2306
 
@@ -1741,7 +2319,7 @@ rb_nc_rename_dim (int argc, VALUE *argv, VALUE mod)
1741
2319
  CHECK_TYPE_ID(argv[1]);
1742
2320
  CHECK_TYPE_STRING(argv[2]);
1743
2321
 
1744
- status = nc_rename_dim(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
2322
+ status = nc_rename_dim(NUM2INT(argv[0]), NUM2INT(argv[1]),
1745
2323
  StringValuePtr(argv[2]));
1746
2324
 
1747
2325
  CHECK_STATUS(status);
@@ -1749,6 +2327,22 @@ rb_nc_rename_dim (int argc, VALUE *argv, VALUE mod)
1749
2327
  return LONG2NUM(status);
1750
2328
  }
1751
2329
 
2330
+ static VALUE
2331
+ rb_nc_rename_grp (int argc, VALUE *argv, VALUE mod)
2332
+ {
2333
+ int status;
2334
+
2335
+ CHECK_ARGC(2);
2336
+ CHECK_TYPE_ID(argv[0]);
2337
+ CHECK_TYPE_STRING(argv[1]);
2338
+
2339
+ status = nc_rename_grp(NUM2INT(argv[0]), StringValuePtr(argv[1]));
2340
+
2341
+ CHECK_STATUS(status);
2342
+
2343
+ return LONG2NUM(status);
2344
+ }
2345
+
1752
2346
  static VALUE
1753
2347
  rb_nc_rename_var (int argc, VALUE *argv, VALUE mod)
1754
2348
  {
@@ -1759,7 +2353,7 @@ rb_nc_rename_var (int argc, VALUE *argv, VALUE mod)
1759
2353
  CHECK_TYPE_ID(argv[1]);
1760
2354
  CHECK_TYPE_STRING(argv[2]);
1761
2355
 
1762
- status = nc_rename_var(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
2356
+ status = nc_rename_var(NUM2INT(argv[0]), NUM2INT(argv[1]),
1763
2357
  StringValuePtr(argv[2]));
1764
2358
 
1765
2359
  CHECK_STATUS(status);
@@ -1778,7 +2372,7 @@ rb_nc_rename_att (int argc, VALUE *argv, VALUE mod)
1778
2372
  CHECK_TYPE_STRING(argv[2]);
1779
2373
  CHECK_TYPE_STRING(argv[3]);
1780
2374
 
1781
- status = nc_rename_att(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
2375
+ status = nc_rename_att(NUM2INT(argv[0]), NUM2INT(argv[1]),
1782
2376
  StringValuePtr(argv[2]), StringValuePtr(argv[3]));
1783
2377
 
1784
2378
  CHECK_STATUS(status);
@@ -1786,10 +2380,8 @@ rb_nc_rename_att (int argc, VALUE *argv, VALUE mod)
1786
2380
  return LONG2NUM(status);
1787
2381
  }
1788
2382
 
1789
- int nc_setfill(int ncid, int fillmode, int* old_fillemode);
1790
-
1791
2383
  static VALUE
1792
- rb_nc_setfill (int argc, VALUE *argv, VALUE mod)
2384
+ rb_nc_set_fill (int argc, VALUE *argv, VALUE mod)
1793
2385
  {
1794
2386
  int status;
1795
2387
  int old_fillmode;
@@ -1798,7 +2390,7 @@ rb_nc_setfill (int argc, VALUE *argv, VALUE mod)
1798
2390
  CHECK_TYPE_ID(argv[0]);
1799
2391
  CHECK_TYPE_INT(argv[1]);
1800
2392
 
1801
- status = nc_setfill(NUM2LONG(argv[0]), NUM2LONG(argv[1]), &old_fillmode);
2393
+ status = nc_set_fill(NUM2INT(argv[0]), NUM2INT(argv[1]), &old_fillmode);
1802
2394
 
1803
2395
  CHECK_STATUS(status);
1804
2396
 
@@ -1817,8 +2409,8 @@ rb_nc_copy_att (int argc, VALUE *argv, VALUE mod)
1817
2409
  CHECK_TYPE_ID(argv[3]);
1818
2410
  CHECK_TYPE_ID(argv[4]);
1819
2411
 
1820
- status = nc_copy_att(NUM2LONG(argv[0]), NUM2LONG(argv[1]),
1821
- StringValuePtr(argv[2]), NUM2LONG(argv[3]), NUM2LONG(argv[4]));
2412
+ status = nc_copy_att(NUM2INT(argv[0]), NUM2INT(argv[1]),
2413
+ StringValuePtr(argv[2]), NUM2INT(argv[3]), NUM2INT(argv[4]));
1822
2414
 
1823
2415
  CHECK_STATUS(status);
1824
2416
 
@@ -1846,122 +2438,226 @@ Init_netcdflib ()
1846
2438
  rb_define_singleton_method(mNetCDF, "enddef", rb_nc_enddef, -1);
1847
2439
  rb_define_module_function(mNetCDF, "nc_sync", rb_nc_sync, -1);
1848
2440
  rb_define_singleton_method(mNetCDF, "sync", rb_nc_sync, -1);
2441
+ rb_define_module_function(mNetCDF, "nc_set_fill", rb_nc_set_fill, -1);
2442
+ rb_define_singleton_method(mNetCDF, "set_fill", rb_nc_set_fill, -1);
1849
2443
 
1850
- rb_define_module_function(mNetCDF, "nc_inq_ndims", rb_nc_inq_ndims, -1);
1851
- rb_define_singleton_method(mNetCDF, "inq_ndims", rb_nc_inq_ndims, -1);
1852
- rb_define_module_function(mNetCDF, "nc_inq_nvars", rb_nc_inq_nvars, -1);
1853
- rb_define_singleton_method(mNetCDF, "inq_nvars", rb_nc_inq_nvars, -1);
1854
- rb_define_module_function(mNetCDF, "nc_inq_natts", rb_nc_inq_natts, -1);
1855
- rb_define_singleton_method(mNetCDF, "inq_natts", rb_nc_inq_natts, -1);
1856
- rb_define_module_function(mNetCDF, "nc_inq_unlimdim", rb_nc_inq_unlimdim, -1);
1857
- rb_define_singleton_method(mNetCDF, "inq_unlimdim", rb_nc_inq_unlimdim, -1);
1858
-
2444
+ rb_define_module_function(mNetCDF, "nc_def_dim", rb_nc_def_dim, -1);
2445
+ rb_define_singleton_method(mNetCDF, "def_dim", rb_nc_def_dim, -1);
2446
+ // nc_inq_dim is not defined
1859
2447
  rb_define_module_function(mNetCDF, "nc_inq_dimid", rb_nc_inq_dimid, -1);
1860
2448
  rb_define_singleton_method(mNetCDF, "inq_dimid", rb_nc_inq_dimid, -1);
1861
- rb_define_module_function(mNetCDF, "nc_inq_varid", rb_nc_inq_varid, -1);
1862
- rb_define_singleton_method(mNetCDF, "inq_varid", rb_nc_inq_varid, -1);
1863
- rb_define_module_function(mNetCDF, "nc_inq_attid", rb_nc_inq_attid, -1);
1864
- rb_define_singleton_method(mNetCDF, "inq_attid", rb_nc_inq_attid, -1);
1865
-
1866
2449
  rb_define_module_function(mNetCDF, "nc_inq_dimlen", rb_nc_inq_dimlen, -1);
1867
2450
  rb_define_singleton_method(mNetCDF, "inq_dimlen", rb_nc_inq_dimlen, -1);
1868
2451
  rb_define_module_function(mNetCDF, "nc_inq_dimname", rb_nc_inq_dimname, -1);
1869
2452
  rb_define_singleton_method(mNetCDF, "inq_dimname", rb_nc_inq_dimname, -1);
2453
+ rb_define_module_function(mNetCDF, "nc_inq_ndims", rb_nc_inq_ndims, -1);
2454
+ rb_define_singleton_method(mNetCDF, "inq_ndims", rb_nc_inq_ndims, -1);
2455
+ rb_define_module_function(mNetCDF, "nc_inq_unlimdim", rb_nc_inq_unlimdim, -1);
2456
+ rb_define_singleton_method(mNetCDF, "inq_unlimdim", rb_nc_inq_unlimdim, -1);
2457
+ rb_define_module_function(mNetCDF, "nc_rename_dim", rb_nc_rename_dim, -1);
2458
+ rb_define_singleton_method(mNetCDF, "rename_dim", rb_nc_rename_dim, -1);
1870
2459
 
1871
- rb_define_module_function(mNetCDF, "nc_inq_varname", rb_nc_inq_varname, -1);
1872
- rb_define_singleton_method(mNetCDF, "inq_varname", rb_nc_inq_varname, -1);
1873
- rb_define_module_function(mNetCDF, "nc_inq_vartype", rb_nc_inq_vartype, -1);
1874
- rb_define_singleton_method(mNetCDF, "inq_vartype", rb_nc_inq_vartype, -1);
1875
- rb_define_module_function(mNetCDF, "nc_inq_varndims", rb_nc_inq_varndims, -1);
1876
- rb_define_singleton_method(mNetCDF, "inq_varndims", rb_nc_inq_varndims, -1);
1877
- rb_define_module_function(mNetCDF, "nc_inq_vardimid", rb_nc_inq_vardimid, -1);
1878
- rb_define_singleton_method(mNetCDF, "inq_vardimid", rb_nc_inq_vardimid, -1);
1879
- rb_define_module_function(mNetCDF, "nc_inq_varnatts", rb_nc_inq_varnatts, -1);
1880
- rb_define_singleton_method(mNetCDF, "inq_varnatts", rb_nc_inq_varnatts, -1);
1881
-
1882
- rb_define_module_function(mNetCDF, "nc_inq_attname", rb_nc_inq_attname, -1);
1883
- rb_define_singleton_method(mNetCDF, "inq_attname", rb_nc_inq_attname, -1);
1884
- rb_define_module_function(mNetCDF, "nc_inq_atttype", rb_nc_inq_atttype, -1);
1885
- rb_define_singleton_method(mNetCDF, "inq_atttype", rb_nc_inq_atttype, -1);
1886
- rb_define_module_function(mNetCDF, "nc_inq_attlen", rb_nc_inq_attlen, -1);
1887
- rb_define_singleton_method(mNetCDF, "inq_attlen", rb_nc_inq_attlen, -1);
1888
- rb_define_module_function(mNetCDF, "nc_inq_attid", rb_nc_inq_attid, -1);
1889
- rb_define_singleton_method(mNetCDF, "inq_attid", rb_nc_inq_attid, -1);
1890
-
1891
- rb_define_module_function(mNetCDF, "nc_def_dim", rb_nc_def_dim, -1);
1892
- rb_define_singleton_method(mNetCDF, "def_dim", rb_nc_def_dim, -1);
1893
2460
  rb_define_module_function(mNetCDF, "nc_def_var", rb_nc_def_var, -1);
1894
2461
  rb_define_singleton_method(mNetCDF, "def_var", rb_nc_def_var, -1);
1895
-
2462
+ rb_define_module_function(mNetCDF, "nc_def_var_chunking", rb_nc_def_var_chunking, -1);
2463
+ rb_define_singleton_method(mNetCDF, "def_var_chunking", rb_nc_def_var_chunking, -1);
1896
2464
  rb_define_module_function(mNetCDF, "nc_def_var_deflate", rb_nc_def_var_deflate, -1);
1897
2465
  rb_define_singleton_method(mNetCDF, "def_var_deflate", rb_nc_def_var_deflate, -1);
1898
- rb_define_module_function(mNetCDF, "nc_inq_var_deflate", rb_nc_inq_var_deflate, -1);
1899
- rb_define_singleton_method(mNetCDF, "inq_var_deflate", rb_nc_inq_var_deflate, -1);
1900
-
1901
- rb_define_module_function(mNetCDF, "nc_rename_dim", rb_nc_rename_dim, -1);
1902
- rb_define_singleton_method(mNetCDF, "rename_dim", rb_nc_rename_dim, -1);
1903
- rb_define_module_function(mNetCDF, "nc_rename_var", rb_nc_rename_var, -1);
1904
- rb_define_singleton_method(mNetCDF, "rename_var", rb_nc_rename_var, -1);
1905
- rb_define_module_function(mNetCDF, "nc_rename_att", rb_nc_rename_att, -1);
1906
- rb_define_singleton_method(mNetCDF, "rename_att", rb_nc_rename_att, -1);
1907
- rb_define_module_function(mNetCDF, "nc_del_att", rb_nc_del_att, -1);
1908
- rb_define_singleton_method(mNetCDF, "del_att", rb_nc_del_att, -1);
1909
- rb_define_module_function(mNetCDF, "nc_setfill", rb_nc_setfill, -1);
1910
- rb_define_singleton_method(mNetCDF, "setfill", rb_nc_setfill, -1);
1911
-
1912
- rb_define_module_function(mNetCDF, "nc_put_att", rb_nc_put_att, -1);
1913
- rb_define_singleton_method(mNetCDF, "put_att", rb_nc_put_att, -1);
1914
- rb_define_module_function(mNetCDF, "nc_get_att", rb_nc_get_att, -1);
1915
- rb_define_singleton_method(mNetCDF, "get_att", rb_nc_get_att, -1);
1916
- rb_define_module_function(mNetCDF, "nc_copy_att", rb_nc_copy_att, -1);
1917
- rb_define_singleton_method(mNetCDF, "copy_att", rb_nc_copy_att, -1);
1918
-
2466
+ // nc_def_var_endian
2467
+ // nc_def_var_fill
2468
+ // nc_def_var_fletcher32
2469
+ // nc_free_string
1919
2470
  rb_define_module_function(mNetCDF, "nc_get_var1", rb_nc_get_var1, -1);
1920
2471
  rb_define_singleton_method(mNetCDF, "get_var1", rb_nc_get_var1, -1);
1921
- rb_define_module_function(mNetCDF, "nc_put_var1", rb_nc_put_var1, -1);
1922
- rb_define_singleton_method(mNetCDF, "put_var1", rb_nc_put_var1, -1);
1923
2472
  rb_define_module_function(mNetCDF, "nc_get_var", rb_nc_get_var, -1);
1924
2473
  rb_define_singleton_method(mNetCDF, "get_var", rb_nc_get_var, -1);
1925
- rb_define_module_function(mNetCDF, "nc_put_var", rb_nc_put_var, -1);
1926
- rb_define_singleton_method(mNetCDF, "put_var", rb_nc_put_var, -1);
1927
2474
  rb_define_module_function(mNetCDF, "nc_get_vara", rb_nc_get_vara, -1);
1928
2475
  rb_define_singleton_method(mNetCDF, "get_vara", rb_nc_get_vara, -1);
1929
- rb_define_module_function(mNetCDF, "nc_put_vara", rb_nc_put_vara, -1);
1930
- rb_define_singleton_method(mNetCDF, "put_vara", rb_nc_put_vara, -1);
1931
2476
  rb_define_module_function(mNetCDF, "nc_get_vars", rb_nc_get_vars, -1);
1932
2477
  rb_define_singleton_method(mNetCDF, "get_vars", rb_nc_get_vars, -1);
1933
- rb_define_module_function(mNetCDF, "nc_put_vars", rb_nc_put_vars, -1);
1934
- rb_define_singleton_method(mNetCDF, "put_vars", rb_nc_put_vars, -1);
1935
2478
  rb_define_module_function(mNetCDF, "nc_get_varm", rb_nc_get_varm, -1);
1936
2479
  rb_define_singleton_method(mNetCDF, "get_varm", rb_nc_get_varm, -1);
2480
+ //nc_inq_var
2481
+ rb_define_module_function(mNetCDF, "nc_inq_var_chunking", rb_nc_inq_var_chunking, -1);
2482
+ rb_define_singleton_method(mNetCDF, "inq_var_chunking", rb_nc_inq_var_chunking, -1);
2483
+ rb_define_module_function(mNetCDF, "nc_inq_var_deflate", rb_nc_inq_var_deflate, -1);
2484
+ rb_define_singleton_method(mNetCDF, "inq_var_deflate", rb_nc_inq_var_deflate, -1);
2485
+ //nc_inq_var_endian
2486
+ //nc_inq_var_fill
2487
+ //nc_inq_var_filter
2488
+ //nc_inq_var_fletcher32
2489
+ //nc_inq_var_szip
2490
+ rb_define_module_function(mNetCDF, "nc_inq_vardimid", rb_nc_inq_vardimid, -1);
2491
+ rb_define_singleton_method(mNetCDF, "inq_vardimid", rb_nc_inq_vardimid, -1);
2492
+ rb_define_module_function(mNetCDF, "nc_inq_varid", rb_nc_inq_varid, -1);
2493
+ rb_define_singleton_method(mNetCDF, "inq_varid", rb_nc_inq_varid, -1);
2494
+ rb_define_module_function(mNetCDF, "nc_inq_varname", rb_nc_inq_varname, -1);
2495
+ rb_define_singleton_method(mNetCDF, "inq_varname", rb_nc_inq_varname, -1);
2496
+ rb_define_module_function(mNetCDF, "nc_inq_varnatts", rb_nc_inq_varnatts, -1);
2497
+ rb_define_singleton_method(mNetCDF, "inq_varnatts", rb_nc_inq_varnatts, -1);
2498
+ rb_define_module_function(mNetCDF, "nc_inq_varndims", rb_nc_inq_varndims, -1);
2499
+ rb_define_singleton_method(mNetCDF, "inq_varndims", rb_nc_inq_varndims, -1);
2500
+ rb_define_module_function(mNetCDF, "nc_inq_vartype", rb_nc_inq_vartype, -1);
2501
+ rb_define_singleton_method(mNetCDF, "inq_vartype", rb_nc_inq_vartype, -1);
2502
+ rb_define_module_function(mNetCDF, "nc_put_var1", rb_nc_put_var1, -1);
2503
+ rb_define_singleton_method(mNetCDF, "put_var1", rb_nc_put_var1, -1);
2504
+ rb_define_module_function(mNetCDF, "nc_put_var", rb_nc_put_var, -1);
2505
+ rb_define_singleton_method(mNetCDF, "put_var", rb_nc_put_var, -1);
2506
+ rb_define_module_function(mNetCDF, "nc_put_vara", rb_nc_put_vara, -1);
2507
+ rb_define_singleton_method(mNetCDF, "put_vara", rb_nc_put_vara, -1);
2508
+ rb_define_module_function(mNetCDF, "nc_put_vars", rb_nc_put_vars, -1);
2509
+ rb_define_singleton_method(mNetCDF, "put_vars", rb_nc_put_vars, -1);
1937
2510
  rb_define_module_function(mNetCDF, "nc_put_varm", rb_nc_put_varm, -1);
1938
2511
  rb_define_singleton_method(mNetCDF, "put_varm", rb_nc_put_varm, -1);
2512
+ rb_define_module_function(mNetCDF, "nc_rename_var", rb_nc_rename_var, -1);
2513
+ rb_define_singleton_method(mNetCDF, "rename_var", rb_nc_rename_var, -1);
2514
+ // nc_set_var_chunk_cache
2515
+
2516
+ rb_define_module_function(mNetCDF, "nc_del_att", rb_nc_del_att, -1);
2517
+ rb_define_singleton_method(mNetCDF, "del_att", rb_nc_del_att, -1);
2518
+ rb_define_module_function(mNetCDF, "nc_get_att", rb_nc_get_att, -1);
2519
+ rb_define_singleton_method(mNetCDF, "get_att", rb_nc_get_att, -1);
2520
+ // nc_inq_att
2521
+ rb_define_module_function(mNetCDF, "nc_inq_attid", rb_nc_inq_attid, -1);
2522
+ rb_define_singleton_method(mNetCDF, "inq_attid", rb_nc_inq_attid, -1);
2523
+ rb_define_module_function(mNetCDF, "nc_inq_attlen", rb_nc_inq_attlen, -1);
2524
+ rb_define_singleton_method(mNetCDF, "inq_attlen", rb_nc_inq_attlen, -1);
2525
+ rb_define_module_function(mNetCDF, "nc_inq_attname", rb_nc_inq_attname, -1);
2526
+ rb_define_singleton_method(mNetCDF, "inq_attname", rb_nc_inq_attname, -1);
2527
+ rb_define_module_function(mNetCDF, "nc_inq_atttype", rb_nc_inq_atttype, -1);
2528
+ rb_define_singleton_method(mNetCDF, "inq_atttype", rb_nc_inq_atttype, -1);
2529
+ rb_define_module_function(mNetCDF, "nc_inq_natts", rb_nc_inq_natts, -1);
2530
+ rb_define_singleton_method(mNetCDF, "inq_natts", rb_nc_inq_natts, -1);
2531
+ rb_define_module_function(mNetCDF, "nc_put_att", rb_nc_put_att, -1);
2532
+ rb_define_singleton_method(mNetCDF, "put_att", rb_nc_put_att, -1);
2533
+ rb_define_module_function(mNetCDF, "nc_rename_att", rb_nc_rename_att, -1);
2534
+ rb_define_singleton_method(mNetCDF, "rename_att", rb_nc_rename_att, -1);
2535
+
2536
+ rb_define_module_function(mNetCDF, "nc_def_grp", rb_nc_def_grp, -1);
2537
+ rb_define_singleton_method(mNetCDF, "def_grp", rb_nc_def_grp, -1);
2538
+ rb_define_module_function(mNetCDF, "nc_inq_dimids", rb_nc_inq_dimids, -1);
2539
+ rb_define_singleton_method(mNetCDF, "inq_dimids", rb_nc_inq_dimids, -1);
2540
+ rb_define_module_function(mNetCDF, "nc_inq_grp_full_ncid", rb_nc_inq_grp_full_ncid, -1);
2541
+ rb_define_singleton_method(mNetCDF, "inq_grp_full_ncid", rb_nc_inq_grp_full_ncid, -1);
2542
+ rb_define_module_function(mNetCDF, "nc_inq_grp_ncid", rb_nc_inq_grp_ncid, -1);
2543
+ rb_define_singleton_method(mNetCDF, "inq_grp_ncid", rb_nc_inq_grp_ncid, -1);
2544
+ rb_define_module_function(mNetCDF, "nc_inq_grp_parent", rb_nc_inq_grp_parent, -1);
2545
+ rb_define_singleton_method(mNetCDF, "inq_grp_parent", rb_nc_inq_grp_parent, -1);
2546
+ rb_define_module_function(mNetCDF, "nc_inq_grpname", rb_nc_inq_grpname, -1);
2547
+ rb_define_singleton_method(mNetCDF, "inq_grpname", rb_nc_inq_grpname, -1);
2548
+ rb_define_module_function(mNetCDF, "nc_inq_grpname_full", rb_nc_inq_grpname_full, -1);
2549
+ rb_define_singleton_method(mNetCDF, "inq_grpname_full", rb_nc_inq_grpname_full, -1);
2550
+ rb_define_module_function(mNetCDF, "nc_inq_grpname_len", rb_nc_inq_grpname_len, -1);
2551
+ rb_define_singleton_method(mNetCDF, "inq_grpname_len", rb_nc_inq_grpname_len, -1);
2552
+ rb_define_module_function(mNetCDF, "nc_inq_grps", rb_nc_inq_grps, -1);
2553
+ rb_define_singleton_method(mNetCDF, "inq_grps", rb_nc_inq_grps, -1);
2554
+ rb_define_module_function(mNetCDF, "nc_inq_ncid", rb_nc_inq_ncid, -1);
2555
+ rb_define_singleton_method(mNetCDF, "inq_ncid", rb_nc_inq_ncid, -1);
2556
+ rb_define_module_function(mNetCDF, "nc_inq_typeids", rb_nc_inq_typeids, -1);
2557
+ rb_define_singleton_method(mNetCDF, "inq_typeids", rb_nc_inq_typeids, -1);
2558
+ rb_define_module_function(mNetCDF, "nc_inq_varids", rb_nc_inq_varids, -1);
2559
+ rb_define_singleton_method(mNetCDF, "inq_varids", rb_nc_inq_varids, -1);
2560
+ rb_define_module_function(mNetCDF, "nc_rename_grp", rb_nc_rename_grp, -1);
2561
+ rb_define_singleton_method(mNetCDF, "rename_grp", rb_nc_rename_grp, -1);
2562
+ rb_define_module_function(mNetCDF, "nc_show_metadata", rb_nc_show_metadata, -1);
2563
+ rb_define_singleton_method(mNetCDF, "show_metadata", rb_nc_show_metadata, -1);
2564
+
2565
+
2566
+ rb_define_module_function(mNetCDF, "nc_copy_att", rb_nc_copy_att, -1);
2567
+ rb_define_singleton_method(mNetCDF, "copy_att", rb_nc_copy_att, -1);
2568
+
2569
+ rb_define_module_function(mNetCDF, "nc_inq_nvars", rb_nc_inq_nvars, -1);
2570
+ rb_define_singleton_method(mNetCDF, "inq_nvars", rb_nc_inq_nvars, -1);
1939
2571
 
1940
- rb_define_const(mNetCDF, "NC_NOERR", INT2FIX(NC_NOERR));
1941
-
1942
- rb_define_const(mNetCDF, "NC_NOWRITE", INT2FIX(NC_NOWRITE));
1943
- rb_define_const(mNetCDF, "NC_WRITE", INT2FIX(NC_WRITE));
1944
- rb_define_const(mNetCDF, "NC_SHARE", INT2FIX(NC_SHARE));
1945
- rb_define_const(mNetCDF, "NC_LOCK", INT2FIX(NC_LOCK));
1946
- rb_define_const(mNetCDF, "NC_CLOBBER", INT2FIX(NC_CLOBBER));
1947
- rb_define_const(mNetCDF, "NC_NOCLOBBER", INT2FIX(NC_NOCLOBBER));
1948
- rb_define_const(mNetCDF, "NC_NETCDF4", INT2FIX(NC_NETCDF4));
1949
- rb_define_const(mNetCDF, "NC_CLASSIC_MODEL", INT2FIX(NC_CLASSIC_MODEL));
1950
- rb_define_const(mNetCDF, "NC_SIZEHINT_DEFAULT", INT2FIX(NC_SIZEHINT_DEFAULT));
1951
-
1952
- rb_define_const(mNetCDF, "NC_GLOBAL", INT2FIX(NC_GLOBAL));
1953
- rb_define_const(mNetCDF, "NC_MAX_NAME", INT2FIX(NC_MAX_NAME));
1954
- rb_define_const(mNetCDF, "NC_MAX_VAR_DIMS", INT2FIX(NC_MAX_VAR_DIMS));
1955
- rb_define_const(mNetCDF, "NC_MAX_DIMS", INT2FIX(NC_MAX_DIMS));
1956
- rb_define_const(mNetCDF, "NC_NOFILL", INT2FIX(NC_NOFILL));
1957
- rb_define_const(mNetCDF, "NC_FILL", INT2FIX(NC_FILL));
1958
-
1959
- rb_define_const(mNetCDF, "NC_NAT", INT2FIX(NC_NAT));
1960
- rb_define_const(mNetCDF, "NC_BYTE", INT2FIX(NC_BYTE));
1961
- rb_define_const(mNetCDF, "NC_CHAR", INT2FIX(NC_CHAR));
1962
- rb_define_const(mNetCDF, "NC_SHORT", INT2FIX(NC_SHORT));
1963
- rb_define_const(mNetCDF, "NC_INT", INT2FIX(NC_INT));
1964
- rb_define_const(mNetCDF, "NC_FLOAT", INT2FIX(NC_FLOAT));
1965
- rb_define_const(mNetCDF, "NC_DOUBLE", INT2FIX(NC_DOUBLE));
2572
+ rb_define_const(mNetCDF, "NC_NOERR", INT2NUM(NC_NOERR));
2573
+
2574
+ rb_define_const(mNetCDF, "NC_NOWRITE", INT2NUM(NC_NOWRITE));
2575
+ rb_define_const(mNetCDF, "NC_WRITE", INT2NUM(NC_WRITE));
2576
+ rb_define_const(mNetCDF, "NC_CLOBBER", INT2NUM(NC_CLOBBER));
2577
+ rb_define_const(mNetCDF, "NC_NOCLOBBER", INT2NUM(NC_NOCLOBBER));
2578
+ rb_define_const(mNetCDF, "NC_DISKLESS", INT2NUM(NC_DISKLESS));
2579
+ rb_define_const(mNetCDF, "NC_MMAP", INT2NUM(NC_MMAP));
2580
+ rb_define_const(mNetCDF, "NC_64BIT_DATA", INT2NUM(NC_64BIT_DATA));
2581
+ rb_define_const(mNetCDF, "NC_CDF5", INT2NUM(NC_CDF5));
2582
+ rb_define_const(mNetCDF, "NC_CLASSIC_MODEL", INT2NUM(NC_CLASSIC_MODEL));
2583
+ rb_define_const(mNetCDF, "NC_LOCK", INT2NUM(NC_LOCK));
2584
+ rb_define_const(mNetCDF, "NC_SHARE", INT2NUM(NC_SHARE));
2585
+ rb_define_const(mNetCDF, "NC_NETCDF4", INT2NUM(NC_NETCDF4));
2586
+ rb_define_const(mNetCDF, "NC_MPIIO", INT2NUM(NC_MPIIO));
2587
+ rb_define_const(mNetCDF, "NC_INMEMORY", INT2NUM(NC_INMEMORY));
2588
+ rb_define_const(mNetCDF, "NC_PNETCDF", INT2NUM(NC_PNETCDF));
2589
+
2590
+ rb_define_const(mNetCDF, "NC_FORMAT_CLASSIC", INT2NUM(NC_FORMAT_CLASSIC));
2591
+ rb_define_const(mNetCDF, "NC_FORMAT_64BIT_OFFSET", INT2NUM(NC_FORMAT_64BIT_OFFSET));
2592
+ rb_define_const(mNetCDF, "NC_FORMAT_64BIT", INT2NUM(NC_FORMAT_64BIT));
2593
+ rb_define_const(mNetCDF, "NC_FORMAT_NETCDF4", INT2NUM(NC_FORMAT_NETCDF4));
2594
+ rb_define_const(mNetCDF, "NC_FORMAT_NETCDF4_CLASSIC", INT2NUM(NC_FORMAT_NETCDF4_CLASSIC));
2595
+ rb_define_const(mNetCDF, "NC_FORMAT_64BIT_DATA", INT2NUM(NC_FORMAT_64BIT_DATA));
2596
+ rb_define_const(mNetCDF, "NC_FORMAT_CDF5", INT2NUM(NC_FORMAT_CDF5));
2597
+
2598
+
2599
+ rb_define_const(mNetCDF, "NC_SIZEHINT_DEFAULT", INT2NUM(NC_SIZEHINT_DEFAULT));
2600
+
2601
+ rb_define_const(mNetCDF, "NC_ALIGN_CHUNK", INT2NUM(NC_ALIGN_CHUNK));
2602
+ rb_define_const(mNetCDF, "NC_UNLIMITED", INT2NUM(NC_UNLIMITED));
2603
+
2604
+ rb_define_const(mNetCDF, "NC_GLOBAL", INT2NUM(NC_GLOBAL));
2605
+ rb_define_const(mNetCDF, "NC_MAX_DIMS", INT2NUM(NC_MAX_DIMS));
2606
+ rb_define_const(mNetCDF, "NC_MAX_ATTRS", INT2NUM(NC_MAX_ATTRS));
2607
+ rb_define_const(mNetCDF, "NC_MAX_VARS", INT2NUM(NC_MAX_VARS));
2608
+ rb_define_const(mNetCDF, "NC_MAX_NAME", INT2NUM(NC_MAX_NAME));
2609
+ rb_define_const(mNetCDF, "NC_MAX_VAR_DIMS", INT2NUM(NC_MAX_VAR_DIMS));
2610
+ rb_define_const(mNetCDF, "NC_FILL", INT2NUM(NC_FILL));
2611
+ rb_define_const(mNetCDF, "NC_NOFILL", INT2NUM(NC_NOFILL));
2612
+
2613
+ rb_define_const(mNetCDF, "NC_ENDIAN_NATIVE", INT2NUM(NC_ENDIAN_NATIVE));
2614
+ rb_define_const(mNetCDF, "NC_ENDIAN_LITTLE", INT2NUM(NC_ENDIAN_LITTLE));
2615
+ rb_define_const(mNetCDF, "NC_ENDIAN_BIG", INT2NUM(NC_ENDIAN_BIG));
2616
+
2617
+ rb_define_const(mNetCDF, "NC_CHUNKED", INT2NUM(NC_CHUNKED));
2618
+ rb_define_const(mNetCDF, "NC_CONTIGUOUS", INT2NUM(NC_CONTIGUOUS));
2619
+
2620
+ rb_define_const(mNetCDF, "NC_NOCHECKSUM", INT2NUM(NC_NOCHECKSUM));
2621
+ rb_define_const(mNetCDF, "NC_FLETCHER32", INT2NUM(NC_FLETCHER32));
2622
+
2623
+ rb_define_const(mNetCDF, "NC_NOSHUFFLE", INT2NUM(NC_NOSHUFFLE));
2624
+ rb_define_const(mNetCDF, "NC_SHUFFLE", INT2NUM(NC_SHUFFLE));
2625
+
2626
+
2627
+ rb_define_const(mNetCDF, "NC_NAT", INT2NUM(NC_NAT));
2628
+ rb_define_const(mNetCDF, "NC_BYTE", INT2NUM(NC_BYTE));
2629
+ rb_define_const(mNetCDF, "NC_UBYTE", INT2NUM(NC_UBYTE));
2630
+ rb_define_const(mNetCDF, "NC_CHAR", INT2NUM(NC_CHAR));
2631
+ rb_define_const(mNetCDF, "NC_SHORT", INT2NUM(NC_SHORT));
2632
+ rb_define_const(mNetCDF, "NC_USHORT", INT2NUM(NC_USHORT));
2633
+ rb_define_const(mNetCDF, "NC_INT", INT2NUM(NC_INT));
2634
+ rb_define_const(mNetCDF, "NC_LONG", INT2NUM(NC_LONG));
2635
+ rb_define_const(mNetCDF, "NC_UINT", INT2NUM(NC_UINT));
2636
+ rb_define_const(mNetCDF, "NC_INT64", INT2NUM(NC_INT64));
2637
+ rb_define_const(mNetCDF, "NC_UINT64", INT2NUM(NC_UINT64));
2638
+ rb_define_const(mNetCDF, "NC_FLOAT", INT2NUM(NC_FLOAT));
2639
+ rb_define_const(mNetCDF, "NC_DOUBLE", INT2NUM(NC_DOUBLE));
2640
+ rb_define_const(mNetCDF, "NC_STRING", INT2NUM(NC_STRING));
2641
+
2642
+ // rb_define_const(mNetCDF, "NC_", INT2NUM(NC_));
2643
+
2644
+ rb_define_const(mNetCDF, "NC_VLEN", INT2NUM(NC_VLEN));
2645
+ rb_define_const(mNetCDF, "NC_OPAQUE", INT2NUM(NC_OPAQUE));
2646
+ rb_define_const(mNetCDF, "NC_ENUM", INT2NUM(NC_ENUM));
2647
+ rb_define_const(mNetCDF, "NC_COMPOUND", INT2NUM(NC_COMPOUND));
2648
+
2649
+
2650
+ rb_define_const(mNetCDF, "NC_FILL_BYTE", INT2NUM(NC_FILL_BYTE));
2651
+ rb_define_const(mNetCDF, "NC_FILL_CHAR", INT2NUM(NC_FILL_CHAR));
2652
+ rb_define_const(mNetCDF, "NC_FILL_SHORT", INT2NUM(NC_FILL_SHORT));
2653
+ rb_define_const(mNetCDF, "NC_FILL_INT", INT2NUM(NC_FILL_INT));
2654
+ rb_define_const(mNetCDF, "NC_FILL_FLOAT", rb_float_new(NC_FILL_FLOAT));
2655
+ rb_define_const(mNetCDF, "NC_FILL_DOUBLE", rb_float_new(NC_FILL_DOUBLE));
2656
+ rb_define_const(mNetCDF, "NC_FILL_UBYTE", UINT2NUM(NC_FILL_UBYTE));
2657
+ rb_define_const(mNetCDF, "NC_FILL_USHORT", UINT2NUM(NC_FILL_USHORT));
2658
+ rb_define_const(mNetCDF, "NC_FILL_UINT", UINT2NUM(NC_FILL_UINT));
2659
+ rb_define_const(mNetCDF, "NC_FILL_IN64", LL2NUM(NC_FILL_INT64));
2660
+ rb_define_const(mNetCDF, "NC_FILL_UIN64", ULL2NUM(NC_FILL_INT64));
2661
+ rb_define_const(mNetCDF, "NC_FILL_STRING", rb_str_new2(NC_FILL_STRING));
1966
2662
 
1967
2663
  }