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