home *** CD-ROM | disk | FTP | other *** search
/ Photo CD Demo 1 / Demo.bin / hdf / unix / hdf3_2r2 / src / vgf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-30  |  27.9 KB  |  1,210 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/vgf.c,v 1.5 1992/10/30 18:36:52 koziol beta koziol $
  30.  
  31. $Log: vgf.c,v $
  32.  * Revision 1.5  1992/10/30  18:36:52  koziol
  33.  * Fixed casts in a bunch of functions to make the SGI ANSI compiler happy
  34.  *
  35.  * Revision 1.4  1992/10/23  19:13:12  koziol
  36.  * Created fortran stubs dfvopen and dfvclos for DFvsetopen() and DFvsetclose
  37.  *
  38.  * Revision 1.3  1992/10/23  00:14:11  koziol
  39.  * Changed all DFIstr*() and DFImem*() calls to HDstr*() and HDmem*() calls
  40.  * #ifdef'd out the macros Jason defined for Hopen, Hclose, etc. for Vsets
  41.  * Replaced Vset VFREESPACE and VGETSPACE calls with actual calls to HDfreespace
  42.  * and HDgetspace
  43.  * Added a MS-Windows lower lower for file I/O (which may not be completely working
  44.  *
  45.  * Revision 1.2  1992/09/11  14:15:04  koziol
  46.  * Changed Fortran stubs' parameter passing to use a new typedef, intf,
  47.  * which should be typed to the size of an INTEGER*4 in whatever Fortran
  48.  * compiler the C functions need to be compatible with.  (This is mostly
  49.  * for the PC and possibly for the Mac)
  50.  *
  51.  * Revision 1.1  1992/08/25  21:40:44  koziol
  52.  * Initial revision
  53.  *
  54. */
  55. /*
  56. *
  57. * vgF.c
  58. * Part of the HDF VSet interface.
  59. *
  60. * C routines (short names) to be called from fortran 
  61. *
  62. *
  63. ************************************************************************/
  64.  
  65. #include "vg.h"
  66.  
  67. #ifndef VG_FNAMES
  68. #   define VG_FNAMES
  69. #ifdef DF_CAPFNAMES
  70. #    define  ndfivopn FNAME(DFIVOPN)
  71. #    define  ndfvclos FNAME(DFVCLOS)
  72. #   define  nvatchc  FNAME(VATCHC)
  73. #   define  nvdtchc  FNAME(VDTCHC)
  74. #   define  nvgnamc  FNAME(VGNAMC)
  75. #   define  nvgclsc  FNAME(VGCLSC)
  76. #   define  nvinqc   FNAME(VINQC)
  77. #   define  nvgidc   FNAME(VGIDC)
  78. #   define  nvgnxtc  FNAME(VGNXTC)
  79. #   define  nvsnamc  FNAME(VSNAMC)
  80. #   define  nvsclsc  FNAME(VSCLSC)
  81. #   define  nvinsrtc FNAME(VINSRTC)
  82. #   define  nvisvgc  FNAME(VISVGC)
  83. #   define  nvisvsc  FNAME(VISVSC)
  84. #   define  nvsatchc FNAME(VSATCHC)
  85. #   define  nvsdtchc FNAME(VSDTCHC)
  86. #   define  nvsseekc FNAME(VSSEEKC)
  87. #   define  nvsgnamc FNAME(VSGNAMC)
  88. #   define  nvsgclsc FNAME(VSGCLSC)
  89. #   define  nvsinqc  FNAME(VSINQC)
  90. #   define  nvsfexc  FNAME(VSFEXC)
  91. #   define  nvsgidc  FNAME(VSGIDC)
  92. #   define  nvssnamc FNAME(VSSNAMC)
  93. #   define  nvssclsc FNAME(VSSCLSC)
  94. #   define  nvssfldc FNAME(VSSFLDC)
  95. #   define  nvssintc FNAME(VSSINTC)
  96. #   define  nvsfdefc FNAME(VSFDEFC)
  97. #   define  nvsreadc FNAME(VSREADC)
  98. #   define  nvswritc FNAME(VSWRITC)
  99. #   define  nvsgintc FNAME(VSGINTC)
  100. #   define  nvseltsc FNAME(VSELTSC)
  101. #   define  nvsgfldc FNAME(VSGFLDC)
  102. #   define  nvssizc  FNAME(VSSIZC)
  103. #   define  nventsc  FNAME(VENTSC)
  104. #   define  nsetjjc  FNAME(SETJJC)
  105. #   define  nsetnojjc    FNAME(SETNOJJC)
  106. #   define  nvlonec  FNAME(VLONEC)
  107. #   define  nvslonec FNAME(VSLONEC)
  108. #   define  nvhsdc   FNAME(VHSDC)
  109. #   define  nvhsdmc  FNAME(VHSDMC)
  110. #   define  nvhmkgpc FNAME(VHMKGPC)
  111. #   define  nvflocc  FNAME(VFLOCC)
  112. #   define  nvinqtrc FNAME(VINQTRC)
  113. #   define  nvntrc   FNAME(VNTRC)
  114. #   define  nvgttrsc FNAME(VGTTRSC)
  115. #   define  nvgttrc  FNAME(VGTTRC)
  116. #   define  nvadtrc  FNAME(VADTRC)
  117. #else   /* !DF_CAPFNAMES */
  118. #    define  ndfivopn FNAME(dfivopn)
  119. #    define  ndfvclos FNAME(dfvclos)
  120. #   define  nvatchc  FNAME(vatchc)
  121. #   define  nvdtchc  FNAME(vdtchc)
  122. #   define  nvgnamc  FNAME(vgnamc)
  123. #   define  nvgclsc  FNAME(vgclsc)
  124. #   define  nvinqc   FNAME(vinqc)
  125. #   define  nvgidc   FNAME(vgidc)
  126. #   define  nvgnxtc  FNAME(vgnxtc)
  127. #   define  nvsnamc  FNAME(vsnamc)
  128. #   define  nvsclsc  FNAME(vsclsc)
  129. #   define  nvinsrtc FNAME(vinsrtc)
  130. #   define  nvisvgc  FNAME(visvgc)
  131. #   define  nvisvsc  FNAME(visvsc)
  132. #   define  nvsatchc FNAME(vsatchc)
  133. #   define  nvsdtchc FNAME(vsdtchc)
  134. #   define  nvsseekc FNAME(vsseekc)
  135. #   define  nvsgnamc FNAME(vsgnamc)
  136. #   define  nvsgclsc FNAME(vsgclsc)
  137. #   define  nvsinqc  FNAME(vsinqc)
  138. #   define  nvsfexc  FNAME(vsfexc)
  139. #   define  nvsgidc  FNAME(vsgidc)
  140. #   define  nvssnamc FNAME(vssnamc)
  141. #   define  nvssclsc FNAME(vssclsc)
  142. #   define  nvssfldc FNAME(vssfldc)
  143. #   define  nvssintc FNAME(vssintc)
  144. #   define  nvsfdefc FNAME(vsfdefc)
  145. #   define  nvsreadc FNAME(vsreadc)
  146. #   define  nvswritc FNAME(vswritc)
  147. #   define  nvsgintc FNAME(vsgintc)
  148. #   define  nvseltsc FNAME(vseltsc)
  149. #   define  nvsgfldc FNAME(vsgfldc)
  150. #   define  nvssizc  FNAME(vssizc)
  151. #   define  nventsc  FNAME(ventsc)
  152. #   define  nsetjjc  FNAME(setjjc)
  153. #   define  nsetnojjc    FNAME(setnojjc)
  154. #   define  nvlonec  FNAME(vlonec)
  155. #   define  nvslonec FNAME(vslonec)
  156. #   define  nvhsdc   FNAME(vhsdc)
  157. #   define  nvhsdmc  FNAME(vhsdmc)
  158. #   define  nvhmkgpc FNAME(vhmkgpc)
  159. #   define  nvflocc  FNAME(vflocc)
  160. #   define  nvinqtrc FNAME(vinqtrc)
  161. #   define  nvntrc   FNAME(vntrc)
  162. #   define  nvgttrsc FNAME(vgttrsc)
  163. #   define  nvgttrc  FNAME(vgttrc)
  164. #   define  nvadtrc  FNAME(vadtrc)
  165. #endif  /* DF_CAPFNAMES */
  166. #endif  /* VG_FNAMES */
  167.  
  168. /* 
  169. **  remove trailing blanks from a string. input argument is a  string
  170. **  and *MUST* be a variable and not a constant!! For internal use only!! 
  171. **  Used only on Crays where the Fortran compiler will pad strings to the 
  172. **  nearest 8-byte boundary.
  173. */
  174.  
  175. void
  176. #ifdef PROTOTYPE
  177. trimendblanks(char *ss) 
  178. #else
  179. trimendblanks(ss) 
  180.     char *ss;
  181. #endif
  182. {
  183.     int32 i,n;
  184.  
  185.     n = HDstrlen(ss);
  186.     for(i=n-1;i>=0;i--) {
  187.         if(ss[i]!=' ') {
  188.             ss[i+1]='\0';
  189.             break;
  190.         }
  191.     }
  192. }
  193.  
  194. /* ================================================== */
  195. /*  VGROUP routines                                   */
  196. /* ================================================== */
  197.  
  198. /*-----------------------------------------------------------------------------
  199.  * Name:    dfivopn
  200.  * Purpose: Fortran stub for dfvopen to call DFvsetopen to open HDF file
  201.  * Inputs:  name: name of file to open
  202.  *          access: access mode - integer with value DFACC_READ etc.
  203.  *          defdds: default number of DDs per header block
  204.  *          namelen: length of name
  205.  * Returns: 0 on success, -1 on failure with error set
  206.  * Users:   HDF Fortran programmers
  207.  * Invokes: Hopen
  208.  * Method:  Convert filename to C string, call Hopen
  209.  *---------------------------------------------------------------------------*/
  210.  
  211.    FRETVAL(intf)
  212. #ifdef PROTOTYPE
  213. ndfivopn(_fcd name, intf *access, intf *defdds, intf *namelen)
  214. #else
  215. ndfivopn(name, access, defdds, namelen)
  216. _fcd name;
  217. intf *access;
  218. intf *defdds;
  219. intf *namelen;
  220. #endif /* PROTOTYPE */
  221. {
  222.    char *fn;
  223.    intf ret;
  224.  
  225.    fn = HDf2cstring(name, *namelen);
  226.    ret = (intf) DFvsetopen(fn, *access, *defdds);
  227.    HDfreespace(fn);
  228.    return(ret);
  229. }    /* end ndfivopn() */
  230.  
  231. /*-----------------------------------------------------------------------------
  232.  * Name:    dfvclos
  233.  * Purpose: Call DFvsetclose to close HDF file
  234.  * Inputs:  file_id: handle to HDF file to close
  235.  * Returns: 0 on success, FAIL on failure with error set
  236.  * Users:   HDF Fortran programmers
  237.  * Invokes: Hclose
  238.  *---------------------------------------------------------------------------*/
  239.  
  240. FRETVAL(intf)
  241. #ifdef PROTOTYPE
  242. ndfvclos(intf *file_id)
  243. #else
  244. ndfvclos(file_id)
  245. intf *file_id;
  246. #endif /* PROTOTYPE */
  247. {
  248.    return(DFvsetclose(*file_id));
  249. }    /* ndfvclos() */
  250.  
  251. /* 
  252. **  attach to a vgroup and returns its ptr
  253. **  related: Vattach--vatchc--VFATCH
  254. */
  255.  
  256.     FRETVAL(intf *)
  257. #ifdef PROTOTYPE
  258. nvatchc(HFILEID *f, intf *vgid, _fcd accesstype)
  259. #else
  260. nvatchc(f, vgid, accesstype)
  261.     HFILEID *f;
  262.     intf       *vgid;
  263.     _fcd        accesstype;                     /* assume one character only */
  264. #endif
  265. {
  266.     VGROUP *vg;
  267.     char     *acc;
  268.  
  269.     acc = HDf2cstring (accesstype, 1);
  270.  
  271.     vg = (VGROUP*) Vattach(*f, *vgid, acc);
  272.     (void) HDfreespace(acc);
  273.  
  274.     if(vg==NULL)
  275.         return( (intf*) -1);
  276.     else 
  277.         return( (intf*) vg);
  278. }
  279.  
  280. /* ------------------------------------------------------------------ */
  281.  
  282. /* 
  283. **  detach from a vgroup
  284. **  related: Vdetach--vdtchc--VFDTCH
  285. */
  286.  
  287.     FRETVAL(void)
  288. #ifdef PROTOTYPE
  289. nvdtchc(VGROUP **vg)
  290. #else
  291. nvdtchc(vg)
  292.     VGROUP  **vg;
  293. #endif
  294. {
  295.     Vdetach(*vg);
  296. }
  297. /* ------------------------------------------------------------------ */
  298.  
  299. /* 
  300. **  get the name of a vgroup
  301. **  related: Vgetname--vgnamc--VFGNAM
  302. */
  303.  
  304.     FRETVAL(void)
  305. #ifdef PROTOTYPE
  306. nvgnamc(VGROUP **vg, _fcd vgname)
  307. #else
  308. nvgnamc(vg, vgname)
  309.     VGROUP  **vg;
  310.     _fcd    vgname;             /* output */
  311. #endif
  312.  
  313. {
  314.     Vgetname (*vg, vgname);
  315. }   /* VGNAMC */
  316.  
  317. /* ------------------------------------------------------------------ */
  318. /* 
  319. **  get the class name of a vgroup
  320. **  related: Vgetclass--vgclsc--VFGCLS
  321. */
  322.  
  323.     FRETVAL(void)
  324. #ifdef PROTOTYPE
  325. nvgclsc(VGROUP ** vg, _fcd vgclass)
  326. #else
  327. nvgclsc(vg, vgclass)
  328.     VGROUP  **vg;
  329.     _fcd         vgclass;                /* output */
  330. #endif
  331.  
  332. {
  333.      Vgetclass (*vg, vgclass);
  334. }   /* VGCLSC */
  335.  
  336. /* ------------------------------------------------------------------ */
  337. /* 
  338. **  general inquiry on a vgroup 
  339. **  related: Vinquire--vinqc--VFINQ
  340. */
  341.  
  342.     FRETVAL(intf)
  343. #ifdef PROTOTYPE
  344. nvinqc(VGROUP** vg, intf *nentries, _fcd vgname)
  345. #else
  346. nvinqc(vg, nentries, vgname)
  347.     VGROUP  **vg;
  348.     intf    *nentries;          /* output */
  349.     _fcd       vgname;                /* output */
  350. #endif
  351.  
  352. {
  353.     return( (intf) Vinquire(*vg, (int32 *)nentries, vgname) );
  354. } /* VINQC */
  355.  
  356.  
  357. /* ------------------------------------------------------------------ */
  358. /* 
  359. **  gets the id of the next vgroup in the file
  360. **  related: Vgetid--vgidc--VFGID
  361. */
  362.  
  363.     FRETVAL(intf)
  364. #ifdef PROTOTYPE
  365. nvgidc(HFILEID *f, intf *vgid)
  366. #else
  367. nvgidc(f,vgid)
  368.     HFILEID     *f;
  369.     intf        *vgid;
  370. #endif
  371. {
  372.     return( (intf) Vgetid (*f, *vgid) );
  373. }
  374.  
  375. /* ------------------------------------------------------------------ */
  376. /* 
  377. **  gets the id of the next entry in the vgroup
  378. **  related: Vgetnext--vgnxtc--VFGNXT
  379. */
  380.  
  381.     FRETVAL(intf)
  382. #ifdef PROTOTYPE
  383. nvgnxtc(VGROUP **vg, intf *id)
  384. #else
  385. nvgnxtc(vg,id)
  386.     VGROUP  **vg;
  387.     intf    *id;
  388. #endif
  389. {
  390.     return( Vgetnext(*vg, *id) );
  391. }
  392.  
  393. /* ------------------------------------------------------------------ */
  394. /* 
  395. **  sets the name of the vgroup
  396. **  related: Vsetname--vsnamc--VFSNAM
  397. */
  398.  
  399.     FRETVAL(void)
  400. #ifdef PROTOTYPE
  401. nvsnamc(VGROUP **vg, _fcd vgname, intf *vgnamelen)
  402. #else
  403. nvsnamc(vg, vgname, vgnamelen)
  404.     VGROUP  **vg;
  405.     _fcd    vgname;
  406.     intf    *vgnamelen;
  407. #endif
  408. {
  409.     char *name;
  410.  
  411.     name = HDf2cstring (vgname, (intn)*vgnamelen);
  412.     /* trimendblanks(name); */
  413.     Vsetname (*vg, name);
  414.     HDfreespace (name);
  415. }
  416.  
  417. /* ------------------------------------------------------------------ */
  418. /* 
  419. **  sets the class name of the vgroup
  420. **  related: Vsetclass--vsclsc--VFSCLS
  421. */
  422.  
  423.     FRETVAL(void)
  424. #ifdef PROTOTYPE
  425. nvsclsc(VGROUP **vg, _fcd vgclass, intf *vgclasslen)
  426. #else
  427. nvsclsc(vg, vgclass, vgclasslen)
  428.     VGROUP  **vg;
  429.     _fcd    vgclass;
  430.     intf    *vgclasslen;
  431. #endif
  432. {
  433.     char *class;
  434.  
  435.     class = HDf2cstring (vgclass, (intn)*vgclasslen);
  436.     /* trimendblanks(class); */
  437.     Vsetclass (*vg, class);
  438.     HDfreespace(class);
  439. }
  440.  
  441. /* ------------------------------------------------------------------ */
  442. /* 
  443. **  inserts a vset object (ie a vgroup or vdata ptr) into the given vgroup
  444. **  related: Vinsert--vinsrtc--VFINSRT
  445. */
  446.  
  447.     FRETVAL(intf)
  448. #ifdef PROTOTYPE
  449. nvinsrtc(VGROUP **vg, intf **vobjptr)
  450. #else
  451. nvinsrtc(vg, vobjptr)
  452.     VGROUP  **vg;
  453.     intf    **vobjptr;
  454. #endif
  455. {
  456.     return( (intf) Vinsert(*vg, (VDATA *)*vobjptr) );
  457. }
  458.  
  459. /* ------------------------------------------------------------------ */
  460. /* 
  461. **  tests if a vset object (having id id) in a vgroup refers to a vgroup
  462. **  related: Visvg--visvgc--VFISVG
  463. */
  464.  
  465.     FRETVAL(intf)
  466. #ifdef PROTOTYPE
  467. nvisvgc(VGROUP **vg, intf *id)
  468. #else
  469. nvisvgc(vg, id)
  470.  
  471.     VGROUP    **vg;
  472.     intf    *id;
  473. #endif
  474. {
  475.     return( (intf) Visvg(*vg, *id) );
  476. }
  477.  
  478. /* ------------------------------------------------------------------ */
  479. /* 
  480. **  tests if an id in a vgroup refers to a vdata
  481. **  related: Visvs--visvsc--VFISVS
  482. */
  483.  
  484.     FRETVAL(intf)
  485. #ifdef PROTOTYPE
  486. nvisvsc(VGROUP **vg, intf *id)
  487. #else
  488. nvisvsc(vg, id)
  489.     VGROUP  **vg;
  490.     intf    *id;
  491. #endif
  492. {
  493.     return( (intf) Visvs(*vg, *id) );
  494. }
  495.  
  496. /* ================================================== */
  497. /*  VDATA routines                                    */
  498. /* ================================================== */
  499.  
  500. /* 
  501. **  attach to a vdata and returns its ptr
  502. **  related: VSattach--vsatchc--VFATCH
  503. */
  504.  
  505.     FRETVAL(intf *)
  506. #ifdef PROTOTYPE
  507. nvsatchc(HFILEID *f, intf *vsid, _fcd accesstype)
  508. #else
  509. nvsatchc(f, vsid, accesstype)
  510.     HFILEID     *f;
  511.     intf        *vsid;
  512.     _fcd        accesstype;
  513. #endif
  514. {
  515.     VDATA *vs;
  516.     char     *acc;
  517.  
  518.     acc = HDf2cstring (accesstype, 1); /* 'r' or 'w' only */
  519.     vs =  (VDATA*) VSattach(*f, *vsid, acc);
  520.     HDfreespace(acc);
  521.     if ( vs == NULL)
  522.         return((intf *) -1);
  523.     else 
  524.         return((intf *) vs);
  525. }
  526.  
  527. /* ------------------------------------------------------------------ */
  528. /*  
  529. **  detach from a vdata
  530. **  related: VSdetach--vsdtchc--VFDTCH
  531. */
  532.  
  533.     FRETVAL(void)
  534. #ifdef PROTOTYPE
  535. nvsdtchc(VDATA **vs)
  536. #else
  537. nvsdtchc(vs)
  538.     VDATA   **vs;
  539. #endif
  540. {
  541.     VSdetach (*vs);
  542. }
  543.  
  544. /* ------------------------------------------------------------------ */
  545. /* 
  546. **  seeks to a given element position in a vadata
  547. **  related: VSseek--vsseekc--VSFSEEK
  548. */
  549.  
  550.     FRETVAL(intf)
  551. #ifdef PROTOTYPE
  552. nvsseekc(VDATA **vs, intf *eltpos)
  553. #else
  554. nvsseekc(vs, eltpos)
  555.     VDATA   **vs;
  556.     intf    *eltpos;
  557. #endif
  558. {
  559.     return( (intf) VSseek(*vs, *eltpos) );
  560. }
  561.  
  562. /* ------------------------------------------------------------------ */
  563. /* 
  564. **  gets the name of a vdata
  565. **  related: VSgetname--vsgnamc--VSFGNAM
  566. */
  567.  
  568.     FRETVAL(void)
  569. #ifdef PROTOTYPE
  570. nvsgnamc(VDATA **vs, _fcd vsname)
  571. #else
  572. nvsgnamc(vs, vsname)
  573.     VDATA   **vs;
  574.     _fcd         vsname;
  575. #endif
  576.  
  577. {
  578.     VSgetname (*vs, vsname);
  579. }    /* VSGNAMC */
  580.  
  581. /* ------------------------------------------------------------------ */
  582. /* 
  583. **  get the class name of a vdata
  584. **  related: VSgetclass--vsgclsc--VSFGCLS
  585. */
  586.  
  587.     FRETVAL(void)
  588. #ifdef PROTOTYPE
  589. nvsgclsc(VDATA **vs, _fcd vsclass)
  590. #else
  591. nvsgclsc(vs, vsclass)
  592.     VDATA   **vs;
  593.     _fcd    vsclass;                    /* output */
  594. #endif
  595. {
  596.     VSgetclass(*vs, vsclass);
  597. }    /* VSGCLSC */
  598.  
  599. /* ------------------------------------------------------------------ */
  600. /*
  601. **  general inquiry on a vdata
  602. **  related: VSinquire--vsinqc--VSFINQ
  603. */
  604.  
  605.     FRETVAL(intf)
  606. #ifdef PROTOTYPE
  607. nvsinqc(VDATA **vs, intf *nelt ,intf *interlace, _fcd fields, intf *eltsize,
  608.     _fcd vsname)
  609. #else
  610. nvsinqc(vs, nelt ,interlace, fields, eltsize, vsname)
  611.     VDATA   **vs;
  612.     intf    *nelt, *interlace, *eltsize;            /* outputs */
  613.     _fcd      fields, vsname;                            /* outputs */
  614. #endif
  615. {
  616.     return( (intf) VSinquire (*vs, (int32 *)nelt, (int32 *)interlace, 
  617.             fields, (int32 *)eltsize, vsname) );
  618. }     /* VSINQC */
  619.  
  620.  
  621. /* ------------------------------------------------------------------ */
  622. /* 
  623. **  tests if given fields exist in the vdata
  624. **  related: VSfexist--vsfexc--VSFEX
  625. */
  626.  
  627.     FRETVAL(intf)
  628. #ifdef PROTOTYPE
  629. nvsfexc(VDATA **vs, _fcd fields, intf *fieldslen)
  630. #else
  631. nvsfexc(vs, fields, fieldslen)
  632.     VDATA   **vs;
  633.     _fcd    fields;
  634.     intf    *fieldslen;
  635. #endif
  636. {
  637.     intf    stat;
  638.     char        *flds;
  639.  
  640.     flds = HDf2cstring (fields, (intn)*fieldslen );
  641.     /* trimendblanks(flds); */
  642.     stat =  (int32) VSfexist(*vs, flds);
  643.     HDfreespace(flds);
  644.  
  645.     return (stat);
  646. }
  647.  
  648. /* ------------------------------------------------------------------ */
  649. /* 
  650. **  gets the id of the next vdata from the file
  651. **  related: VSgetid--vsgidc--VSFGID
  652. */
  653.  
  654.     FRETVAL(intf)
  655. #ifdef PROTOTYPE
  656. nvsgidc(HFILEID *f, intf *vsid)
  657. #else
  658. nvsgidc(f, vsid)
  659.     HFILEID *f;
  660.     intf    *vsid;
  661. #endif
  662. {
  663.     return( (intf) VSgetid(*f, *vsid) );
  664. }
  665.  
  666. /* ------------------------------------------------------------------ */
  667. /* 
  668. **  sets the name of a vdata
  669. **  related: VSsetname--vssnamc--VSFSNAM
  670. */
  671.  
  672.     FRETVAL(void)
  673. #ifdef PROTOTYPE
  674. nvssnamc(VDATA **vs, _fcd vsname,intf *vsnamelen)
  675. #else
  676. nvssnamc(vs, vsname, vsnamelen)
  677.     VDATA  **vs;
  678.     _fcd   vsname;
  679.     intf   *vsnamelen;
  680. #endif
  681. {
  682.     char   *name;
  683.  
  684.     name = HDf2cstring(vsname, (intn)*vsnamelen);
  685.     /* trimendblanks (name); */
  686.     VSsetname (*vs, name);
  687.     HDfreespace (name);
  688. }
  689.  
  690. /* ------------------------------------------------------------------ */
  691. /* 
  692. **  sets the class name of the vdata
  693. **  related: VSsetclass--vssclsc--VSFSCLS
  694. */
  695.  
  696.     FRETVAL(void)
  697. #ifdef PROTOTYPE
  698. nvssclsc(VDATA **vs, _fcd vsclass, intf *vsclasslen)
  699. #else
  700. nvssclsc(vs, vsclass, vsclasslen)
  701.     VDATA   **vs;
  702.     _fcd    vsclass;
  703.     intf    *vsclasslen;
  704. #endif
  705. {
  706.     char     *class;
  707.  
  708.     class = HDf2cstring (vsclass, (intn)*vsclasslen);
  709.     /* trimendblanks(class); */
  710.     VSsetclass (*vs, class);
  711.     HDfreespace(class);
  712. }
  713.  
  714. /* ------------------------------------------------------------------ */
  715. /* 
  716. **  sets the fields in a vdata for reading or writing
  717. **  related: VSsetfields--vssfldc--VSFSFLD
  718. */
  719.  
  720.     FRETVAL(intf)
  721. #ifdef PROTOTYPE
  722. nvssfldc(VDATA **vs, _fcd fields, intf *fieldslen)
  723. #else
  724. nvssfldc(vs,fields, fieldslen)
  725.     VDATA   **vs;
  726.     _fcd    fields;
  727.     intf    *fieldslen;
  728. #endif
  729. {
  730.     char     *flds;
  731.     intf    stat;
  732.  
  733.     flds = HDf2cstring (fields, (intn)*fieldslen);
  734.     /* trimendblanks(flds); */
  735.     stat =    (int32) VSsetfields (*vs, flds);
  736.     HDfreespace(flds);
  737.  
  738.     return(stat);
  739. }
  740.  
  741. /* ------------------------------------------------------------------ */
  742. /* 
  743. **  sets the file interlace of a vdata
  744. **  related: VSsetinterlace--vssintc--VSFSINT
  745. */
  746.  
  747.     FRETVAL(intf)
  748. #ifdef PROTOTYPE
  749. nvssintc(VDATA **vs, intf *interlace)
  750. #else
  751. nvssintc(vs, interlace)
  752.     VDATA   **vs;
  753.     intf    *interlace;
  754. #endif
  755. {
  756.     return( (intf) VSsetinterlace (*vs, *interlace) );
  757. }
  758.  
  759. /* ------------------------------------------------------------------ */
  760. /* 
  761. **  defines a new field to be used in the vdata
  762. **  related: VSfdefine--vsfdefc--VSFFDEF
  763. */
  764.  
  765.     FRETVAL(intf)
  766. #ifdef PROTOTYPE
  767. nvsfdefc(VDATA **vs, _fcd field, intf *localtype, intf *order, intf *fieldlen)
  768. #else
  769. nvsfdefc(vs, field, localtype, order, fieldlen)
  770.     VDATA   **vs;
  771.     _fcd    field;
  772.     intf    *localtype, *order;
  773.     intf    *fieldlen;
  774. #endif
  775. {
  776.     intf    stat;
  777.     char    *fld;
  778.  
  779.     fld  = HDf2cstring (field, (intn)*fieldlen);
  780.     /* trimendblanks(fld); */
  781.     stat =  (int32) VSfdefine(*vs, fld, *localtype, *order );
  782.     HDfreespace(fld);
  783.     return (stat);
  784. }
  785.  
  786. /* ------------------------------------------------------------------ */
  787. /* 
  788. **  reads from a vdata
  789. **  related: VSread--vsreadc--VSFREAD
  790. */
  791.  
  792.     FRETVAL(intf)
  793. #ifdef PROTOTYPE
  794. nvsreadc(VDATA **vs, BYTE *buf, intf *nelt, intf *interlace)
  795. #else
  796. nvsreadc(vs, buf, nelt, interlace)
  797.     VDATA       **vs;
  798.     BYTE        *buf;
  799.     intf        *nelt, *interlace;
  800. #endif
  801. {
  802.     return( (intf) VSread(*vs, buf, *nelt, *interlace) );
  803. }
  804.  
  805. /* ------------------------------------------------------------------ */
  806. /* 
  807. **  writes to a vdata
  808. **  related: VSwrite--vswritc--VSFWRIT
  809. */
  810.  
  811.     FRETVAL(intf)
  812. #ifdef PROTOTYPE
  813. nvswritc(VDATA **vs, BYTE *buf, intf *nelt, intf *interlace)
  814. #else
  815. nvswritc(vs, buf, nelt, interlace)
  816.     VDATA       **vs;
  817.     BYTE        *buf;
  818.     intf        *nelt, *interlace;
  819. #endif
  820. {
  821.     return( (intf) VSwrite(*vs, buf, *nelt, *interlace) );
  822. }
  823.  
  824. /* ======================================== */
  825. /* miscellaneous VDATA inquiry routines */
  826. /* ======================================== */
  827. /* undocumented */
  828.  
  829. /* ------------------------------------------------------------------ */
  830. /* 
  831. **  gets the interlace of the vdata
  832. **  related: VSgetinterlace--vsgintc--VSFGINT
  833. */
  834.  
  835.     FRETVAL(intf)
  836. #ifdef PROTOTYPE
  837. nvsgintc(VDATA **vs)
  838. #else
  839. nvsgintc(vs)
  840.     VDATA       **vs;
  841. #endif
  842. {
  843.     return( (intf) VSgetinterlace(*vs) );
  844. }
  845.  
  846. /* ------------------------------------------------------------------ */
  847. /* 
  848. **  gets the number of elements in the vdata
  849. **  related: VSelts--vseltsc--VSFELTS
  850. */
  851.  
  852.     FRETVAL(intf)
  853. #ifdef PROTOTYPE
  854. nvseltsc(VDATA **vs)
  855. #else
  856. nvseltsc(vs)
  857.     VDATA       **vs;
  858. #endif
  859. {
  860.     return( (intf) VSelts (*vs) );
  861. }
  862.  
  863. /* ------------------------------------------------------------------ */
  864. /* 
  865. **  gets the fields in the vdata
  866. **  related: VSgetfields--vsgfldc--VSFGFLD
  867. */
  868.  
  869.     FRETVAL(intf)
  870. #ifdef PROTOTYPE
  871. nvsgfldc(VDATA **vs, _fcd fields)
  872. #else
  873. nvsgfldc(vs, fields)
  874.     VDATA   **vs;
  875.     _fcd      fields;            /* output */
  876. #endif
  877. {
  878.     return ( (intf) VSgetfields (*vs, fields) );
  879. }   /* VSGFLDC */
  880.  
  881. /* ------------------------------------------------------------------ */
  882. /* 
  883. **  determines the (machine) size of the given fields
  884. **  related: VSsizeof--vssizc--VSFSIZ
  885. */
  886.  
  887.     FRETVAL(intf)
  888. #ifdef PROTOTYPE
  889. nvssizc(VDATA **vs, _fcd fields, intf *fieldslen)
  890. #else
  891. nvssizc(vs, fields, fieldslen)
  892.     VDATA   **vs;
  893.     _fcd    fields;
  894.     intf    *fieldslen;
  895. #endif
  896. {
  897.     char     *flds;
  898.     intf    stat;
  899.  
  900.     flds = HDf2cstring (fields, (intn)*fieldslen);
  901.     /* trimendblanks(flds); */
  902.     stat =  VSsizeof(*vs, flds);
  903.     HDfreespace(flds);
  904.     return (stat);
  905. }
  906.  
  907. /* ------------------------------------------------------------------ */
  908. /*
  909. **  determines the no of entries in a vgroup
  910. **  related: Ventries--ventsc--VFENTS
  911. */
  912.  
  913.     FRETVAL(intf)
  914. #ifdef PROTOTYPE
  915. nventsc(HFILEID *f,intf *vgid)
  916. #else
  917. nventsc(f,vgid)
  918.     HFILEID *f;
  919.     intf    *vgid;
  920. #endif
  921. {
  922.     return( (intf) Ventries (*f,*vgid) );
  923. }
  924.  
  925. /* ======================================================= */
  926. /* DEBUGGING ROUTINES                                      */
  927. /* ======================================================= */
  928. /*
  929. **  enable debug
  930. **  related: setjj--setjjc--SETFJJ
  931. */
  932.  
  933.     FRETVAL(void)
  934. #ifdef PROTOTYPE
  935. nsetjjc(void)
  936. #else
  937. nsetjjc()
  938. #endif
  939. {
  940.     setjj(); 
  941. }
  942.  
  943. /* ------------------------------------------------------------------ */
  944. /*
  945. **  disable debug
  946. **  related: setnojj--setnojjc--SETFNJJ
  947. */
  948.  
  949.     FRETVAL(void)
  950. #ifdef PROTOTYPE
  951. nsetnojjc(void)
  952. #else
  953. nsetnojjc()
  954. #endif
  955. {
  956.     setnojj(); 
  957. }
  958.  
  959. /* ------------------------------------------------------------------ */
  960. /* 
  961. **  gets the refs of all lone vgroups in the file
  962. **  related: Vlone--vlonec--VFLONE
  963. */
  964.  
  965.     FRETVAL(intf)
  966. #ifdef PROTOTYPE
  967. nvlonec(HFILEID *f, intf **idarray, intf *asize)
  968. #else
  969. nvlonec(f, idarray, asize)
  970.     HFILEID     *f;
  971.     intf    **idarray;          /* output -- an integer array */
  972.     intf    *asize;
  973. #endif
  974. {
  975.     return( (intf) Vlone( *f, (int32 *)*idarray, (int32)*asize) );
  976. }
  977.  
  978. /* ------------------------------------------------------------------ */
  979. /*
  980. **  gets the refs of all lone vdatas in the file
  981. **  related: VSlone--vslonec--VSFLONE
  982. */
  983.  
  984.     FRETVAL(intf)
  985. #ifdef PROTOTYPE
  986. nvslonec(HFILEID *f, intf **idarray, intf *asize)
  987. #else
  988. nvslonec(f, idarray, asize)
  989.     HFILEID     *f;
  990.     intf    **idarray;      /* output -- an integer array */
  991.     intf    *asize;
  992. #endif
  993. {
  994.     return( VSlone( *f, (int32 *)*idarray, (int32)*asize) );
  995. }
  996.  
  997. /*
  998. ** ==================================================================
  999. ** HIGH-LEVEL VSET ROUTINES --- VHxxxxx()
  1000. ** ==================================================================
  1001. */
  1002.  
  1003. /*
  1004. **  store a simple dataset in a vdata 
  1005. **  related: VHstoredata--vhsdc--vhfsd
  1006. */
  1007.  
  1008.     FRETVAL(intf)
  1009. #ifdef PROTOTYPE
  1010. nvhsdc(HFILEID *f, _fcd field, BYTE *buf, intf *n, intf *datatype, _fcd vsname,
  1011.     _fcd vsclass, intf *fieldlen, intf *vsnamelen, intf *vsclasslen)
  1012. #else
  1013. nvhsdc(f, field, buf, n, datatype, vsname, vsclass, fieldlen, vsnamelen,
  1014.         vsclasslen)
  1015.     HFILEID     *f;
  1016.     _fcd       field, vsname, vsclass;
  1017.     intf    *n, *datatype;
  1018.     BYTE    *buf;
  1019.     intf    *fieldlen, *vsnamelen, *vsclasslen;
  1020. #endif
  1021. {
  1022.     char *fld, *name, *class;
  1023.  
  1024.     fld = HDf2cstring(field, *fieldlen);
  1025.     name = HDf2cstring(vsname, *vsnamelen);
  1026.     class = HDf2cstring(vsclass, *vsclasslen);
  1027.  
  1028.     return( (intf) VHstoredata (*f, fld, buf, *n, *datatype,
  1029.                  name, class));
  1030. }
  1031.  
  1032. /* ------------------------------------------------------------------ */
  1033. /*
  1034. **  store an aggregate dataset in a vdata
  1035. **  related: VHstoredatam--vhsdmc--vhfsdm
  1036. */
  1037.  
  1038.     FRETVAL(intf)
  1039. #ifdef PROTOTYPE
  1040. nvhsdmc(HFILEID *f, _fcd field, BYTE *buf, intf *n, intf *datatype,
  1041.         _fcd vsname, _fcd vsclass, intf *order, intf *fieldlen,
  1042.         intf *vsnamelen, intf *vsclasslen)
  1043. #else
  1044. nvhsdmc(f, field, buf, n, datatype, vsname, vsclass, order,
  1045.            fieldlen, vsnamelen, vsclasslen)
  1046.  
  1047.     HFILEID    *f;
  1048.     _fcd      field, vsname, vsclass;
  1049.     intf    *n, *datatype, *order;
  1050.     BYTE    *buf;
  1051.     intf    *fieldlen, *vsnamelen, *vsclasslen;
  1052. #endif
  1053. {
  1054.     char *fld, *name, *class;
  1055.  
  1056.     fld = HDf2cstring(field, *fieldlen);
  1057.     name = HDf2cstring(vsname, *vsnamelen);
  1058.     class = HDf2cstring(vsclass, *vsclasslen);
  1059.  
  1060.     return( (intf) VHstoredatam (*f, fld , buf, *n,
  1061.       *datatype, name, class, *order));
  1062. }
  1063.  
  1064. /* ------------------------------------------------------------------ */
  1065. /*
  1066. **  make a new vgroup given several tag/ref pairs 
  1067. **  related: VHmakegroup--vhmkgpc--vhfmkgp
  1068. */
  1069.  
  1070.     FRETVAL(intf)
  1071. #ifdef PROTOTYPE
  1072. nvhmkgpc(HFILEID *f, intf *tagarray, intf *refarray, intf *n, _fcd vgname,
  1073.     _fcd vgclass, intf *vgnamelen, intf *vgclasslen)
  1074. #else
  1075. nvhmkgpc(f, tagarray, refarray , n, vgname, vgclass, vgnamelen, vgclasslen)
  1076.     HFILEID *f;
  1077.     _fcd       vgname, vgclass;
  1078.     intf    *n, *tagarray, *refarray;
  1079.     intf    *vgnamelen, *vgclasslen;
  1080. #endif
  1081. {
  1082.     char *gname, *gclass;
  1083.  
  1084.     gname = HDf2cstring(vgname, *vgnamelen);
  1085.     gclass = HDf2cstring(vgclass, *vgclasslen);
  1086.  
  1087.     return( (intf) VHmakegroup (*f, (int32 *)tagarray, (int32 *)refarray, 
  1088.             *n, gname, gclass));
  1089. }
  1090.  
  1091. /* ================================================================== */
  1092. /*
  1093. **  locate a field in a vdata that belongs to this VGROUP
  1094. **  related: Vflocate--vffloc--vflocc
  1095. */
  1096.  
  1097.     FRETVAL(intf)
  1098. #ifdef PROTOTYPE
  1099. nvflocc(VGROUP **vg, _fcd field, intf *fieldlen)
  1100. #else
  1101. nvflocc(vg, field, fieldlen)
  1102.     VGROUP  **vg;
  1103.     _fcd       field;
  1104.     intf    *fieldlen;
  1105. #endif
  1106. {
  1107.     char  *fld;
  1108.     intf  stat;
  1109.  
  1110.     fld = HDf2cstring (field, (intn)*fieldlen);
  1111.     /* trimendblanks(fld); */
  1112.     stat = (int32) Vflocate (*vg, fld);
  1113.     HDfreespace(fld);
  1114.  
  1115.     return(stat);
  1116. }
  1117.  
  1118. /* ------------------------------------------------------------------ */
  1119. /* 
  1120. **  tests if a tag/ref pair is in a vgroup.
  1121. **  related: Vinqtagref--vinqtrc--vfinqtr
  1122. */
  1123.  
  1124.     FRETVAL(intf)
  1125. #ifdef PROTOTYPE
  1126. nvinqtrc(VGROUP **vg, intf *tag, intf *ref)
  1127. #else
  1128. nvinqtrc(vg, tag, ref)
  1129.     VGROUP  **vg;
  1130.     intf    *tag, *ref;
  1131. #endif
  1132. {
  1133.     return ( (intf) Vinqtagref ( *vg, *tag, *ref) );
  1134. }
  1135. /* ------------------------------------------------------------------ */
  1136. /* 
  1137. **  gets the number of tag/refs stored in a vgroup
  1138. **  related: Vntagrefs--vntrc--VFNTR
  1139. */
  1140.  
  1141.     FRETVAL(intf)
  1142. #ifdef PROTOTYPE
  1143. nvntrc(VGROUP **vg)
  1144. #else
  1145. nvntrc(vg)
  1146.     VGROUP  **vg;
  1147. #endif
  1148. {
  1149.     return ( (intf) Vntagrefs (*vg) );
  1150. }
  1151. /* ------------------------------------------------------------------ */
  1152.  
  1153. /*
  1154. **  returns all the tag/ref pairs in a vgroup 
  1155. **  related: Vgettagrefs--vgttrsc--vfgttrs
  1156. */
  1157.  
  1158.     FRETVAL(intf)
  1159. #ifdef PROTOTYPE
  1160. nvgttrsc(VGROUP **vg, intf *tagarray, intf *refarray, intf *n)
  1161. #else
  1162. nvgttrsc(vg, tagarray, refarray, n)
  1163.     VGROUP  **vg;
  1164.     intf    *tagarray, *refarray;       /* outputs - integer arrays */
  1165.     intf    *n;
  1166. #endif
  1167. {
  1168.     return ((intf)Vgettagrefs (*vg, (int32 *)tagarray, (int32 *)refarray, *n) );
  1169. }
  1170.  
  1171. /* ------------------------------------------------------------------ */
  1172. /*
  1173. **  returns a specified tag/ref pair in a vgroup 
  1174. **  related: Vgettagref--vgttrc--vfgttr
  1175. */
  1176.  
  1177.     FRETVAL(intf)
  1178. #ifdef PROTOTYPE
  1179. nvgttrc(VGROUP **vg, intf *which, intf *tag, intf *ref)
  1180. #else
  1181. nvgttrc(vg, which, tag, ref)
  1182.     VGROUP  **vg;
  1183.     intf    *which;
  1184.     intf    *tag, *ref;                     /* outputs */
  1185. #endif
  1186. {
  1187.     return ( (intf) Vgettagref (*vg, *which, (int32 *)tag, (int32 *)ref) );
  1188. }
  1189. /* ------------------------------------------------------------------ */
  1190.  
  1191. /*
  1192. **  add a tag/ref pair to a vgroup 
  1193. **  related: Vaddtagref--vadtrc--VFADTR 
  1194. */
  1195.  
  1196.     FRETVAL(intf)
  1197. #ifdef PROTOTYPE
  1198. nvadtrc(VGROUP **vg, intf *tag, intf *ref)
  1199. #else
  1200. nvadtrc(vg, tag, ref)
  1201.     VGROUP  **vg;
  1202.     intf   *tag, *ref;
  1203. #endif
  1204. {
  1205.     return ( (intf) Vaddtagref ( *vg, *tag, *ref) );
  1206. }
  1207.  
  1208. /* ------------------------------------------------------------------ */
  1209.  
  1210.