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