/*--------------------------------------------------------------------------
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 */