void
set_mark(unsigned char mark, struct view_state *mark_vs)
{
struct view_state *vs;
int i;
if (!is_valid_mark_char(mark))
return;
i = index_from_char(mark);
free_mark_by_index(i);
if (!mark_vs) return;
vs = mem_calloc(1, sizeof(*vs));
if (!vs) return;
copy_vs(vs, mark_vs);
marks[i] = vs;
}
void
goto_mark(unsigned char mark, struct view_state *vs)
{
int old_current_link;
#ifdef CONFIG_ECMASCRIPT
struct ecmascript_interpreter *ecmascript;
int ecmascript_fragile;
#endif
struct document_view *doc_view;
int i;
if (!is_valid_mark_char(mark))
return;
i = index_from_char(mark);
assert(is_valid_mark_index(i));
/* TODO: Support for cross-document marks. --pasky */
if (!marks[i] || !compare_uri(marks[i]->uri, vs->uri, 0))
return;
old_current_link = vs->current_link;
#ifdef CONFIG_ECMASCRIPT
ecmascript = vs->ecmascript;
ecmascript_fragile = vs->ecmascript_fragile;
#endif
doc_view = vs->doc_view;
destroy_vs(vs, 0);
copy_vs(vs, marks[i]);
vs->doc_view = doc_view;
vs->doc_view->vs = vs;
#ifdef CONFIG_ECMASCRIPT
vs->ecmascript = ecmascript;
vs->ecmascript_fragile = ecmascript_fragile;
#endif
vs->old_current_link = old_current_link;
}
int vgroup_insert(int32 infile_id,
int32 outfile_id,
int32 sd_id, /* SD interface identifier */
int32 sd_out, /* SD interface identifier */
int32 gr_id, /* GR interface identifier */
int32 gr_out, /* GR interface identifier */
int32 vgroup_id_out_par, /* output parent group ID */
char*path_name, /* absolute path for input group name */
int32* in_tags, /* tag list for parent group */
int32* in_refs, /* ref list for parent group */
int npairs, /* number tag/ref pairs for parent group */
list_table_t *list_tbl,
dim_table_t *td1,
dim_table_t *td2,
options_t *options)
{
int32 vg_id; /* vgroup identifier for opened group in input */
int32 ntagrefs; /* number of tag/ref pairs in a vgroup */
int32 *tags=NULL; /* buffer to hold the tag numbers of vgroups */
int32 *refs=NULL; /* buffer to hold the ref numbers of vgroups */
int32 vgroup_id_out =-1; /* vgroup identifier for the created group in output */
char *vg_name;
char *vg_class;
char *path=NULL;
uint16 name_len;
int visited;
int32 tag;
int32 ref;
int i;
for ( i = 0; i < npairs; i++ )
{
tag = in_tags[i];
ref = in_refs[i];
switch(tag)
{
/*-------------------------------------------------------------------------
* DFTAG_VG
*-------------------------------------------------------------------------
*/
case DFTAG_VG:
visited = list_table_search(list_tbl,DFTAG_VG,ref);
/*-------------------------------------------------------------------------
* open input
*-------------------------------------------------------------------------
*/
vg_id = Vattach (infile_id, ref, "r");
/* Get vgroup's name */
if (Vgetnamelen(vg_id, &name_len)==FAIL)
{
printf("Error: Could not get name length for group with ref <%d>\n", ref);
goto out;
}
vg_name = (char *) HDmalloc(sizeof(char) * (name_len+1));
if (Vgetname (vg_id, vg_name)==FAIL)
{
printf( "Could not get name for group\n");
goto out;
}
/* Get vgroup's class name */
if (Vgetclassnamelen(vg_id, &name_len)==FAIL)
{
printf("Error: Could not get name length for group with ref <%d>\n", ref);
goto out;
}
vg_class = (char *) HDmalloc(sizeof(char) * (name_len+1));
if (Vgetclass (vg_id, vg_class)==FAIL)
{
printf( "Could not get class for group\n");
goto out;
}
/* ignore reserved HDF groups/vdatas */
if( is_reserved(vg_class))
{
if (Vdetach (vg_id)==FAIL)
{
printf( "Could not detach group\n");
goto out;
}
continue;
}
if(strcmp(vg_name,GR_NAME)==0)
{
if (Vdetach (vg_id)==FAIL)
{
printf( "Could not detach group\n");
goto out;
}
continue;
}
/*-------------------------------------------------------------------------
* create the group in output or create the link
*-------------------------------------------------------------------------
*/
if (options->trip==1)
{
if ( visited < 0 )
{
/*
* create the group in the output file. the vgroup reference number
* is set to -1 for creating and the access mode is "w" for writing
*/
vgroup_id_out = Vattach (outfile_id, -1, "w");
if (Vsetname (vgroup_id_out, vg_name)==FAIL)
{
printf("Error: Could not create group <%s>\n", vg_name);
goto out;
}
if (Vsetclass (vgroup_id_out, vg_class)==FAIL)
{
printf("Error: Could not create group <%s>\n", vg_name);
goto out;
}
if (copy_vgroup_attrs(vg_id,vgroup_id_out,path,options)<0)
goto out;
if (copy_vg_an(infile_id,outfile_id,vg_id,vgroup_id_out,path,options)<0)
goto out;
}
else
{
/* open previously visited group */
vgroup_id_out = Vattach (outfile_id, ref, "r");
}
/* insert the created (or opened) vgroup into its parent */
if (Vinsert (vgroup_id_out_par, vgroup_id_out)==FAIL)
{
printf("Could not insert group <%s>\n", vg_name);
goto out;
}
} /* create the group in output or create the link */
/*-------------------------------------------------------------------------
* if group not visited, add to table and check for more tag/ref pairs
*-------------------------------------------------------------------------
*/
/* check if already visited */
if ( visited < 0 )
{
/* initialize path */
path=get_path(path_name,vg_name);
/* add object to table */
list_table_add(list_tbl,tag,ref,path);
if (options->verbose)
printf(PFORMAT,"","","",path);
if ( options->trip==0 )
{
/*we must go to other groups always */
}
/* insert objects for this group */
ntagrefs = Vntagrefs(vg_id);
if ( ntagrefs > 0 )
{
tags = (int32 *) malloc(sizeof(int32) * ntagrefs);
refs = (int32 *) malloc(sizeof(int32) * ntagrefs);
if (Vgettagrefs(vg_id, tags, refs, ntagrefs)<0)
goto out;
/* recurse */
if (vgroup_insert(
infile_id,
outfile_id,
sd_id,
sd_out,
gr_id,
gr_out,
vgroup_id_out,
path,
tags,
refs,
ntagrefs,
list_tbl,
td1,
td2,
options)<0) {
goto out;
}
free (tags);
tags=NULL;
free (refs);
refs=NULL;
} /* ntagrefs > 0 */
if (path)
free(path);
} /* check if already visited */
if(Vdetach (vg_id)==FAIL)
{
printf("Error: Could not detach group <%s>\n", vg_name);
goto out;
}
if (options->trip==1)
{
if (Vdetach (vgroup_id_out)==FAIL)
{
printf("Error: Could not detach group <%s>\n", vg_name);
goto out;
}
}
break;
/*-------------------------------------------------------------------------
* SDS
*-------------------------------------------------------------------------
*/
case DFTAG_SD: /* Scientific Data */
case DFTAG_SDG: /* Scientific Data Group */
case DFTAG_NDG: /* Numeric Data Group */
/* copy dataset */
if (copy_sds(sd_id,
sd_out,
tag,ref,
vgroup_id_out_par,
path_name,
options,
list_tbl,
td1,
td2,
infile_id,
outfile_id)<0)
return FAIL;
break;
/*-------------------------------------------------------------------------
* Image
*-------------------------------------------------------------------------
*/
case DFTAG_RI: /* Raster Image */
case DFTAG_CI: /* Compressed Image */
case DFTAG_RIG: /* Raster Image Group */
case DFTAG_RI8: /* Raster-8 image */
case DFTAG_CI8: /* RLE compressed 8-bit image */
case DFTAG_II8: /* IMCOMP compressed 8-bit image */
/* copy GR */
if (copy_gr(infile_id,
outfile_id,
gr_id,
gr_out,
tag,
ref,
vgroup_id_out_par,
path_name,
options,
list_tbl)<0)
return FAIL;
break;
/*-------------------------------------------------------------------------
* Vdata
*-------------------------------------------------------------------------
*/
case DFTAG_VH: /* Vdata Header */
if (copy_vs(infile_id,
outfile_id,
tag,
ref,
vgroup_id_out_par,
path_name,
options,
list_tbl,
0)<0)
return FAIL;
break;
} /* switch */
} /* i */
return SUCCEED;
out:
if (tags!=NULL)
free (tags);
if (refs!=NULL)
free (refs);
return FAIL;
}
int list_vs(int32 infile_id,
int32 outfile_id,
list_table_t *list_tbl,
options_t *options)
{
int32 nlones = 0, /* number of lone vdatas */
*ref_array=NULL, /* buffer to hold the ref numbers of lone vdatas */
ref; /* temporary ref number */
int i;
/*-------------------------------------------------------------------------
* initialize the V interface
*-------------------------------------------------------------------------
*/
if (Vstart(infile_id) == FAIL)
{
return FAIL;
}
if (options->trip==1)
{
if (Vstart(outfile_id) == FAIL)
{
return FAIL;
}
}
/*-------------------------------------------------------------------------
* get the names and class names of all the lone vdatas
* first, call Vlone with nlones set to 0 to get the number of lone vdatas
* in the file
*
*-------------------------------------------------------------------------
*/
nlones = VSlone (infile_id, NULL, nlones );
if (nlones > 0)
{
/*
* use the nlones returned to allocate sufficient space for the
* buffer ref_array to hold the reference numbers of all lone vgroups,
*/
ref_array = (int32 *) malloc(sizeof(int32) * nlones);
/*
* and call VSlone again to retrieve the reference numbers into
* the buffer ref_array.
*/
nlones = VSlone (infile_id, ref_array, nlones);
/*
* iterate tru each lone vdata.
*/
for (i = 0; i < nlones; i++)
{
/*
* attach to the current vdata then get its
* name and class. note: the current vdata must be detached before
* moving to the next.
*/
ref = ref_array[i];
/* check if already inserted in Vgroup, search with VS tag */
if ( list_table_search(list_tbl,DFTAG_VH,ref)>=0 )
{
continue;
}
/* copy VS */
if (copy_vs(infile_id,outfile_id,DFTAG_VH,ref,0,NULL,options,list_tbl,1)<0)
{
goto out;
}
} /* for */
/* free the space allocated */
if (ref_array)
{
free (ref_array);
ref_array = NULL;
}
} /* if */
/*-------------------------------------------------------------------------
* terminate access to the V interface
*-------------------------------------------------------------------------
*/
if (Vend (infile_id)==FAIL)
{
printf("Error: Could not end Vdata interface\n");
return FAIL;
}
if (options->trip==1)
{
if (Vend (outfile_id)==FAIL){
printf("Error: Could not end Vdata interface\n");
return FAIL;
}
}
return SUCCEED;
out:
Vend (infile_id);
if (options->trip==1)
Vend (outfile_id);
/* free the space allocated */
if (ref_array!=NULL)
free (ref_array);
return FAIL;
}
