void main(void)
{
char vdata_name[MAX_NC_NAME], vdata_class[MAX_NC_NAME];
char fields[60];
int32 file_id, vdata_id, istat;
int32 n_records, interlace, vdata_size, vdata_ref;
int bufsz = (2 * sizeof(float32) + sizeof(char) \
+ sizeof(int16)) * NRECORDS;
int i;
uint8 databuf[((2 * sizeof(float32)) + sizeof(char) \
+ sizeof(int16)) * NRECORDS];
VOIDP fldbufptrs[4];
float32 itemp[NRECORDS], ispeed[NRECORDS];
int16 iheight[NRECORDS];
char idents[NRECORDS];
/* Open the HDF file. */
file_id = Hopen("VD_Ex4.hdf", DFACC_READ, 0);
/* Initialize the Vset interface. */
istat = Vstart(file_id);
/*
* Get the reference number for the first Vdata in
* the file.
*/
vdata_ref = -1;
vdata_ref = VSgetid(file_id, vdata_ref);
/* Attach to the first Vdata in read mode. */
vdata_id = VSattach(file_id, vdata_ref, "r");
for (i=0; i<60; i++)
fields[i] = '\0';
/* Get the list of field names. */
istat =VSinquire(vdata_id, &n_records, &interlace,
fields, &vdata_size, vdata_name);
printf("files: %s, n_records: %d, vdata_size: %d\n",
fields, n_records, vdata_size);
/* Get the class. */
istat = VSgetclass(vdata_id, vdata_class);
/* Determine the fields that will be read. */
istat = VSsetfields(vdata_id, fields);
/* Print the Vdata information. */
printf("Current Vdata name: %s \nCurrent Vdata class: %s.\n",
vdata_name, vdata_class);
/* Read the data. */
istat = VSread(vdata_id, (VOIDP)databuf, n_records,
FULL_INTERLACE);
/* set fldbufptrs and unpack field values */
fldbufptrs[0] = &idents[0];
fldbufptrs[1] = &ispeed[0];
fldbufptrs[2] = &iheight[0];
fldbufptrs[3] = &itemp[0];
istat = VSfpack(vdata_id, _HDF_VSUNPACK, fields, databuf,
bufsz, n_records, "Ident,Speed,Height,Temp",
fldbufptrs);
printf(" Temp Height Speed Ident\n");
for (i=0; i < n_records; i++) {
printf(" %6.2f %6d %6.2f %c\n",
itemp[i],iheight[i],ispeed[i],idents[i]);
}
/* Detach from the Vdata, close the interface and the file. */
istat = VSdetach(vdata_id);
istat = Vend(file_id);
istat = Hclose(file_id);
}
static uint32 vdata_cmp(int32 vs1,
int32 vs2,
char *gname,
char *cname,
diff_opt_t * opt)
{
int32 i, j, k, iflag;
uint32 err_cnt;
int32 nv1, interlace1, vsize1;
int32 vsotag1;
char fields1[VSFIELDMAX*FIELDNAMELENMAX];
char vsclass1[VSNAMELENMAX], vsname1[VSNAMELENMAX];
int32 nv2, interlace2, vsize2;
int32 vsotag2;
char fields2[VSFIELDMAX*FIELDNAMELENMAX];
char vsclass2[VSNAMELENMAX], vsname2[VSNAMELENMAX];
uint8 *buf1, *buf2, *b1, *b2;
int32 off1[60], off2[60];
DYN_VWRITELIST *w1, *w2;
uint32 nfound=0;
uint32 max_err_cnt = opt->max_err_cnt;
VSinquire(vs1, &nv1, &interlace1, fields1, &vsize1, vsname1);
VSinquire(vs2, &nv2, &interlace2, fields2, &vsize2, vsname2);
vsotag1 = VSQuerytag(vs1);
VSgetclass(vs1,vsclass1);
vsotag2 = VSQuerytag(vs2);
VSgetclass(vs2,vsclass2);
if (vsotag1 != vsotag2 || nv1 != nv2 || interlace1 != interlace2 ||
strcmp(fields1, fields2) != 0 || strcmp(vsclass1, vsclass2) != 0 ||
(strcmp(vsclass1, "Attr0.0") != 0 && vsize1 != vsize2))
{
printf("\n---------------------------\n");
printf("Vdata Name: %s <%s/%s> (Different attributes)\n",
vsname1, gname, cname);
printf("> <%d> nrec=%d interlace=%d fld=[%s] vsize=%d class={%s})\n",
vsotag1, nv1, interlace1, fields1, vsize1, vsclass1);
printf("< <%d> nrec=%d interlace=%d fld=[%s] vsize=%d class={%s})\n",
vsotag2, nv2, interlace2, fields2, vsize2, vsclass2);
return 0;
}
/* compare the data */
buf1 = (uint8 *) malloc((unsigned) (nv1 * vsize1));
buf2 = (uint8 *) malloc((unsigned) (nv2 * vsize2));
if (!buf1 || !buf2)
{
printf("Out of memory!");
opt->err_stat = 1;
return 0;
}
VSsetfields(vs1, fields1);
VSread(vs1, buf1, nv1, interlace1);
w1 = (DYN_VWRITELIST*) vswritelist(vs1);
VSsetfields(vs2, fields2);
VSread(vs2, buf2, nv2, interlace2);
w2 = (DYN_VWRITELIST*) vswritelist(vs2);
b1 = buf1;
b2 = buf2;
for (j=0; j < w1->n; j++)
off1[j] = DFKNTsize(w1->type[j] | DFNT_NATIVE);
for (j=0; j < w2->n; j++)
off2[j] = DFKNTsize(w2->type[j] | DFNT_NATIVE);
iflag = 0;
err_cnt = 0;
if (vsize1 == vsize2)
{
for (i=0; i<nv1; i++)
{
if (memcmp(b1, b2, (size_t)vsize1) == 0)
{
b1 += vsize1;
b2 += vsize2;
continue;
}
if (iflag == 0)
{
iflag = 1; /* there is a difference */
printf("\n---------------------------\n");
printf("Vdata Name: %s (Data record comparison)\n",
vsname1);
nfound ++;
}
printf("> %d: ", i);
for (j=0; j<w1->n; j++)
{
for (k=0; k<w1->order[j]; k++)
{
fmt_print(b1, w1->type[j]);
b1 += off1[j];
if (w1->type[j] != DFNT_CHAR)
putchar(' ');
}
}
putchar('\n');
printf("< %d: ", i);
for (j=0; j<w2->n; j++)
{
for (k=0; k<w2->order[j]; k++)
{
fmt_print(b2, w2->type[j]);
b2 += off2[j];
if (w2->type[j] != DFNT_CHAR)
putchar(' ');
}
}
putchar('\n');
if (max_err_cnt > 0)
{
err_cnt++;
if (err_cnt >= max_err_cnt)
break;
}
}
}
else
{
printf("****....\n");
for (i=0; i<nv1; i++)
{
if (iflag == 0)
{
iflag = 1; /* there is a difference */
printf("\n---------------------------\n");
printf("Vdata Name: %s (Data record comparison)\n",
vsname1);
nfound ++;
}
printf("> %d: ", i);
for (j=0; j<w1->n; j++)
{
for (k=0; k<w1->order[j]; k++)
{
fmt_print(b1, w1->type[j]);
b1 += off1[j];
if (w1->type[j] != DFNT_CHAR)
putchar(' ');
}
}
putchar('\n');
printf("< %d: ", i);
for (j=0; j<w2->n; j++)
{
for (k=0; k<w2->order[j]; k++)
{
fmt_print(b2, w2->type[j]);
b1 += off2[j];
if (w2->type[j] != DFNT_CHAR)
putchar(' ');
}
}
putchar('\n');
if (max_err_cnt > 0)
{
err_cnt++;
if (err_cnt >= max_err_cnt)
break;
}
}
}
if (buf1)free((char *) buf1);
if (buf2)free((char *) buf2);
return nfound;
}
uint32 diff_vs( int32 file1_id,
int32 file2_id,
int32 ref1,
int32 ref2,
diff_opt_t * opt)
{
int32 vdata1_id, /* vdata identifier */
n_records1, /* number of records */
vdata1_size,
interlace1_mode,
vdata2_id=-1, /* vdata identifier */
n_records2, /* number of records */
vdata2_size,
interlace2_mode;
char vdata1_name [VSNAMELENMAX];
char vdata1_class[VSNAMELENMAX];
char fieldname1_list[VSFIELDMAX*FIELDNAMELENMAX];
char vdata2_name [VSNAMELENMAX];
char vdata2_class[VSNAMELENMAX];
char fieldname2_list[VSFIELDMAX*FIELDNAMELENMAX];
uint32 nfound=0;
/*-------------------------------------------------------------------------
* object 1
*-------------------------------------------------------------------------
*/
if (Vstart (file1_id)==FAIL) {
printf("Error: Could not start VS interface in VS ref %d\n", ref1);
goto out;
}
if ((vdata1_id = VSattach (file1_id, ref1, "r")) == FAIL ){
printf( "Failed to attach VS ref %d\n", ref1);
goto out;
}
if (VSgetname (vdata1_id, vdata1_name) == FAIL ){
printf( "Failed to name for VS ref %d\n", ref1);
goto out;
}
if (VSgetclass (vdata1_id, vdata1_class) == FAIL ){
printf( "Failed to name for VS ref %d\n", ref1);
goto out;
}
if (VSinquire(vdata1_id, &n_records1, &interlace1_mode, fieldname1_list,
&vdata1_size, vdata1_name) == FAIL) {
printf( "Failed to get info for VS ref %d\n", ref1);
goto out;
}
if (VFnfields(vdata1_id)== FAIL ){
printf( "Failed getting fields forVS ref %d\n", ref1);
goto out;
}
/*-------------------------------------------------------------------------
* object 2
*-------------------------------------------------------------------------
*/
if (Vstart (file2_id)==FAIL) {
printf("Error: Could not start VS interface in VS ref %d\n", ref1);
goto out;
}
if ((vdata2_id = VSattach (file2_id, ref2, "r")) == FAIL ){
printf("Failed to attach VS ref %d\n", ref2);
goto out;
}
if (VSgetname (vdata2_id, vdata2_name) == FAIL ){
printf("Failed to name for VS ref %d\n", ref2);
goto out;
}
if (VSgetclass (vdata2_id, vdata2_class) == FAIL ){
printf("Failed to name for VS ref %d\n", ref2);
goto out;
}
if (VSinquire(vdata2_id, &n_records2, &interlace2_mode, fieldname2_list,
&vdata2_size, vdata2_name) == FAIL) {
printf("Failed to get info for VS ref %d\n", ref2);
goto out;
}
if (VFnfields(vdata2_id)== FAIL ){
printf("Failed getting fields forVS ref %d\n", ref2);
goto out;
}
/*-------------------------------------------------------------------------
* check for input VSs
*-------------------------------------------------------------------------
*/
if (opt->nuvars > 0) /* if specified vdata is selected */
{
int imatch = 0, j;
for (j = 0; j < opt->nuvars; j++)
{
if (strcmp(vdata1_name, opt->uvars[j]) == 0)
{
imatch = 1;
break;
}
}
if (imatch == 0)
{
goto do_nothing;
}
}
/*-------------------------------------------------------------------------
* Comparing
*-------------------------------------------------------------------------
*/
if (opt->verbose)
printf("Comparing <%s>\n",vdata1_name);
nfound=vdata_cmp(vdata1_id,vdata2_id,vdata1_name,vdata1_class,opt);
do_nothing:
/* terminate access to the VSs */
if (VSdetach (vdata1_id)==FAIL) {
printf("Failed to dettach VS ref %d\n", ref1);
goto out;
}
if (vdata2_id!=-1)
{
if (VSdetach (vdata2_id)==FAIL) {
printf("Failed to dettach VS ref %d\n", ref2);
goto out;
}
}
return nfound;
out:
opt->err_stat = 1;
return 0;
}
int32
dumpvd(int32 vd,
file_format_t ff,
int data_only,
FILE *fp,
char separater[2],
int32 flds_indices[VSFIELDMAX],
int dumpallfields)
{
char vdname[VSNAMELENMAX+1];
int32 j, i, t, interlace, nv, vsize;
uint8 *bb = NULL;
uint8 *b = NULL;
DYN_VWRITELIST *w = NULL;
intn (*vfmtfn[VSFIELDMAX]) (VOIDP , file_format_t ff, FILE *);
int32 off[VSFIELDMAX];
int32 order[VSFIELDMAX];
int32 nattrs[VSFIELDMAX];
int32 bufsize; /* size of the buffer we are using */
int32 chunk; /* number of rows that will fit in the buffer */
int32 done; /* number of rows we have done */
int32 count; /* number of rows to do this time through
the loop */
int32 nf; /* number of fields in this Vdata */
int32 x, display;
int32 temp;
int32 addr_width = 0;
int32 num_digits;
int32 address = 0;
int32 nfields;
int32 cnt1, cnt2;
int32 cn = 0;
int32 ret_value = SUCCEED;
char fields[VSFIELDMAX*FIELDNAMELENMAX];
char flds[VSFIELDMAX*FIELDNAMELENMAX];
/* inquire about vdata */
if (FAIL == VSinquire(vd, &nv, &interlace, fields, &vsize, vdname))
{
ret_value = FAIL;
goto done;
}
if (nv * vsize > BUFFER) /* If the number of records in the vdata is
bigger than the buffer size, then divide
the records into chunks. */
{
bufsize = BUFFER;
chunk = BUFFER / vsize;
}
else
/* Otherwise, all the records will be read in at one time. */
{
bufsize = nv * vsize;
chunk = nv;
}
done = 0;
/* Allocate space for the buffer and terminate hdp if allocation fails. */
bb = (uint8 *) HDmalloc(bufsize);
CHECK_ALLOC( fields, "fields", "dumpvd" );
if (FAIL == VSsetfields(vd, fields))
{
fprintf(stderr,"dumpvd: VSsetfields failed for vd = %d \n",(int)vd);
ret_value = FAIL;
goto done;
}
w = vswritelist(vd);
nf = w->n;
x = 0; /* Used for accessing the array storing the indices of the
selected fields. */
for (i = 0; i < nf; i++) /* Read in data of all the fields. */
{
order[i] = w->order[i];
/* Set offset for the next element. */
off[i] = DFKNTsize(w->type[i] | DFNT_NATIVE);
nattrs[i] = VSfnattrs(vd, i);
if (FAIL == nattrs[i])
{
fprintf(stderr,"dumpvd: VSfnattrs failed for vd = %d \n",(int)vd);
ret_value = FAIL;
goto done;
}
/* Display the header of a vdata if the user didn't specify the
data-only option. */
if (!data_only)
{
if(ff==DASCII)
{
if ((dumpallfields) || (flds_indices[x] == i))
{
fprintf(fp, "- field index %d: [%s], type=%d, order=%d\n",
(int) i, w->name[i], w->type[i], w->order[i]);
x++;
}
}
/* display attributes - BMR moved this block inside if(!data_only)
to keep the attributes from being printed - bug #231*/
if (FAIL == dumpattr(vd, i, 1, ff, fp))
{
fprintf(stderr,"dumpvd: dumpattr() failed for vd = %d \n",(int)vd);
ret_value = FAIL;
goto done;
}
} /* if !data_only */
/* Choose a function for displaying a piece of data of a
particular type. */
switch (w->type[i] & 0xff)
{
case DFNT_CHAR:
case DFNT_UCHAR:
vfmtfn[i] = fmtchar;
break;
case DFNT_UINT8:
vfmtfn[i] = fmtuint8;
break;
case DFNT_INT8:
vfmtfn[i] = fmtint8;
break;
case DFNT_UINT16:
vfmtfn[i] = fmtuint16;
break;
case DFNT_INT16:
vfmtfn[i] = fmtint16;
break;
case DFNT_UINT32:
vfmtfn[i] = fmtuint32;
break;
case DFNT_INT32:
vfmtfn[i] = fmtint32;
break;
case DFNT_FLOAT32:
vfmtfn[i] = fmtfloat32;
break;
case DFNT_FLOAT64:
vfmtfn[i] = fmtfloat64;
break;
default:
fprintf(stderr, "sorry, type [%d] not supported\n", (int) w->type[i]);
ret_value = FAIL;
goto done;
} /* switch */
} /* for */
cn = 0;
done = count = 0;
if(ff==DASCII)
{
/* If not just the data will be dumped out, then put an address-type
column on the left so that the user can recognize which record
he/she is looking at. */
if (!data_only)
{
temp = nv / 10;
address = 0;
addr_width = num_digits = 1;
while (temp != 0)
{
if (temp != 1)
addr_width++;
temp = temp / 10;
}
fprintf(fp, "Loc.");
for (j = 0; j < addr_width - 3; j++)
fprintf(fp, " ");
fprintf(fp, " Data\n");
/* The address of the first record is 0. Also, fill in the extra
space on the left with 0's. */
while (num_digits <= addr_width)
{
fprintf(fp, "0");
num_digits++;
cn++;
}
fprintf(fp, " ");
cn += 6;
if (addr_width == 2)
{
fprintf(fp, " ");
cn++;
}
else if (addr_width == 1)
{
fprintf(fp, " ");
cn += 2;
}
} /* while */
nfields = VSgetfields(vd, flds);
if (FAIL == nfields )
{
fprintf(stderr,"dumpvd: VSgetfields failed for vd = %d \n",(int)vd);
ret_value = FAIL;
goto done;
}
cnt1 = 0;
cnt2 = 0;
while (done != nv)
{
/* Determine the amount of data to be read this time. */
if ((nv - done) > chunk)
count = chunk;
else
count = nv - done;
/* read and update bookkeeping */
if (FAIL == VSread(vd, bb, count, interlace))
{
/* If the data set has external element, get the external file
name to provide information */
intn extfile_namelen = VSgetexternalfile(vd, 0, NULL, NULL);
if (extfile_namelen > 0)
{
char *extfile_name = NULL;
extfile_name = (char *)HDmalloc(sizeof(char *)*(extfile_namelen+1));
CHECK_ALLOC(extfile_name, "extfile_name", "dumpvd" );
/* Get the external file info, we don't need offset here */
extfile_namelen = VSgetexternalfile(vd, extfile_namelen+1, extfile_name, NULL);
ERROR_GOTO_3( "in %s: VSread failed for vd(%d) with external file %s. Please verify the file exists in the same directory.",
"dumpvd", (int)vd, extfile_name);
}
else
ERROR_GOTO_2( "in %s: VSread failed for vd(%d)",
"dumpvd", (int)vd );
}
done += count;
b = bb;
/* Display the data. */
for (j = 0; j < count; j++) /* each iteration causes one record
to be printed */
{
cnt1++;
x = 0;
for (i = 0; i < nf; i++) /* display all fields in one record */
{
if ((!dumpallfields) && (flds_indices[x] != i))
display = 0;
else
{
display = 1;
x++;
}
for (t = 0; t < order[i]; t++)
{
if(display)
cn+=(vfmtfn[i]) (b, ff, fp);
b += off[i];
if (display)
{
fprintf(fp, " ");
cn++;
cnt2++;
}
}
if (display)
{
fprintf(fp, " ");
cn++;
cnt2++;
}
} /* for i to nf-1 */
if (cnt2 > 0)
{
address++;
/* "separator" is the symbol used for separating
different records. */
fprintf(fp, "%s ", separater);
}
if (!data_only)
{
if ((cnt1 * cnt2) > 30)
{
cnt1 = 0;
cnt2 = 0;
fprintf(fp, "\n");
cn = 0;
/* As long as there is data to be displayed,
fill in the extra space with 0's on the left
of each address. */
if (j < (count - 1))
{
temp = address;
num_digits = 1;
while ((temp = temp / 10) != 0)
num_digits++;
while (num_digits < addr_width)
{
fprintf(fp, "0");
num_digits++;
cn++;
}
fprintf(fp, "%d ", (int)address);
cn += 6 + num_digits;
if (addr_width == 2)
{
fprintf(fp, " ");
cn++;
}
else if (addr_width == 1)
{
fprintf(fp, " ");
cn += 2;
}
} /* if (!data_only) */
}
}
else
fprintf(fp, "\n");
} /* for (j=0; j<count; j++) */
} /* while (done != nv) */
/* ============================================ */
HDfree((VOIDP) bb);
bb = NULL;
fprintf(fp, "\n\n");
} /* for DASCII */
else
{ /* binary file */
nfields = VSgetfields(vd, flds);
if (FAIL == nfields )
{
fprintf(stderr,"dumpvd: VSgetfields failed for vd = %d \n",(int)vd);
ret_value = FAIL;
goto done;
}
cnt1 = 0;
cnt2 = 0;
while (done != nv)
{
/* Determine the amount of data to be read this time. */
if ((nv - done) > chunk)
count = chunk;
else
count = nv - done;
/* read and update bookkeeping */
if (FAIL == VSread(vd, bb, count, interlace))
{
/* If the data set has external element, get the external
file name to provide information */
intn extfile_namelen = VSgetexternalfile(vd, 0, NULL, NULL);
if (extfile_namelen > 0)
{
char *extfile_name = NULL;
extfile_name = (char *)HDmalloc(sizeof(char *)*(extfile_namelen+1));
CHECK_ALLOC(extfile_name, "extfile_name", "dumpvd" );
/* Get the external file info, we don't need offset here */
extfile_namelen = VSgetexternalfile(vd, extfile_namelen+1, extfile_name, NULL);
ERROR_GOTO_3( "in %s: VSread failed for vd(%d) with external file %s. Please verify the file exists in the same directory",
"dumpvd", (int)vd, extfile_name);
}
else
ERROR_GOTO_2( "in %s: VSread failed for vd(%d)",
"dumpvd", (int)vd );
}
done += count;
b = bb;
/* Display the data. */
for (j = 0; j < count; j++) /* each iteration causes one record
to be printed */
{
cnt1++;
x = 0;
for (i = 0; i < nf; i++) /* display all fields in one record */
{
if ((!dumpallfields) && (flds_indices[x] != i))
display = 0;
else
{
display = 1;
x++;
}
for (t = 0; t < order[i]; t++)
{
if(display)
cn+=(vfmtfn[i]) (b, ff, fp);
b += off[i];
if (display)
{
cn++;
cnt2++;
}
}
if (display)
{
cn++;
cnt2++;
}
} /* for i to nf-1 */
if (cnt2 > 0)
{
address++;
/* "separator" is the symbol used for separating
different records. */
}
} /* for (j=0; j<count; j++) */
} /* while (done != nv) */
/* ============================================ */
HDfree((VOIDP) bb);
bb = NULL;
} /* binary file */
done:
if (ret_value == FAIL)
{ /* Failure cleanup */
if (bb != NULL)
HDfree((VOIDP)bb);
}
/* Normal cleanup */
return ret_value;
} /* dumpvd */
