int
getCurrRig(int32 *pXdim, int32 *pYdim, char **pPalette, char **pRaster)
{
int ispal;
goTo(he_currDesc);
if (DFR8getdims(he_file, pXdim, pYdim, &ispal) < 0)
{
fprintf(stderr, "Error getting image group.\n");
HEprint(stderr, 0);
return FAIL;
}
if (ispal)
*pPalette = (char *) HDmalloc(HE_PALETTE_SZ);
else
*pPalette = (char *) NULL;
*pRaster = (char *) HDmalloc((size_t)(*pXdim) * (size_t)(*pYdim));
if (DFR8getimage(he_file, (unsigned char *) *pRaster, *pXdim, *pYdim,
(unsigned char *) *pPalette) == FAIL)
{
fprintf(stderr, "Error getting image group.\n");
HEprint(stderr, 0);
return FAIL;
}
return HE_OK;
}
PRIVATE VOID
split_box(struct box * ptr)
{
int dim, j, i;
float median;
struct box *l_child, *r_child;
dim = select_dim(ptr);
median = find_med(ptr, dim);
/* create 2 child */
l_child = (struct box *) HDmalloc(sizeof(struct box));
r_child = (struct box *) HDmalloc(sizeof(struct box));
for (i = RED; i <= BLUE; i++)
for (j = HI; j <= LO; j++)
{
l_child->bnd[i][j] = ptr->bnd[i][j];
r_child->bnd[i][j] = ptr->bnd[i][j];
}
l_child->bnd[dim][HI] = median;
r_child->bnd[dim][LO] = median;
classify(ptr, l_child);
classify(ptr, r_child);
r_child->right = ptr->right;
r_child->left = l_child;
l_child->right = r_child;
l_child->left = ptr->left;
(ptr->left)->right = l_child;
if (ptr->right != NULL)
(ptr->right)->left = r_child;
} /* end of split_box */
static void
get_unique_name(void)
{
const char *prefix = NULL;
const char *env = HDgetenv("HDF5_PREFIX");
if (env)
prefix = env;
if (option_prefix)
prefix = option_prefix;
if (prefix)
/* 2 = 1 for '/' + 1 for null terminator */
filename = (char *) HDmalloc(HDstrlen(prefix) + HDstrlen(ZIP_PERF_FILE) + 2);
else
filename = (char *) HDmalloc(HDstrlen(ZIP_PERF_FILE) + 1);
if (!filename)
error("out of memory");
filename[0] = 0;
if (prefix){
HDstrcpy(filename, prefix);
HDstrcat(filename, "/");
}
HDstrcat(filename, ZIP_PERF_FILE);
}
static int
test_encode_decode(hid_t orig_pl, int mpi_rank, int recv_proc)
{
MPI_Request req[2];
MPI_Status status;
hid_t pl; /* Decoded property list */
size_t buf_size = 0;
void *sbuf = NULL;
herr_t ret; /* Generic return value */
if(mpi_rank == 0) {
int send_size = 0;
/* first call to encode returns only the size of the buffer needed */
ret = H5Pencode(orig_pl, NULL, &buf_size);
VRFY((ret >= 0), "H5Pencode succeeded");
sbuf = (uint8_t *)HDmalloc(buf_size);
ret = H5Pencode(orig_pl, sbuf, &buf_size);
VRFY((ret >= 0), "H5Pencode succeeded");
/* this is a temp fix to send this size_t */
send_size = (int)buf_size;
MPI_Isend(&send_size, 1, MPI_INT, recv_proc, 123, MPI_COMM_WORLD, &req[0]);
MPI_Isend(sbuf, send_size, MPI_BYTE, recv_proc, 124, MPI_COMM_WORLD, &req[1]);
} /* end if */
if(mpi_rank == recv_proc) {
int recv_size;
void *rbuf;
MPI_Recv(&recv_size, 1, MPI_INT, 0, 123, MPI_COMM_WORLD, &status);
buf_size = recv_size;
rbuf = (uint8_t *)HDmalloc(buf_size);
MPI_Recv(rbuf, recv_size, MPI_BYTE, 0, 124, MPI_COMM_WORLD, &status);
pl = H5Pdecode(rbuf);
VRFY((pl >= 0), "H5Pdecode succeeded");
VRFY(H5Pequal(orig_pl, pl), "Property List Equal Succeeded");
ret = H5Pclose(pl);
VRFY((ret >= 0), "H5Pclose succeeded");
if(NULL != rbuf)
HDfree(rbuf);
} /* end if */
if(0 == mpi_rank)
MPI_Waitall(2, req, MPI_STATUSES_IGNORE);
if(NULL != sbuf)
HDfree(sbuf);
MPI_Barrier(MPI_COMM_WORLD);
return(0);
}
int_f
nh5sselect_hyperslab_c ( hid_t_f *space_id , int_f *op, hsize_t_f *start, hsize_t_f *count, hsize_t_f *stride, hsize_t_f *block)
{
int ret_value = -1;
hid_t c_space_id;
hsize_t *c_start = NULL;
hsize_t *c_count = NULL;
hsize_t *c_stride = NULL;
hsize_t *c_block = NULL;
H5S_seloper_t c_op;
herr_t status;
int rank;
int i;
rank = H5Sget_simple_extent_ndims(*space_id);
if (rank < 0 ) return ret_value;
c_start = (hsize_t *)HDmalloc(sizeof(hsize_t)*rank);
if (c_start == NULL) goto DONE;
c_count = (hsize_t *)HDmalloc(sizeof(hsize_t)*rank);
if (c_count == NULL) goto DONE;
c_stride = (hsize_t *)HDmalloc(sizeof(hsize_t)*rank);
if (c_stride == NULL) goto DONE;
c_block = (hsize_t *)HDmalloc(sizeof(hsize_t)*rank);
if (c_block == NULL) goto DONE;
/*
* Reverse dimensions due to C-FORTRAN storage order.
*/
for (i=0; i < rank; i++) {
int t= (rank - i) - 1;
c_start[i] = (hsize_t)start[t];
c_count[i] = (hsize_t)count[t];
c_stride[i] = (hsize_t)stride[t];
c_block[i] = (hsize_t)block[t];
}
c_op = (H5S_seloper_t)*op;
/*
if (*op == H5S_SELECT_SET_F) c_op = H5S_SELECT_SET;
if (*op == H5S_SELECT_OR_F) c_op = H5S_SELECT_OR;
*/
c_space_id = *space_id;
status = H5Sselect_hyperslab(c_space_id, c_op, c_start, c_stride, c_count, c_block);
if ( status >= 0 ) ret_value = 0;
DONE:
if(c_start != NULL) HDfree(c_start);
if(c_count != NULL) HDfree(c_count);
if(c_stride!= NULL) HDfree(c_stride);
if(c_block != NULL) HDfree(c_block);
return ret_value;
}
int_f
h5dread_vl_string_c( hid_t_f *dset_id , hid_t_f *mem_type_id, hid_t_f *mem_space_id, hid_t_f *file_space_id, hid_t_f *xfer_prp, _fcd buf, hsize_t_f *dims, size_t_f *len)
/******/
{
int ret_value = -1;
hid_t c_dset_id;
hid_t c_mem_type_id;
hid_t c_mem_space_id;
hid_t c_file_space_id;
hid_t c_xfer_prp;
herr_t status;
char *tmp, *tmp_p;
size_t max_len;
char **c_buf;
hsize_t i;
hsize_t num_elem;
max_len = (size_t)dims[0];
num_elem = (hsize_t)dims[1];
c_dset_id = (hid_t)*dset_id;
c_mem_type_id = (hid_t)*mem_type_id;
c_mem_space_id = (hid_t)*mem_space_id;
c_file_space_id = (hid_t)*file_space_id;
c_xfer_prp = (hid_t)*xfer_prp;
/*
* Allocate array of character pointers
*/
c_buf = (char **)HDmalloc((size_t)num_elem * sizeof(char *));
if (c_buf == NULL) return ret_value;
/*
* Call H5Dread function.
*/
status = H5Dread(c_dset_id, c_mem_type_id, c_mem_space_id, c_file_space_id, c_xfer_prp, c_buf);
if (status < 0) { HDfree(c_buf);
return ret_value;
}
/* Copy data to long C string */
tmp = (char *)HDmalloc((size_t)(max_len*num_elem) +1);
tmp_p = tmp;
for (i=0; i<max_len*num_elem; i++) tmp[i] = ' ';
tmp[max_len*num_elem] = '\0';
for (i=0; i < num_elem; i++) {
memcpy(tmp_p, c_buf[i], strlen(c_buf[i]));
len[i] = (size_t_f)strlen(c_buf[i]);
tmp_p = tmp_p + max_len;
}
HD5packFstring(tmp, _fcdtocp(buf), (size_t)(max_len*num_elem));
ret_value = 0;
H5Dvlen_reclaim(c_mem_type_id, c_mem_space_id, H5P_DEFAULT, c_buf);
HDfree(c_buf);
HDfree(tmp);
return ret_value;
}
/*-------------------------------------------------------------------------
* Function: init_table
*
* Purpose: allocate and initialize tables for shared groups, datasets,
* and committed types
*
* Return: void
*
* Programmer: Ruey-Hsia Li
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
init_table(table_t **tbl)
{
table_t *table = (table_t *)HDmalloc(sizeof(table_t));
table->size = 20;
table->nobjs = 0;
table->objs = (obj_t *)HDmalloc(table->size * sizeof(obj_t));
*tbl = table;
}
/*-------------------------------------------------------------------------
* Function: trav_print_visit_lnk
*
* Purpose: Callback for visiting link, when printing info
*
* Return: 0 on success,
* -1 on failure
*-------------------------------------------------------------------------
*/
static int
trav_print_visit_lnk(const char *path, const H5L_info_t *linfo, void *udata)
{
trav_print_udata_t *print_udata = (trav_print_udata_t *)udata;
/* Print appropriate information for the type of link */
switch(linfo->type) {
case H5L_TYPE_SOFT:
if(linfo->u.val_size > 0) {
char *targbuf = (char*)HDmalloc(linfo->u.val_size + 1);
if(targbuf) {
if(H5Lget_val(print_udata->fid, path, targbuf, linfo->u.val_size + 1, H5P_DEFAULT) < 0)
targbuf[0] = 0;
printf(" %-10s %s -> %s\n", "link", path, targbuf);
HDfree(targbuf);
}
} /* end if */
else
printf(" %-10s %s ->\n", "link", path);
break;
case H5L_TYPE_EXTERNAL:
if(linfo->u.val_size > 0) {
char *targbuf = NULL;
const char *filename = NULL;
const char *objname = NULL;
targbuf = (char*)HDmalloc(linfo->u.val_size + 1);
if(targbuf) {
if(H5Lget_val(print_udata->fid, path, targbuf, linfo->u.val_size + 1, H5P_DEFAULT) < 0)
targbuf[0] = 0;
if(H5Lunpack_elink_val(targbuf, linfo->u.val_size, NULL, &filename, &objname) >= 0)
printf(" %-10s %s -> %s %s\n", "ext link", path, filename, objname);
HDfree(targbuf);
}
} /* end if */
else
printf(" %-10s %s ->\n", "ext link", path);
break;
case H5L_TYPE_HARD:
/* Should be handled elsewhere */
return(-1);
case H5L_TYPE_ERROR:
case H5L_TYPE_MAX:
default:
printf(" %-10s %s -> ???\n", "unknown type of UD link", path);
break;
} /* end switch() */
return(0);
} /* end trav_print_visit_lnk() */
static int
test_plists(const char *filename1, const char *filename2)
{
int fd_le, fd_be;
size_t size_le = 0, size_be = 0;
void *buf_le = NULL, *buf_be = NULL;
hid_t plist_le, plist_be; /* dataset create prop. list */
const char *testfile;
testfile = H5_get_srcdir_filename(filename1);
if((fd_le = HDopen(testfile, O_RDONLY, 0666)) < 0)
TEST_ERROR
size_le = HDlseek(fd_le, (HDoff_t)0, SEEK_END);
HDlseek(fd_le, (HDoff_t)0, SEEK_SET);
buf_le = (void *)HDmalloc(size_le);
if(HDread(fd_le, buf_le, size_le) < 0)
TEST_ERROR
HDclose(fd_le);
testfile = H5_get_srcdir_filename(filename2);
if((fd_be = HDopen(testfile, O_RDONLY, 0666)) < 0)
TEST_ERROR
size_be = HDlseek(fd_be, (HDoff_t)0, SEEK_END);
HDlseek(fd_be, (HDoff_t)0, SEEK_SET);
buf_be = (void *)HDmalloc(size_be);
if(HDread(fd_be, buf_be, size_be) < 0)
TEST_ERROR
HDclose(fd_be);
if((plist_le = H5Pdecode(buf_le)) < 0)
FAIL_STACK_ERROR
if((plist_be = H5Pdecode(buf_be)) < 0)
FAIL_STACK_ERROR
if(!H5Pequal(plist_le, plist_be))
FAIL_PUTS_ERROR("PLIST encoding/decoding comparison failed\n")
if((H5Pclose(plist_le)) < 0)
FAIL_STACK_ERROR
if((H5Pclose(plist_be)) < 0)
FAIL_STACK_ERROR
HDfree(buf_le);
HDfree(buf_be);
return 1;
error:
printf("***** Plist Encode/Decode tests FAILED! *****\n");
return -1;
}
/*
* This function opens all the datasets in a certain, checks the data using
* dataset_vrfy function.
*
* Changes: Updated function to use a dynamically calculated size,
* instead of the old SIZE #define. This should allow it
* to function with an arbitrary number of processors.
*
* JRM - 8/11/04
*/
int read_dataset(hid_t memspace, hid_t filespace, hid_t gid)
{
int i, j, n, mpi_rank, mpi_size, size, attr_errors=0, vrfy_errors=0;
char dname[32];
DATATYPE *outdata = NULL, *indata = NULL;
hid_t did;
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
size = get_size();
indata = (DATATYPE*)HDmalloc((size_t)(size * size * sizeof(DATATYPE)));
VRFY((indata != NULL), "HDmalloc succeeded for indata");
outdata = (DATATYPE*)HDmalloc((size_t)(size * size * sizeof(DATATYPE)));
VRFY((outdata != NULL), "HDmalloc succeeded for outdata");
for(n=0; n<NDATASET; n++) {
sprintf(dname, "dataset%d", n);
did = H5Dopen(gid, dname);
VRFY((did>0), dname);
H5Dread(did, H5T_NATIVE_INT, memspace, filespace, H5P_DEFAULT,
indata);
/* this is the original value */
for(i=0; i<size; i++)
for(j=0; j<size; j++) {
*outdata = n*1000 + mpi_rank;
outdata++;
}
outdata -= size * size;
/* compare the original value(outdata) to the value in file(indata).*/
vrfy_errors = check_value(indata, outdata, size);
/* check attribute.*/
if( (attr_errors = read_attribute(did, is_dset, n))>0 )
vrfy_errors += attr_errors;
H5Dclose(did);
}
HDfree(indata);
HDfree(outdata);
return vrfy_errors;
}
int
DFgetcomp(int32 file_id, uint16 tag, uint16 ref, uint8 *image, int32 xdim,
int32 ydim, uint16 scheme)
{
CONSTR(FUNC, "DFgetcomp");
uint8 *buffer;
uint8 *in;
uint8 *out;
int32 cisize, crowsize, buflen, bufleft; /* bufleft: bytes left in buffer */
int32 i;
int32 totalread;
int32 n;
int32 aid;
if (!HDvalidfid(file_id) || !tag || !ref || xdim <= 0 || ydim <= 0 || !image)
HRETURN_ERROR(DFE_ARGS, FAIL);
/* put this call up here instead of in switch statement, to make the */
/* code easier to follow */
if (scheme == DFTAG_JPEG5 || scheme == DFTAG_GREYJPEG5
|| scheme==DFTAG_JPEG || scheme==DFTAG_GREYJPEG)
return (DFCIunjpeg(file_id, tag, ref, (VOIDP) image, xdim, ydim, (int16)scheme));
/* Only do this stuff for non-JPEG compressed images */
aid = Hstartread(file_id, tag, ref);
if (aid == FAIL)
HRETURN_ERROR(DFE_NOMATCH, FAIL);
if (Hinquire(aid, (int32 *) NULL, (uint16 *) NULL, (uint16 *) NULL, &cisize,
(int32 *) NULL, (int32 *) NULL, (int16 *) NULL, (int16 *) NULL) == FAIL)
return FAIL;
switch (scheme)
{
case DFTAG_RLE:
crowsize = xdim * 121 / 120 + 128; /* max size of a row */
buffer = (uint8 *) HDmalloc((uint32) cisize);
if (!buffer)
{
buffer = (uint8 *) HDmalloc((uint32) crowsize);
if (!buffer)
{
Hendaccess(aid);
HRETURN_ERROR(DFE_NOSPACE, FAIL)
} /* end if */
buflen = crowsize;
} /* end if */
/*----------------------------------------------------------------------------
* Name: h5aget_name_c
* Purpose: Call H5Aget_name to get attribute's name
* Inputs: attr_id - attribute identifier
* bufsize -size of the buffer
* Outputs: buf - buffer to hold the name
* Returns: 0 on success, -1 on failure
* Programmer: Elena Pourmal
* Thursday, August 12, 1999
* Modifications:
*---------------------------------------------------------------------------*/
int_f
nh5aget_name_c(hid_t_f *attr_id, size_t_f *bufsize, _fcd buf)
{
char *c_buf=NULL; /* Buffer to hold C string */
int_f ret_value=0; /* Return value */
/*
* Allocate buffer to hold name of an attribute
*/
if ((c_buf = HDmalloc((size_t)*bufsize +1)) == NULL)
HGOTO_DONE(FAIL);
/*
* Call H5Aget_name function
*/
if ((ret_value = (int_f)H5Aget_name((hid_t)*attr_id, (size_t)*bufsize, c_buf)) < 0)
HGOTO_DONE(FAIL);
/*
* Convert C name to FORTRAN and place it in the given buffer
*/
HD5packFstring(c_buf, _fcdtocp(buf), (size_t)*bufsize);
done:
if(c_buf) HDfree(c_buf);
return ret_value;
}
static int
encode_plist(hid_t plist_id, int little_endian, const char *filename_le, const char *filename_be)
{
int fd = 0; /* file descriptor */
herr_t ret = 0;
void *temp_buf = NULL;
size_t temp_size = 0;
ssize_t write_size;
/* first call to encode returns only the size of the buffer needed */
if((ret = H5Pencode(plist_id, NULL, &temp_size)) < 0)
assert(ret > 0);
temp_buf = (void *)HDmalloc(temp_size);
assert(temp_buf);
if((ret = H5Pencode(plist_id, temp_buf, &temp_size)) < 0)
assert(ret > 0);
if(little_endian)
fd = HDopen(filename_le, O_RDWR | O_CREAT | O_TRUNC, 0666);
else
fd = HDopen(filename_be, O_RDWR | O_CREAT | O_TRUNC, 0666);
assert(fd > 0);
write_size = HDwrite(fd, temp_buf, temp_size);
assert(write_size == (ssize_t)temp_size);
HDclose(fd);
HDfree(temp_buf);
return 1;
}
/*
* Class: hdf_hdf5lib_H5
* Method: H5Oget_comment
* Signature: (J)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL
Java_hdf_hdf5lib_H5_H5Oget_1comment
(JNIEnv *env, jclass clss, jlong loc_id)
{
jstring str = NULL;
ssize_t buf_size;
ssize_t status = -1;
char *oComment = NULL;
UNUSED(clss);
/* Get the length of the comment */
if ((buf_size = H5Oget_comment((hid_t)loc_id, NULL, 0)) < 0)
H5_LIBRARY_ERROR(ENVONLY);
if (buf_size) {
if (NULL == (oComment = (char *) HDmalloc(sizeof(char) * (size_t)buf_size + 1)))
H5_JNI_FATAL_ERROR(ENVONLY, "H5Oget_comment: failed to allocate object comment buffer");
if ((status = H5Oget_comment((hid_t)loc_id, oComment, (size_t)buf_size + 1)) < 0)
H5_LIBRARY_ERROR(ENVONLY);
oComment[buf_size] = '\0';
if (NULL == (str = ENVPTR->NewStringUTF(ENVONLY, oComment)))
CHECK_JNI_EXCEPTION(ENVONLY, JNI_FALSE);
}
done:
if (oComment)
HDfree(oComment);
return (jstring)str;
} /* end Java_hdf_hdf5lib_H5_H5Oget_1comment */
int32
getElement(int desc, char **pdata)
{
int32 length;
int32 fid;
length = he_desc[desc].length;
/* alloc memory to read the element in */
*pdata = (char *) HDmalloc(length);
if (*pdata == NULL)
return FAIL;
/* read in the element and check for error */
if ((fid = Hopen(he_file, DFACC_READ, 0)) == 0)
{
HEprint(stderr, 0);
return FAIL;
}
if (Hgetelement(fid, he_desc[desc].tag, he_desc[desc].ref, (unsigned char *) (*pdata)) < 0)
{
HDfree(*pdata);
fprintf(stderr, "Cannot read element.\n");
return FAIL;
}
Hclose(fid);
return length;
}
PRIVATE VOID
init_global(int32 xdim, int32 ydim, VOIDP out, VOIDP out_pal)
{
int32 i, j;
/* allocate memory */
image = (unsigned char *) out;
new_pal = (unsigned char *) out_pal;
if (color_pt)
HDfree((VOIDP) color_pt);
color_pt = (struct rgb *) HDmalloc((unsigned) ((xdim * ydim) / 8) *
sizeof(struct rgb));
if (image == NULL || color_pt == NULL || new_pal == NULL)
{
return; /* punt! */
}
/* initialize */
for (i = 0; i < (xdim * ydim / 4); i++)
image[i] = 0;
for (i = 0; i < (xdim * ydim / 8); i++)
for (j = RED; j <= BLUE; j++)
color_pt[i].c[j] = 0;
for (i = 0; i < MAXCOLOR; i++)
trans[i] = -1;
} /* end of init_global */
/*
NAME
HDgettagsname -- return a text name of a tag
USAGE
char * HDgettagsname(tag)
uint16 tag; IN: tag of element to find
RETURNS
Descriptive text or NULL
DESCRIPTION
Map a tag to a dynamically allocated text name of it.
Checks for special elements now.
--------------------------------------------------------------------------- */
char *
HDgettagsname(uint16 tag)
{
CONSTR(FUNC, "HDgettagsname"); /* for HERROR */
char *ret = NULL;
intn i;
if (SPECIALTAG(tag))
ret = (char *) HDstrdup("Special ");
tag = BASETAG(tag);
for (i = 0; i < (intn)(sizeof(tag_descriptions) / sizeof(tag_descript_t)); i++)
if (tag_descriptions[i].tag == tag)
{
if (ret == NULL)
ret = (char *) HDstrdup(tag_descriptions[i].name);
else
{
char *t;
t = (char *) HDmalloc(HDstrlen(ret) +
HDstrlen(tag_descriptions[i].name) + 2);
if (t == NULL)
{
HDfree(ret);
HRETURN_ERROR(DFE_NOSPACE, NULL)
} /* end if */
HDstrcpy(t, ret);
HDstrcat(t, tag_descriptions[i].name);
HDfree(ret);
ret = t;
} /* end else */
} /* end if */
/******************************************************************************
NAME
HULIget_list_node - Gets a list node
DESCRIPTION
Either gets an list node from the free list (if there is one available)
or allocate a node.
RETURNS
Returns list node ptr if successful and NULL otherwise
*******************************************************************************/
static node_info_t *HULIget_list_node(void)
{
CONSTR(FUNC, "HULIget_list_node"); /* for HERROR */
node_info_t *ret_value=NULL;
HEclear();
if(node_free_list!=NULL)
{
ret_value=node_free_list;
node_free_list=node_free_list->next;
} /* end if */
else
{
if((ret_value=(node_info_t *)HDmalloc(sizeof(node_info_t)))==NULL)
HGOTO_ERROR(DFE_NOSPACE, NULL);
} /* end else */
done:
if(ret_value == NULL)
{ /* Error condition cleanup */
} /* end if */
/* Normal function cleanup */
return ret_value;
} /* end HULIget_list_node() */
void list_table_add(list_table_t *list_tbl, int tag, int ref, char* path)
{
int path_len;
int i;
if (list_tbl->nobjs == list_tbl->size)
{
list_tbl->size *= 2;
list_tbl->objs = (obj_info_t*)realloc(list_tbl->objs, list_tbl->size * sizeof(obj_info_t));
for (i = list_tbl->nobjs; i < list_tbl->size; i++)
{
list_tbl->objs[i].tag = -1;
list_tbl->objs[i].ref = -1;
list_tbl->objs[i].path = NULL;
}
}
i = list_tbl->nobjs++;
list_tbl->objs[i].tag = tag;
list_tbl->objs[i].ref = ref;
/* copy the path over */
path_len = HDstrlen(path);
list_tbl->objs[i].path = (char *)HDmalloc(path_len+1);
HIstrncpy(list_tbl->objs[i].path, path, path_len+1);
}
/****if* H5Ff/h5fget_obj_ids_c
* NAME
* h5fget_obj_ids_c
* PURPOSE
* Call H5Fget_obj_count to get number of open objects within a file
* INPUTS
* file_id - identifier of the file to be closed
* obj_type - type of the object
* RETURNS
* obj_ids - iarray of open objects identifiers
* 0 on success, -1 on failure
* AUTHOR
* Elena Pourmal
* Monday, September 30, 2002
* HISTORY
*
* Changed type of max_obj to size_t_f; added parameter for the
* number of open objects
* Thursday, September 25, 2008 EIP
*
* SOURCE
*/
int_f
nh5fget_obj_ids_c ( hid_t_f *file_id , int_f *obj_type, size_t_f *max_objs,
hid_t_f *obj_ids, size_t_f *num_objs)
/******/
{
int ret_value = 0;
hid_t c_file_id;
unsigned c_obj_type;
size_t u;
size_t c_max_objs;
ssize_t c_num_objs;
hid_t *c_obj_ids;
c_file_id = (hid_t)*file_id;
c_obj_type = (unsigned) *obj_type;
c_max_objs = (size_t)*max_objs;
c_obj_ids = (hid_t *)HDmalloc(sizeof(hid_t)*c_max_objs);
c_num_objs = H5Fget_obj_ids(c_file_id, c_obj_type, c_max_objs, c_obj_ids);
if(c_num_objs < 0)
ret_value = -1;
for(u = 0; u < c_max_objs; u++)
obj_ids[u] = (hid_t_f)c_obj_ids[u];
HDfree(c_obj_ids);
*num_objs = (size_t_f)c_num_objs;
return ret_value;
}
/*
* Class: hdf_hdf5lib_H5
* Method: H5Iget_name_long
* Signature: (JLjava/lang/String;J)J
*/
JNIEXPORT jlong JNICALL
Java_hdf_hdf5lib_H5_H5Iget_1name_1long
(JNIEnv *env, jclass clss, jlong obj_id, jobjectArray name, jlong buf_size)
{
char *aName;
jstring str;
hssize_t size = -1;
long bs;
bs = (long)buf_size;
if (bs <= 0) {
h5badArgument(env, "H5Iget_name: buf_size <= 0");
} /* end if */
else {
aName = (char*)HDmalloc(sizeof(char) * (size_t)bs);
if (aName == NULL) {
h5outOfMemory(env, "H5Iget_name: malloc failed");
} /* end if */
else {
size = H5Iget_name((hid_t)obj_id, aName, (size_t)buf_size);
if (size < 0) {
h5libraryError(env);
} /* end if */
else {
str = ENVPTR->NewStringUTF(ENVPAR aName);
ENVPTR->SetObjectArrayElement(ENVPAR name, 0, str);
}
HDfree(aName);
}
}
return (jlong)size;
} /* end Java_hdf_hdf5lib_H5_H5Iget_1name */
ndailist(_fcd filename, intf * tag, intf reflist[], _fcd labellist,
intf * listsize, intf * maxlen, intf * startpos, intf * fnlen)
{
char *fn;
int i;
intf nrefs;
uint16 *tempreflist;
fn = HDf2cstring(filename, (intn) *fnlen);
if (!fn)
return(-1);
/* create reflist with true uint16s to maintain compatibility
** with machines that allocate more than 16 bits per uint16.
*/
tempreflist = (uint16 *) HDmalloc((size_t) (*listsize) * sizeof(uint16));
/* 1 for isfortran */
nrefs = DFANIlablist(fn, (uint16) *tag, tempreflist,
(uint8 *) _fcdtocp(labellist),
(int) *listsize, (int) *maxlen, (int) *startpos, 1);
if (nrefs < 0)
return FAIL;
/* move ref numbers into caller's reflist */
for (i = 0; i < *listsize; i++)
reflist[i] = (intf)tempreflist[i];
HDfree((VOIDP) fn);
HDfree((VOIDP) tempreflist);
return (nrefs);
}
/*
* Class: hdf_hdf5lib_H5
* Method: H5Aget_name
* Signature: (J)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL
Java_hdf_hdf5lib_H5_H5Aget_1name
(JNIEnv *env, jclass clss, jlong attr_id)
{
char *aName;
jstring str = NULL;
ssize_t buf_size;
/* get the length of the name */
buf_size = H5Aget_name((hid_t)attr_id, 0, NULL);
if (buf_size <= 0) {
h5badArgument(env, "H5Aget_name: buf_size <= 0");
} /* end if */
else {
buf_size++; /* add extra space for the null terminator */
aName = (char*)HDmalloc(sizeof(char) * (size_t)buf_size);
if (aName == NULL) {
h5outOfMemory(env, "H5Aget_name: malloc failed");
} /* end if */
else {
buf_size = H5Aget_name((hid_t)attr_id, (size_t)buf_size, aName);
if (buf_size < 0) {
HDfree(aName);
h5libraryError(env);
} /* end if */
else {
/* save the string; */
str = ENVPTR->NewStringUTF(ENVPAR aName);
HDfree(aName);
} /* end else */
} /* end else */
} /* end else */
return str;
} /* end Java_hdf_hdf5lib_H5_H5Aget_1name */
/****if* H5Ff/h5fget_name_c
* NAME
* h5fget_name_c
* PURPOSE
* Call H5Fget_name to get file's name
* INPUTS
* obj_id - object identifier
* buflen -size of the buffer
* OUTPUTS
* buf - buffer to hold the name
* size - size of the file's name
* RETURNS
* 0 on success, -1 on failure
* AUTHOR
* Elena Pourmal
* Tuesday, July 6, 2004
* SOURCE
*/
int_f
nh5fget_name_c(hid_t_f *obj_id, size_t_f *size, _fcd buf, size_t_f *buflen)
/******/
{
char *c_buf = NULL; /* Buffer to hold C string */
ssize_t size_c = -1;
int_f ret_value = 0; /* Return value */
/*
* Allocate buffer to hold name of an attribute
*/
if(NULL == (c_buf = (char *)HDmalloc((size_t)*buflen + 1)))
HGOTO_DONE(FAIL);
/*
* Call H5Fget_name function
*/
if ((size_c = H5Fget_name((hid_t)*obj_id, c_buf, (size_t)*buflen)) < 0)
HGOTO_DONE(FAIL);
/*
* Convert C name to FORTRAN and place it in the given buffer
*/
HD5packFstring(c_buf, _fcdtocp(buf), (size_t)*buflen);
done:
*size = (size_t_f)size_c;
if(c_buf) HDfree(c_buf);
return ret_value;
}
/*----------------------------------------------------------------------------
* Name: h5_fixname_c
* Purpose: Call h5_fixname to modify file name
* Inputs: base_name - name of the file
* base_namelen - name length
* fapl - file access property list
* full_name - buffer to return full name
* full_namelen - name length
* Returns: 0 on success, -1 on failure
* Programmer: Elena Pourmal
* Friday, September 13, 2002
* Modifications:
*---------------------------------------------------------------------------*/
int_f
nh5_fixname_c(_fcd base_name, size_t_f *base_namelen, hid_t_f* fapl, _fcd full_name, size_t_f *full_namelen)
{
int ret_value = -1;
char *c_base_name;
char *c_full_name;
hid_t c_fapl;
/*
* Define ifile access property list
*/
c_fapl = (hid_t)*fapl;
/*
* Convert FORTRAN name to C name
*/
c_base_name = (char *)HD5f2cstring(base_name, (size_t)*base_namelen);
if (c_base_name == NULL) goto DONE;
c_full_name = (char *) HDmalloc((size_t)*full_namelen + 1);
if (c_full_name == NULL) goto DONE;
/*
* Call h5_fixname function.
*/
if (NULL != h5_fixname(c_base_name, c_fapl, c_full_name, (size_t)*full_namelen + 1)) {
HD5packFstring(c_full_name, _fcdtocp(full_name), (size_t)*full_namelen);
ret_value = 0;
goto DONE;
}
DONE:
if (NULL != c_base_name) HDfree(c_base_name);
if (NULL != c_full_name) HDfree(c_full_name);
return ret_value;
}
/****if* H5If/h5iget_name_c
* NAME
* h5iget_name_c
* PURPOSE
* Call H5Iget_name to get object's name
* INPUTS
* obj_id - object identifier
* buf_size - size of the buffer
* OUTPUTS
* buf - buffer to hold the name
* RETURNS
* length of the name on success, -1 on failure
* AUTHOR
* Elena Pourmal
* Wednesday, March 12, 2003
* HISTORY
*
* Changed the size of c_buf_size to c_buf_size + 1, which
* fixes the problem of truncating the string by 1 if the
* exact size of the string (buf_size) is passed in.
* M. Scot Breitenfeld, April 21, 2008
* SOURCE
*/
int_f
h5iget_name_c(hid_t_f *obj_id, _fcd buf, size_t_f *buf_size, size_t_f *name_size)
/******/
{
int ret_value = -1;
hid_t c_obj_id;
ssize_t c_size;
size_t c_buf_size;
char *c_buf =NULL;
/*
* Allocate buffer to hold name of an object
*/
c_buf_size = (size_t)*buf_size +1;
c_buf = (char *)HDmalloc(c_buf_size);
if (c_buf == NULL) return ret_value;
/*
* Call H5IAget_name function
*/
c_obj_id = (hid_t)*obj_id;
c_size = H5Iget_name(c_obj_id, c_buf, c_buf_size);
if (c_size < 0) goto DONE;
/*
* Convert C name to FORTRAN and place it in the given buffer
*/
HD5packFstring(c_buf, _fcdtocp(buf), c_buf_size-1);
*name_size = (size_t_f)c_size;
ret_value = 0;
DONE:
HDfree(c_buf);
return ret_value;
}
/*--------------------------------------------------------------------------
NAME
HCIcszip_encode -- Encode data from a buffer into SZIP compressed data
USAGE
int32 HCIcszip_encode(info,length,buf)
compinfo_t *info; IN: the info about the compressed element
int32 length; IN: number of bytes to store from the buffer
const uint8 *buf; OUT: buffer to get the bytes from
RETURNS
Returns SUCCEED or FAIL
DESCRIPTION
Common code called to encode SZIP data into a file.
GLOBAL VARIABLES
COMMENTS, BUGS, ASSUMPTIONS
EXAMPLES
REVISION LOG
--------------------------------------------------------------------------*/
PRIVATE int32
HCIcszip_encode(compinfo_t * info, int32 length, const uint8 *buf)
{
CONSTR(FUNC, "HCIcszip_encode");
#ifdef H4_HAVE_SZIP_ENCODER
int bytes_per_pixel;
comp_coder_szip_info_t *szip_info; /* ptr to SZIP info */
int32 buffer_size;
if (SZ_encoder_enabled() == 0)
HRETURN_ERROR(DFE_NOENCODER, FAIL);
szip_info = &(info->cinfo.coder_info.szip_info);
if (szip_info->szip_state == SZIP_INIT) {
/* Need to initialize */
bytes_per_pixel = (szip_info->bits_per_pixel + 7) >> 3;
if (bytes_per_pixel == 3)
bytes_per_pixel = 4;
buffer_size = szip_info->pixels * bytes_per_pixel;
if ((szip_info->buffer = HDmalloc(buffer_size)) == NULL)
HRETURN_ERROR(DFE_NOSPACE, FAIL);
szip_info->buffer_size = buffer_size;
szip_info->buffer_pos = 0;
szip_info->szip_state = SZIP_RUN;
}
/*
* Class: hdf_hdf5lib_H5
* Method: H5PLget
* Signature: (I)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL
Java_hdf_hdf5lib_H5_H5PLget
(JNIEnv *env, jclass clss, jint index)
{
char *aName;
jstring str = NULL;
ssize_t buf_size;
/* get the length of the name */
buf_size = H5PLget(index, NULL, 0);
if (buf_size <= 0) {
h5badArgument(env, "H5PLget: buf_size <= 0");
} /* end if */
else {
buf_size++; /* add extra space for the null terminator */
aName = (char*)HDmalloc(sizeof(char) * (size_t)buf_size);
if (aName == NULL) {
h5outOfMemory(env, "H5PLget: malloc failed");
} /* end if */
else {
buf_size = H5PLget(index, aName, (size_t)buf_size);
if (buf_size < 0) {
h5libraryError(env);
} /* end if */
else {
str = ENVPTR->NewStringUTF(ENVPAR aName);
}
HDfree(aName);
}
}
return str;
} /* end Java_hdf_hdf5lib_H5_H5PLget */
/*-------------------------------------------------------------------------
* Function: test_long_desc
*
* Purpose: Test long error description handling
*
* Return: Success: 0
*
* Failure: -1
*
* Programmer: Quincey Koziol
* January 19, 2005
*
*-------------------------------------------------------------------------
*/
static herr_t
test_long_desc(void)
{
const char *format = "Testing very long description string, %s";
char *long_desc = NULL;
char *full_desc = NULL;
size_t u;
const char *test_FUNC = "test_long_desc";
/* Allocate space for the error description info */
if(NULL == (long_desc = (char*)HDmalloc(LONG_DESC_SIZE))) TEST_ERROR;
if(NULL == (full_desc = (char*)HDmalloc(LONG_DESC_SIZE + 128))) TEST_ERROR;
/* Create the long part of the error description */
for(u = 0; u < LONG_DESC_SIZE; u++)
long_desc[u] = 'A' + (u % 26);
long_desc[LONG_DESC_SIZE - 1] = '\0';
/* Clear the default error stack */
if(H5Eclear2(H5E_DEFAULT) < 0) TEST_ERROR;
/* Push an error with a long description */
if(H5Epush(H5E_DEFAULT, __FILE__, test_FUNC, __LINE__, ERR_CLS, ERR_MAJ_TEST, ERR_MIN_SUBROUTINE, format, long_desc) < 0) TEST_ERROR;
/* Create the string that should be in the description. Must use HDsnprintf here
* because snprintf is _snprintf on Windows */
HDsnprintf(full_desc, (size_t)(LONG_DESC_SIZE + 128), format, long_desc);
/* Make certain that the description is correct */
if(H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, long_desc_cb, full_desc) < 0) TEST_ERROR;
/* Clear the default error stack again */
if(H5Eclear2(H5E_DEFAULT) < 0) TEST_ERROR;
HDfree(long_desc);
HDfree(full_desc);
return(0);
error:
if(long_desc)
HDfree(long_desc);
if(full_desc)
HDfree(full_desc);
return(-1);
} /* end test_long_desc() */
/*
* Class: hdf_hdf5lib_H5
* Method: H5Eget_msg
* Signature: (J[I)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL
Java_hdf_hdf5lib_H5_H5Eget_1msg
(JNIEnv *env, jclass cls, jlong msg_id, jintArray error_msg_type_list)
{
char *namePtr;
jstring str = NULL;
jboolean isCopy;
ssize_t buf_size;
jint *theArray;
H5E_type_t error_msg_type;
if (msg_id < 0) {
h5badArgument(env, "H5Eget_msg: invalid argument");
} /* end if */
else if (error_msg_type_list == NULL) {
h5nullArgument(env, "H5Eget_msg: error_msg_type_list is NULL");
} /* end if */
else {
/* get the length of the name */
buf_size = H5Eget_msg((hid_t)msg_id, NULL, NULL, 0);
if ((buf_size < 0) || (buf_size == 0)) {
h5JNIFatalError(env, "H5Eget_msg: Invalid message");
} /* end if */
else {
buf_size++; /* add extra space for the null terminator */
namePtr = (char*)HDmalloc(sizeof(char) * (size_t)buf_size);
if (namePtr == NULL) {
h5outOfMemory(env, "H5Eget_msg: malloc failed");
} /* end if */
else {
theArray = (jint*)ENVPTR->GetIntArrayElements(ENVPAR error_msg_type_list, &isCopy);
if (theArray == NULL) {
HDfree(namePtr);
h5JNIFatalError(env, "H5Eget_msg: error_msg_type_list not pinned");
} /* end if */
else {
buf_size = H5Eget_msg((hid_t)msg_id, &error_msg_type, (char *)namePtr, (size_t)buf_size);
if (buf_size < 0) {
HDfree(namePtr);
ENVPTR->ReleaseIntArrayElements(ENVPAR error_msg_type_list, theArray, JNI_ABORT);
h5libraryError(env);
} /* end if */
else {
theArray[0] = error_msg_type;
ENVPTR->ReleaseIntArrayElements(ENVPAR error_msg_type_list, theArray, 0);
str = ENVPTR->NewStringUTF(ENVPAR namePtr);
HDfree(namePtr);
} /* end else */
} /* end else */
} /* end else */
} /* end else */
} /* end else */
return str;
} /* end Java_hdf_hdf5lib_H5_H5Eget_1msg */
