/*-------------------------------------------------------------------------- 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; }
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 HCPmstdio_endaccess -- Close the compressed data element USAGE intn HCPendaccess(access_rec) accrec_t *access_rec; IN: the access record of the data element RETURNS Returns SUCCEED or FAIL DESCRIPTION Close the compressed data element and free modelling info. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ intn HCPmstdio_endaccess(accrec_t * access_rec) { CONSTR(FUNC, "HCPmstdio_endaccess"); compinfo_t *info; /* information on the special element */ intn ret; info = (compinfo_t *) access_rec->special_info; if ((ret = (*(info->cinfo.coder_funcs.endaccess)) (access_rec)) == FAIL) HRETURN_ERROR(DFE_CODER, FAIL); return (ret); } /* HCPmstdio_endaccess() */
/*-------------------------------------------------------------------------- NAME HCPmstdio_inquire -- Inquire information about the access record and data element. USAGE int32 HCPmstdio_inquire(access_rec,pfile_id,ptag,pref,plength,poffset,pposn, paccess,pspecial) accrec_t *access_rec; IN: the access record of the data element int32 *pfile_id; OUT: ptr to file id uint16 *ptag; OUT: ptr to tag of information uint16 *pref; OUT: ptr to ref of information int32 *plength; OUT: ptr to length of data element int32 *poffset; OUT: ptr to offset of data element int32 *pposn; OUT: ptr to position of access in element int16 *paccess; OUT: ptr to access mode int16 *pspecial; OUT: ptr to special code RETURNS Returns SUCCEED or FAIL DESCRIPTION Inquire information about the access record and data element. [Currently a NOP]. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ int32 HCPmstdio_inquire(accrec_t * access_rec, int32 *pfile_id, uint16 *ptag, uint16 *pref, int32 *plength, int32 *poffset, int32 *pposn, int16 *paccess, int16 *pspecial) { CONSTR(FUNC, "HCPmstdio_inquire"); compinfo_t *info; /* information on the special element */ int32 ret; info = (compinfo_t *) access_rec->special_info; if ((ret = (*(info->cinfo.coder_funcs.inquire)) (access_rec, pfile_id, ptag, pref, plength, poffset, pposn, paccess, pspecial)) == FAIL) HRETURN_ERROR(DFE_CODER, FAIL); return (ret); } /* HCPmstdio_inquire() */
/* NAME HDflush -- flush the HDF file USAGE intn HDflush(fid) int32 fid; IN: file ID RETURNS SUCCEED / FAIL DESCRIPTION Force the system to flush the HDF file stream This should be primarily used for debugging The MAC does not really support fflush() so this r outine just returns SUCCEED always on a MAC w/o really doing anything. ---------------------------------------------------------------------------*/ intn HDflush(int32 file_id) { CONSTR(FUNC, "HDflush"); /* for HERROR */ filerec_t *file_rec; file_rec = HAatom_object(file_id); if (BADFREC(file_rec)) HRETURN_ERROR(DFE_ARGS, FAIL); HI_FLUSH(file_rec->file); return SUCCEED; } /* HDflush */
/*-------------------------------------------------------------------------- NAME HCPmstdio_read -- Read in a portion of data from a compressed data element. USAGE int32 HCPmstdio_read(access_rec,length,data) accrec_t *access_rec; IN: the access record of the data element int32 length; IN: the number of bytes to read void * data; OUT: the buffer to place the bytes read RETURNS Returns the number of bytes read or FAIL DESCRIPTION Read in a number of bytes from a compressed data element, using stdio functionality. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ int32 HCPmstdio_read(accrec_t * access_rec, int32 length, void * data) { CONSTR(FUNC, "HCPmstdio_read"); compinfo_t *info; /* information on the special element */ int32 ret; info = (compinfo_t *) access_rec->special_info; /* adjust model position */ info->minfo.model_info.stdio_info.pos += length; if ((ret = (*(info->cinfo.coder_funcs.read)) (access_rec, length, data)) == FAIL) HRETURN_ERROR(DFE_CODER, FAIL); return (ret); } /* HCPmstdio_read() */
/*-------------------------------------------------------------------------- NAME HCPmstdio_seek -- Seek to offset within the data element USAGE int32 HCPmstdio_seek(access_rec,offset,origin) accrec_t *access_rec; IN: the access record of the data element int32 offset; IN: the offset in bytes from the origin specified intn origin; IN: the origin to seek from [UNUSED!] RETURNS Returns SUCCEED or FAIL DESCRIPTION Seek to a position with a compressed data element. The 'origin' calculations have been taken care of at a higher level, it is an un-used parameter. The 'offset' is used as an absolute offset because of this. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ int32 HCPmstdio_seek(accrec_t * access_rec, int32 offset, int origin) { CONSTR(FUNC, "HCPmstdio_seek"); compinfo_t *info; /* information on the special element */ int32 ret; info = (compinfo_t *) access_rec->special_info; /* set the offset */ info->minfo.model_info.stdio_info.pos = offset; if ((ret = (*(info->cinfo.coder_funcs.seek)) (access_rec, offset, origin)) == FAIL) HRETURN_ERROR(DFE_CODER, FAIL); return (ret); } /* HCPmstdio_seek() */
/*-------------------------------------------------------------------------- NAME HCPmstdio_stread -- start read access for compressed file USAGE int32 HCPmstdio_stread(access_rec) accrec_t *access_rec; IN: the access record of the data element RETURNS Returns SUCCEED or FAIL DESCRIPTION Start read access on a compressed data element using the stdio modeling scheme. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ int32 HCPmstdio_stread(accrec_t * access_rec) { CONSTR(FUNC, "HCPmstdio_stread"); compinfo_t *info; /* information on the special element */ info = (compinfo_t *) access_rec->special_info; /* set the offset */ info->minfo.model_info.stdio_info.pos = 0; #ifdef TESTING printf("%s(): info=%p\n", FUNC, info); #endif if ((*(info->cinfo.coder_funcs.stread)) (access_rec) == FAIL) HRETURN_ERROR(DFE_CODER, FAIL); return (SUCCEED); } /* HCPmstdio_stread() */
/* NAME HDf2cstring -- convert a Fortran string to a C string USAGE char * HDf2cstring(fdesc, len) _fcd fdesc; IN: Fortran string descriptor intn len; IN: length of Fortran string RETURNS Pointer to the C string if success, else NULL DESCRIPTION Chop off trailing blanks off of a Fortran string and move it into a newly allocated C string. It is up to the user to free this string. ---------------------------------------------------------------------------*/ char * HDf2cstring(_fcd fdesc, intn len) { CONSTR(FUNC, "HDf2cstring"); /* for HERROR */ char *cstr, *str; int i; str = _fcdtocp(fdesc); /* This should be equivalent to the above test -QAK */ for(i=len-1; i>=0 && !isgraph((int)str[i]); i--) /*EMPTY*/; cstr = (char *) HDmalloc((uint32) (i + 2)); if (!cstr) HRETURN_ERROR(DFE_NOSPACE, NULL); cstr[i + 1] = '\0'; HDmemcpy(cstr,str,i+1); return cstr; } /* HDf2cstring */
/*-------------------------------------------------------------------------- NAME HCPmstdio_write -- Write out a portion of data from a compressed data element. USAGE int32 HCPwrite(access_rec,length,data) accrec_t *access_rec; IN: the access record of the data element int32 length; IN: the number of bytes to write void * data; IN: the buffer to retrieve the bytes written RETURNS Returns the number of bytes written or FAIL DESCRIPTION Write out a number of bytes to a compressed data element. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ int32 HCPmstdio_write(accrec_t * access_rec, int32 length, const void * data) { CONSTR(FUNC, "HCPmstdio_write"); compinfo_t *info; /* information on the special element */ int32 ret; info = (compinfo_t *) access_rec->special_info; /* adjust model position */ info->minfo.model_info.stdio_info.pos += length; #ifdef TESTING printf("%s(): before function ptr call func_ptr=%p\n", FUNC, info->cinfo.coder_funcs.write); #endif if ((ret = (*(info->cinfo.coder_funcs.write)) (access_rec, length, data)) == FAIL) HRETURN_ERROR(DFE_CODER, FAIL); #ifdef TESTING printf("%s(): after function ptr call, ret=%d\n",FUNC,(int)ret); #endif return (ret); } /* HCPmstdio_write() */
intn DFputcomp(int32 file_id, uint16 tag, uint16 ref, const uint8 *image, int32 xdim, int32 ydim, uint8 *palette, uint8 *newpal, int16 scheme, comp_info * cinfo) { CONSTR(FUNC, "DFputcomp"); uint8 *buffer; /* buffer to hold compressed image */ const uint8 *in; /* pointer to input for compression */ uint8 *out; /* pointer to space for compressed output */ int32 cisize; /* maximum size of compressed image */ int32 crowsize; /* maximum size of compressed row */ intn buftype; /* buftype = 1: buffer enough for whole image */ /* buftype = 2: buffer holds 1 row */ int32 n; /* number of compressed bytes produced */ int32 total; /* total compressed bytes produced so far */ int32 i; int32 ret = 0; int32 aid = 0; if (!HDvalidfid(file_id) || !tag || !ref || xdim <= 0 || ydim <= 0 || !image) HRETURN_ERROR(DFE_ARGS, FAIL); switch (scheme) { case DFTAG_RLE: /* RLE compression (8-bit or 24-bit(?) images */ cisize = ydim * (xdim * 121 / 120 + 1); /* 120 chars can compress to 121! */ crowsize = xdim * 121 / 120 + 128; /* allocate buffer for compression */ buffer = (uint8 *) HDmalloc((uint32) cisize); if (!buffer) { buffer = (uint8 *) HDmalloc((uint32) crowsize); if (!buffer) HRETURN_ERROR(DFE_NOSPACE, FAIL); buftype = 2; /* compress and write out row by row */ } else /* can hold whole image, then write */ buftype = 1; in = image; out = buffer; n = total = 0; /* no bytes compressed so far */ if (buftype == 2) { int32 num_blocks; int32 block_length; num_blocks = (ydim > (int32) R8_MAX_BLOCKS) ? (int32) R8_MAX_BLOCKS : ydim; block_length = (xdim > (int32) R8_MAX_LENGTH) ? (int32) R8_MAX_LENGTH : xdim; aid = HLcreate(file_id, tag, ref, block_length, num_blocks); if (aid == FAIL) return FAIL; } /* compress row by row */ for (i = 0; i < ydim; i++) { n = DFCIrle(in, out, xdim); /* compress row */ in += xdim; /* move input pointer */ total += n; /* keep running total */ if (buftype == 1) /* can hold whole image */ out = &buffer[total]; /* move out buffer pointer */ else { /* buffer too small, */ /* write out what was produced */ if (Hwrite(aid, n, buffer) == FAIL) { ret = FAIL; /* flag value */ break; } out = buffer; /* reset output pointer */ } } if (buftype == 1) { /* write out entire image */ ret = Hputelement(file_id, tag, ref, buffer, total); HDfree((VOIDP) buffer); } break; case DFTAG_IMC: /* IMCOMP compression (8-bit images) */ if (!palette || !newpal) /* need palette and newpal */ HRETURN_ERROR(DFE_ARGS, FAIL); cisize = xdim * ydim / 4; /* IMCOMP always cuts to 1/4 */ buffer = (uint8 *) HDmalloc((uint32) cisize); if (!buffer) HRETURN_ERROR(DFE_NOSPACE, FAIL); DFCIimcomp(xdim, ydim, image, buffer, palette, newpal, 0); ret = Hputelement(file_id, tag, ref, buffer, cisize); HDfree((VOIDP) buffer); break; case DFTAG_JPEG5: /* JPEG compression (for 24-bit images) */ case DFTAG_GREYJPEG5: /* JPEG compression (for 8-bit images) */ ret = DFCIjpeg(file_id, tag, ref, xdim, ydim, image, scheme, cinfo); break; default: /* unknown compression scheme */ HRETURN_ERROR(DFE_BADSCHEME, FAIL) } return ((intn) ret); } /* end DFputcomp() */
/*-------------------------------------------------------------------------- NAME HCIcszip_decode -- Decode SZIP compressed data into a buffer. USAGE int32 HCIcszip_decode(info,length,buf) compinfo_t *info; IN: the info about the compressed element int32 length; IN: number of bytes to read into the buffer uint8 *buf; OUT: buffer to store the bytes read RETURNS Returns SUCCEED or FAIL DESCRIPTION Common code called to decode SZIP data from the file. GLOBAL VARIABLES COMMENTS, BUGS, ASSUMPTIONS EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ PRIVATE int32 HCIcszip_decode(compinfo_t * info, int32 length, uint8 *buf) { CONSTR(FUNC, "HCIcszip_decode"); #ifdef H4_HAVE_LIBSZ accrec_t *access_rec; comp_coder_szip_info_t *szip_info; /* ptr to SZIP info */ uint8 *in_buffer; uint8 *out_buffer; int32 in_length; int32 out_length; int bytes_per_pixel; int32 rbytes; uint16 tag,ref; int32 len1; int32 aid; int32 status; size_t size_out; uint8 *cp; int32 good_bytes; int32 old_way; SZ_com_t sz_param; #endif #ifdef H4_HAVE_LIBSZ szip_info = &(info->cinfo.coder_info.szip_info); if (szip_info->szip_state == SZIP_INIT) { /* Load from disk, decode the data */ if ((access_rec = HAatom_object(info->aid)) == NULL) /* get the access_rec pointer */ HRETURN_ERROR(DFE_ARGS, FAIL); /* Discover how much data must be read */ if(HTPinquire(access_rec->ddid,&tag,&ref,NULL,&in_length)==FAIL) HRETURN_ERROR(DFE_INTERNAL, FAIL); if (in_length == -1) HRETURN_ERROR(DFE_INTERNAL, FAIL); if (tag & 0x4000) { /* this is linked list -- get the length of the data */ aid = Hstartread(access_rec->file_id, tag, ref); if (HDinqblockinfo(aid, &len1, NULL, NULL, NULL) == FAIL) { Hendaccess(aid); HRETURN_ERROR(DFE_INTERNAL, FAIL); } in_length = len1; Hendaccess(aid); } old_way = (int)(szip_info->options_mask & SZ_H4_REV_2); if (old_way == 0) { /* special case: read data encoded in V4.2r0 */ old_way = 1; good_bytes = in_length; in_length = in_length+5; if ((in_buffer = (uint8 *) HDmalloc(in_length)) == NULL) HRETURN_ERROR(DFE_NOSPACE, FAIL); cp = in_buffer; *cp = 0; cp++; INT32ENCODE(cp, good_bytes); } else { /* V4.2r1: in_length is correct */ old_way = 0; if ((in_buffer = (uint8 *) HDmalloc(in_length)) == NULL) HRETURN_ERROR(DFE_NOSPACE, FAIL); } /* Allocate memory for the uncompressed data */ bytes_per_pixel = (szip_info->bits_per_pixel + 7) >> 3; if (bytes_per_pixel == 3) bytes_per_pixel++; out_length = szip_info->pixels * bytes_per_pixel; if ((out_buffer = (uint8 *) HDmalloc(out_length)) == NULL) HRETURN_ERROR(DFE_NOSPACE, FAIL); /* Read the unompressed data */ if (old_way == 1) { /* this is encoded in V4.2r0 */ /* the preamble isn't in the file, so read only the data */ if ((rbytes = Hread(info->aid, in_length-5, in_buffer+5)) == FAIL) { HDfree(out_buffer); HDfree(in_buffer); HRETURN_ERROR(DFE_READERROR, FAIL); } if (rbytes == 0 || rbytes != (in_length - 5)) { /* is this possible? */ HDfree(out_buffer); HDfree(in_buffer); HRETURN_ERROR(DFE_READERROR, FAIL); } } else { /* HDF4.2R1: read the data plus preamble */ if ((rbytes = Hread(info->aid, in_length, in_buffer)) == FAIL) { HDfree(out_buffer); HDfree(in_buffer); HRETURN_ERROR(DFE_READERROR, FAIL); } if (rbytes == 0 || rbytes != in_length) { /* is this possible? */ HDfree(out_buffer); HDfree(in_buffer); HRETURN_ERROR(DFE_READERROR, FAIL); } } cp = in_buffer; cp++; INT32DECODE(cp, good_bytes); if (in_buffer[0] == 1) { /* This byte means the data was not compressed -- just copy out */ szip_info->szip_state = SZIP_RUN; HDmemcpy(out_buffer, in_buffer+5, good_bytes); szip_info->buffer = out_buffer; szip_info->buffer_pos = 0; szip_info->buffer_size = good_bytes; szip_info->offset = 0; if (good_bytes > length) { /* partial read */ HDmemcpy(buf, in_buffer+5, length); szip_info->buffer_pos += length; szip_info->buffer_size -= length; } else { /* read the whole data block to the user buffer */ HDmemcpy(buf, in_buffer+5, good_bytes); szip_info->buffer_pos += good_bytes; szip_info->buffer_size -= good_bytes; } szip_info->offset = szip_info->buffer_pos; HDfree(in_buffer); if (szip_info->buffer_size == 0) { if (szip_info->buffer != NULL) { HDfree(szip_info->buffer); szip_info->buffer = NULL; } } return (SUCCEED); } /* Decompress the data */ /* set up the parameters */ sz_param.options_mask = (szip_info->options_mask & ~SZ_H4_REV_2); sz_param.bits_per_pixel = szip_info->bits_per_pixel; sz_param.pixels_per_block = szip_info->pixels_per_block; sz_param.pixels_per_scanline = szip_info->pixels_per_scanline; size_out = out_length; if(SZ_OK!= (status = SZ_BufftoBuffDecompress(out_buffer, &size_out, (in_buffer+5), good_bytes, &sz_param))) { HDfree(out_buffer); HDfree(in_buffer); HRETURN_ERROR(DFE_CDECODE, FAIL); } if ((int32)size_out != out_length) { /* This should never happen?? */ printf("status: %d ??bytes != out_length %d != %d\n",status,size_out,out_length); } /* The data is successfully decompressed. Put into the szip struct */ HDfree(in_buffer); szip_info->szip_state = SZIP_RUN; szip_info->buffer = out_buffer; szip_info->buffer_pos = 0; szip_info->buffer_size = out_length; szip_info->offset = 0; } /* copy the data into the return buffer */ if (length > szip_info->buffer_size) { /* can't happen?? panic?? */ if (szip_info->buffer != NULL) { HDfree(szip_info->buffer); szip_info->buffer = NULL; } return (FAIL); } HDmemcpy(buf, szip_info->buffer + szip_info->buffer_pos, length); szip_info->buffer_pos += length; szip_info->buffer_size -= length; szip_info->offset = szip_info->buffer_pos; if (szip_info->buffer_size == 0) { if (szip_info->buffer != NULL) { HDfree(szip_info->buffer); szip_info->buffer = NULL; } } return (SUCCEED); #else /* ifdef H4_HAVE_LIBSZ */ HRETURN_ERROR(DFE_CANTCOMP, FAIL); #endif /* H4_HAVE_LIBSZ */ } /* end HCIcszip_decode() */
int32 vimakecompat(HFILEID f) { VGROUP *vg; VDATA *vs; uint8 *buf = NULL; /* to store an old vdata or vgroup descriptor */ int32 old_bsize = 0, bsize=0; int32 aid; int32 ret; uintn u; uint16 tag=DFTAG_NULL, ref=DFTAG_NULL; CONSTR(FUNC, "vimakecompat"); /* ============================================= */ /* --- read all vgs and convert each --- */ /* allocate space for vg */ if (NULL == (vg =VIget_vgroup_node())) HRETURN_ERROR(DFE_NOSPACE, 0); ret = aid = Hstartread(f, (uint16) OLD_VGDESCTAG, DFREF_WILDCARD); while (ret != FAIL) { HQuerytagref(aid, &tag, &ref); HQuerylength(aid, &bsize); if (buf == NULL || bsize > old_bsize) { if (buf != NULL) HDfree((VOIDP) buf); if ((buf = (uint8 *) HDmalloc(bsize)) == NULL) HRETURN_ERROR(DFE_NOSPACE, 0); old_bsize = bsize; } /* end if */ ret = Hgetelement(f, (uint16) OLD_VGDESCTAG, ref, (uint8 *) buf); if (ret == FAIL) { HDfree((VOIDP) buf); HRETURN_ERROR(DFE_READERROR, 0) } /* end if */ oldunpackvg(vg, buf, &bsize); /* add new items */ vg->vgclass = NULL; /* vg->vgclass[0] = '\0'; */ vg->extag = 0; vg->exref = 0; vg->version = 2; /* version 2 */ vg->more = 0; /* inside each vgroup, change the old tags to new */ for (u = 0; u < (uintn)vg->nvelt; u++) if (vg->tag[u] == OLD_VGDESCTAG) vg->tag[u] = NEW_VGDESCTAG; else if (vg->tag[u] == OLD_VSDESCTAG) vg->tag[u] = NEW_VSDESCTAG; else /* BAD */ HERROR(DFE_NOTINSET); vpackvg(vg, buf, &bsize); ret = Hputelement(f, VGDESCTAG, ref, (uint8 *) buf, bsize); HDfree((VOIDP) buf); if (ret == FAIL) HRETURN_ERROR(DFE_WRITEERROR, 0); ret = Hnextread(aid, (uint16) OLD_VGDESCTAG, DFREF_WILDCARD, DF_CURRENT); } /* while */