//--------------------------------------------------------------------------
// Function: Exception::getMajorString
///\brief Returns a text string that describes the error
/// specified by a major error number.
///\param err_major - IN: Major error number
///\return Major error string
///\par Description
/// In the failure case, the string "Invalid major error number"
/// will be returned.
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
H5std_string Exception::getMajorString( hid_t err_major ) const
{
// Preliminary call to H5Eget_msg() to get the length of the message
ssize_t mesg_size = H5Eget_msg(err_major, NULL, NULL, 0);
// If H5Eget_msg() returns a negative value, raise an exception,
if( mesg_size < 0 )
throw IdComponentException("Exception::getMajorString",
"H5Eget_msg failed");
// Call H5Eget_msg again to get the actual message
char* mesg_C = new char[mesg_size+1]; // temporary C-string for C API
mesg_size = H5Eget_msg(err_major, NULL, mesg_C, mesg_size+1);
// Check for failure again
if( mesg_size < 0 )
{
delete []mesg_C;
throw IdComponentException("Exception::getMajorString",
"H5Eget_msg failed");
}
// Convert the C error description and return
H5std_string major_str(mesg_C);
delete []mesg_C;
return( major_str );
}
/*-------------------------------------------------------------------------
* Function: custom_print_cb
*
* Purpose: Callback function to print error stack in customized way.
*
* Return: Success: 0
*
* Failure: -1
*
* Programmer: Raymond Lu
* July 17, 2003
*
*-------------------------------------------------------------------------
*/
static herr_t
custom_print_cb(unsigned n, const H5E_error2_t *err_desc, void* client_data)
{
FILE *stream = (FILE *)client_data;
char maj[MSG_SIZE];
char min[MSG_SIZE];
char cls[MSG_SIZE];
const int indent = 4;
/* Get descriptions for the major and minor error numbers */
if(H5Eget_class_name(err_desc->cls_id, cls, MSG_SIZE) < 0)
TEST_ERROR;
if(H5Eget_msg(err_desc->maj_num, NULL, maj, MSG_SIZE) < 0)
TEST_ERROR;
if(H5Eget_msg(err_desc->min_num, NULL, min, MSG_SIZE) < 0)
TEST_ERROR;
HDfprintf(stream, "%*serror #%03d: %s in %s(): line %u\n",
indent, "", n, err_desc->file_name,
err_desc->func_name, err_desc->line);
HDfprintf(stream, "%*sclass: %s\n", indent * 2, "", cls);
HDfprintf(stream, "%*smajor: %s\n", indent * 2, "", maj);
HDfprintf(stream, "%*sminor: %s\n", indent * 2, "", min);
return 0;
error:
return -1;
} /* end custom_print_cb() */
/*
* 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 */
/*
* h5libraryError() determines the HDF-5 major error code
* and creates and throws the appropriate sub-class of
* HDF5LibraryException(). This routine should be called
* whenever a call to the HDF-5 library fails, i.e., when
* the return is -1.
*
* Note: This routine never returns from the 'throw',
* and the Java native method immediately raises the
* exception.
*/
jboolean
h5libraryError
(JNIEnv *env)
{
char *args[2];
const char *exception = NULL;
char *msg_str = NULL;
int num_errs = 0;
hid_t min_num;
hid_t maj_num;
ssize_t msg_size = 0;
H5E_type_t error_msg_type;
jstring str = NULL;
hid_t stk_id = -1;
H5E_num_t exceptionNumbers;
exceptionNumbers.maj_num = 0;
exceptionNumbers.min_num = 0;
/* Save current stack contents for future use */
stk_id = H5Eget_current_stack(); /* This will clear current stack */
if(stk_id >= 0)
H5Ewalk2(stk_id, H5E_WALK_DOWNWARD, walk_error_callback, &exceptionNumbers);
maj_num = exceptionNumbers.maj_num;
min_num = exceptionNumbers.min_num;
exception = defineHDF5LibraryException(maj_num);
/* get the length of the name */
msg_size = H5Eget_msg(min_num, NULL, NULL, 0);
if(msg_size > 0) {
msg_size++; /* add extra space for the null terminator */
msg_str = (char*)HDcalloc((size_t)msg_size, sizeof(char));
if(msg_str) {
msg_size = H5Eget_msg(min_num, &error_msg_type, (char *)msg_str, (size_t)msg_size);
str = ENVPTR->NewStringUTF(ENVPAR msg_str);
HDfree(msg_str);
} /* end if */
} /* end if */
else
str = NULL;
if(stk_id >= 0)
H5Eset_current_stack(stk_id);
args[0] = (char *)str;
args[1] = 0;
THROWEXCEPTION(exception, args);
} /* end h5libraryError() */
/*-------------------------------------------------------------------------
* Function: init_error
*
* Purpose: Initialize error information.
*
* Return: Success: 0
*
* Failure: -1
*
* Programmer: Raymond Lu
* July 10, 2003
*
*-------------------------------------------------------------------------
*/
static herr_t
init_error(void)
{
ssize_t cls_size = (ssize_t)HDstrlen(ERR_CLS_NAME) + 1;
ssize_t msg_size = (ssize_t)HDstrlen(ERR_MIN_SUBROUTINE_MSG) + 1;
char *cls_name = NULL;
char *msg = NULL;
H5E_type_t msg_type;
if(NULL == (cls_name = (char *)HDmalloc(HDstrlen(ERR_CLS_NAME) + 1)))
TEST_ERROR
if(NULL == (msg = (char *)HDmalloc(HDstrlen(ERR_MIN_SUBROUTINE_MSG) + 1)))
TEST_ERROR
if((ERR_CLS = H5Eregister_class(ERR_CLS_NAME, PROG_NAME, PROG_VERS)) < 0)
TEST_ERROR;
if(cls_size != H5Eget_class_name(ERR_CLS, cls_name, (size_t)cls_size) + 1)
TEST_ERROR;
if(HDstrcmp(ERR_CLS_NAME, cls_name))
TEST_ERROR;
if((ERR_MAJ_TEST = H5Ecreate_msg(ERR_CLS, H5E_MAJOR, ERR_MAJ_TEST_MSG)) < 0)
TEST_ERROR;
if((ERR_MAJ_IO = H5Ecreate_msg(ERR_CLS, H5E_MAJOR, ERR_MAJ_IO_MSG)) < 0)
TEST_ERROR;
if((ERR_MAJ_API = H5Ecreate_msg(ERR_CLS, H5E_MAJOR, ERR_MAJ_API_MSG)) < 0)
TEST_ERROR;
if((ERR_MIN_SUBROUTINE = H5Ecreate_msg(ERR_CLS, H5E_MINOR, ERR_MIN_SUBROUTINE_MSG)) < 0)
TEST_ERROR;
if((ERR_MIN_ERRSTACK = H5Ecreate_msg(ERR_CLS, H5E_MINOR, ERR_MIN_ERRSTACK_MSG)) < 0)
TEST_ERROR;
if((ERR_MIN_CREATE = H5Ecreate_msg(ERR_CLS, H5E_MINOR, ERR_MIN_CREATE_MSG)) < 0)
TEST_ERROR;
if((ERR_MIN_WRITE = H5Ecreate_msg(ERR_CLS, H5E_MINOR, ERR_MIN_WRITE_MSG)) < 0)
TEST_ERROR;
if((ERR_MIN_GETNUM = H5Ecreate_msg(ERR_CLS, H5E_MINOR, ERR_MIN_GETNUM_MSG)) < 0)
TEST_ERROR;
if(msg_size != H5Eget_msg(ERR_MIN_SUBROUTINE, &msg_type, msg, (size_t)msg_size) + 1)
TEST_ERROR;
if(msg_type != H5E_MINOR)
TEST_ERROR;
if(HDstrcmp(msg, ERR_MIN_SUBROUTINE_MSG))
TEST_ERROR;
/* Register another class for later testing. */
if((ERR_CLS2 = H5Eregister_class(ERR_CLS2_NAME, PROG2_NAME, PROG_VERS)) < 0)
TEST_ERROR;
HDfree(cls_name);
HDfree(msg);
return 0;
error:
if(cls_name)
HDfree(cls_name);
if(msg)
HDfree(msg);
return -1;
} /* end init_error() */
