home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / UIFlow 1.0.1 / UIFlow Source / VSet2.0 / Src / vgp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-04-20  |  26.9 KB  |  1,234 lines  |  [TEXT/????]
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF Vset release 2.1
  4. *                    May 1991
  5. *
  6. * NCSA HDF Vset release 2.1 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. *****************************************************************************
  21. * Likkai Ng NCSA May 1991
  22. * 
  23. * vgp.c
  24. * Part of the vertex-set interface.
  25. * VGROUPs are handled by routines in here.
  26. *
  27. *************************************************************************/
  28.  
  29. #include "vg.h"
  30.  
  31. /* ------------------------------------------------------------ */
  32. /* 
  33. *
  34. * G L O B A L S 
  35. *
  36. * These are the *only* globals in the vset interface!!  
  37. * They are used only for debugging.  No globals in other files. 
  38. * The 2 functions below turn debugging on and off.
  39. *
  40. */
  41.  
  42. PUBLIC    char         sjs[200];
  43. PUBLIC    int      vjv    =    0;
  44.  
  45. /*
  46. turn debug on 
  47. */
  48. PUBLIC void    setjj()              /*@-@*/
  49. { 
  50.     vjv=1; 
  51. }
  52.  
  53. /*
  54. turn debug off 
  55. */
  56. PUBLIC void setnojj()         /*@-@*/
  57. { 
  58.     vjv=0; 
  59. }
  60.  
  61.  
  62. /*
  63. * -------------------------------------------------------------------- 
  64. * PRIVATE  data structure and routines.
  65. * 
  66. * Info about all vgroups in the file are loaded into vgtab  at start;
  67. * and the vg field set to NULL until that vgroup is attached,
  68. * and reset back to NULL when that vgroup is detached. 
  69. * Info about all vdatas in the file are loaded into vstab  at start;
  70. * and the vs field set to NULL until that vdata is attached,
  71. * and reset back to NULL when that vdata is detached. 
  72. * -------------------------------------------------------------------- 
  73. */
  74.  
  75.  
  76. PRIVATE vfile_t  vfile [VFILEMAX];
  77. PRIVATE int      nvfile = 0;
  78.  
  79. /*
  80.   ***Only called by Get_vfile()***   
  81. loads vgtab table with info of all vgroups in file f.
  82. Will allocate a new vfile_t, then proceed to load vg instances.
  83. RETURNS -1 if error
  84. RETURNS INDEX into vfile[] if ok.
  85. */
  86. PRIVATE int Load_vfile (f)              /*@@*/
  87.  
  88. DF *f;
  89. {
  90.     DFdesc   d;
  91.     vfile_t    * vf;
  92.     vginstance_t  * v;
  93.     vsinstance_t  * w;
  94.     int returnval;
  95.  
  96.     if (vjv) {
  97.         sprintf(sjs,"@Load_vfile \n");
  98.         zj;
  99.     }
  100.  
  101.     /* allocate a new vfile_t structure */
  102.     if (nvfile >= VFILEMAX-1) RTNEG ("Load_vfile: full\n");
  103.  
  104.     returnval = nvfile;
  105.     vf = &vfile[nvfile];
  106.     nvfile++;
  107.  
  108.     vf->f            = f;
  109.  
  110.     /* load all the vg's  tag/refs from file */
  111.     vf->vgtabn    = -1;
  112.     vf->vgtabtail = &(vf->vgtab);
  113.  
  114.     vf->vgtab.ref      = -1;
  115.     vf->vgtab.nattach  = -1;
  116.     vf->vgtab.nentries = -1;
  117.     vf->vgtab.vg       = NULL;
  118.     vf->vgtab.next     = NULL;
  119.  
  120.     vf->vgtabn = 0;
  121.     DFsetfind(f,VGDESCTAG,DFREF_WILDCARD);
  122.  
  123.     while (1) {
  124.         if ( DFfind(f,&d) != 0) break;          /* no more vgs */
  125.         if (vjv) {
  126.             sprintf(sjs,"#LOADVGDIR:FOUND (%d) <%d/%d>\n ",
  127.                 vf->vgtabn, d.tag,d.ref);
  128.             zj;
  129.         }
  130.  
  131.         if (NULL == (v = (vginstance_t*) DFIgetspace(sizeof(vginstance_t))))
  132.             RTNEG ("Load_vfile: no more space\n");
  133.  
  134.         vf->vgtabtail->next    = v;
  135.         vf->vgtabtail            = v;
  136.         v->next        = NULL;
  137.         v->ref      = d.ref;
  138.         v->vg       = (VGROUP*) NULL; /* ie not attached yet */
  139.         v->nattach  = 0;
  140.         v->nentries = 0;
  141.         vf->vgtabn++;
  142.  
  143.     }
  144.  
  145.     /* load all the vs's  tag/refs from file */
  146.     vf->vstabn    = -1;
  147.     vf->vstabtail = &(vf->vstab);
  148.  
  149.     vf->vstab.ref      = -1;
  150.     vf->vstab.nattach  = -1;
  151.     vf->vstab.nvertices= -1;
  152.     vf->vstab.vs       = NULL;
  153.     vf->vstab.next     = NULL;
  154.  
  155.     vf->vstabn = 0;
  156.     DFsetfind(f,VSDESCTAG,DFREF_WILDCARD);
  157.  
  158.     while (1) {
  159.         if ( DFfind(f,&d) != 0) break;      /* no more vgs */
  160.         if (vjv) {
  161.             sprintf(sjs,"#LOADVSDIR:FOUND (%d) <%d/%d>\n ",
  162.                 vf->vstabn, d.tag,d.ref);
  163.             zj;
  164.         }
  165.         if (NULL == (w = (vsinstance_t*) DFIgetspace(sizeof(vsinstance_t))))
  166.             RTNEG ("Load_vfile: no more space\n");
  167.  
  168.         vf->vstabtail->next  = w;
  169.         vf->vstabtail        = w;
  170.         w->next     = NULL;
  171.         w->ref      = d.ref;
  172.         w->vs       = (VDATA*) NULL; /* ie not attached yet */
  173.         w->nattach  = 0;
  174.         w->nvertices= 0;
  175.         vf->vstabn++;
  176.  
  177.     }
  178.  
  179.     /* file may be incompatible with vset version 2.x. Need to check it */
  180.     if ( (0 == vf->vgtabn) && (0 == vf->vstabn) )
  181.         if ( 0 == vicheckcompat (f) ) { /* not compatible */
  182.             sprintf(sjs,"********************************************\n\n");
  183.             zj;
  184.             sprintf(sjs,"%cFile incompatible with vset version 2.0\n",7); 
  185.             zj;
  186.             sprintf(sjs,"%cFirst use the utility vcompat on this file\n",7); 
  187.             zj;
  188.             sprintf(sjs,"********************************************\n\n");
  189.             zj;
  190.             nvfile--;     /* delete the structure for that file */
  191.             RTNEG ("Load_vfile: incompatible file\n");
  192.         }
  193.  
  194.     /* otherwise, success */
  195.     return (returnval); /* ok, return the index  */
  196.  
  197. } /* Load_vfile */
  198.  
  199. /* returns the vfile pointer for file f, else NULL */
  200. vfile_t * Get_vfile (f)
  201. DF * f;
  202. {
  203.     int i, vfileno;
  204.  
  205.     /* loop thru vfile[], if found, return ptr */
  206.     for (i=0;i<nvfile;i++) if (vfile[i].f == f)    return(&vfile[i]);
  207.  
  208.     /* not found, try to load it */
  209.     vfileno = Load_vfile (f);
  210.  
  211.     if (-1 == vfileno) {
  212.         RTNULL("Get_vfile: cannot load file\n");
  213.     }
  214.     else
  215.         return( &vfile[vfileno]); /* ok, return vfile pointer */
  216.  
  217. } /* Get_vfile */
  218.  
  219.  
  220.  
  221. PRIVATE void Remove_vfile (f)
  222. DF * f;
  223. {
  224.     int i;
  225.  
  226.     /* loop thru vfile[], if found, delete it */
  227.         for (i=0;i<nvfile;i++)
  228.             if (vfile[i].f == f) { vfile[i].f = NULL; break; }
  229.             }
  230.  
  231. /* should be replaced by HDFopen() or such */
  232. /* is called by DFvsetopen() only */
  233.  
  234. PUBLIC void Vinitialize(f)
  235. DF * f; {
  236.   if (f!=NULL) Remove_vfile (f);
  237.     if (vjv) {
  238.         sprintf(sjs,"@Vinitialize: f=%x\n", f);
  239.         zj;
  240.     }
  241.   }
  242.  
  243. /* ==================================================================== */
  244.  
  245. /*
  246. * Looks thru vgtab for vgid and return the addr of the vg instance
  247. * where vgid is found.
  248. * RETURNS NULL if error or not found.
  249. * RETURNS vginstance_t pointer if ok.
  250. *
  251. */
  252.  
  253. vginstance_t * vginstance (f,vgid)             /*@@*/
  254. DF  *f;
  255. int vgid;
  256.  
  257. {
  258.     vginstance_t * v;
  259.     vfile_t      * vf;
  260.  
  261.     if (NULL== (vf = (vfile_t*) Get_vfile(f)))
  262.         RTNULL ("vginstance: no such file\n");
  263.  
  264.     v = vf->vgtab.next;
  265.     while (NULL != v) {
  266.         if (v->ref == vgid) return(v);
  267.         v = v->next;
  268.     }
  269.     return(NULL);
  270.  
  271. } /* vginstance */
  272.  
  273. /* 
  274. * Tests if a vgroup with id vgid is in the file's vgtab.
  275. * returns -1 if not found,
  276. * returns 1 if found.
  277. */
  278. int vexistvg (f,vgid)             /*@@*/
  279. DF  *f;
  280. int vgid;
  281. {
  282.     if (NULL== (vginstance_t *) vginstance(f,vgid))
  283.         return(-1);
  284.     else
  285.         return (1);
  286.  
  287. } /* vexistvg */
  288. /* ==================================================================== */
  289. /*
  290. * vpackvg() and vunpackvg() : Packing and unpacking routines.
  291. * For use in retrieving and storing vgroups to/from the HDF file.
  292. *
  293. *    Fields of VGROUP  that gets stored in HDF as a VGDESCTAG data object:
  294. *        int16        nvelt (no of entries )
  295. *        char        vgname[MAXVGNAMELEN]
  296. *        int16        tag[1..nvelt]        
  297. *        int16        ref[1..nvelt]        
  298. */
  299. /* ==================================================================== */
  300.  
  301. #define INT16SIZE 2
  302.  
  303. /* ==================================================================== */
  304. /* 
  305. *    vpackvg
  306. *    extracts fields from  a VGROUP struct vg and pack the fields
  307. *  into array buf in preparation for storage in the HDF file.
  308. *
  309. *  NO RETURN VALUES.
  310. */
  311.  
  312. void vpackvg (vg,buf,size)       /*@@*/
  313.  
  314. VGROUP            *vg;        /* vgroup to be saved to file */
  315. unsigned char     buf[];     /* buffer to receive the packed fields */
  316. int               *size;    /* the size of buf is returned here */
  317.  
  318. {
  319.     int              i;
  320.     unsigned     char*b, *bb;
  321.     int16            int16var;
  322.  
  323.     bb = &buf[0];
  324.  
  325.     /* save nvelt */
  326.     b= bb;
  327.     INT16WRITE(b,vg->nvelt);
  328.     bb +=INT16SIZE;
  329.  
  330.  
  331.     /* save all tags */
  332.     for(i=0;i<vg->nvelt;i++) {
  333.         b= bb;
  334.         INT16WRITE(b,vg->tag[i]);
  335.         bb +=INT16SIZE;
  336.     }
  337.  
  338.     /* save all refs */
  339.     for(i=0;i<vg->nvelt;i++) {
  340.         b= bb;
  341.         INT16WRITE(b,vg->ref[i]);
  342.         bb +=INT16SIZE;
  343.     }
  344.  
  345.     /* save the vgnamelen and vgname - omit the null */
  346.     b= bb;
  347.     int16var = strlen(vg->vgname);
  348.     INT16WRITE(b,int16var);
  349.     bb +=INT16SIZE;
  350.  
  351.     strcpy((char*) bb,vg->vgname);
  352.     bb +=  strlen(vg->vgname) ;
  353.  
  354.     /* save the vgclasslen and vgclass- omit the null */
  355.     b= bb;
  356.     int16var = strlen(vg->vgclass);
  357.     INT16WRITE(b,int16var);
  358.     bb +=INT16SIZE;
  359.  
  360.     strcpy((char*) bb,vg->vgclass);
  361.     bb +=  strlen(vg->vgclass) ;
  362.  
  363.     /* save the expansion tag/ref pair */
  364.     b= bb;
  365.     INT16WRITE(b,vg->extag);   /* the vg's expansion tag */
  366.     bb +=INT16SIZE;
  367.  
  368.     b= bb;
  369.     INT16WRITE(b,vg->exref);   /* the vg's expansion ref */
  370.     bb +=INT16SIZE;
  371.  
  372.     /*  save the vg's version field */
  373.     b= bb;
  374.     INT16WRITE(b,vg->version);
  375.     bb +=INT16SIZE;
  376.  
  377.     /* save the vg's more field */
  378.     b= bb;
  379.     INT16WRITE(b,vg->more);
  380.     bb +=INT16SIZE;
  381.  
  382.     if (vjv) {
  383.         sprintf(sjs,"vpackvg: vgname is [%s]\n",vg->vgname);
  384.         zj;
  385.     }
  386.  
  387.     /* returns the size of total fields saved */
  388.     *size = bb - buf + 1;
  389.  
  390.     if (vjv) {
  391.         sprintf(sjs,"#vpackvg: vg->nvelt=%d\n",vg->nvelt);
  392.         zj;
  393.     }
  394.  
  395. } /* vpackvg */
  396.  
  397. /* ==================================================================== */
  398. /*
  399. *    vunpackvg:
  400. *    Unpacks the fields from a buf (ie a VGDESCTAG data object just 
  401. *    read in from the HDF file), into a VGROUP structure vg.
  402. *
  403. *     Will first zero out vg, unpack fields, then inits as much of 
  404. *  vg as it can.
  405. *
  406. *    NO RETURN VALUES
  407. *
  408. */
  409.  
  410. void vunpackvg (vg,buf,size)          /*@@*/
  411.  
  412. VGROUP*              vg;        /* vgroup to be loaded with file data */
  413. unsigned char     buf[];     /* must contain a VGDESCTAG data object from file */
  414.  
  415. int*              size;      /* ignored, but included to look like vpackvg() */
  416.  
  417. {
  418.  
  419.     unsigned char    *b, *bb;
  420.     int                 i;
  421.     int                 int16var;
  422.  
  423.     i = *size; /* dummy, so that compiler thinks it is used  */
  424.  
  425.     bb = &buf[0];
  426.  
  427.     /* retrieve nvelt */
  428.     b = bb;
  429.     INT16READ(b,vg->nvelt);
  430.     bb+=INT16SIZE;
  431.  
  432.     /* retrieve the tags */
  433.     for (i=0;i<vg->nvelt;i++) {
  434.         b= bb;
  435.         INT16READ(b,vg->tag[i]);
  436.         bb +=INT16SIZE;
  437.     }
  438.  
  439.     /* retrieve the refs */
  440.     for (i=0;i<vg->nvelt;i++) {
  441.         b= bb;
  442.         INT16READ(b,vg->ref[i]);
  443.         bb +=INT16SIZE;
  444.     }
  445.  
  446.     /* retrieve vgname (and its len)  */
  447.     b= bb;
  448.     INT16READ(b,int16var);
  449.     bb +=INT16SIZE;
  450.  
  451.     strncpy(vg->vgname, (char*) bb, int16var);
  452.     vg->vgname[int16var] = '\0';
  453.     bb += int16var;
  454.  
  455.     if (vjv) {
  456.         sprintf(sjs,"vunpackvg: vgname is [%s]\n",vg->vgname);
  457.         zj;
  458.     }
  459.  
  460.     /* retrieve vgclass (and its len)  */
  461.     b= bb;
  462.     INT16READ(b,int16var);
  463.     bb +=INT16SIZE;
  464.  
  465.     strncpy(vg->vgclass, (char*) bb, int16var);
  466.     vg->vgclass[int16var] = '\0';
  467.     bb += int16var;
  468.  
  469.     b = bb;
  470.     INT16READ(b,vg->extag); /* retrieve the vg's expansion tag */
  471.     bb += INT16SIZE;
  472.  
  473.     b = bb;
  474.     INT16READ(b,vg->exref); /* retrieve the vg's expansion ref */
  475.     bb += INT16SIZE;
  476.  
  477.     b = bb;
  478.     INT16READ(b,vg->version); /* retrieve the vg's version field */
  479.     bb += INT16SIZE;
  480.  
  481.     b = bb;
  482.     INT16READ(b,vg->more); /* retrieve the vg's more field */
  483.     bb += INT16SIZE;
  484.  
  485.  
  486. } /* vunpackvg */
  487.  
  488.  
  489. /* ------------------------------------------------- */
  490.  
  491.  
  492. /* ==================================================================== */
  493.  
  494. /*
  495. *     Vattach:
  496. *
  497. *   attaches to an existing vgroup or creates a new vgroup.
  498. *     returns NULL if  error, else ptr to vgroup.
  499. *
  500. *    IGNORE accesstype. (but save it)  
  501. *  if vgid == -1,
  502. *      create a NEW vg if vgdir is not full.
  503. *      Also set nattach =1, nentries=0.
  504. *  if vgid +ve, 
  505. *      look in vgdir to see if already attached,
  506. *      if yes, incr nattach 
  507. *      if not, fetch from file. attach, set nattach=1, netries= val from file 
  508. *
  509. *    In any case, set marked flag to 0.
  510. */
  511.  
  512. PUBLIC VGROUP *Vattach (f, vgid, accesstype)     /*@-@*/
  513.  
  514. int         vgid;                 /* actual vgroup's vgid or -1 for new vgroup */
  515. char       *accesstype;     /* ignored */
  516. DF            *f;                 /* HDF file handle */
  517.  
  518. {
  519.     VGROUP            *vg;
  520.     int                 access,  vgpacksize;
  521.     unsigned char     vgpack[sizeof(VGROUP)];
  522.     vginstance_t    * v;
  523.     vfile_t            * vf;
  524.  
  525.  
  526.     if (f==NULL)
  527.         RTNULL("vattach:bad f");
  528.  
  529.     if (NULL==(vf = (vfile_t*) Get_vfile(f)))
  530.         RTNULL ("Vattach: no such file\n");
  531.  
  532.     if      ( accesstype[0]=='R' || accesstype[0]=='r') { 
  533.         access = 'r'; 
  534.     }
  535.     else if ( accesstype[0]=='W' || accesstype[0]=='w') { 
  536.         access = 'w'; 
  537.     }
  538.     else RTNULL("Vattach: bad access type");
  539.  
  540.     if (vgid == -1) {             /******* create a NEW vg in vgdir ******/
  541.  
  542.         if (access=='r') RTNULL("Vattach: don't use r acces with new vg\n");
  543.  
  544.         /* allocate space for vg, & zero it out */
  545.         if ( (vg = (VGROUP*) DFIgetspace(sizeof(VGROUP)) ) == NULL)
  546.             RTNULL("Vattach: cannot getspace\n");
  547.         zerofill ((unsigned char*) vg,sizeof(VGROUP));
  548.  
  549.         /* initialize new vg */
  550.         vg->nvelt         = 0;
  551.         vg->vgname[0]    = '\0';
  552.         vg->f                = f;
  553.         vg->otag         = VGDESCTAG;
  554.         vg->oref            = vnewref(f);  /* create a new unique ref for it */
  555.         vg->access      = access;
  556.  
  557.         vg->marked        = 0;
  558.         vg->vgclass[0]    = '\0';
  559.         vg->extag        = 0;
  560.         vg->exref        = 0;
  561.         vg->more            = 0;
  562.         vg->version        = VSET_VERSION;
  563.  
  564.         if( vg->oref < 0)
  565.             RTNULL("Vattach: no more refs");
  566.  
  567.         /* attach new vg to file's vgtab  */
  568.         if ( NULL == (v = (vginstance_t*) DFIgetspace(sizeof(vginstance_t))))
  569.             RTNULL("Vattach: cannot getspace for vgtab \n");
  570.  
  571.         vf->vgtabtail->next = v;
  572.         vf->vgtabtail          = v;
  573.         vf->vgtabn++;
  574.         v->next                  = NULL;
  575.         v->ref       = vg->oref;
  576.         v->vg          = vg;
  577.         v->nattach    = 1;
  578.         v->nentries    = 0;
  579.  
  580.         return(vg);
  581.     }
  582.  
  583.     else {                             /******* access an EXISTING vg *********/
  584.  
  585.         if (NULL == (v= (vginstance_t*) vginstance (f,vgid)))
  586.             RTNULL("Vattach: vgid not in vgtab");
  587.  
  588.         if (v->vg != NULL) {  /* vg already attached */
  589.             v->nattach++;         /* so, just incr nattach */
  590.             return(v->vg);        /* & return that vg's ptr */
  591.  
  592.         }
  593.  
  594.         /* else vg not attached, must fetch vg from file */
  595.  
  596.         if (-1 ==  DFgetelement(f,VGDESCTAG,vgid,vgpack))
  597.             RTNULL("Vattach: vg  not in file");
  598.  
  599.         /* allocate space for vg, & zero it out */
  600.  
  601.         if (NULL== (vg =(VGROUP*) DFIgetspace(sizeof(VGROUP))) )
  602.             RTNULL("Vattach: cannot getspace\n");
  603.         zerofill((unsigned char*) vg,sizeof(VGROUP));
  604.  
  605.         /* unpack vgpack into structure vg, and init  */
  606.  
  607.         vunpackvg(vg,vgpack,&vgpacksize);
  608.         vg->f                = f;
  609.         vg->oref            = vgid;
  610.         vg->otag         = VGDESCTAG;
  611.         vg->access        = access;
  612.         vg->marked        = 0;
  613.  
  614.         /* attach vg to file's vgtab at the vg instance v */
  615.         v->vg                = vg;
  616.         v->nattach        = 1;
  617.         v->nentries = vg->nvelt;
  618.  
  619.         return(vg);
  620.     }
  621.  
  622.  
  623. } /* Vattach */
  624.  
  625. /* ==================================================================== */
  626. /* 
  627. *    Vdetach
  628. *    Detaches access to vg.    
  629. *    NO RETURN VALUES
  630. *
  631. *  if marked flag is 1, write out vg to file.
  632. *    if vg still has velts attached to it, cannot detach vg.
  633. *    decr  nattach. if (nattach is 0), free vg from vg instance.
  634. *    (check that no velts are still attached to vg before freeing)
  635. *
  636. *  if attached with read access, just return.
  637. *
  638. * after detach, set marked flag to 0.    
  639. *
  640. */
  641.  
  642. PUBLIC void Vdetach (vg)             /*@-@*/
  643.  
  644. VGROUP *vg;
  645. {
  646.  
  647.     int              i,vgpacksize;
  648.     unsigned char vgpack[sizeof(VGROUP)];
  649.     vginstance_t * v;
  650.  
  651.     if (vg==NULL) return;
  652.     if (vg->otag != VGDESCTAG) return;
  653.  
  654.     /* locate vg's index in vgtab */
  655.     if (NULL ==( v = (vginstance_t*) vginstance (vg->f,vg->oref))) {
  656.         sprintf(sjs,"@Vdetach: vg not found\n");
  657.         zj;
  658.         return;
  659.     }
  660.  
  661.     /* update vgroup to file if it has write-access */
  662.  
  663.     /* if its marked flag is 1 */
  664.     /* - OR - */
  665.     /* if that vgroup is empty */
  666.     if (vg->access == 'w') {
  667.         if ((vg->nvelt==0) || (vg->marked == 1)) {
  668.             if (vjv) {
  669.                 sprintf(sjs,"@VDETACH: added %d entries in vg..update vg to file\n",
  670.                     vg->nvelt - v->nentries);
  671.                 zj;
  672.             }
  673.             vpackvg(vg,vgpack,&vgpacksize);
  674.             if (DFputelement(vg->f,VGDESCTAG,vg->oref,vgpack,vgpacksize) == -1)
  675.                 sprintf(sjs,"@Vdetach: putelement error\n"); 
  676.             zj;
  677.             vg->marked = 0;
  678.             return;
  679.         }
  680.     }
  681.  
  682.     v->nattach--;
  683.     if (vjv) {
  684.         sprintf(sjs,"#Vdetach: nattach is now %d\n", v->nattach);
  685.         zj;
  686.     }
  687.  
  688.     if (v->nattach > 0)
  689.         return;    /* ok */
  690.  
  691.  
  692.     /* else, we can detach and remove vg from file's vgtab  */
  693.  
  694.     for (i=0;i<vg->nvelt;i++)       /* check if vg still has attached entries */
  695.         if (vg->velt[i] != NULL) {
  696.             sprintf(sjs,"@Vdetach: vg has vs %d undetached! continuing. \n",i);
  697.             zj;
  698.             break;
  699.         }
  700.  
  701.     v->vg = NULL;              /* detach vg from vgdir */
  702.  
  703.     DFIfreespace(vg);
  704.  
  705.     return; /* ok */
  706.  
  707. } /* Vdetach */
  708.  
  709.  
  710. /* ==================================================================== */
  711. /*
  712. *    Vinsert
  713. *  inserts a velt (vs or vg)  into a vg 
  714. *    RETURNS entry position within vg (0 or +ve) or -1 on error.
  715. *
  716. *    checks and prevents duplicate links.
  717. *
  718. * Since multiple files are now possible, check that both vg and velt
  719. * are from the same file. else error.
  720. */
  721.  
  722. PUBLIC int Vinsert (vg,velt)             /*@-@*/
  723.  
  724. VGROUP    *vg;
  725. VDATA     *velt;            /* (VGROUP*) or (VDATA*), doesn't matter */
  726.  
  727. {
  728.     int i;
  729.     char ss[80];
  730.  
  731.     if (vg == NULL || velt == NULL) return(FAIL);
  732.     if (vg->otag != VGDESCTAG || vg->nvelt >= MAXNVELT) return(FAIL);
  733.  
  734.     if ( (vfile_t*) Get_vfile(vg->f) != (vfile_t*) Get_vfile(velt->f) )
  735.         RTNEG("Vinsert: vg and velt not in same file\n");
  736.  
  737.     /* check in vstab  (kkk!!)  or vgtab that velt actually exist in file */
  738.  
  739.     switch (velt->otag) {
  740.     case VSDESCTAG:
  741.         if (-1 == vexistvs (vg->f,velt->oref))
  742.             RTNEG("@Vinsert vs doesn't exist\n");
  743.         break;
  744.  
  745.     case VGDESCTAG:
  746.         if (-1 == vexistvg (vg->f,velt->oref))
  747.             RTNEG("@Vinsert: vg doesn't exist\n");
  748.         break;
  749.  
  750.     default:
  751.         RTNEG("@Vinsert: unknown element\n");
  752.         break;
  753.     } /* switch */
  754.  
  755.     /* check and prevent duplicate links */
  756.     for(i=0;i<vg->nvelt;i++)
  757.         if ( (vg->tag[i] == velt->otag) && (vg->ref[i] == velt->oref) ) {
  758.             sprintf(ss,"@Vinsert: duplicate link <%d/%d>\n", 
  759.                 velt->otag,velt->oref);
  760.             RTNEG(ss);
  761.         }
  762.  
  763.     /* Finally, ok to insert */
  764.     vinsertpair ( vg, velt->otag, velt->oref);
  765.  
  766.     if (vjv) {
  767.         sprintf(sjs,"#Vinsert:inserted <%d/%d> at nvelt=%d\n",
  768.             velt->otag, velt->oref, vg->nvelt);
  769.         zj;
  770.     }
  771.  
  772.     vg->marked = 1;
  773.     return(vg->nvelt - 1);
  774.  
  775. } /* Vinsert */
  776.  
  777. /* ------------------------------------------------------------------ */
  778. /*
  779. Checks to see if the given field exists in a vdata belonging to this vgroup.
  780. If found, returns the ref of the vdata.
  781. If not found, or error, returns -1.
  782. 28-MAR-91 Jason Ng NCSA
  783. */
  784.  
  785. PUBLIC int Vflocate (vg, field)
  786. VGROUP * vg;
  787. char * field;
  788. {
  789.     int     i, s;
  790.     VDATA *vs;
  791.  
  792.     for (i=0;i<vg->nvelt;i++)  {
  793.         if (vg->tag[i] != VSDESCTAG) continue;
  794.         vs = (VDATA*) VSattach (vg->f,vg->ref[i],"r"); 
  795.         if (vs==NULL) return (-1);
  796.         s = VSfexist (vs, field);
  797.         VSdetach (vs);
  798.         if (s==1) return (vg->ref[i]); /* found. return vdata's ref */
  799.     }
  800.  
  801.     return (-1); /* field not found */
  802.  
  803. } /* Vflocate */
  804.  
  805. /* ------------------------------------------------------------------ */
  806. /*
  807. * Checks whether the given tag/ref pair already exists in the vgroup.
  808. * RETURNS 1 if exist
  809. * RETURNS 0 if not.
  810. * 28-MAR-91 Jason Ng NCSA
  811. */
  812. PUBLIC int Vinqtagref ( vg, tag, ref)
  813. VGROUP * vg;
  814. int tag, ref;
  815. {
  816.     int i;
  817.  
  818.     for (i=0; i<vg->nvelt; i++)
  819.         if ( (tag== vg->tag[i]) && (ref== vg->ref[i]) ) return (1); /* exist */
  820.  
  821.     return (0); /* does not exist */
  822.  
  823. } /* Vinqtagref */
  824.  
  825. /* ------------------------------------------------------------------ */
  826. /*
  827. * Returns the number (0 or +ve integer) of tag/ref pairs in a vgroup.
  828. * If error, returns -1.
  829. * 28-MAR-91 Jason Ng NCSA.
  830. */
  831.  
  832. PUBLIC int Vntagrefs (vg)
  833. VGROUP * vg;
  834. {
  835.     return ( (vg->otag==VGDESCTAG) ? vg->nvelt: -1);
  836. } /* Vntagrefs */
  837.  
  838. /* ------------------------------------------------------------------ */
  839. /*
  840. * Returns n tag/ref pairs from the vgroup into the caller-supplied arrays
  841. * tagrarray and refarray.
  842. * n can be any +ve number, but arrays must be this big.
  843. * RETURNS the total number of (0 or +ve #)  tag/ref pairs returned.
  844. * RETURNS -1 if error.
  845. * 28-MAR-91 Jason Ng NCSA.
  846. *
  847. * NOTE: Do not confuse with Vgettagref().
  848. *
  849. */
  850.  
  851. PUBLIC int Vgettagrefs (vg, tagarray, refarray, n)
  852. VGROUP * vg;
  853. int n;
  854. int tagarray[], refarray[];
  855.  
  856. {
  857.     int i, ntagrefs;
  858.  
  859.     if ( n <= vg->nvelt) ntagrefs = n;
  860.     else n = vg->nvelt;
  861.  
  862.     for (i=0; i<ntagrefs; i++) {
  863.         tagarray[i] = vg->tag[i];
  864.         refarray[i] = vg->ref[i];
  865.     }
  866.  
  867.     return (ntagrefs);
  868. } /* Vgettagrefs */
  869.  
  870. /* ------------------------------------------------------------------ */
  871. /*
  872. * Returns a specified tag/ref pair from the vgroup.
  873. * User specifies an index. 
  874. * RETURNS 1 if OK.
  875. * RETURNS -1 if error.
  876. * 12-MAY-91 Jason Ng NCSA.
  877. *
  878. * NOTE: Do not confuse with Vgettagrefs().
  879. *
  880. */
  881.  
  882. PUBLIC int Vgettagref (vg, which, tag, ref)
  883. VGROUP * vg;
  884. int which;
  885. int *tag, *ref; /* these are returned */
  886.  
  887. {
  888.  
  889.     if (vg==NULL) return (-1);
  890.     if (which < 0 || which > vg->nvelt-1) return (-1); /* range err */
  891.  
  892.         *tag  = vg->tag[which];
  893.         *ref  = vg->ref[which];
  894.     return (1); /* ok */
  895.  
  896. } /* Vgettagref */
  897. /* ------------------------------------------------------------------ */
  898. /*
  899. * Inserts a tag/ref pair into the attached vgroup vg.
  900. * First checks that the tag/ref is unique.
  901. * If error, returns -1 or tag/ref is not inserted.
  902. * If OK, returns the total number of tag/refs in the vgroup (a +ve integer).
  903. * 28-MAR-91 Jason Ng NCSA.
  904. */
  905.  
  906. PUBLIC int Vaddtagref ( vg, tag, ref)
  907. VGROUP * vg;
  908. int tag, ref;
  909. {
  910.     int  n;
  911.  
  912.     if (Vinqtagref (vg, tag, ref) == 1) return (-1); /* error, already exists */
  913.     n = vinsertpair (vg, tag, ref);
  914.     return (n);
  915. } /* Vaddtagref */
  916.  
  917. /* ------------------------------------------------------------------ */
  918. /*
  919. * Inserts a tag/ref pair into the attached vgroup vg.
  920. * Does not check for errors. 
  921. * Returns the total number of tag/refs in theat vgroup.
  922. */
  923.  
  924. int vinsertpair ( vg, tag, ref)
  925. VGROUP    * vg;
  926. int        tag, ref;
  927. {
  928.     vg->velt[vg->nvelt]  = NULL;
  929.     vg->tag[vg->nvelt]   = tag;
  930.     vg->ref[vg->nvelt]   = ref;
  931.     vg->nvelt ++;
  932.  
  933.     vg->marked = 1;
  934.     return (vg->nvelt);
  935. }
  936.  
  937. /* ==================================================================== */
  938. /* 
  939. *     Ventries
  940. *    returns the no of entries (+ve integer) in the vgroup vgid.
  941. *  vgid must be an actual id
  942. *  RETURNS -1 if error
  943. *
  944. *  undocumented
  945. *
  946. */
  947.  
  948. int Ventries (f,vgid)                 /*@@*/
  949.  
  950. DF* f;
  951. int vgid;
  952. {
  953.     unsigned char vgpack[sizeof(VGROUP)];
  954.     VGROUP vg;
  955.     int    vgpacksize;
  956.  
  957.     if (vgid < 1) return(FAIL);
  958.     if ( DFgetelement(f,VGDESCTAG ,vgid,vgpack) == -1) {
  959.         sprintf(sjs,"@Ventries: cannot get vg from file\n");
  960.         zj;
  961.         return(FAIL);
  962.     }
  963.  
  964.     vunpackvg(&vg,vgpack,&vgpacksize);
  965.     return(vg.nvelt);
  966.  
  967. } /* Ventries */
  968.  
  969.  
  970. /* ==================================================================== */
  971. /*
  972. *    Vsetname
  973. *     gives a name to the VGROUP vg.
  974. *
  975. * NO RETURN VALUES.
  976. *
  977. *    truncates to max length of VGNAMELENMAX 
  978. */
  979.  
  980. PUBLIC void Vsetname (vg, vgname)         /*@-@*/
  981.  
  982. VGROUP    *vg;
  983. char        *vgname;
  984.  
  985. {
  986.     if (vg == NULL) return;
  987.     if ( strlen(vgname) > VGNAMELENMAX) {
  988.         strncpy(vg->vgname, vgname,VGNAMELENMAX);
  989.         vg->vgname[VGNAMELENMAX]='\0';
  990.     }
  991.     else
  992.         strcpy(vg->vgname, vgname);
  993.     vg->marked = 1;
  994.     return;
  995.  
  996. } /* Vsetname */
  997.  
  998. /* ==================================================================== */
  999. /*
  1000. *    Vsetclass
  1001. *     assigns a class name to the VGROUP vg.
  1002. *
  1003. * NO RETURN VALUES.
  1004. *
  1005. *    truncates to max length of VGNAMELENMAX 
  1006. */
  1007.  
  1008. PUBLIC void Vsetclass (vg, vgclass)         /*@-@*/
  1009.  
  1010. VGROUP    *vg;
  1011. char        *vgclass;
  1012.  
  1013. {
  1014.     if (vg == NULL) return;
  1015.     if ( strlen(vgclass) > VGNAMELENMAX) {
  1016.         strncpy(vg->vgclass, vgclass,VGNAMELENMAX);
  1017.         vg->vgclass[VGNAMELENMAX]='\0';
  1018.     }
  1019.     else
  1020.         strcpy(vg->vgclass, vgclass);
  1021.     vg->marked = 1;
  1022.     return;
  1023.  
  1024. } /* Vsetclass*/
  1025.  
  1026.  
  1027. /* ======================================================= */
  1028. /*
  1029. *     Visvg
  1030. *    tests if an entry in the vgroup vg is a VGROUP, given the entry's id. 
  1031. *
  1032. *    RETURNS 1 if so
  1033. *    RETURNS 0 if not, or if error
  1034. *
  1035. */
  1036.  
  1037. PUBLIC int Visvg (vg,id)           /*@-@*/
  1038.  
  1039. VGROUP    *vg;
  1040. int         id;        /* valid id of the entry in question */
  1041. {
  1042.     int     i;
  1043.  
  1044.     for(i=0;i<vg->nvelt;i++)
  1045.         if (vg->ref[i] == id   &&      /* if the ids match, */
  1046.         vg->tag[i]==VGDESCTAG)     /* and it is a vgroup */
  1047.             return (1);
  1048.  
  1049.     return (0);
  1050.  
  1051. } /* Visvg */
  1052.  
  1053. /* ======================================================= */
  1054. /* 
  1055. *    Vgetid
  1056. *    
  1057. *    Given a vgroup's id, returns the next vgroup's id in the file f .
  1058. *    The call Vgetid(f,-1) returns the id of the FIRST vgroup in the file. 
  1059. *
  1060. *    RETURNS -1 if error
  1061. *    RETURNS the next vgroup's id (0 or +ve integer).
  1062. *
  1063. *    This id is actually the "ref" of the vgroup "tag/ref".
  1064. */
  1065.  
  1066. PUBLIC int Vgetid (f,vgid)               /*@-@*/
  1067.  
  1068. int     vgid;                    /* current vgid */
  1069. DF*     f;                        /* HDF file handle */
  1070.  
  1071. {
  1072.     vginstance_t * v;
  1073.     vfile_t        * vf;
  1074.  
  1075.     if ( vgid < -1) return(FAIL);
  1076.  
  1077.     if (NULL==(vf = (vfile_t*) Get_vfile(f)))
  1078.         RTNEG ("Vgetid: no such file\n");
  1079.  
  1080.     if (vjv) {
  1081.         sprintf(sjs,"#Vgetid:vgtabn= %d vgid=%d\n",vf->vgtabn,vgid);
  1082.         zj;
  1083.     }
  1084.  
  1085.     if (vgid == -1) {
  1086.         if (NULL == vf->vgtab.next)
  1087.             return (-1);
  1088.         else
  1089.             return( (vf->vgtab.next)->ref); /* rets 1st vgroup's ref */
  1090.     }
  1091.  
  1092.     /* look in vgtab for vgid */
  1093.     v = (vf->vgtab).next;
  1094.     while(NULL != v) {
  1095.         if(v->ref == vgid) break;
  1096.         v = v->next;
  1097.     }
  1098.     if (v==NULL)
  1099.         return (FAIL); /* none found */
  1100.     else
  1101.         if( v->next ==NULL)
  1102.             return (FAIL); /* this is the last vg, no more after it */
  1103.         else
  1104.             return((v->next)->ref); /* success, return the next vg's ref */
  1105.  
  1106. } /* Vgetid */
  1107.  
  1108.  
  1109. /* ================================================================= */
  1110. /*
  1111. *    Vgetnext
  1112. *
  1113. *    Given the id of an entry from a vgroup vg, looks in vg for the next
  1114. *    entry after it, and returns its id.
  1115. *    The call Vgetnext (vg,-1) returns the id of the FIRST entry in the vgroup.
  1116. *
  1117. *  Vgetnext will look at only VSET elements in the vgroup.
  1118. *  To look at all links in a vgroup, use Vgettagrefs instead.
  1119. *
  1120. *    RETURNS -1 if error
  1121. *    RETURNS the id of the next entry( 0 or +ve integer)  in the vgroup.
  1122. *
  1123. *    This id is actually the "ref" of the entry's "tag/ref".
  1124. *
  1125. */
  1126.  
  1127. PUBLIC int Vgetnext (vg,id)           /*@-@*/
  1128.  
  1129. VGROUP    *vg;
  1130. int         id;                    /* actual id of an entry in the vgroup vg */
  1131. {
  1132.     int     i;
  1133.  
  1134.     if (id < -1) return(FAIL);
  1135.     if (vg == NULL) return(FAIL);
  1136.     if (vg->otag != VGDESCTAG) return(FAIL);
  1137.  
  1138.     if (vjv) {
  1139.         sprintf(sjs,"#Vgetnext:vg->nvelt is %d\n",vg->nvelt);
  1140.         zj;
  1141.     }
  1142.     if (vg->nvelt  == 0) return(FAIL);             /* nothing in vg */
  1143.  
  1144.     if (id == -1) {
  1145.         if ((vg->tag[0]==VGDESCTAG) || (vg->tag[0]==VSDESCTAG)) 
  1146.                 return(vg->ref[0]);         /* id of first entry */
  1147.         }
  1148.     
  1149.     /* look in vg for id */
  1150.     for(i=0;i<vg->nvelt;i++) 
  1151.         if ((vg->tag[i]==VGDESCTAG) || (vg->tag[i]==VSDESCTAG)) {
  1152.             if(vg->ref[i] == id) {
  1153.                 if (i == (vg->nvelt - 1) )
  1154.                     return(FAIL);
  1155.                 else  {
  1156.                     if ((vg->tag[i+1]==VGDESCTAG) ||
  1157.                          (vg->tag[i+1]==VSDESCTAG)) 
  1158.                         return(vg->ref[i+1]);        /* return the id of next entry */
  1159.                     else  return (-1); 
  1160.                     }
  1161.             }
  1162.         }
  1163.  
  1164.     return (FAIL);
  1165.  
  1166. } /* Vgetnext  */
  1167.  
  1168. /* ================================================================= */
  1169. /*
  1170. *    Vgetname
  1171. *    returns the vgroup's name
  1172. *
  1173. */
  1174.  
  1175. PUBLIC void Vgetname (vg, vgname)          /*@-@*/
  1176.  
  1177. VGROUP    *vg;
  1178. char        *vgname;                /* its name is returned in this var */
  1179. {
  1180.     if(vg != NULL) strcpy(vgname, vg->vgname);
  1181.     return;
  1182.  
  1183. } /* Vgetname */
  1184. /* ================================================================= */
  1185. /*
  1186. *    Vgetclass
  1187. *    returns the vgroup's class name 
  1188. *
  1189. */
  1190.  
  1191. PUBLIC void Vgetclass (vg, vgclass)          /*@-@*/
  1192.  
  1193. VGROUP    *vg;
  1194. char        *vgclass;                /* its class name is returned in this var */
  1195. {
  1196.     if(vg != NULL) strcpy(vgclass, vg->vgclass);
  1197.     return;
  1198.  
  1199. } /* Vgetclass*/
  1200.  
  1201. /* ================================================================= */
  1202. /*
  1203. *    Vinquire
  1204. *
  1205. *    General inquiry routine for VGROUP. 
  1206. *
  1207. *    output parameters:
  1208. *            nentries - no of entries in the vgroup
  1209. *            vgname    - the vgroup's name
  1210. *
  1211. *    RETURNS -1 if error
  1212. *    RETURNS 1 if ok
  1213. *
  1214. */
  1215.  
  1216. PUBLIC int Vinquire (vg, nentries, vgname)     /*@-@*/
  1217.  
  1218. VGROUP    *vg;
  1219. char        *vgname;
  1220. int         *nentries;
  1221. {
  1222.     if (vg == NULL) return(FAIL);
  1223.     if (vg->otag != VGDESCTAG) return(FAIL);
  1224.  
  1225.     strcpy(vgname, vg->vgname);
  1226.     *nentries = vg->nvelt;
  1227.  
  1228.     return(1); /* ok */
  1229.  
  1230. } /* Vinquire */
  1231.  
  1232. /* ================================================================= */
  1233.  
  1234.