home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / hdf / unix / hdf3_2r2.lha / HDF3.2r2 / src / vgp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-28  |  36.9 KB  |  1,655 lines
  1. /***************************************************************************
  2. *
  3. *
  4. *                         NCSA HDF version 3.2r2
  5. *                            October 30, 1992
  6. *
  7. * NCSA HDF Version 3.2 source code and documentation are in the public
  8. * domain.  Specifically, we give to the public domain all rights for future
  9. * licensing of the source code, all resale rights, and all publishing rights.
  10. *
  11. * We ask, but do not require, that the following message be included in all
  12. * derived works:
  13. *
  14. * Portions developed at the National Center for Supercomputing Applications at
  15. * the University of Illinois at Urbana-Champaign, in collaboration with the
  16. * Information Technology Institute of Singapore.
  17. *
  18. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  19. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  20. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  21. *
  22. ****************************************************************************
  23. */
  24.  
  25. #ifdef RCSID
  26. static char RcsId[] = "@(#)$Revision: 1.5 $";
  27. #endif
  28. /*
  29. $Header: /hdf/hdf/v3.2r2/src/RCS/vgp.c,v 1.5 1992/10/23 00:14:11 koziol beta koziol $
  30.  
  31. $Log: vgp.c,v $
  32.  * Revision 1.5  1992/10/23  00:14:11  koziol
  33.  * Changed all DFIstr*() and DFImem*() calls to HDstr*() and HDmem*() calls
  34.  * #ifdef'd out the macros Jason defined for Hopen, Hclose, etc. for Vsets
  35.  * Replaced Vset VFREESPACE and VGETSPACE calls with actual calls to HDfreespace
  36.  * and HDgetspace
  37.  * Added a MS-Windows lower lower for file I/O (which may not be completely working
  38.  *
  39.  * Revision 1.3  1992/10/12  18:11:51  koziol
  40.  * Updated for v3.2r2 release
  41.  *
  42.  * Revision 1.2  1992/08/27  19:54:56  likkai
  43.  * Vclose now returns an (intn) status.
  44.  *
  45.  * Revision 1.1  1992/08/25  21:40:44  koziol
  46.  * Initial revision
  47.  *
  48. */
  49. /*****************************************************************************
  50. * 
  51. * vgp.c
  52. * Part of the vertex-set interface.
  53. * VGROUPs are handled by routines in here.
  54. *
  55. *************************************************************************/
  56.  
  57. #include "vg.h"
  58. #include "hfile.h"
  59. /* ------------------------------------------------------------ */
  60. /* 
  61. *
  62. * G L O B A L S 
  63. *
  64. * These are the *only* globals in the Vset interface!!  
  65. * They are used only for debugging.  No globals in other files. 
  66. * The 2 functions below turn debugging on and off.
  67. *
  68. */
  69.  
  70. PRIVATE int32 Load_vfile
  71.   PROTO((HFILEID f));
  72.  
  73. PRIVATE void Remove_vfile
  74.   PROTO((HFILEID f));
  75.  
  76. PUBLIC    char         sjs[200];
  77. PUBLIC    int16   vjv    =    0;
  78.  
  79. /*
  80. turn debug on 
  81. */
  82. #ifdef PROTOTYPE
  83. PUBLIC void    setjj (void)          
  84. #else
  85.  
  86. PUBLIC void    setjj()          
  87.  
  88. #endif
  89.  
  90. { 
  91.     vjv=1; 
  92. }
  93.  
  94. /*
  95. turn debug off 
  96. */
  97. #ifdef PROTOTYPE
  98. PUBLIC void    setnojj (void)          
  99. #else
  100.  
  101. PUBLIC void    setnojj()          
  102. #endif
  103.  
  104. { 
  105.     vjv=0; 
  106. }
  107.  
  108.  
  109. /*
  110. * -------------------------------------------------------------------- 
  111. * PRIVATE  data structure and routines.
  112. * 
  113. * Info about all vgroups in the file are loaded into vgtab  at start;
  114. * and the vg field set to NULL until that vgroup is attached,
  115. * and reset back to NULL when that vgroup is detached. 
  116. * Info about all vdatas in the file are loaded into vstab  at start;
  117. * and the vs field set to NULL until that vdata is attached,
  118. * and reset back to NULL when that vdata is detached. 
  119. * -------------------------------------------------------------------- 
  120. */
  121.  
  122.  
  123. PUBLIC vfile_t  vfile [MAX_FILE];
  124.  
  125. /* -------------------------- Load_vfile ------------------------ */
  126. /*
  127.   *** Only called by Vinitialize()  ***   
  128.  
  129. loads vgtab table with info of all vgroups in file f.
  130. Will allocate a new vfile_t, then proceed to load vg instances.
  131. RETURNS -1 if error or no more file slots available.
  132. RETURNS 1 if ok.
  133. */
  134.  
  135. #ifdef PROTOTYPE
  136. PRIVATE int32 Load_vfile (HFILEID f)    
  137. #else
  138.  
  139. PRIVATE int32 Load_vfile (f)              
  140.  
  141.     HFILEID    f;
  142.  
  143. #endif
  144.  
  145. {
  146.     vfile_t          * vf;
  147.     vginstance_t  * v;
  148.     vsinstance_t  * w;
  149.     int32             aid, stat;
  150.     uint16            tag, ref;
  151.     char * FUNC = "Load_vfile";
  152.  
  153.     if (vjv) { sprintf(sjs,"@Load_vfile \n"); zj; }
  154.  
  155.     /* allocate a new vfile_t structure */
  156.         vf = Get_vfile(f);
  157.         if(!vf) return FAIL;
  158.  
  159.     /* load all the vg's  tag/refs from file */
  160.     vf->vgtabn    = -1;
  161.     vf->vgtabtail = &(vf->vgtab);
  162.  
  163.     vf->vgtab.ref      = -1;
  164.     vf->vgtab.nattach  = -1;
  165.     vf->vgtab.nentries = -1;
  166.     vf->vgtab.vg       = NULL;
  167.     vf->vgtab.next     = NULL;
  168.  
  169.     vf->vgtabn = 0;
  170.  
  171.     stat = aid = QQstartread(f, DFTAG_VG,  DFREF_WILDCARD);
  172.     while (stat != FAIL) {
  173.           QQQuerytagref (aid, &tag, &ref);
  174. #ifdef DEBUG
  175.           if (vjv) {
  176.             sprintf(sjs,"#LOADVGDIR:FOUND (%d) <%d/%d>\n ",
  177.                     vf->vgtabn, tag, ref); zj;
  178.           }
  179. #endif          
  180.           if (!(v = (vginstance_t*) HDgetspace (sizeof(vginstance_t)))) {
  181.             HERROR(DFE_NOSPACE);
  182.             return(FAIL);
  183.           }
  184.           
  185.           vf->vgtabtail->next  = v;
  186.           vf->vgtabtail         = v;
  187.           v->next             = NULL;
  188.           v->ref      = (intn) ref;
  189.           v->vg       = (VGROUP*) NULL; /* ie not attached yet */
  190.           v->nattach  = 0;
  191.           v->nentries = 0;
  192.           vf->vgtabn++;
  193.           stat = QQnextread (aid, DFTAG_VG, DFREF_WILDCARD, DF_CURRENT);
  194.     }
  195.     QQendaccess (aid);
  196.  
  197.  
  198.     /* load all the vs's  tag/refs from file */
  199.     vf->vstabn    = -1;
  200.     vf->vstabtail = &(vf->vstab);
  201.  
  202.     vf->vstab.ref      = -1;
  203.     vf->vstab.nattach  = -1;
  204.     vf->vstab.nvertices= -1;
  205.     vf->vstab.vs       = NULL;
  206.     vf->vstab.next     = NULL;
  207.  
  208.     vf->vstabn = 0;
  209.     stat = aid = QQstartread(f, VSDESCTAG,  DFREF_WILDCARD);
  210.     while (stat != FAIL) {
  211.  
  212.           QQQuerytagref (aid, &tag, &ref);
  213.           
  214. #ifdef DEBUG
  215.           if (vjv) {
  216.             sprintf(sjs,"#LOADVSDIR:FOUND (%d) <%d/%d>\n ",
  217.                     vf->vstabn, tag,ref); zj;
  218.           }
  219. #endif
  220.           if (!(w = (vsinstance_t*) HDgetspace (sizeof(vsinstance_t)))) {
  221.             HERROR(DFE_NOSPACE);
  222.             return(FAIL);
  223.           }
  224.           
  225.           vf->vstabtail->next  = w;
  226.           vf->vstabtail        = w;
  227.           w->next     = NULL;
  228.           w->ref      = (intn) ref;
  229.           w->vs       = (VDATA*) NULL; /* ie not attached yet */
  230.           w->nattach  = 0;
  231.           w->nvertices= 0;
  232.           vf->vstabn++;
  233.           stat = QQnextread (aid, VSDESCTAG, DFREF_WILDCARD, DF_CURRENT);
  234.     }
  235.     QQendaccess (aid);
  236.  
  237.     /* file may be incompatible with vset version 2.x. Need to check it */
  238.         if ( ((int32)0 == vf->vgtabn) && ((int32)0 == vf->vstabn) )
  239.           if ( (int32)0 == vicheckcompat (f) ) { /* not compatible */
  240.             sprintf(sjs,"********************************************\n\n"); zj;
  241.             sprintf(sjs,"%cFile incompatible with vset version 2.0\n",7); zj;
  242.             sprintf(sjs,"%cFirst use the utility vcompat on this file\n",7); zj;
  243.             sprintf(sjs,"********************************************\n\n"); zj;
  244. #if 0
  245.             nvfile--;     /* delete the structure for that file */
  246. #endif
  247.             HERROR(DFE_BADOPEN);
  248.             HEreport("This file is incompatible with the current release");
  249.             return(FAIL);
  250.           }
  251.         
  252.     /* otherwise, success */
  253.     return (SUCCEED);
  254.         
  255. } /* Load_vfile */
  256.  
  257. /* ---------------------------- Remove_vfile ------------------------- */
  258. /*
  259.   removes the file ptr from the vfile[] table. 
  260.   *** Only called by Vfinish() ***
  261. */
  262. #ifdef PROTOTYPE
  263. PRIVATE void Remove_vfile (HFILEID f)
  264. #else
  265. PRIVATE void Remove_vfile (f)
  266.     HFILEID f;
  267. #endif
  268. {
  269.     vginstance_t *vginst, *vg1;
  270.     vsinstance_t *vsinst, *vs1;
  271.     vfile_t      *vf=NULL;
  272.  
  273.     char * FUNC = "Remove_vfile";
  274.  
  275.  
  276.     /* Figure out what file to work on */
  277.     vf = Get_vfile(f);
  278.         
  279.     if(vf==NULL)
  280.         return;
  281.         
  282.     /* free vstab and vgtab link-list entries */
  283.     vginst = &(vf->vgtab);
  284.     while (vginst) {
  285.         vg1 = vginst->next;
  286.         if (vginst->vg)  {
  287.             HDfreespace (vginst->vg);
  288.             HDfreespace (vginst);
  289.         }
  290.         vginst = vg1;
  291.     }
  292.  
  293.     vsinst = &(vf->vstab);
  294.     while (vsinst) {
  295.         vs1 = vsinst->next; 
  296.         if (vsinst->vs) {
  297.             HDfreespace (vsinst->vs);
  298.             HDfreespace (vsinst);
  299.         }
  300.         vsinst = vs1; 
  301.     }
  302.         
  303. }  /* Remove_vfile */
  304.  
  305. /* ---------------------------- Vinitialize ------------------------- */
  306. /* should be replaced by HDFopen() or such */
  307. /* is called by DFvsetopen() only */
  308.  
  309. #ifdef PROTOTYPE
  310. PUBLIC void Vinitialize (HFILEID f)
  311. #else
  312.  
  313. PUBLIC void Vinitialize (f)
  314.     HFILEID f;
  315.  
  316. #endif
  317.  
  318. {
  319.     char * FUNC = "Vinitialize";
  320.  
  321.       Load_vfile (f);
  322.     if (vjv) { sprintf(sjs,"@Vinitialize: f=%ld\n", f); zj; }
  323. }
  324.  
  325. /* ---------------------------- Vfinish ------------------------- */
  326. /* should be replaced by HDFclose() or such */
  327. /* is called by DFvsetclose() only */
  328.  
  329. #ifdef PROTOTYPE
  330. PUBLIC void Vfinish (HFILEID f)
  331. #else
  332.  
  333. PUBLIC void Vfinish (f)
  334.     HFILEID f;
  335.  
  336. #endif
  337.  
  338. {
  339.     char * FUNC = "Vfinish";
  340.  
  341.       Remove_vfile (f);
  342.     if (vjv) { sprintf(sjs,"@Vfinish: f=%ld\n", f); zj; }
  343. }
  344.  
  345.  
  346. /* ---------------------------- vginstance ----------------------------- */
  347. /*
  348. * Looks thru vgtab for vgid and return the addr of the vg instance
  349. * where vgid is found.
  350. * RETURNS NULL if error or not found.
  351. * RETURNS vginstance_t pointer if ok.
  352. *
  353. */
  354.  
  355. #ifdef PROTOTYPE
  356. vginstance_t * vginstance (HFILEID f, uint16 vgid)
  357. #else
  358.  
  359. vginstance_t * vginstance (f, vgid)
  360.     HFILEID     f;
  361.     uint16     vgid;
  362.  
  363. #endif
  364.  
  365. {
  366.   register uintn ref;
  367.   register vginstance_t * v;
  368.   vfile_t      * vf;
  369.   char * FUNC = "vginstance";
  370.   
  371.   if (NULL== (vf = Get_vfile(f))) HRETURN_ERROR(DFE_FNF, NULL);
  372.   
  373.   ref = (uintn) vgid;
  374.   for(v = vf->vgtab.next; v; v = v->next) 
  375.     if (v->ref == ref) return(v);
  376.   
  377.   HERROR(DFE_NOMATCH);
  378.   return(NULL);
  379.   
  380. } /* vginstance */
  381.  
  382. /* ------------------------ vexistvg --------------------------- */
  383. /* 
  384. * Tests if a vgroup with id vgid is in the file's vgtab.
  385. * returns FAIL if not found,
  386. * returns TRUE if found.
  387. */
  388.  
  389. #ifdef PROTOTYPE
  390. int32 vexistvg (HFILEID f, uint16 vgid)          
  391. #else
  392.  
  393. int32 vexistvg (f, vgid)          
  394.     HFILEID     f;
  395.     uint16     vgid;
  396.  
  397. #endif
  398.  
  399. {
  400.   char * FUNC = "vexistvg";
  401.   
  402.   if (NULL== (vginstance_t *) vginstance(f,vgid))
  403.     return(FAIL);
  404.   else
  405.     return (TRUE);
  406.   
  407. } /* vexistvg */
  408.  
  409. /* ==================================================================== */
  410. /*
  411. * vpackvg() and vunpackvg() : Packing and unpacking routines.
  412. * For use in retrieving and storing vgroups to/from the HDF file.
  413. *
  414. *    Fields of VGROUP  that gets stored in HDF as a DFTAG_VG data object:
  415. *        int16        nvelt (no of entries )
  416. *        char        vgname[MAXVGNAMELEN]
  417. *     char     vgclass[MAXVGNAMELEN]
  418. *        int16        tag[1..nvelt]        
  419. *        int16        ref[1..nvelt]        
  420. */
  421. /* ==================================================================== */
  422.  
  423. #define INT16SIZE 2
  424. #define UINT16SIZE 2
  425.  
  426. /* ==================================================================== */
  427. /* 
  428. *    vpackvg
  429. *    extracts fields from  a VGROUP struct vg and pack the fields
  430. *  into array buf in preparation for storage in the HDF file.
  431. *
  432. *  NO RETURN VALUES.
  433. */
  434.  
  435. #ifdef PROTOTYPE
  436. void vpackvg (VGROUP *vg, BYTE buf[], int32 *size)
  437. #else
  438.  
  439. void vpackvg (vg, buf, size)
  440.     VGROUP          *vg;    /* vgroup to be saved to file */
  441.     BYTE            buf[];  /* buffer to receive the packed fields */
  442.     int32             *size;    /* the size of buf is returned here */
  443.  
  444. #endif
  445.  
  446. {
  447.     register uint16     i;
  448.     register BYTE        *b, *bb;
  449.     register uint16        uint16var;
  450.     char * FUNC = "vpackvg";
  451.  
  452.     bb = &buf[0];
  453.  
  454.     /* save nvelt */
  455.     b= bb;
  456.     UINT16ENCODE(b,vg->nvelt);
  457.     bb +=UINT16SIZE;
  458.  
  459.     /* save all tags */
  460.     for(i=0;i<vg->nvelt;i++) {
  461.         b= bb;
  462.         UINT16ENCODE(b,vg->tag[i]);
  463.         bb +=UINT16SIZE;
  464.     }
  465.  
  466.     /* save all refs */
  467.     for(i=0;i<vg->nvelt;i++) {
  468.         b= bb;
  469.         UINT16ENCODE(b,vg->ref[i]);
  470.         bb +=UINT16SIZE;
  471.     }
  472.  
  473.     /* save the vgnamelen and vgname - omit the null */
  474.     b= bb;
  475.     uint16var = HDstrlen(vg->vgname);
  476.     UINT16ENCODE(b,uint16var);
  477.     bb +=UINT16SIZE;
  478.  
  479.     HDstrcpy((char*) bb,vg->vgname);
  480.     bb +=  HDstrlen(vg->vgname) ;
  481.  
  482.     /* save the vgclasslen and vgclass- omit the null */
  483.     b= bb;
  484.     uint16var = HDstrlen(vg->vgclass);
  485.     UINT16ENCODE(b,uint16var);
  486.     bb +=INT16SIZE;
  487.  
  488.     HDstrcpy((char*) bb,vg->vgclass);
  489.     bb +=  HDstrlen(vg->vgclass) ;
  490.  
  491.     /* save the expansion tag/ref pair */
  492.     b= bb;
  493.     UINT16ENCODE(b,vg->extag);   /* the vg's expansion tag */
  494.     bb +=UINT16SIZE;
  495.  
  496.     b= bb;
  497.     UINT16ENCODE(b,vg->exref);   /* the vg's expansion ref */
  498.     bb +=UINT16SIZE;
  499.  
  500.     /*  save the vg's version field */
  501.     b= bb;
  502.     UINT16ENCODE(b,vg->version);
  503.     bb +=UINT16SIZE;
  504.  
  505.     /* save the vg's more field */
  506.     b= bb;
  507.     UINT16ENCODE(b,vg->more);
  508.     bb +=UINT16SIZE;
  509.  
  510.     if (vjv) {
  511.         sprintf(sjs,"vpackvg: vgname is [%s]\n",vg->vgname);
  512.         zj;
  513.     }
  514.  
  515.     /* returns the size of total fields saved */
  516.     *size = (int32) (bb - buf) + 1;
  517.  
  518.     if (vjv) {
  519.         sprintf(sjs,"#vpackvg: vg->nvelt=%d\n",vg->nvelt);
  520.         zj;
  521.     }
  522.  
  523. } /* vpackvg */
  524.  
  525. /* ==================================================================== */
  526. /*
  527. *    vunpackvg:
  528. *    Unpacks the fields from a buf (ie a DFTAG_VG data object just 
  529. *    read in from the HDF file), into a VGROUP structure vg.
  530. *
  531. *     Will first zero out vg, unpack fields, then inits as much of 
  532. *  vg as it can.
  533. *
  534. *    NO RETURN VALUES
  535. *
  536. */
  537.  
  538. #ifdef PROTOTYPE
  539. void vunpackvg (VGROUP *vg, BYTE buf[], int32* size)      
  540. #else
  541.  
  542. void vunpackvg (vg, buf, size)      
  543.  
  544.     VGROUP*              vg;    /* vgroup to be loaded with file data */
  545.     BYTE            buf[];     /* must contain a DFTAG_VG data object from file */
  546.     int32*        size;      /* ignored, but included to look like vpackvg() */
  547.  
  548. #endif
  549.  
  550. {
  551.  
  552.     register BYTE      *b, *bb;
  553.     register uint16   i;
  554.     register uint16      uint16var;
  555.     char * FUNC = "vunpackvg";
  556.  
  557.     *size = *size; /* dummy, so that compiler thinks it is used  */
  558.  
  559.     bb = &buf[0];
  560.  
  561.     /* retrieve nvelt */
  562.     b = bb;
  563.     UINT16DECODE(b,vg->nvelt);
  564.     bb+=UINT16SIZE;
  565.  
  566.     /* retrieve the tags */
  567.     for (i=0;i<vg->nvelt;i++) {
  568.         b= bb;
  569.         UINT16DECODE(b,vg->tag[i]);
  570.         bb +=UINT16SIZE;
  571.     }
  572.  
  573.     /* retrieve the refs */
  574.     for (i=0;i<vg->nvelt;i++) {
  575.         b= bb;
  576.         UINT16DECODE(b,vg->ref[i]);
  577.         bb +=UINT16SIZE;
  578.     }
  579.  
  580.     /* retrieve vgname (and its len)  */
  581.     b= bb;
  582.     UINT16DECODE(b,uint16var);
  583.     bb +=UINT16SIZE;
  584.  
  585.         HIstrncpy(vg->vgname, (char*) bb, (int32) uint16var + 1);
  586.     bb += uint16var;
  587.  
  588.     if (vjv) {
  589.         sprintf(sjs,"vunpackvg: vgname is [%s]\n",vg->vgname);
  590.         zj;
  591.     }
  592.  
  593.     /* retrieve vgclass (and its len)  */
  594.     b= bb;
  595.     UINT16DECODE(b,uint16var);
  596.     bb +=UINT16SIZE;
  597.         
  598.         HIstrncpy(vg->vgclass, (char*) bb, (int32) uint16var + 1);
  599.     bb += uint16var;
  600.  
  601.     b = bb;
  602.     UINT16DECODE(b,vg->extag); /* retrieve the vg's expansion tag */
  603.     bb += UINT16SIZE;
  604.  
  605.     b = bb;
  606.     UINT16DECODE(b,vg->exref); /* retrieve the vg's expansion ref */
  607.     bb += UINT16SIZE;
  608.  
  609.     b = bb;
  610.     UINT16DECODE(b,vg->version); /* retrieve the vg's version field */
  611.     bb += UINT16SIZE;
  612.  
  613.     b = bb;
  614.     UINT16DECODE(b,vg->more); /* retrieve the vg's more field */
  615.     bb += UINT16SIZE;
  616.  
  617. } /* vunpackvg */
  618.  
  619.  
  620. /* ----------------------------- Vattach --------------------------- */
  621.  
  622. /*
  623. *     Vattach:
  624. *
  625. *   attaches to an existing vgroup or creates a new vgroup.
  626. *     returns NULL if  error, else ptr to vgroup.
  627. *
  628. *    IGNORE accesstype. (but save it)  
  629. *  if vgid == -1,
  630. *      create a NEW vg if vgdir is not full.
  631. *      Also set nattach =1, nentries=0.
  632. *  if vgid +ve, 
  633. *      look in vgdir to see if already attached,
  634. *      if yes, incr nattach 
  635. *      if not, fetch from file. attach, set nattach=1, netries= val from file 
  636. *
  637. *    In any case, set marked flag to 0.
  638. */
  639.  
  640. #ifdef PROTOTYPE
  641. PUBLIC VGROUP *Vattach (HFILEID f, int32 vgid, char *accesstype)
  642. #else
  643.  
  644. PUBLIC VGROUP *Vattach (f, vgid, accesstype)
  645.     int32     vgid;                /* actual vgroup's vgid or -1 for new vgroup */
  646.     char       *accesstype;     /* ignored */
  647.     HFILEID    f;                 /* HDF file handle */
  648.  
  649. #endif
  650.  
  651. {
  652.     VGROUP            *vg;
  653.     int16           access;
  654.     int32           vgpacksize;
  655.     BYTE            vgpack[sizeof(VGROUP)];
  656.     vginstance_t    * v;
  657.     vfile_t            * vf;
  658.     char * FUNC = "Vattach";
  659.  
  660.     if (f == FAIL)             {HERROR(DFE_ARGS); return(NULL);}
  661.     if (!(vf = Get_vfile(f)))  {HERROR(DFE_FNF); return(NULL);}
  662.  
  663.     if ( accesstype[0]=='R' || accesstype[0]=='r')      access = 'r';
  664.     else if ( accesstype[0]=='W' || accesstype[0]=='w') access = 'w';
  665.     else HRETURN_ERROR(DFE_BADACC, NULL);
  666.  
  667.         if (vgid == -1) {           /******* create a NEW vg in vgdir ******/
  668.           
  669.           if (access=='r') {
  670.             HERROR(DFE_ARGS);
  671.             return(NULL);
  672.           }
  673.           
  674.           /* allocate space for vg, & zero it out */
  675.           if ( (vg = (VGROUP*) HDgetspace (sizeof(VGROUP)) ) == NULL) {
  676.             HERROR(DFE_NOSPACE);
  677.             return(NULL);
  678.           }
  679.  
  680.           /* initialize new vg */
  681.           vg->nvelt         = 0;
  682.           vg->vgname[0]    = '\0';
  683.           vg->f               = f;
  684.           vg->otag         = DFTAG_VG;
  685.           vg->oref           = vnewref(f);  /* create a new unique ref for it */
  686.           if( vg->oref == 0 ) { HERROR(DFE_NOREF); return(NULL); }
  687.           
  688.           vg->access      = access;
  689.           
  690.           vg->marked        = 0;
  691.           vg->vgclass[0]    = '\0';
  692.           vg->extag        = 0;
  693.           vg->exref        = 0;
  694.           vg->more            = 0;
  695.           vg->version        = VSET_VERSION;
  696.           
  697.           /* attach new vg to file's vgtab  */
  698.           if ( NULL == (v = (vginstance_t*) HDgetspace (sizeof(vginstance_t)))) {
  699.             HERROR(DFE_NOSPACE);
  700.             return(NULL);
  701.           }
  702.           
  703.           vf->vgtabtail->next = v;
  704.           vf->vgtabtail          = v;
  705.           vf->vgtabn++;
  706.           v->next     = NULL;
  707.           v->ref    = (intn) vg->oref;
  708.           v->vg          = vg;
  709.           v->nattach    = 1;
  710.           v->nentries    = 0;
  711.           
  712.           return(vg);
  713.     }
  714.  
  715.     else {         
  716.           /******* access an EXISTING vg *********/
  717.           
  718.           if (NULL == (v= vginstance (f,(uint16)vgid))) {
  719.             HERROR(DFE_NOMATCH);
  720.             HEreport("Vgid (%d) is not in vgtab[]", vgid);
  721.             return(NULL);
  722.           }
  723.           
  724.           /*
  725.            * vg already attached.  inc nattach and return existing ptr
  726.            */
  727.           if (v->vg != NULL) {  
  728.             v->nattach++;
  729.             return(v->vg);
  730.           }
  731.           
  732.           /* else vg not attached, must fetch vg from file */
  733.           
  734.           if (QQgetelement(f, DFTAG_VG, (uint16)vgid, vgpack) == (int32)FAIL) {
  735.             HERROR(DFE_NOMATCH);
  736.             return(NULL);
  737.           }
  738.           
  739.           /* allocate space for vg, & zero it out */
  740.           
  741.           if (NULL == (vg =(VGROUP*) HDgetspace (sizeof(VGROUP))) ) {
  742.             HERROR(DFE_NOSPACE);
  743.             return(NULL);
  744.           }
  745.           /*
  746.             zerofill((unsigned char*) vg,sizeof(VGROUP));
  747.             */
  748.           
  749.           /* unpack vgpack into structure vg, and init  */
  750.           
  751.           vunpackvg(vg,vgpack,&vgpacksize);
  752.           vg->f                = f;
  753.           vg->oref            = (uint16)vgid;
  754.           vg->otag         = DFTAG_VG;
  755.           vg->access        = access;
  756.           vg->marked        = 0;
  757.           
  758.           /* attach vg to file's vgtab at the vg instance v */
  759.           v->vg                = vg;
  760.           v->nattach        = 1;
  761.           v->nentries    = vg->nvelt;
  762.           
  763.           return(vg);
  764.     }
  765.         
  766.         
  767. } /* Vattach */
  768.  
  769. /* ---------------------------- Vdetach ---------------------------- */
  770. /* 
  771. *    Vdetach
  772. *    Detaches access to vg.    
  773. *    NO RETURN VALUES
  774. *
  775. *  if marked flag is 1, write out vg to file.
  776. *    if vg still has velts attached to it, cannot detach vg.
  777. *    decr  nattach. if (nattach is 0), free vg from vg instance.
  778. *    (check that no velts are still attached to vg before freeing)
  779. *
  780. *  if attached with read access, just return.
  781. *
  782. * after detach, set marked flag to 0.    
  783. *
  784. */
  785.  
  786. #ifdef PROTOTYPE
  787. PUBLIC void Vdetach (VGROUP *vg)
  788. #else
  789.  
  790. PUBLIC void Vdetach (vg)
  791.     VGROUP *vg;
  792.  
  793. #endif
  794.  
  795. {
  796.  
  797.   int32             vgpacksize;
  798. #if 0
  799.   uint16            u;
  800. #endif
  801.   BYTE                vgpack[sizeof(VGROUP)];
  802.   vginstance_t     * v;
  803.   char * FUNC = "Vdetach";
  804.   
  805.   if ((vg == NULL) || (vg->otag != DFTAG_VG)) {
  806.     HERROR(DFE_ARGS);
  807.     HEprint(stderr, 0);
  808.     return;
  809.   }
  810.   
  811.   /* locate vg's index in vgtab */
  812.   if (NULL ==( v = (vginstance_t*) vginstance (vg->f, vg->oref))) {
  813.     HERROR(DFE_NOVS);
  814.     HEprint(stderr, 0);
  815.     return;
  816.   }
  817.   
  818.   /* update vgroup to file if it has write-access */
  819.   
  820.   /* if its marked flag is 1 */
  821.   /* - OR - */
  822.   /* if that vgroup is empty */
  823.   if (vg->access == 'w') {
  824.     if ((vg->nvelt==0) || (vg->marked == 1)) {
  825.       if (vjv) {
  826.         sprintf(sjs,"@VDETACH: added %d entries in vg..update vg to file\n",
  827.                 vg->nvelt - v->nentries); zj;
  828.       }
  829.       vpackvg(vg,vgpack,&vgpacksize);
  830.  
  831.       /* 
  832.        *  For now attempt to blow away the old one.  This is a total HACK
  833.        *    but the H-level needs to stabilize first
  834.        */
  835.       Hdeldd(vg->f, DFTAG_VG, vg->oref);
  836.       if(vjv) {sprintf(sjs,"OLD VGROUP deleted.  Now writing again\n"); zj;}
  837.  
  838.       if(QQputelement(vg->f, DFTAG_VG, vg->oref, vgpack, vgpacksize) == FAIL) {
  839.         HERROR(DFE_WRITEERROR);
  840.         HEprint(stderr, 0);
  841.       }
  842.       vg->marked = 0;
  843.       return;
  844.     }
  845.   }
  846.   
  847.   v->nattach--;
  848.   if (vjv) { sprintf(sjs,"#Vdetach: nattach is now %d\n", v->nattach); zj; }
  849.   
  850.   if (v->nattach > 0)
  851.     return;    /* ok */
  852.   
  853.   
  854.   /* else, we can detach and remove vg from file's vgtab  */
  855.   
  856. #if 0
  857.   if(vjv) {
  858.     /* check if vg still has attached entries */
  859.     for (u=0; u<vg->nvelt; u++)     
  860.       if (vg->velt[u]) {
  861.         sprintf(sjs,"@Vdetach: vg has vs %d undetached! continuing. \n",u); zj;
  862.         break;
  863.       }
  864.   }
  865. #endif
  866.   v->vg = NULL;             /* detach vg from vgdir */
  867.   
  868.   HDfreespace (vg);
  869.   
  870.   return; /* ok */
  871.   
  872. } /* Vdetach */
  873.  
  874.  
  875. /* ------------------------------ Vinsert ----------------------------- */
  876. /*
  877. *    Vinsert
  878. *  inserts a velt (vs or vg)  into a vg 
  879. *    RETURNS entry position within vg (0 or +ve) or FAIL on error.
  880. *
  881. *    checks and prevents duplicate links.
  882. *
  883. * Since multiple files are now possible, check that both vg and velt
  884. * are from the same file. else error.
  885. */
  886.  
  887. #ifdef PROTOTYPE
  888. PUBLIC int32 Vinsert (VGROUP *vg, VDATA *velt)             
  889. #else
  890.  
  891. PUBLIC int32 Vinsert (vg, velt)             
  892.     VGROUP    *vg;
  893.     VDATA     *velt;            /* (VGROUP*) or (VDATA*), doesn't matter */
  894.  
  895. #endif
  896.  
  897. {
  898.     uint16 u;
  899.     char * FUNC = "Vinsert";
  900.  
  901.     if (vg == NULL || velt == NULL) {
  902.           HERROR(DFE_BADPTR);
  903.           return(FAIL);
  904.         }
  905.  
  906.     if (vg->otag != DFTAG_VG) {
  907.           HERROR(DFE_ARGS);
  908.           return(FAIL);
  909.         }
  910.  
  911.         if(vg->nvelt >= MAXNVELT) {
  912.           HERROR(DFE_VGSIZE);
  913.           return(FAIL);
  914.         }
  915.  
  916.     if ( Get_vfile(vg->f) != Get_vfile(velt->f) ) {
  917.           HERROR(DFE_DIFFFILES);
  918.           return(FAIL);
  919.         }
  920.  
  921.     /* check in vstab  or vgtab that velt actually exist in file */
  922.  
  923.     switch (velt->otag) {
  924.         case VSDESCTAG:
  925.             if (vexistvs (vg->f,velt->oref) == FAIL) 
  926.                   {HERROR(DFE_NOVS); return(FAIL);}
  927.             break;
  928.  
  929.         case DFTAG_VG:
  930.             if (vexistvg (vg->f,velt->oref) == FAIL) 
  931.                   {HERROR(DFE_NOVS); return(FAIL);}
  932.             break;
  933.  
  934.       default:
  935.           HERROR(DFE_ARGS);
  936.           return(FAIL);
  937.     } /* switch */
  938.  
  939.     /* check and prevent duplicate links */
  940.     for(u=0;u<vg->nvelt;u++)
  941.         if ( (vg->tag[u] == velt->otag) && (vg->ref[u] == velt->oref) ) {
  942.            HERROR(DFE_DUPDD);
  943.            HEreport("Vinsert: duplicate link <%d/%d>", velt->otag,velt->oref);
  944.            return(FAIL);
  945.         }
  946.  
  947.     /* Finally, ok to insert */
  948.     vinsertpair (vg, velt->otag, velt->oref);
  949.  
  950.     if (vjv) {
  951.         sprintf(sjs,"#Vinsert:inserted <%d/%d> at nvelt=%d\n",
  952.             velt->otag, velt->oref, vg->nvelt); zj;
  953.     }
  954.  
  955.     vg->marked = TRUE;
  956.     return(vg->nvelt - 1);
  957.  
  958. } /* Vinsert */
  959.  
  960. /* ----------------------------- Vflocate -------------------------------- */
  961. /*
  962. Checks to see if the given field exists in a vdata belonging to this vgroup.
  963. If found, returns the ref of the vdata.
  964. If not found, or error, returns FAIL
  965. 28-MAR-91 Jason Ng NCSA
  966. */
  967.  
  968. #ifdef PROTOTYPE
  969. PUBLIC int32 Vflocate (VGROUP *vg, char *field)
  970. #else
  971.  
  972. PUBLIC int32 Vflocate (vg, field)
  973.     VGROUP * vg;
  974.     char * field;
  975. #endif
  976.  
  977. {
  978.     int32   s;
  979.     uint16  u;
  980.     VDATA     *vs;
  981.     char * FUNC = "Vflocate";
  982.  
  983.     for (u=0;u<vg->nvelt;u++)  {
  984.         if (vg->tag[u] != VSDESCTAG) continue;
  985.         vs = (VDATA*) VSattach (vg->f,vg->ref[u],"r");
  986.         if (vs==NULL) return (FAIL);
  987.         s = VSfexist (vs, field);
  988.         VSdetach (vs);
  989.         if (s==1) return (vg->ref[u]); /* found. return vdata's ref */
  990.     }
  991.  
  992.     return (FAIL); /* field not found */
  993.  
  994. } /* Vflocate */
  995.  
  996. /* ----------------------- Vinqtagref ------------------------------------- */
  997. /*
  998. * Checks whether the given tag/ref pair already exists in the vgroup.
  999. * RETURNS TRUE if exist
  1000. * RETURNS FALSE if not.
  1001. * 28-MAR-91 Jason Ng NCSA
  1002. */
  1003. #ifdef PROTOTYPE
  1004. PUBLIC int32 Vinqtagref (VGROUP *vg, int32 tag, int32 ref)
  1005. #else
  1006.  
  1007. PUBLIC int32 Vinqtagref (vg, tag, ref)
  1008.     VGROUP     * vg;
  1009.     int32     tag, ref;
  1010.  
  1011. #endif
  1012.  
  1013. {
  1014.     register intn   i;
  1015.     register uint16     ttag, rref;
  1016.     char * FUNC = "Vinqtagref";
  1017.  
  1018.     ttag = (uint16) tag;
  1019.     rref = (uint16) ref;
  1020.  
  1021.     for (i=0; i < vg->nvelt; i++)
  1022.         if ((ttag == vg->tag[i]) && (rref == vg->ref[i])) 
  1023.             return (TRUE); /* exist */
  1024.  
  1025.     return (FALSE); /* does not exist */
  1026.  
  1027. } /* Vinqtagref */
  1028.  
  1029. /* ------------------------- Vntagrefs ------------------------------- */
  1030. /*
  1031. * Returns the number (0 or +ve integer) of tag/ref pairs in a vgroup.
  1032. * If error, returns FAIL
  1033. * 28-MAR-91 Jason Ng NCSA.
  1034. */
  1035.  
  1036. #ifdef PROTOTYPE
  1037. PUBLIC int32 Vntagrefs (VGROUP *vg)
  1038. #else
  1039.  
  1040. PUBLIC int32 Vntagrefs (vg)
  1041.     VGROUP * vg;
  1042.  
  1043. #endif
  1044.  
  1045. {
  1046.     char * FUNC = "Vntagrefs";
  1047.  
  1048.     return ( (vg->otag == DFTAG_VG) ? (int32) vg->nvelt : FAIL);
  1049.  
  1050. } /* Vntagrefs */
  1051.  
  1052. /* -------------------------- Vgettagrefs ----------------------------- */
  1053. /*
  1054. * Returns n tag/ref pairs from the vgroup into the caller-supplied arrays
  1055. * tagrarray and refarray.
  1056. * n can be any +ve number, but arrays must be this big.
  1057. * RETURNS the total number of (0 or +ve #)  tag/ref pairs returned.
  1058. * 28-MAR-91 Jason Ng NCSA.
  1059. *
  1060. * NOTE: Do not confuse with Vgettagref().
  1061. *
  1062. */
  1063.  
  1064. #ifdef PROTOTYPE
  1065. PUBLIC int32 Vgettagrefs (VGROUP *vg, int32 tagarray[], int32 refarray[], int32 n)
  1066. #else
  1067.  
  1068. PUBLIC int32 Vgettagrefs (vg, tagarray, refarray, n)
  1069.     VGROUP     * vg;
  1070.     int32     n;
  1071.     int32 tagarray[], refarray[];
  1072.  
  1073. #endif
  1074.  
  1075. {
  1076.     int32 i;
  1077.     char * FUNC = "Vgettagrefs";
  1078.  
  1079.     if (n > (int32)vg->nvelt)
  1080.         n = vg->nvelt;
  1081.  
  1082.     for (i=0; i<n; i++) {
  1083.         tagarray[i] = (int32) vg->tag[i];
  1084.         refarray[i] = (int32) vg->ref[i];
  1085.     }
  1086.  
  1087.     return (n);
  1088. } /* Vgettagrefs */
  1089.  
  1090. /* -------------------------- Vgettagref -------------------------------- */
  1091. /*
  1092. * Returns a specified tag/ref pair from the vgroup.
  1093. * User specifies an index. 
  1094. * RETURNS FAIL if OK.
  1095. * RETURNS SUCCEED if error.
  1096. * 12-MAY-91 Jason Ng NCSA.
  1097. *
  1098. * NOTE: Do not confuse with Vgettagrefs().
  1099. *
  1100. */
  1101.  
  1102. #ifdef PROTOTYPE
  1103. PUBLIC int32 Vgettagref (VGROUP *vg, int32 which, int32 *tag, int32 *ref)
  1104. #else
  1105.  
  1106. PUBLIC int32 Vgettagref (vg, which, tag, ref)
  1107.     VGROUP     * vg;
  1108.     int32     which;
  1109.     int32     *tag, *ref; /* these are returned */
  1110.  
  1111. #endif
  1112.  
  1113. {
  1114.     char * FUNC = "Vgettagref";
  1115.  
  1116.     if (vg==NULL) return (FAIL);
  1117.     if (which < 0 || which > (int32)(vg->nvelt-1))
  1118.           return (FAIL); /* range err */
  1119.  
  1120.         *tag  = (int32) vg->tag[which];
  1121.         *ref  = (int32) vg->ref[which];
  1122.     return (SUCCEED); /* ok */
  1123.  
  1124. } /* Vgettagref */
  1125.  
  1126. /* ------------------------ Vaddtagref ---------------------------------- */
  1127. /*
  1128. * Inserts a tag/ref pair into the attached vgroup vg.
  1129. * First checks that the tag/ref is unique.
  1130. * If error, returns FAIL or tag/ref is not inserted.
  1131. * If OK, returns the total number of tag/refs in the vgroup (a +ve integer).
  1132. * 28-MAR-91 Jason Ng NCSA.
  1133. */
  1134.  
  1135. #ifdef PROTOTYPE
  1136. PUBLIC int32 Vaddtagref (VGROUP *vg, int32 tag, int32 ref)
  1137. #else
  1138.  
  1139. PUBLIC int32 Vaddtagref ( vg, tag, ref)
  1140.     VGROUP     * vg;
  1141.     int32     tag, ref;
  1142.  
  1143. #endif
  1144.  
  1145. {
  1146.     int32  n;
  1147.     char * FUNC = "Vaddtagref";
  1148.  
  1149.     if (Vinqtagref (vg, tag, ref) == 1) {
  1150.           /* error, already exists */
  1151.           HERROR(DFE_DUPDD);
  1152.           return (FAIL);
  1153.         }
  1154.     n = vinsertpair (vg, (uint16) tag, (uint16) ref);
  1155.     return (n);
  1156.  
  1157. } /* Vaddtagref */
  1158.  
  1159. /* ------------------------ vinsertpair --------------------------------- */
  1160. /*
  1161. * Inserts a tag/ref pair into the attached vgroup vg.
  1162. * Does not check for errors. 
  1163. * Returns the total number of tag/refs in the vgroup.
  1164. */
  1165.  
  1166. #ifdef PROTOTYPE
  1167. int32 vinsertpair (VGROUP *vg, uint16 tag, uint16 ref)
  1168. #else
  1169.  
  1170. int32 vinsertpair ( vg, tag, ref)
  1171.     VGROUP        * vg;
  1172.     uint16        tag, ref;      /* this MUST be uint16 -  private routine */
  1173.  
  1174. #endif
  1175.  
  1176. {
  1177.     char * FUNC = "vinsertpair";
  1178.  
  1179.     vg->velt[vg->nvelt]  = NULL;
  1180.     vg->tag[vg->nvelt]   = tag;
  1181.     vg->ref[vg->nvelt]   = ref;
  1182.     vg->nvelt ++;
  1183.  
  1184.     vg->marked = TRUE;
  1185.     return ((int32) vg->nvelt);
  1186. }
  1187.  
  1188. /* ==================================================================== */
  1189. /* 
  1190. *     Ventries
  1191. *    returns the no of entries (+ve integer) in the vgroup vgid.
  1192. *  vgid must be an actual id
  1193. *  RETURNS FAIL if error
  1194. *
  1195. *  undocumented
  1196. *
  1197. */
  1198.  
  1199. #ifdef PROTOTYPE
  1200. int32 Ventries (HFILEID f, int32 vgid)    
  1201. #else
  1202.  
  1203. int32 Ventries (f, vgid)    
  1204.     HFILEID    f;
  1205.     int32      vgid;
  1206.  
  1207. #endif
  1208.  
  1209. {
  1210.     BYTE        vgpack[sizeof(VGROUP)];
  1211.     VGROUP     vg;
  1212.     int32       vgpacksize;
  1213.     char * FUNC = "Ventries";
  1214.  
  1215.     if (vgid < 1) {
  1216.       HERROR(DFE_ARGS);
  1217.       return(FAIL);
  1218.       }
  1219.     if ( QQgetelement(f, DFTAG_VG, (uint16)vgid, vgpack) == FAIL) {
  1220.         sprintf(sjs,"@Ventries: cannot get vg from file\n"); zj;
  1221.         return (FAIL);
  1222.     }
  1223.  
  1224.     vunpackvg(&vg,vgpack,&vgpacksize);
  1225.     return( (int32) vg.nvelt);
  1226.  
  1227. } /* Ventries */
  1228.  
  1229. /* ==================================================================== */
  1230. /*
  1231. *    Vsetname
  1232. *     gives a name to the VGROUP vg.
  1233. *
  1234. * NO RETURN VALUES.
  1235. *
  1236. *    truncates to max length of VGNAMELENMAX 
  1237. */
  1238.  
  1239. #ifdef PROTOTYPE
  1240. PUBLIC void Vsetname (VGROUP *vg, char *vgname)   
  1241. #else
  1242.  
  1243. PUBLIC void Vsetname (vg, vgname)   
  1244.     VGROUP    *vg;
  1245.     char        *vgname;
  1246.  
  1247. #endif
  1248.  
  1249. {
  1250.   char * FUNC = "Vsetname";
  1251.   
  1252.   if (vg == NULL) return;
  1253.   if ( HDstrlen(vgname) > VGNAMELENMAX ) {
  1254.     HIstrncpy(vg->vgname, vgname, VGNAMELENMAX);
  1255.     vg->vgname[VGNAMELENMAX]='\0';
  1256.   } 
  1257.   else {
  1258.     HDstrcpy(vg->vgname, vgname);
  1259.   }
  1260.   vg->marked = TRUE;
  1261.   return;
  1262.   
  1263. } /* Vsetname */
  1264.  
  1265. /* ==================================================================== */
  1266. /*
  1267. *    Vsetclass
  1268. *     assigns a class name to the VGROUP vg.
  1269. *
  1270. * NO RETURN VALUES.
  1271. *
  1272. *    truncates to max length of VGNAMELENMAX 
  1273. */
  1274.  
  1275. #ifdef PROTOTYPE
  1276. PUBLIC void Vsetclass (VGROUP *vg, char *vgclass)         
  1277. #else
  1278.  
  1279. PUBLIC void Vsetclass (vg, vgclass)         
  1280.     VGROUP    *vg;
  1281.     char        *vgclass;
  1282.  
  1283. #endif
  1284.  
  1285. {
  1286.   char * FUNC = "Vsetclass";
  1287.   
  1288.   if (vg == NULL) return;
  1289.   if ( HDstrlen(vgclass) > VGNAMELENMAX) {
  1290.     HIstrncpy(vg->vgclass, vgclass,VGNAMELENMAX);
  1291.     vg->vgclass[VGNAMELENMAX]='\0';
  1292.   }
  1293.   else
  1294.     HDstrcpy(vg->vgclass, vgclass);
  1295.   vg->marked = TRUE;
  1296.   return;
  1297.   
  1298. } /* Vsetclass*/
  1299.  
  1300.  
  1301. /* -------------------------------- Visvg --------------------------------- */
  1302. /*
  1303. *     Visvg
  1304. *    tests if an entry in the vgroup vg is a VGROUP, given the entry's id. 
  1305. *
  1306. *    RETURNS TRUE if so
  1307. *    RETURNS FALSE if not, or if error
  1308. *
  1309. */
  1310.  
  1311. #ifdef PROTOTYPE
  1312. PUBLIC int32 Visvg (VGROUP *vg, int32 id) 
  1313. #else
  1314.  
  1315. PUBLIC int32 Visvg (vg, id) 
  1316.     VGROUP    *vg;
  1317.     int32     id;        /* valid id of the entry in question */
  1318. #endif
  1319.  
  1320. {
  1321.   register intn u;
  1322.   register uint16 ID;
  1323.   char * FUNC = "Visvg";
  1324.   
  1325.   ID = (uint16) id;
  1326.  
  1327.   for(u = 0; u < vg->nvelt; u++)
  1328.     if (vg->ref[u] == ID   &&   /* if the ids match, */
  1329.         vg->tag[u] == DFTAG_VG)     /* and it is a vgroup */
  1330.       return (TRUE);
  1331.   
  1332.   return (FALSE);
  1333.   
  1334. } /* Visvg */
  1335.  
  1336. /* ======================================================= */
  1337. /* 
  1338. *    Vgetid
  1339. *    
  1340. *    Given a vgroup's id, returns the next vgroup's id in the file f .
  1341. *    The call Vgetid(f,-1) returns the id of the FIRST vgroup in the file. 
  1342. *
  1343. *    RETURNS -1 if error
  1344. *    RETURNS the next vgroup's id (0 or +ve integer).
  1345. *
  1346. *    This id is actually the "ref" of the vgroup "tag/ref".
  1347. */
  1348.  
  1349. #ifdef PROTOTYPE
  1350. PUBLIC int32 Vgetid (HFILEID f,int32 vgid)         
  1351. #else
  1352.  
  1353. PUBLIC int32 Vgetid (f, vgid)         
  1354.     int32     vgid;                    /* current vgid */
  1355.     HFILEID     f;                        /* HDF file handle */
  1356.  
  1357. #endif
  1358.  
  1359. {
  1360.     vginstance_t * v;
  1361.     vfile_t        * vf;
  1362.     char * FUNC = "Vgetid";
  1363.  
  1364.     if ( vgid < -1 ) {
  1365.           HERROR(DFE_ARGS);
  1366.           return(FAIL);
  1367.         }
  1368.  
  1369.     if (NULL==(vf = Get_vfile(f))) {
  1370.           HERROR(DFE_FNF);
  1371.           return(FAIL);
  1372.         }
  1373.  
  1374.     if (vjv) {
  1375.         sprintf(sjs,"#Vgetid:vgtabn= %ld vgid=%ld\n",vf->vgtabn,vgid);
  1376.         zj;
  1377.     }
  1378.  
  1379.     if (vgid == FAIL) {
  1380.        if (NULL == vf->vgtab.next)
  1381.           return (FAIL);
  1382.        else
  1383.           return( (vf->vgtab.next)->ref); /* rets 1st vgroup's ref */
  1384.     }
  1385.  
  1386.     /* look in vgtab for vgid */
  1387.     v = (vf->vgtab).next;
  1388.     while(NULL != v) {
  1389.         if(v->ref == (uint16)vgid) break;
  1390.         v = v->next;
  1391.     }
  1392.     if (v==NULL)
  1393.         return (FAIL); /* none found */
  1394.     else
  1395.         if( v->next ==NULL)
  1396.             return (FAIL); /* this is the last vg, no more after it */
  1397.         else
  1398.             return((v->next)->ref); /* success, return the next vg's ref */
  1399.  
  1400. } /* Vgetid */
  1401.  
  1402.  
  1403. /* ================================================================= */
  1404. /*
  1405. *    Vgetnext
  1406. *
  1407. *    Given the id of an entry from a vgroup vg, looks in vg for the next
  1408. *    entry after it, and returns its id.
  1409. *    The call Vgetnext (vg,-1) returns the id of the FIRST entry in the vgroup.
  1410. *
  1411. *  Vgetnext will look at only VSET elements in the vgroup.
  1412. *  To look at all links in a vgroup, use Vgettagrefs instead.
  1413. *
  1414. *    RETURNS -1 if error
  1415. *    RETURNS the id of the next entry( 0 or +ve integer)  in the vgroup.
  1416. *
  1417. *    This id is actually the "ref" of the entry's "tag/ref".
  1418. *
  1419. */
  1420.  
  1421. #ifdef PROTOTYPE
  1422. PUBLIC int32 Vgetnext (VGROUP *vg, int32 id)    
  1423. #else
  1424.  
  1425. PUBLIC int32 Vgetnext (vg, id)    
  1426.     VGROUP    *vg;
  1427.     int32     id;        /* actual id of an entry in the vgroup vg */
  1428.  
  1429. #endif
  1430.  
  1431. {
  1432.     register intn  u;
  1433.     char * FUNC = "Vgetnext";
  1434.   
  1435.     if ((id < -1) || (vg == NULL) || (vg->otag != DFTAG_VG)) {
  1436.         HERROR(DFE_ARGS);
  1437.         return(FAIL);
  1438.     }
  1439.   
  1440.     if (vjv) { sprintf(sjs,"#Vgetnext:vg->nvelt is %d\n",vg->nvelt); zj; }
  1441.   
  1442.     if (vg->nvelt == 0) return(FAIL);             /* nothing in vg */
  1443.   
  1444.     if (id == -1) {
  1445.         if ((vg->tag[0] == DFTAG_VG) || (vg->tag[0]==VSDESCTAG))
  1446.             return(vg->ref[0]);       /* id of first entry */
  1447.     }
  1448.   
  1449.     /* look in vg for id */
  1450.     for(u=0;u<vg->nvelt;u++)
  1451.         if ((vg->tag[u] == DFTAG_VG) || (vg->tag[u]==VSDESCTAG)) {
  1452.             if(vg->ref[u] == (uint16)id) {
  1453.                 if (u == (vg->nvelt - 1) )
  1454.                     return(FAIL);
  1455.                 else  {
  1456.                     if ((vg->tag[u+1] == DFTAG_VG) || (vg->tag[u+1]==VSDESCTAG))
  1457.                         return(vg->ref[u+1]);     /* return the id of next entry */
  1458.                     else  return (FAIL);
  1459.                 }
  1460.             }
  1461.         }
  1462.     
  1463.     return (FAIL);
  1464.  
  1465. } /* Vgetnext  */
  1466.  
  1467. /* ================================================================= */
  1468. /*
  1469. *    Vgetname
  1470. *    returns the vgroup's name
  1471. *   ASSUME that vgname has been allocated large enough to hold
  1472. *   the name
  1473. *
  1474. */
  1475.  
  1476. #ifdef PROTOTYPE
  1477. PUBLIC void Vgetname (VGROUP *vg, char *vgname)          
  1478. #else
  1479.  
  1480. PUBLIC void Vgetname (vg, vgname)          
  1481.     VGROUP    *vg;
  1482.     char    *vgname;            /* its name is returned in this var */
  1483.  
  1484. #endif
  1485.  
  1486. {
  1487.     char * FUNC = "Vgetname";
  1488.  
  1489.     if (vg != NULL) HDstrcpy(vgname, vg->vgname);
  1490.     return;
  1491.  
  1492. } /* Vgetname */
  1493. /* ================================================================= */
  1494. /*
  1495. *    Vgetclass
  1496. *    returns the vgroup's class name 
  1497. *   ASSUME that vgclass has been allocated large enough to hold
  1498. *   the name
  1499. *
  1500. */
  1501.  
  1502. #ifdef PROTOTYPE
  1503. PUBLIC void Vgetclass (VGROUP *vg, char *vgclass)  
  1504. #else
  1505.  
  1506. PUBLIC void Vgetclass (vg, vgclass)  
  1507.     VGROUP    *vg;
  1508.     char    *vgclass;    /* its class name is returned in this var */
  1509.  
  1510. #endif
  1511.  
  1512. {
  1513.   char * FUNC = "Vgetclass";
  1514.   
  1515.   if(vg && vgclass) HIstrncpy(vgclass, vg->vgclass, HDstrlen(vg->vgclass) + 1);
  1516.   return;
  1517.  
  1518. } /* Vgetclass*/
  1519.  
  1520. /* ================================================================= */
  1521. /*
  1522. *    Vinquire
  1523. *
  1524. *    General inquiry routine for VGROUP. 
  1525. *
  1526. *    output parameters:
  1527. *            nentries - no of entries in the vgroup
  1528. *            vgname    - the vgroup's name
  1529. *
  1530. *    RETURNS FAIL if error
  1531. *    RETURNS SUCCEED if ok
  1532. *
  1533. */
  1534.  
  1535. #ifdef PROTOTYPE
  1536. PUBLIC int32 Vinquire (VGROUP *vg, int32 *nentries, char *vgname)
  1537. #else
  1538.  
  1539. PUBLIC int32 Vinquire (vg, nentries, vgname)
  1540.     VGROUP    *vg;
  1541.     int32     *nentries;
  1542.     char        *vgname;
  1543.  
  1544. #endif
  1545.  
  1546. {
  1547.   char * FUNC = "Vinquire";
  1548.   
  1549.   if ((vg == NULL) || (vg->otag != DFTAG_VG)) {
  1550.     HERROR(DFE_ARGS);
  1551.     return(FAIL);
  1552.   }
  1553.  
  1554.   HDstrcpy(vgname, vg->vgname);
  1555.   *nentries = vg->nvelt;
  1556.   
  1557.   return(SUCCEED); 
  1558.  
  1559. } /* Vinquire */
  1560.  
  1561. /* ================================================================= */
  1562.  
  1563. /* ---------------------------- Vopen ------------------------- */
  1564. /* 
  1565. * 
  1566. * This routine will replace the code segment " Hopen(); Vinitialize(f)".
  1567. * Thus, if Vopen is used, do not call Vinitialize after that.
  1568. * 
  1569. * Similar to Hopen().
  1570. * INPUTS: 
  1571. *        char * path     - file name.
  1572. *     int n  access   - type of access. See Hopen().
  1573. *     int16  ndds     - no. of dd blocks. See Hopen().
  1574. *
  1575. * This routine opens the HDF file and initializes it for Vset operations.
  1576. *
  1577. * RETURN VALUE:
  1578. *  if error:  -1 (FAIL).
  1579. *  if successful: the id of the file (>0).
  1580. *
  1581. * See also Vclose().
  1582. *
  1583. * By: Jason Ng 10 Aug 92
  1584. * 
  1585. */
  1586. #ifdef OLD_WAY
  1587. #undef Hopen
  1588. #undef Hclose
  1589. #endif
  1590.  
  1591. #ifdef PROTOTYPE
  1592. PUBLIC HFILEID Vopen( char *path, intn access, int16 ndds)
  1593.  
  1594. #else
  1595. PUBLIC HFILEID Vopen (path, access, ndds)
  1596. char         *path;
  1597. intn         access;
  1598. int16     ndds;
  1599.  
  1600. #endif
  1601.  
  1602. {
  1603.     char * FUNC = "Vopen";
  1604.     HFILEID  f;
  1605.  
  1606.       f = Hopen(path, access, ndds);
  1607.    if (f==FAIL) return(FAIL);
  1608.  
  1609.     Vinitialize(f);
  1610.    return (f);
  1611.  
  1612.     }
  1613.  
  1614.  
  1615. /* ---------------------------- Vclose ------------------------- */
  1616. /* 
  1617. * 
  1618. * This routine will replace the code segment " Vfinish(f); Hclose(f);".
  1619. * Thus, if Vclose is used, do not call Vfinish before that.
  1620. *
  1621. * This routine closes the HDF file, after it has freed all memory and 
  1622. * updated the file.
  1623. * 
  1624. * INPUTS: 
  1625. *     int32   f       - if of HDF file to be closed.
  1626. *
  1627. * RETURN VALUE:  intn status - result of Hopen().
  1628. *
  1629. * See also Vopen().
  1630. *
  1631. * By: Jason Ng 10 Aug 92
  1632. * 
  1633. */
  1634.  
  1635. #ifdef PROTOTYPE
  1636. PUBLIC intn Vclose (HFILEID f)
  1637.  
  1638. #else
  1639.  
  1640. PUBLIC intn Vclose (f)
  1641.     HFILEID f;
  1642. #endif
  1643.  
  1644. {
  1645.     char * FUNC = "Vclose";
  1646.    intn status;
  1647.  
  1648.     Vfinish (f);
  1649.     status = Hclose (f);
  1650.  
  1651.     return (status);
  1652.  
  1653. }
  1654.  
  1655.