philipp/hdf5
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
7438a71a0b04b6cf7d6c19245952426c400ef871
hdf5/tools/lib/h5diff.c
Pedro Vicente Nunes 7438a71a0b [svn-r8748] Purpose: 
dumper new feautures

Description:
1) added options for not printing : datasets, groups, datatypes, links
2) added a section for the user block
3) in the traversal routine, added the printing of an arrow for soft links and the word HARDLINK for hardlinks
   the print of the file contents is made during traversal , instead of at the end of it (this is helpful
    for very large files, where the wait time can be very long)
4) changed the description of the fill value properties
5) added a colon after the printing of the array indices



Solution:

Platforms tested:
linux
AIX
solaris

Misc. update:
2004-06-28 09:05:16 -05:00

538 lines
14 KiB
C
Raw Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include <stdlib.h>
#include "h5diff.h"
#include "H5private.h"
/*-------------------------------------------------------------------------
* Function: h5diff
*
* Purpose: public function, can be called in an application program.
* return differences between 2 HDF5 files
*
* Return: Number of differences found; -1 for error.
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: October 22, 2003
*
*-------------------------------------------------------------------------
*/
int h5diff(const char *fname1,
const char *fname2,
const char *objname1,
const char *objname2,
diff_opt_t *options)
{
int nobjects1, nobjects2;
trav_info_t *info1=NULL;
trav_info_t *info2=NULL;
hid_t file1_id, file2_id;
int nfound=0;
/*-------------------------------------------------------------------------
* open the files first; if they are not valid, no point in continuing
*-------------------------------------------------------------------------
*/
/* disable error reporting */
H5E_BEGIN_TRY {
/* Open the files */
if ((file1_id=H5Fopen(fname1,H5F_ACC_RDONLY,H5P_DEFAULT))<0 )
{
printf("h5diff: <%s>: unable to open file\n", fname1 );
nfound = -1;
}
if ((file2_id=H5Fopen(fname2,H5F_ACC_RDONLY,H5P_DEFAULT))<0 )
{
printf("h5diff: <%s>: unable to open file\n", fname2 );
nfound = -1;
}
/* enable error reporting */
} H5E_END_TRY;
if (nfound<0)
return -1;
/*-------------------------------------------------------------------------
* get the number of objects in the files
*-------------------------------------------------------------------------
*/
nobjects1 = h5trav_getinfo( file1_id, NULL, 0 );
nobjects2 = h5trav_getinfo( file2_id, NULL, 0 );
/*-------------------------------------------------------------------------
* get the list of objects in the files
*-------------------------------------------------------------------------
*/
info1 = (trav_info_t*) malloc( nobjects1 * sizeof(trav_info_t));
info2 = (trav_info_t*) malloc( nobjects2 * sizeof(trav_info_t));
if (info1==NULL || info2==NULL)
{
nfound=-1;
goto out;
}
h5trav_getinfo( file1_id, info1, 0 );
h5trav_getinfo( file2_id, info2, 0 );
/*-------------------------------------------------------------------------
* object name was supplied
*-------------------------------------------------------------------------
*/
if ( objname1 )
{
assert(objname2);
nfound=diff_compare(file1_id,fname1,objname1,nobjects1,info1,
file2_id,fname2,objname2,nobjects2,info2,options);
}
/*-------------------------------------------------------------------------
* compare all
*-------------------------------------------------------------------------
*/
else
{
nfound=diff_match(file1_id,nobjects1,info1,
file2_id,nobjects2,info2,options);
}
h5trav_freeinfo(info1,nobjects1);
h5trav_freeinfo(info2,nobjects2);
out:
/* close */
H5Fclose(file1_id);
H5Fclose(file2_id);
return nfound;
}
/*-------------------------------------------------------------------------
* Function: diff_match
*
* Purpose: Find common objects; the algorithm used for this search is the
* cosequential match algorithm and is described in
* Folk, Michael; Zoellick, Bill. (1992). File Structures. Addison-Wesley.
*
* Return: Number of differences found
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: May 9, 2003
*
*-------------------------------------------------------------------------
*/
int diff_match( hid_t file1_id,
int nobjects1,
trav_info_t *info1,
hid_t file2_id,
int nobjects2,
trav_info_t *info2,
diff_opt_t *options )
{
int more_names_exist = (nobjects1>0 && nobjects2>0) ? 1 : 0;
trav_table_t *table=NULL;
int cmp;
int curr1=0;
int curr2=0;
unsigned infile[2];
char c1, c2;
int nfound=0, i;
/*-------------------------------------------------------------------------
* build the list
*-------------------------------------------------------------------------
*/
trav_table_init( &table );
while ( more_names_exist )
{
/* criteria is string compare */
cmp = strcmp( info1[curr1].name, info2[curr2].name );
if ( cmp == 0 )
{
infile[0]=1; infile[1]=1;
trav_table_addflags(infile, info1[curr1].name, info1[curr1].type, table );
curr1++;
curr2++;
}
else if ( cmp < 0 )
{
infile[0]=1; infile[1]=0;
trav_table_addflags(infile, info1[curr1].name, info1[curr1].type, table );
curr1++;
}
else
{
infile[0]=0; infile[1]=1;
trav_table_addflags(infile, info2[curr2].name, info2[curr2].type, table );
curr2++;
}
more_names_exist = (curr1<nobjects1 && curr2<nobjects2) ? 1 : 0;
} /* end while */
/* list1 did not end */
if (curr1<nobjects1)
{
while ( curr1<nobjects1 )
{
infile[0]=1; infile[1]=0;
trav_table_addflags(infile, info1[curr1].name, info1[curr1].type, table );
curr1++;
}
}
/* list2 did not end */
if (curr2<nobjects2)
{
while ( curr2<nobjects2 )
{
infile[0]=0; infile[1]=1;
trav_table_addflags(infile, info2[curr2].name, info2[curr2].type, table );
curr2++;
}
}
/*-------------------------------------------------------------------------
* print the list
*-------------------------------------------------------------------------
*/
if (options->verbose)
{
printf("\n");
printf("file1 file2\n");
printf("---------------------------------------\n");
for (i = 0; i < table->nobjs; i++)
{
c1 = (table->objs[i].flags[0]) ? 'x' : ' ';
c2 = (table->objs[i].flags[1]) ? 'x' : ' ';
printf("%5c %6c %-15s\n", c1, c2, table->objs[i].name);
}
printf("\n");
}
/*-------------------------------------------------------------------------
* do the diff for common objects
*-------------------------------------------------------------------------
*/
for (i = 0; i < table->nobjs; i++)
{
if ( table->objs[i].flags[0] && table->objs[i].flags[1] )
nfound+=diff( file1_id,
table->objs[i].name,
file2_id,
table->objs[i].name,
options,
table->objs[i].type );
}
/* free table */
trav_table_free(table);
/*-------------------------------------------------------------------------
* do the diff for the root.
* this is a special case, we get an ID for the root group and call diff()
* with this ID; it compares only the root group attributes
*-------------------------------------------------------------------------
*/
nfound+=diff( file1_id,
"/",
file2_id,
"/",
options,
H5G_GROUP );
return nfound;
}
/*-------------------------------------------------------------------------
* Function: diff_compare
*
* Purpose: get objects from list, and check for the same type
*
* Return: Number of differences found
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: May 9, 2003
*
*-------------------------------------------------------------------------
*/
int diff_compare( hid_t file1_id,
const char *file1_name,
const char *obj1_name,
int nobjects1,
trav_info_t *info1,
hid_t file2_id,
const char *file2_name,
const char *obj2_name,
int nobjects2,
trav_info_t *info2,
diff_opt_t *options )
{
int f1=0, f2=0;
int nfound=0;
int i = h5trav_getindex( obj1_name, nobjects1, info1 );
int j = h5trav_getindex( obj2_name, nobjects2, info2 );
if ( i == -1 )
{
printf( "Object <%s> could not be found in <%s>\n", obj1_name, file1_name );
f1=1;
}
if ( j == -1 )
{
printf( "Object <%s> could not be found in <%s>\n", obj2_name, file2_name );
f2=1;
}
if ( f1 || f2 )
return -1;
/* use the name with "/" first, as obtained by iterator function */
obj1_name=info1[i].name;
obj2_name=info2[j].name;
/* objects are not the same type */
if ( info1[i].type != info2[j].type && options->verbose)
{
printf("Comparison not possible: <%s> is of type %s and <%s> is of type %s\n",
obj1_name, get_type(info1[i].type),
obj2_name, get_type(info2[j].type) );
return 1;
}
nfound=diff( file1_id, obj1_name, file2_id, obj2_name, options, info1[i].type );
return nfound;
}
/*-------------------------------------------------------------------------
* Function: diff
*
* Purpose: switch between types and choose the diff function
* TYPE is either
* H5G_LINK Object is a symbolic link
* H5G_GROUP Object is a group
* H5G_DATASET Object is a dataset
* H5G_TYPE Object is a named data type
*
* Return: Number of differences found
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: May 9, 2003
*
*-------------------------------------------------------------------------
*/
int diff( hid_t file1_id,
const char *path1,
hid_t file2_id,
const char *path2,
diff_opt_t *options,
H5G_obj_t1 type )
{
hid_t type1_id=-1;
hid_t type2_id=-1;
hid_t grp1_id=-1;
hid_t grp2_id=-1;
int ret;
H5G_stat_t sb1;
H5G_stat_t sb2;
char *buf1=NULL;
char *buf2=NULL;
int nfound=-1;
switch ( type )
{
/*-------------------------------------------------------------------------
* H5G_DATASET
*-------------------------------------------------------------------------
*/
case H5G_DATASET:
if (options->verbose)
printf( "Dataset: <%s> and <%s>\n",path1,path2);
nfound=diff_dataset(file1_id,file2_id,path1,path2,options);
break;
/*-------------------------------------------------------------------------
* H5G_TYPE
*-------------------------------------------------------------------------
*/
case H5G_TYPE:
if (options->verbose)
printf( "Datatype: <%s> and <%s>\n",path1,path2);
if ((type1_id = H5Topen(file1_id, path1))<0)
goto out;
if ((type2_id = H5Topen(file2_id, path2))<0)
goto out;
if ((ret = H5Tequal(type1_id,type2_id))<0)
goto out;
/* if H5Tequal is > 0 then the datatypes refer to the same datatype */
nfound = (ret>0) ? 0 : 1;
/*-------------------------------------------------------------------------
* compare attributes
* the if condition refers to cases when the dataset is a referenced object
*-------------------------------------------------------------------------
*/
if (path1)
nfound=diff_attr(type1_id,type2_id,path1,path2,options);
if ( H5Tclose(type1_id)<0)
goto out;
if ( H5Tclose(type2_id)<0)
goto out;
break;
/*-------------------------------------------------------------------------
* H5G_GROUP
*-------------------------------------------------------------------------
*/
case H5G_GROUP:
if (options->verbose)
printf( "Group: <%s> and <%s>\n",path1,path2);
if ((grp1_id = H5Gopen(file1_id, path1))<0)
goto out;
if ((grp2_id = H5Gopen(file2_id, path2))<0)
goto out;
ret = HDstrcmp(path1,path2);
/* if "path1" != "path2" then the groups are "different" */
nfound = (ret!=0) ? 1 : 0;
/*-------------------------------------------------------------------------
* compare attributes
* the if condition refers to cases when the dataset is a referenced object
*-------------------------------------------------------------------------
*/
if (path1)
nfound=diff_attr(grp1_id,grp2_id,path1,path2,options);
if ( H5Gclose(grp1_id)<0)
goto out;
if ( H5Gclose(grp2_id)<0)
goto out;
break;
/*-------------------------------------------------------------------------
* H5G_LINK
*-------------------------------------------------------------------------
*/
case H5G_LINK:
if (options->verbose)
printf( "Link: <%s> and <%s>\n",path1,path2);
if (H5Gget_objinfo(file1_id,path1,FALSE,&sb1)<0)
goto out;
if (H5Gget_objinfo(file1_id,path1,FALSE,&sb2)<0)
goto out;
buf1 = malloc(sb1.linklen);
buf2 = malloc(sb2.linklen);
if (H5Gget_linkval(file1_id,path1,sb1.linklen,buf1)<0)
goto out;
if (H5Gget_linkval(file2_id,path2,sb1.linklen,buf2)<0)
goto out;
ret = HDstrcmp(buf1,buf2);
/* if "buf1" != "buf2" then the links are "different" */
nfound = (ret!=0) ? 1 : 0;
if (buf1) {
free(buf1);
buf1=NULL;
}
if (buf2) {
free(buf2);
buf2=NULL;
}
break;
default:
nfound=0;
if (options->verbose) {
printf("Comparison not supported: <%s> and <%s> are of type %s\n",
path1, path2, get_type(type) );
}
break;
}
out:
/* close */
/* disable error reporting */
H5E_BEGIN_TRY {
H5Tclose(type1_id);
H5Tclose(type2_id);
H5Gclose(grp1_id);
H5Tclose(grp2_id);
/* enable error reporting */
} H5E_END_TRY;
if (buf1)
free(buf1);
if (buf2)
free(buf2);
return nfound;
}
Reference in New Issue View Git Blame Copy Permalink