/* * Copyright (C) 1998 Spizella Software * All rights reserved. * * Programmer: Robb Matzke * Tuesday, January 13, 1998 * * Purpose: Data type conversions. */ #define H5T_PACKAGE /*suppress error about including H5Tpkg */ #include #include #include #include /* Interface initialization */ static intn interface_initialize_g = FALSE; #define INTERFACE_INIT NULL /*------------------------------------------------------------------------- * Function: H5T_conv_noop * * Purpose: The no-op conversion. The library knows about this * conversion without it being registered. * * Return: Success: SUCCEED * * Failure: never fails * * Programmer: Robb Matzke * Wednesday, January 14, 1998 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5T_conv_noop(hid_t src_id, hid_t dst_id, void **pcdata, size_t nelmts, void *buf, void *background) { FUNC_ENTER(H5T_conv_noop, FAIL); FUNC_LEAVE(SUCCEED); } /*------------------------------------------------------------------------- * Function: H5T_conv_order * * Purpose: Convert one type to another when byte order is the only * difference. * * Note: This is a soft conversion function. * * Return: Success: SUCCEED * * Failure: FAIL * * Programmer: Robb Matzke * Tuesday, January 13, 1998 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5T_conv_order(hid_t src_id, hid_t dst_id, void **pcdata, size_t nelmts, void *_buf, void *background) { uint8 *buf = (uint8 *) _buf; uint8 tmp; H5T_t *src = NULL; H5T_t *dst = NULL; intn i, j, md; FUNC_ENTER(H5T_conv_order, FAIL); /* Check args */ if (H5_DATATYPE != H5A_group(src_id) || NULL == (src = H5A_object(src_id)) || H5_DATATYPE != H5A_group(dst_id) || NULL == (dst = H5A_object(dst_id))) { HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type"); } if (!buf) { /* Capability query */ if (src->size != dst->size || 0 != src->u.atomic.offset || 0 != dst->u.atomic.offset || !((H5T_ORDER_BE == src->u.atomic.order && H5T_ORDER_LE == dst->u.atomic.order) || (H5T_ORDER_LE == src->u.atomic.order && H5T_ORDER_BE == dst->u.atomic.order))) { HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "conversion not supported"); } switch (src->type) { case H5T_INTEGER: /* nothing to check */ break; case H5T_FLOAT: if (src->u.atomic.u.f.sign != dst->u.atomic.u.f.sign || src->u.atomic.u.f.epos != dst->u.atomic.u.f.epos || src->u.atomic.u.f.esize != dst->u.atomic.u.f.esize || src->u.atomic.u.f.ebias != dst->u.atomic.u.f.ebias || src->u.atomic.u.f.mpos != dst->u.atomic.u.f.mpos || src->u.atomic.u.f.msize != dst->u.atomic.u.f.msize || src->u.atomic.u.f.norm != dst->u.atomic.u.f.norm || src->u.atomic.u.f.pad != dst->u.atomic.u.f.pad) { HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "conversion not supported"); } break; default: HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "conversion not supported"); } HRETURN(SUCCEED); } /* The conversion */ md = src->size / 2; for (i = 0; i < nelmts; i++, buf += src->size) { for (j = 0; j < md; j++) { tmp = buf[j]; buf[j] = buf[src->size - (j + 1)]; buf[src->size - (j + 1)] = tmp; } } FUNC_LEAVE(SUCCEED); } /*------------------------------------------------------------------------- * Function: H5T_conv_struct * * Purpose: Converts between compound data types. This is a soft * conversion function. The algorithm is basically: * * For I=1..NUM_MEMBERS do * If sizeof detination type <= sizeof source type then * Convert member to destination type; * Move member as far left as possible; * * For I=NUM_MEMBERS..1 do * If not destination type then * Convert member to destination type; * Move member to correct position in BACKGROUND * * Copy BACKGROUND to BUF * * Return: Success: SUCCEED * * Failure: FAIL * * Programmer: Robb Matzke * Thursday, January 22, 1998 * * Modifications: * *------------------------------------------------------------------------- */ herr_t H5T_conv_struct(hid_t src_id, hid_t dst_id, void **_pcdata, size_t nelmts, void *_buf, void *_bkg) { H5T_conv_struct_t **pcdata = (H5T_conv_struct_t **)_pcdata; uint8 *buf = (uint8 *)_buf; /*cast for pointer arithmetic */ uint8 *bkg = (uint8 *)_bkg; /*background pointer arithmetic */ H5T_t *src = NULL; /*source data type */ H5T_t *dst = NULL; /*destination data type */ H5T_t *type = NULL; /*temporary type pointer */ hid_t tid; /*temporary type ID */ intn *src2dst = NULL; /*maps src member to dst member */ H5T_member_t *src_memb = NULL; /*source struct member descript.*/ H5T_member_t *dst_memb = NULL; /*destination struct memb desc. */ H5T_conv_t tconv_func = NULL; /*member data type conv. func. */ size_t offset; /*byte offset wrt struct */ size_t src_delta, dst_delta; /*source & destination stride */ intn elmtno, i, j; /*counters */ void *memb_cdata = NULL; /*member conversion data */ herr_t ret_value = FAIL; FUNC_ENTER (H5T_conv_struct, FAIL); /* Check args */ if (H5_DATATYPE != H5A_group(src_id) || NULL == (src = H5A_object(src_id)) || H5_DATATYPE != H5A_group(dst_id) || NULL == (dst = H5A_object(dst_id))) { HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type"); } /* Capability query? */ if (!buf) { assert (H5T_COMPOUND==src->type); assert (H5T_COMPOUND==dst->type); #ifndef LATER /* * Struct members must be scalar for now. */ for (i=0; iu.compnd.nmembs; i++) { assert (0==src->u.compnd.memb[i].ndims); } for (i=0; iu.compnd.nmembs; i++) { assert (0==dst->u.compnd.memb[i].ndims); } #endif /* * Okay, we've determined that this conversion function applies to * the data types supplied as arguments. Now we build information * which is expensive to calculate but is constant for all * conversions from SRC_ID to DST_ID. Notice: the thing marked with * `!' really is `dst' and not `src' because we're only interested in * the members of the source type that are also in the destination * type. */ assert (pcdata); *pcdata = H5MM_xcalloc (1, sizeof(H5T_conv_struct_t)); src2dst = H5MM_xmalloc (src->u.compnd.nmembs * sizeof(intn)); (*pcdata)->src2dst = src2dst; (*pcdata)->src_memb_id = H5MM_xmalloc (/*!*/dst->u.compnd.nmembs * sizeof(hid_t)); (*pcdata)->dst_memb_id = H5MM_xmalloc (dst->u.compnd.nmembs * sizeof(hid_t)); /* * Insure that members are sorted. */ H5T_sort_by_offset (src); H5T_sort_by_offset (dst); /* * Build a mapping from source member number to destination member * number. If some source member is not a destination member then that * mapping element will be negative. Also create atoms for each * source and destination member data type so we can look up the * member data type conversion functions later. */ for (i=0; iu.compnd.nmembs; i++) { src2dst[i] = -1; for (j=0; ju.compnd.nmembs; j++) { if (!HDstrcmp (src->u.compnd.memb[i].name, dst->u.compnd.memb[j].name)) { src2dst[i] = j; break; } } if (src2dst[i]>=0) { type = &(src->u.compnd.memb[i].type); tid = H5A_register (H5_DATATYPE, type); assert (tid>=0); (*pcdata)->src_memb_id[i] = tid; type = &(dst->u.compnd.memb[src2dst[i]].type); tid = H5A_register (H5_DATATYPE, type); assert (tid>=0); (*pcdata)->dst_memb_id[i] = tid; } } HRETURN (SUCCEED); } /* * Here comes the real conversion... */ assert (pcdata && *pcdata); assert ((*pcdata)->src2dst); assert ((*pcdata)->src_memb_id); assert ((*pcdata)->dst_memb_id); /* * Insure that members are sorted. */ H5T_sort_by_offset (src); H5T_sort_by_offset (dst); src2dst = (*pcdata)->src2dst; /* * Direction of conversion. */ if (dst->size <= src->size) { src_delta = src->size; dst_delta = dst->size; } else { src_delta = -(src->size); dst_delta = -(dst->size); buf += (nelmts-1) * src->size; bkg += (nelmts-1) * dst->size; } for (elmtno=0; elmtnou.compnd.nmembs; i++) { if (src2dst[i]<0) continue; src_memb = src->u.compnd.memb + i; dst_memb = dst->u.compnd.memb + src2dst[i]; if (dst_memb->type.size <= src_memb->type.size) { tconv_func = H5T_find (&(dst_memb->type), &(src_memb->type), &memb_cdata); if (!tconv_func) { HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unable to convert member data type"); } (tconv_func)((*pcdata)->src_memb_id[i], (*pcdata)->dst_memb_id[i], &memb_cdata, 1, buf + src_memb->offset, bkg + dst_memb->offset); HDmemmove (buf + offset, buf + src_memb->offset, dst_memb->type.size); offset += dst_memb->type.size; } else { HDmemmove (buf + offset, buf + src_memb->offset, src_memb->type.size); offset += src_memb->type.size; } } /* * For each source member which will be present in the destination, * convert the member to the destination type if it is larger than the * source type (that is, has not been converted yet). Then copy the * member to the destination offset in the background buffer. */ for (i=src->u.compnd.nmembs-1; i>=0; --i) { if (src2dst[i]<0) continue; src_memb = src->u.compnd.memb + i; dst_memb = dst->u.compnd.memb + src2dst[i]; offset -= dst_memb->type.size; if (dst_memb->type.size > src_memb->type.size) { tconv_func = H5T_find (&(src_memb->type), &(dst_memb->type), &memb_cdata); if (!tconv_func) { HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unable to convert member data type"); } (tconv_func)((*pcdata)->src_memb_id[i], (*pcdata)->dst_memb_id[i], &memb_cdata, 1, buf + offset, bkg + dst_memb->offset); } HDmemmove (bkg+dst_memb->offset, buf+offset, dst_memb->type.size); } assert (0==offset); /* * Update buf and background. */ buf += src_delta; bkg += dst_delta; } /* * Copy the background buffer back into the in-place conversion buffer. */ HDmemcpy (_buf, _bkg, nelmts*dst->size); ret_value = SUCCEED; done: FUNC_LEAVE (ret_value); }