NeXusJavaBindings  1
 All Classes Namespaces Files Functions Variables Typedefs Macros Pages
hdfnativeImp.c
Go to the documentation of this file.
1 
2 /****************************************************************************
3  * NCSA HDF *
4  * National Comptational Science Alliance *
5  * University of Illinois at Urbana-Champaign *
6  * 605 E. Springfield, Champaign IL 61820 *
7  * *
8  * For conditions of distribution and use, see the accompanying *
9  * hdf/COPYING file. *
10  * *
11  ****************************************************************************/
12 
13 /*
14  * This module contains the implementation of all the native methods
15  * used for number conversion. This is represented by the Java
16  * class HDFNativeData.
17  *
18  * These routines convert one dimensional arrays of bytes into
19  * one-D arrays of other types (int, float, etc) and vice versa.
20  *
21  * These routines are called from the Java parts of the Java-C
22  * interface.
23  *
24  * ***Important notes:
25  *
26  * 1. These routines are designed to be portable--they use the
27  * C compiler to do the required native data manipulation.
28  * 2. These routines copy the data at least once -- a serious
29  * but unavoidable performance hit.
30  */
31 
32 #include <stdio.h>
33 
34 /* #include "hdf.h" /* this only seems to be needed to define "intn" */
35 typedef int intn;
36 
37 #include "jni.h"
38 #include "hdfexceptionImp.h"
39 
40 /* returns int [] */
41 JNIEXPORT jintArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_byteToInt___3B
42 ( JNIEnv *env,
43 jclass class,
44 jbyteArray bdata) /* IN: array of bytes */
45 {
46  intn rval;
47  jbyte *barr;
48  jintArray rarray;
49  int blen;
50  jint *iarray;
51  jboolean bb;
52  char *bp;
53  jint *iap;
54  int ii;
55  int len;
56 
57  if (bdata == NULL) {
58  raiseException( env, "byteToInt: bdata is NULL?");
59  return NULL;
60  }
61  barr = (*env)->GetByteArrayElements(env,bdata,&bb);
62  if (barr == NULL) {
63  JNIFatalError( env, "byteToInt: pin failed");
64  return NULL;
65  }
66 
67  blen = (*env)->GetArrayLength(env,bdata);
68 
69  len = blen/sizeof(jint);
70  rarray = (*env)->NewIntArray(env,len);
71  if (rarray == NULL) {
72  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
73  outOfMemory( env, "byteToInt" );
74  return NULL;
75  }
76 
77  iarray = (*env)->GetIntArrayElements(env,rarray,&bb);
78  if (iarray == NULL) {
79  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
80  JNIFatalError( env, "byteToInt: pin iarray failed");
81  return NULL;
82  }
83 
84  bp = (char *)barr;
85  iap = iarray;
86  for (ii = 0; ii < len; ii++) {
87  *iap = *(jint *)bp;
88  iap++;
89  bp += sizeof(jint);
90  }
91 
92  (*env)->ReleaseIntArrayElements(env,rarray,iarray, 0);
93  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
94 
95  return rarray;
96 
97 }
98 
99 /* returns float [] */
100 JNIEXPORT jfloatArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_byteToFloat___3B
101 ( JNIEnv *env,
102 jclass class,
103 jbyteArray bdata) /* IN: array of bytes */
104 {
105  jbyte *barr;
106  jfloatArray rarray;
107  int blen;
108  jfloat *farray;
109  jboolean bb;
110  char *bp;
111  jfloat *iap;
112  int ii;
113  int len;
114 
115  if (bdata == NULL) {
116  raiseException( env, "byteToFloat: bdata is NULL?");
117  return NULL;
118  }
119  barr = (*env)->GetByteArrayElements(env,bdata,&bb);
120  if (barr == NULL) {
121  JNIFatalError( env, "byteToFloat: pin failed");
122  return NULL;
123  }
124  blen = (*env)->GetArrayLength(env,bdata);
125 
126  len = blen/sizeof(jfloat);
127  rarray = (*env)->NewFloatArray(env,len);
128  if (rarray == NULL) {
129  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
130  outOfMemory( env, "byteToFloat" );
131  return NULL;
132  }
133  farray = (*env)->GetFloatArrayElements(env,rarray,&bb);
134  if (farray == NULL) {
135  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
136  JNIFatalError( env, "byteToFloat: pin farray failed");
137  return NULL;
138  }
139 
140  bp = (char *)barr;
141  iap = farray;
142  for (ii = 0; ii < len; ii++) {
143  *iap = *(jfloat *)bp;
144  iap++;
145  bp += sizeof(jfloat);
146  }
147 
148  (*env)->ReleaseFloatArrayElements(env,rarray,farray, 0);
149  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
150 
151  return rarray;
152 
153 }
154 
155 /* returns short [] */
156 JNIEXPORT jshortArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_byteToShort___3B
157 ( JNIEnv *env,
158 jclass class,
159 jbyteArray bdata) /* IN: array of bytes */
160 {
161  jbyte *barr;
162  jshortArray rarray;
163  int blen;
164  jshort *sarray;
165  jboolean bb;
166  char *bp;
167  jshort *iap;
168  int ii;
169  int len;
170 
171  if (bdata == NULL) {
172  raiseException( env, "byteToShort: bdata is NULL?");
173  return NULL;
174  }
175  barr = (*env)->GetByteArrayElements(env,bdata,&bb);
176  if (barr == NULL) {
177  JNIFatalError( env, "byteToShort: pin failed");
178  return NULL;
179  }
180 
181  blen = (*env)->GetArrayLength(env,bdata);
182 
183  len = blen/sizeof(jshort);
184  rarray = (*env)->NewShortArray(env,len);
185  if (rarray == NULL) {
186  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
187  outOfMemory( env, "byteToShort" );
188  return NULL;
189  }
190 
191  sarray = (*env)->GetShortArrayElements(env,rarray,&bb);
192  if (sarray == NULL) {
193  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
194  JNIFatalError( env, "byteToShort: pin sarray failed");
195  return NULL;
196  }
197 
198  bp = (char *)barr;
199  iap = sarray;
200  for (ii = 0; ii < len; ii++) {
201  *iap = *(jshort *)bp;
202  iap++;
203  bp += sizeof(jshort);
204  }
205 
206  (*env)->ReleaseShortArrayElements(env,rarray,sarray, 0);
207  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
208 
209  return rarray;
210 
211 }
212 
213 
214 /* returns long [] */
215 JNIEXPORT jlongArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_byteToLong___3B
216 ( JNIEnv *env,
217 jclass class,
218 jbyteArray bdata) /* IN: array of bytes */
219 {
220  jbyte *barr;
221  jlongArray rarray;
222  int blen;
223  jlong *larray;
224  jboolean bb;
225  char *bp;
226  jlong *iap;
227  int ii;
228  int len;
229 
230  if (bdata == NULL) {
231  raiseException( env, "byteToLong: bdata is NULL?");
232  return NULL;
233  }
234  barr = (*env)->GetByteArrayElements(env,bdata,&bb);
235  if (barr == NULL) {
236  JNIFatalError( env, "byteToLong: pin failed");
237  return NULL;
238  }
239  blen = (*env)->GetArrayLength(env,bdata);
240 
241  len = blen/sizeof(jlong);
242  rarray = (*env)->NewLongArray(env,len);
243  if (rarray == NULL) {
244  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
245  outOfMemory( env, "byteToLong" );
246  return NULL;
247  }
248 
249  larray = (*env)->GetLongArrayElements(env,rarray,&bb);
250  if (larray == NULL) {
251  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
252  JNIFatalError( env, "byteToLong: pin larray failed");
253  return NULL;
254  }
255 
256  bp = (char *)barr;
257  iap = larray;
258  for (ii = 0; ii < len; ii++) {
259  *iap = *(jlong *)bp;
260  iap++;
261  bp += sizeof(jlong);
262  }
263  (*env)->ReleaseLongArrayElements(env,rarray,larray, 0);
264  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
265 
266  return rarray;
267 
268 }
269 
270 
271 /* returns double [] */
272 JNIEXPORT jdoubleArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_byteToDouble___3B
273 ( JNIEnv *env,
274 jclass class,
275 jbyteArray bdata) /* IN: array of bytes */
276 {
277  jbyte *barr;
278  jdoubleArray rarray;
279  int blen;
280  jdouble *darray;
281  jboolean bb;
282  char *bp;
283  jdouble *iap;
284  int ii;
285  int len;
286 
287  if (bdata == NULL) {
288  raiseException( env, "byteToDouble: bdata is NULL?");
289  return NULL;
290  }
291  barr = (*env)->GetByteArrayElements(env,bdata,&bb);
292  if (barr == NULL) {
293  JNIFatalError( env, "byteToDouble: pin failed");
294  return NULL;
295  }
296  blen = (*env)->GetArrayLength(env,bdata);
297 
298  len = blen/sizeof(jdouble);
299  rarray = (*env)->NewDoubleArray(env,len);
300  if (rarray == NULL) {
301  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
302  outOfMemory( env, "byteToDouble" );
303  return NULL;
304  }
305 
306  darray = (*env)->GetDoubleArrayElements(env,rarray,&bb);
307  if (darray == NULL) {
308  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
309  JNIFatalError( env, "byteToDouble: pin darray failed");
310  return NULL;
311  }
312 
313  bp = (char *)barr;
314  iap = darray;
315  for (ii = 0; ii < len; ii++) {
316  *iap = *(jdouble *)bp;
317  iap++;
318  bp += sizeof(jdouble);
319  }
320 
321  (*env)->ReleaseDoubleArrayElements(env,rarray,darray,0);
322  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
323 
324  return rarray;
325 }
326 
327 
328 /* returns int [] */
329 JNIEXPORT jintArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_byteToInt__II_3B
330 ( JNIEnv *env,
331 jclass class,
332 jint start,
333 jint len,
334 jbyteArray bdata) /* IN: array of bytes */
335 {
336  char *bp;
337  jbyte *barr;
338  jintArray rarray;
339  int blen;
340  jint *iarray;
341  jint *iap;
342  int ii;
343  jboolean bb;
344 
345  if (bdata == NULL) {
346  raiseException( env, "byteToInt: bdata is NULL?");
347  return NULL;
348  }
349  barr = (*env)->GetByteArrayElements(env,bdata,&bb);
350  if (barr == NULL) {
351  JNIFatalError( env, "byteToInt: pin failed");
352  return NULL;
353  }
354 
355  blen = (*env)->GetArrayLength(env,bdata);
356  if ((start < 0) || ((start + (len*sizeof(jint))) > blen)) {
357  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
358  JNIFatalError( env, "byteToInt: getLen failed");
359  return NULL;
360  }
361 
362  bp = (char *)barr + start;
363 
364  rarray = (*env)->NewIntArray(env,len);
365  if (rarray == NULL) {
366  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
367  outOfMemory( env, "byteToInt" );
368  return NULL;
369  }
370 
371  iarray = (*env)->GetIntArrayElements(env,rarray,&bb);
372  if (iarray == NULL) {
373  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
374  JNIFatalError( env, "byteToInt: pin iarray failed");
375  return NULL;
376  }
377 
378  iap = iarray;
379  for (ii = 0; ii < len; ii++) {
380  *iap = *(jint *)bp;
381  iap++;
382  bp += sizeof(jint);
383  }
384 
385  (*env)->ReleaseIntArrayElements(env,rarray,iarray, 0);
386  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
387 
388  return rarray;
389 
390 }
391 
392 /* returns short [] */
393 JNIEXPORT jshortArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_byteToShort__II_3B
394 ( JNIEnv *env,
395 jclass class,
396 jint start,
397 jint len,
398 jbyteArray bdata) /* IN: array of bytes */
399 {
400  char *bp;
401  jbyte *barr;
402  jshortArray rarray;
403  int blen;
404  jshort *iarray;
405  jshort *iap;
406  int ii;
407  jboolean bb;
408 
409  if (bdata == NULL) {
410  raiseException( env, "byteToShort: bdata is NULL?");
411  return NULL;
412  }
413  barr = (*env)->GetByteArrayElements(env,bdata,&bb);
414  if (barr == NULL) {
415  JNIFatalError( env, "byteToShort: getByte failed?");
416  return NULL;
417  }
418 
419  blen = (*env)->GetArrayLength(env,bdata);
420  if ((start < 0) || ((start + (len*(sizeof(jshort)))) > blen)) {
421  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
422  raiseException( env, "byteToShort: start or len is out of bounds");
423  return NULL;
424  }
425 
426  bp = (char *)barr + start;
427 
428  rarray = (*env)->NewShortArray(env,len);
429  if (rarray == NULL) {
430  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
431  outOfMemory( env, "byteToShort" );
432  return NULL;
433  }
434 
435  iarray = (*env)->GetShortArrayElements(env,rarray,&bb);
436  if (iarray == NULL) {
437  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
438  JNIFatalError( env, "byteToShort: getShort failed?");
439  return NULL;
440  }
441 
442  iap = iarray;
443  for (ii = 0; ii < len; ii++) {
444  *iap = *(jshort *)bp;
445  iap++;
446  bp += sizeof(jshort);
447  }
448 
449  (*env)->ReleaseShortArrayElements(env,rarray,iarray, 0);
450  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
451 
452  return rarray;
453 
454 }
455 
456 /* returns float [] */
457 JNIEXPORT jfloatArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_byteToFloat__II_3B
458 ( JNIEnv *env,
459 jclass class,
460 jint start,
461 jint len,
462 jbyteArray bdata) /* IN: array of bytes */
463 {
464  char *bp;
465  jbyte *barr;
466  jfloatArray rarray;
467  int blen;
468  jfloat *iarray;
469  jfloat *iap;
470  int ii;
471  jboolean bb;
472 
473  if (bdata == NULL) {
474  raiseException( env, "byteToFloat: bdata is NULL?");
475  return NULL;
476  }
477  barr = (*env)->GetByteArrayElements(env,bdata,&bb);
478  if (barr == NULL) {
479  JNIFatalError( env, "byteToFloat: getByte failed?");
480  return NULL;
481  }
482 
483  blen = (*env)->GetArrayLength(env,bdata);
484  if ((start < 0) || ((start + (len*(sizeof(jfloat)))) > blen)) {
485  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
486  raiseException( env, "byteToFloat: start or len is out of bounds");
487  return NULL;
488  }
489 
490  bp = (char *)barr + start;
491 
492  rarray = (*env)->NewFloatArray(env,len);
493  if (rarray == NULL) {
494  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
495  outOfMemory( env, "byteToFloat" );
496  return NULL;
497  }
498 
499  iarray = (*env)->GetFloatArrayElements(env,rarray,&bb);
500  if (iarray == NULL) {
501  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
502  JNIFatalError( env, "byteToFloat: getFloat failed?");
503  return NULL;
504  }
505 
506  iap = iarray;
507  for (ii = 0; ii < len; ii++) {
508  *iap = *(jfloat *)bp;
509  iap++;
510  bp += sizeof(jfloat);
511  }
512 
513  (*env)->ReleaseFloatArrayElements(env,rarray,iarray, 0);
514  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
515 
516  return rarray;
517 
518 }
519 
520 /* returns long [] */
521 JNIEXPORT jlongArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_byteToLong__II_3B
522 ( JNIEnv *env,
523 jclass class,
524 jint start,
525 jint len,
526 jbyteArray bdata) /* IN: array of bytes */
527 {
528  char *bp;
529  jbyte *barr;
530  jlongArray rarray;
531  int blen;
532  jlong *iarray;
533  jlong *iap;
534  int ii;
535  jboolean bb;
536 
537  if (bdata == NULL) {
538  raiseException( env, "byteToLong: bdata is NULL?");
539  return NULL;
540  }
541  barr = (*env)->GetByteArrayElements(env,bdata,&bb);
542  if (barr == NULL) {
543  JNIFatalError( env, "byteToLong: getByte failed?");
544  return NULL;
545  }
546 
547  blen = (*env)->GetArrayLength(env,bdata);
548  if ((start < 0) || ((start + (len*(sizeof(jlong)))) > blen)) {
549  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
550  raiseException( env, "byteToLong: start or len is out of bounds");
551  return NULL;
552  }
553 
554  bp = (char *)barr + start;
555 
556  rarray = (*env)->NewLongArray(env,len);
557  if (rarray == NULL) {
558  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
559  outOfMemory( env, "byteToLong" );
560  return NULL;
561  }
562 
563  iarray = (*env)->GetLongArrayElements(env,rarray,&bb);
564  if (iarray == NULL) {
565  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
566  JNIFatalError( env, "byteToLong: getLong failed?");
567  return NULL;
568  }
569 
570  iap = iarray;
571  for (ii = 0; ii < len; ii++) {
572 
573  *iap = *(jlong *)bp;
574  iap++;
575  bp += sizeof(jlong);
576  }
577 
578  (*env)->ReleaseLongArrayElements(env,rarray,iarray, 0);
579  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
580 
581  return rarray;
582 
583 }
584 
585 /* returns double [] */
586 JNIEXPORT jdoubleArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_byteToDouble__II_3B
587 ( JNIEnv *env,
588 jclass class,
589 jint start,
590 jint len,
591 jbyteArray bdata) /* IN: array of bytes */
592 {
593  char *bp;
594  jbyte *barr;
595  jdoubleArray rarray;
596  int blen;
597  jdouble *iarray;
598  jdouble *iap;
599  int ii;
600  jboolean bb;
601 
602  if (bdata == NULL) {
603  raiseException( env, "byteToDouble: bdata is NULL?");
604  return NULL;
605  }
606  barr = (*env)->GetByteArrayElements(env,bdata,&bb);
607  if (barr == NULL) {
608  JNIFatalError( env, "byteToDouble: getByte failed?");
609  return NULL;
610  }
611 
612  blen = (*env)->GetArrayLength(env,bdata);
613  if ((start < 0) || ((start + (len*(sizeof(jdouble)))) > blen)) {
614  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
615  raiseException( env, "byteToDouble: start or len is out of bounds");
616  return NULL;
617  }
618 
619  bp = (char *)barr + start;
620 
621  rarray = (*env)->NewDoubleArray(env,len);
622  if (rarray == NULL) {
623  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
624  outOfMemory( env, "byteToDouble" );
625  return NULL;
626  }
627 
628  iarray = (*env)->GetDoubleArrayElements(env,rarray,&bb);
629  if (iarray == NULL) {
630  JNIFatalError( env, "byteToDouble: getDouble failed?");
631  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
632  return NULL;
633  }
634 
635  iap = iarray;
636  for (ii = 0; ii < len; ii++) {
637  *iap = *(jdouble *)bp;
638  iap++;
639  bp += sizeof(jdouble);
640  }
641 
642  (*env)->ReleaseDoubleArrayElements(env,rarray,iarray, 0);
643  (*env)->ReleaseByteArrayElements(env,bdata,barr,JNI_ABORT);
644 
645  return rarray;
646 }
647 
648 /* returns byte [] */
649 JNIEXPORT jbyteArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_intToByte__II_3I
650 (JNIEnv *env,
651 jclass class,
652 jint start,
653 jint len,
654 jintArray idata) /* IN: array of int */
655 {
656  jint *ip;
657  jint *iarr;
658  int ilen;
659  jbyteArray rarray;
660  int blen;
661  jbyte *barray;
662  jbyte *bap;
663  jboolean bb;
664  int ii;
665  int ij;
666  union things {
667  int ival;
668  char bytes[4];
669  } u;
670 
671  if (idata == NULL) {
672  raiseException( env, "intToByte: idata is NULL?");
673  return NULL;
674  }
675  iarr = (*env)->GetIntArrayElements(env,idata,&bb);
676  if (iarr == NULL) {
677  JNIFatalError( env, "intToByte: getInt failed?");
678  return NULL;
679  }
680 
681  ilen = (*env)->GetArrayLength(env,idata);
682  if ((start < 0) || (((start + len)) > ilen)) {
683  (*env)->ReleaseIntArrayElements(env,idata,iarr,JNI_ABORT);
684  raiseException( env, "intToByte: start or len is out of bounds");
685  return NULL;
686  }
687 
688  ip = iarr + start;
689 
690  blen = ilen * sizeof(jint);
691  rarray = (*env)->NewByteArray(env,blen);
692  if (rarray == NULL) {
693  (*env)->ReleaseIntArrayElements(env,idata,iarr,JNI_ABORT);
694  outOfMemory( env, "intToByte" );
695  return NULL;
696  }
697 
698  barray = (*env)->GetByteArrayElements(env,rarray,&bb);
699  if (barray == NULL) {
700  (*env)->ReleaseIntArrayElements(env,idata,iarr,JNI_ABORT);
701  JNIFatalError( env, "intToByte: getByte failed?");
702  return NULL;
703  }
704 
705  bap = barray;
706  for (ii = 0; ii < len; ii++) {
707  u.ival = *ip++;
708  for (ij = 0; ij < sizeof(jint); ij++) {
709  *bap = u.bytes[ij];
710  bap++;
711  }
712  }
713 
714  (*env)->ReleaseByteArrayElements(env,rarray,barray, 0);
715  (*env)->ReleaseIntArrayElements(env,idata,iarr,JNI_ABORT);
716 
717  return rarray;
718 
719 }
720 
721 /* returns byte [] */
722 JNIEXPORT jbyteArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_shortToByte__II_3S
723 ( JNIEnv *env,
724 jclass class,
725 jint start,
726 jint len,
727 jshortArray idata) /* IN: array of short */
728 {
729  jshort *ip;
730  jshort *iarr;
731  int ilen;
732  jbyteArray rarray;
733  int blen;
734  jbyte *barray;
735  jbyte *bap;
736  jboolean bb;
737  int ii;
738  int ij;
739  union things {
740  short ival;
741  char bytes[4];
742  } u;
743 
744  if (idata == NULL) {
745  raiseException( env, "shortToByte: idata is NULL?");
746  return NULL;
747  }
748  iarr = (*env)->GetShortArrayElements(env,idata,&bb);
749  if (iarr == NULL) {
750  JNIFatalError( env, "shortToByte: getShort failed?");
751  return NULL;
752  }
753 
754  ilen = (*env)->GetArrayLength(env,idata);
755  if ((start < 0) || (((start + len)) > ilen)) {
756  (*env)->ReleaseShortArrayElements(env,idata,iarr,JNI_ABORT);
757  raiseException( env, "shortToByte: start or len is out of bounds");
758  return NULL;
759  }
760 
761  ip = iarr + start;
762 
763  blen = ilen * sizeof(jshort);
764  rarray = (*env)->NewByteArray(env,blen);
765  if (rarray == NULL) {
766  (*env)->ReleaseShortArrayElements(env,idata,iarr,JNI_ABORT);
767  outOfMemory( env, "shortToByte" );
768  return NULL;
769  }
770 
771  barray = (*env)->GetByteArrayElements(env,rarray,&bb);
772  if (barray == NULL) {
773  (*env)->ReleaseShortArrayElements(env,idata,iarr,JNI_ABORT);
774  JNIFatalError( env, "shortToByte: getByte failed?");
775  return NULL;
776  }
777 
778  bap = barray;
779  for (ii = 0; ii < len; ii++) {
780  u.ival = *ip++;
781  for (ij = 0; ij < sizeof(jshort); ij++) {
782  *bap = u.bytes[ij];
783  bap++;
784  }
785  }
786 
787  (*env)->ReleaseByteArrayElements(env,rarray,barray, 0);
788  (*env)->ReleaseShortArrayElements(env,idata,iarr,JNI_ABORT);
789 
790  return rarray;
791 
792 }
793 
794 /* returns byte [] */
795 JNIEXPORT jbyteArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_floatToByte__II_3F
796 ( JNIEnv *env,
797 jclass class,
798 jint start,
799 jint len,
800 jfloatArray idata) /* IN: array of float */
801 {
802  jfloat *ip;
803  jfloat *iarr;
804  int ilen;
805  jbyteArray rarray;
806  int blen;
807  jbyte *barray;
808  jbyte *bap;
809  jboolean bb;
810  int ii;
811  int ij;
812  union things {
813  float ival;
814  char bytes[4];
815  } u;
816 
817  if (idata == NULL) {
818  raiseException( env, "floatToByte: idata is NULL?");
819  return NULL;
820  }
821  iarr = (*env)->GetFloatArrayElements(env,idata,&bb);
822  if (iarr == NULL) {
823  JNIFatalError( env, "floatToByte: getFloat failed?");
824  return NULL;
825  }
826 
827  ilen = (*env)->GetArrayLength(env,idata);
828  if ((start < 0) || (((start + len)) > ilen)) {
829  (*env)->ReleaseFloatArrayElements(env,idata,iarr,JNI_ABORT);
830  raiseException( env, "floatToByte: start or len is out of bounds");
831  return NULL;
832  }
833 
834  ip = iarr + start;
835 
836  blen = ilen * sizeof(jfloat);
837  rarray = (*env)->NewByteArray(env,blen);
838  if (rarray == NULL) {
839  (*env)->ReleaseFloatArrayElements(env,idata,iarr,JNI_ABORT);
840  outOfMemory( env, "floatToByte" );
841  return NULL;
842  }
843 
844  barray = (*env)->GetByteArrayElements(env,rarray,&bb);
845  if (barray == NULL) {
846  (*env)->ReleaseFloatArrayElements(env,idata,iarr,JNI_ABORT);
847  JNIFatalError( env, "floatToByte: getByte failed?");
848  return NULL;
849  }
850 
851  bap = barray;
852  for (ii = 0; ii < len; ii++) {
853  u.ival = *ip++;
854  for (ij = 0; ij < sizeof(jfloat); ij++) {
855  *bap = u.bytes[ij];
856  bap++;
857  }
858  }
859 
860  (*env)->ReleaseByteArrayElements(env,rarray,barray, 0);
861  (*env)->ReleaseFloatArrayElements(env,idata,iarr,JNI_ABORT);
862 
863  return rarray;
864 
865 }
866 
867 /* returns byte [] */
868 JNIEXPORT jbyteArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_doubleToByte__II_3D
869 ( JNIEnv *env,
870 jclass class,
871 jint start,
872 jint len,
873 jdoubleArray idata) /* IN: array of double */
874 {
875  jdouble *ip;
876  jdouble *iarr;
877  int ilen;
878  jbyteArray rarray;
879  int blen;
880  jbyte *barray;
881  jbyte *bap;
882  jboolean bb;
883  int ii;
884  int ij;
885  union things {
886  double ival;
887  char bytes[8];
888  } u;
889 
890  if (idata == NULL) {
891  raiseException( env, "doubleToByte: idata is NULL?");
892  return NULL;
893  }
894  iarr = (*env)->GetDoubleArrayElements(env,idata,&bb);
895  if (iarr == NULL) {
896  JNIFatalError( env, "doubleToByte: getDouble failed?");
897  return NULL;
898  }
899 
900  ilen = (*env)->GetArrayLength(env,idata);
901  if ((start < 0) || (((start + len)) > ilen)) {
902  (*env)->ReleaseDoubleArrayElements(env,idata,iarr,JNI_ABORT);
903  raiseException( env, "doubleToByte: start or len is out of bounds");
904  return NULL;
905  }
906 
907  ip = iarr + start;
908 
909  blen = ilen * sizeof(jdouble);
910  rarray = (*env)->NewByteArray(env,blen);
911  if (rarray == NULL) {
912  (*env)->ReleaseDoubleArrayElements(env,idata,iarr,JNI_ABORT);
913  outOfMemory( env, "doubleToByte" );
914  return NULL;
915  }
916 
917  barray = (*env)->GetByteArrayElements(env,rarray,&bb);
918  if (barray == NULL) {
919  (*env)->ReleaseDoubleArrayElements(env,idata,iarr,JNI_ABORT);
920  JNIFatalError( env, "doubleToByte: getByte failed?");
921  return NULL;
922  }
923 
924  bap = barray;
925  for (ii = 0; ii < len; ii++) {
926  u.ival = *ip++;
927  for (ij = 0; ij < sizeof(jdouble); ij++) {
928  *bap = u.bytes[ij];
929  bap++;
930  }
931  }
932 
933  (*env)->ReleaseByteArrayElements(env,rarray,barray, 0);
934  (*env)->ReleaseDoubleArrayElements(env,idata,iarr,JNI_ABORT);
935 
936  return rarray;
937 
938 }
939 
940 
941 /* returns byte [] */
942 JNIEXPORT jbyteArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_longToByte__II_3J
943 ( JNIEnv *env,
944 jclass class,
945 jint start,
946 jint len,
947 jlongArray idata) /* IN: array of long */
948 {
949  jlong *ip;
950  jlong *iarr;
951  int ilen;
952  jbyteArray rarray;
953  int blen;
954  jbyte *barray;
955  jbyte *bap;
956  jboolean bb;
957  int ii;
958  int ij;
959  union things {
960  jlong ival;
961  char bytes[8];
962  } u;
963 
964  if (idata == NULL) {
965  raiseException( env, "longToByte: idata is NULL?");
966  return NULL;
967  }
968  iarr = (*env)->GetLongArrayElements(env,idata,&bb);
969  if (iarr == NULL) {
970  JNIFatalError( env, "longToByte: getLong failed?");
971  return NULL;
972  }
973 
974  ilen = (*env)->GetArrayLength(env,idata);
975  if ((start < 0) || (((start + len)) > ilen)) {
976  (*env)->ReleaseLongArrayElements(env,idata,iarr,JNI_ABORT);
977  raiseException( env, "longToByte: start or len is out of bounds?\n");
978  return NULL;
979  }
980 
981  ip = iarr + start;
982 
983  blen = ilen * sizeof(jlong);
984  rarray = (*env)->NewByteArray(env,blen);
985  if (rarray == NULL) {
986  (*env)->ReleaseLongArrayElements(env,idata,iarr,JNI_ABORT);
987  outOfMemory( env, "longToByte" );
988  return NULL;
989  }
990 
991  barray = (*env)->GetByteArrayElements(env,rarray,&bb);
992  if (barray == NULL) {
993  (*env)->ReleaseLongArrayElements(env,idata,iarr,JNI_ABORT);
994  JNIFatalError( env, "longToByte: getByte failed?");
995  return NULL;
996  }
997 
998  bap = barray;
999  for (ii = 0; ii < len; ii++) {
1000  u.ival = *ip++;
1001  for (ij = 0; ij < sizeof(jlong); ij++) {
1002  *bap = u.bytes[ij];
1003  bap++;
1004  }
1005  }
1006 
1007  (*env)->ReleaseByteArrayElements(env,rarray,barray, 0);
1008  (*env)->ReleaseLongArrayElements(env,idata,iarr,JNI_ABORT);
1009 
1010  return rarray;
1011 
1012 }
1013  /******/
1014 
1015 
1016 /* returns byte [] */
1017 JNIEXPORT jbyteArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_intToByte__I
1018 ( JNIEnv *env,
1019 jclass class,
1020 jint idata) /* IN: int */
1021 {
1022  jbyteArray rarray;
1023  jbyte *barray;
1024  jbyte *bap;
1025  int ij;
1026  jboolean bb;
1027  union things {
1028  int ival;
1029  char bytes[sizeof(int)];
1030  } u;
1031 
1032  rarray = (*env)->NewByteArray(env,sizeof(jint));
1033  if (rarray == NULL) {
1034  outOfMemory( env, "intToByte" );
1035  return NULL;
1036  }
1037 
1038  barray = (*env)->GetByteArrayElements(env,rarray,&bb);
1039  if (barray == NULL) {
1040  JNIFatalError( env, "intToByte: getByte failed?");
1041  return NULL;
1042  }
1043 
1044  bap = barray;
1045  u.ival = idata;
1046  for (ij = 0; ij < sizeof(jint); ij++) {
1047  *bap = u.bytes[ij];
1048  bap++;
1049  }
1050 
1051  (*env)->ReleaseByteArrayElements(env,rarray,barray, 0);
1052  return rarray;
1053 
1054 }
1055 
1056 /* returns byte [] */
1057 JNIEXPORT jbyteArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_floatToByte__F
1058 ( JNIEnv *env,
1059 jclass class,
1060 jfloat idata) /* IN: int */
1061 {
1062  jbyteArray rarray;
1063  jbyte *barray;
1064  jbyte *bap;
1065  jboolean bb;
1066  int ij;
1067  union things {
1068  float ival;
1069  char bytes[sizeof(float)];
1070  } u;
1071 
1072  rarray = (*env)->NewByteArray(env,sizeof(jfloat));
1073  if (rarray == NULL) {
1074  outOfMemory( env, "floatToByte" );
1075  return NULL;
1076  }
1077 
1078  barray = (*env)->GetByteArrayElements(env,rarray,&bb);
1079  if (barray == NULL) {
1080  JNIFatalError( env, "floatToByte: getByte failed?");
1081  return NULL;
1082  }
1083 
1084  bap = barray;
1085  u.ival = idata;
1086  for (ij = 0; ij < sizeof(jfloat); ij++) {
1087  *bap = u.bytes[ij];
1088  bap++;
1089  }
1090 
1091  (*env)->ReleaseByteArrayElements(env,rarray,(jbyte *)barray, 0);
1092  return rarray;
1093 
1094 }
1095 
1096 /* returns byte [] */
1097 JNIEXPORT jbyteArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_shortToByte__S
1098 ( JNIEnv *env,
1099 jclass class,
1100 jshort idata) /* IN: short */
1101 {
1102  jbyteArray rarray;
1103  jbyte *barray;
1104  jbyte *bap;
1105  jboolean bb;
1106  int ij;
1107  union things {
1108  short ival;
1109  char bytes[sizeof(short)];
1110  } u;
1111 
1112  rarray = (*env)->NewByteArray(env,sizeof(jshort));
1113  if (rarray == NULL) {
1114  outOfMemory( env, "shortToByte" );
1115  return NULL;
1116  }
1117 
1118  barray = (*env)->GetByteArrayElements(env,rarray,&bb);
1119  if (barray == NULL) {
1120  JNIFatalError( env, "shortToByte: getShort failed?");
1121  return NULL;
1122  }
1123 
1124  bap = barray;
1125  u.ival = idata;
1126  for (ij = 0; ij < sizeof(jshort); ij++) {
1127  *bap = u.bytes[ij];
1128  bap++;
1129  }
1130 
1131  (*env)->ReleaseByteArrayElements(env,rarray,(jbyte *)barray, 0);
1132 
1133  return rarray;
1134 
1135 }
1136 
1137 
1138 /* returns byte [] */
1139 JNIEXPORT jbyteArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_doubleToByte__D
1140 ( JNIEnv *env,
1141 jclass class,
1142 jdouble idata) /* IN: double */
1143 {
1144  jbyteArray rarray;
1145  jbyte *barray;
1146  jbyte *bap;
1147  jboolean bb;
1148  int ij;
1149  union things {
1150  double ival;
1151  char bytes[sizeof(double)];
1152  } u;
1153 
1154  rarray = (*env)->NewByteArray(env,sizeof(jdouble));
1155  if (rarray == NULL) {
1156  outOfMemory( env, "doubleToByte" );
1157  return NULL;
1158  }
1159 
1160  barray = (*env)->GetByteArrayElements(env,rarray,&bb);
1161  if (barray == NULL) {
1162  JNIFatalError( env, "doubleToByte: getDouble failed?");
1163  return NULL;
1164  }
1165 
1166  bap = barray;
1167  u.ival = idata;
1168  for (ij = 0; ij < sizeof(jdouble); ij++) {
1169  *bap = u.bytes[ij];
1170  bap++;
1171  }
1172 
1173  (*env)->ReleaseByteArrayElements(env,rarray,(jbyte *)barray, 0);
1174 
1175  return rarray;
1176 }
1177 
1178 
1179 /* returns byte [] */
1180 JNIEXPORT jbyteArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_longToByte__J
1181 ( JNIEnv *env,
1182 jclass class,
1183 jlong idata) /* IN: array of long */
1184 {
1185  jbyteArray rarray;
1186  jbyte *barray;
1187  jbyte *bap;
1188  jboolean bb;
1189  int ij;
1190  union things {
1191  jlong ival;
1192  char bytes[sizeof(jlong)];
1193  } u;
1194 
1195  rarray = (*env)->NewByteArray(env,sizeof(jlong));
1196  if (rarray == NULL) {
1197  outOfMemory( env, "longToByte" );
1198  return NULL;
1199  }
1200 
1201  barray = (*env)->GetByteArrayElements(env,rarray,&bb);
1202  if (barray == NULL) {
1203  JNIFatalError( env, "longToByte: getLong failed?");
1204  return NULL;
1205  }
1206 
1207  bap = barray;
1208  u.ival = idata;
1209  for (ij = 0; ij < sizeof(jlong); ij++) {
1210  *bap = u.bytes[ij];
1211  bap++;
1212  }
1213 
1214  (*env)->ReleaseByteArrayElements(env,rarray,(jbyte *)barray, 0);
1215 
1216  return rarray;
1217 
1218 }
1219 
1220 /* returns byte [] */
1221 JNIEXPORT jbyteArray JNICALL Java_ncsa_hdf_hdflib_HDFNativeData_byteToByte__B
1222 ( JNIEnv *env,
1223 jclass class,
1224 jbyte idata) /* IN: array of long */
1225 {
1226  jbyteArray rarray;
1227  jbyte *barray;
1228  jbyte *bap;
1229  jboolean bb;
1230  int ij;
1231  union things {
1232  jbyte ival;
1233  char bytes[sizeof(jbyte)];
1234  } u;
1235 
1236  rarray = (*env)->NewByteArray(env,sizeof(jbyte));
1237  if (rarray == NULL) {
1238  outOfMemory( env, "byteToByte" );
1239  return NULL;
1240  }
1241 
1242  barray = (*env)->GetByteArrayElements(env,rarray,&bb);
1243  if (barray == NULL) {
1244  JNIFatalError( env, "byteToByte: getByte failed?");
1245  return NULL;
1246  }
1247 
1248  bap = barray;
1249  u.ival = idata;
1250  for (ij = 0; ij < sizeof(jbyte); ij++) {
1251  *bap = u.bytes[ij];
1252  bap++;
1253  }
1254 
1255  (*env)->ReleaseByteArrayElements(env,rarray,(jbyte *)barray, 0);
1256 
1257  return rarray;
1258 }