home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / procssng / compstol / cmpsttl1.lha / CompositeTool / v1.1.dist / HDF / dfgroup.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-08  |  10.2 KB  |  337 lines
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF version 3.00
  4. *                December, 1989
  5. *
  6. * NCSA HDF Version 3.00 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. /*-----------------------------------------------------------------------------
  22.  * File:    dfgroup.c
  23.  * Purpose: Low level functions for implementing groups
  24.  * Invokes: df.c df.h
  25.  * Contents: 
  26.  *  DFdiread: read in the data identifier list from the group
  27.  *  DFdiget: get next data identifier from list
  28.  *  DFdisetup: get ready to store a list of data identifiers to write out
  29.  *  DFdiput: add a data identifier to the list to be written out
  30.  *  DFdiwrite: write out the list of data identifiers
  31.  *  DFDIputgroup: write out a group (array of tag/refs)
  32.  *  DFDIgetgroup: read in a group (array of tag/refs)
  33.  * Remarks: A group is a way of associating data elements with each other.
  34.  *          It is a tag whose data is a list of tag/refs
  35.  *          Each tag/ref combination is called a data identifier (DI).
  36.  *---------------------------------------------------------------------------*/
  37.  
  38.  
  39. #include "df.h"
  40.  
  41.  
  42. static DFdi *Dilist=NULL;    /* list of tag/refs constituting group */
  43. static int Dinlist;             /* no of tag/refs in list */
  44. static int Ndi;                 /* current position in list */
  45.  
  46. /*-----------------------------------------------------------------------------
  47.  * Name:    DFdiread
  48.  * Purpose: Read a list of DIs into memory
  49.  * Inputs:  dfile: HDF file pointer
  50.  *          tag, ref: id of group which is to be read in
  51.  * Returns: 0 on success, -1 on failure with DFerror set
  52.  * Users:   HDF systems programmers, DF8getrig, other routines
  53.  * Invokes: DFIcheck, DFIfind, DFgetelement
  54.  * Remarks: assumes tag is a group
  55.  *---------------------------------------------------------------------------*/
  56.  
  57. int DFdiread(dfile, tag, ref)
  58. DF *dfile;
  59. uint16 tag, ref;        /* tag, ref of group */
  60. {
  61.     DFdle *dlep;
  62.     int cdd;
  63.     int32 length;
  64.  
  65.     if (DFIcheck(dfile))
  66.         return(-1);
  67.  
  68.     /* find group */
  69.     if (DFIfind(dfile, tag, ref, 1, 0, 0, &dlep, &cdd) <0) {
  70.         DFerror = DFE_NOMATCH;
  71.         return(-1);
  72.     }
  73.  
  74.     /* get space for group */
  75.     length = dlep->dd[cdd].length;
  76.     if (Dilist) DFIfreespace((char*)Dilist); /* ensure earlier allocs freed */
  77.     Dilist = (DFdi *) DFIgetspace((unsigned)length);
  78.     if (!Dilist) {
  79.         DFerror = DFE_NOSPACE;
  80.         return(-1);
  81.     }
  82.  
  83.     Dinlist = length / 4;    /* 4==sizeof DFdi */
  84.     Ndi = 0;            /* no DIs returned so far */
  85.  
  86.     /* read in group */
  87.     if (DFgetelement(dfile, tag, ref, (char*) Dilist)<0) {
  88.         DFIfreespace((char*)Dilist);
  89.         Dilist = NULL;        /* flag value */
  90.         return(-1);
  91.     }
  92.     return(0);
  93. }
  94.  
  95. /*-----------------------------------------------------------------------------
  96.  * Name:    DFdiget
  97.  * Purpose: reaturn next DI from list
  98.  * Inputs:  di: space to return DI
  99.  * Returns: 0 on success, -1 on failure with DFerror set
  100.  * Users:   HDF systems programmers, DF8getrig, other routines
  101.  * Invokes: none
  102.  * Remarks: frees Dilist space when all DIs returned
  103.  *---------------------------------------------------------------------------*/
  104.  
  105. int DFdiget(di)
  106. DFdi *di;
  107. {
  108.     if (Ndi>=Dinlist)
  109.     return(-1);
  110.  
  111. #ifdef DF_STRUCTOK
  112.     *di = Dilist[Ndi++];    /* return next DI on list */
  113. #else /*DF_STRUCTOK*/
  114.     {
  115.         register char *p;
  116.     /* compute address of Ndi'th di */
  117.         p = (char *) Dilist + 4 * Ndi++;
  118.         UINT16READ(p, di->tag);
  119.         UINT16READ(p, di->ref);
  120.     }
  121. #endif /*DF_STRUCTOK*/
  122.     
  123.     if (Ndi==Dinlist) {
  124.         DFIfreespace((char*)Dilist); /* if all returned, free storage */
  125.         Dilist = NULL;        /* flag value */
  126.     }
  127.     return(0);
  128. }
  129.  
  130.  
  131. /*-----------------------------------------------------------------------------
  132.  * Name:    DFdisetup
  133.  * Purpose: setup space for storing a list of DIs to be written out
  134.  * Inputs:  maxsize: maximum number of DIs expected in the list
  135.  * Returns: 0 on success, -1 on failure with DFerror set
  136.  * Users:   HDF systems programmers, DF8putrig, other routines
  137.  * Invokes: none
  138.  * Remarks: This call should go away sometime.  Need better way to allocate
  139.  *          space, possibly just use a big block of static space
  140.  *---------------------------------------------------------------------------*/
  141.  
  142. int DFdisetup(maxsize)
  143. int maxsize;
  144. {
  145.     if (Dilist) DFIfreespace((char*)Dilist);
  146.     Dilist = (DFdi *) DFIgetspace((unsigned)(maxsize * 4));
  147.                 /* 4==sizeof(DFdi) */
  148.     if (!Dilist) {
  149.         DFerror = DFE_NOSPACE;
  150.         return(-1);
  151.     }
  152.     Dinlist = maxsize;        /* maximum size of list */
  153.     Ndi = 0;                    /* current size of list */
  154.     return(0);
  155. }
  156.  
  157. /*-----------------------------------------------------------------------------
  158.  * Name:    DFdiput
  159.  * Purpose: add a DI to the list to be written out
  160.  * Inputs:  tag, ref: DI to add
  161.  * Returns: 0 on success, -1 on failure with DFerror set
  162.  * Users:   HDF systems programmers, DF8putrig, other routines
  163.  * Invokes: none
  164.  * Remarks: arg is tag/ref rather than DI for convenience
  165.  *---------------------------------------------------------------------------*/
  166.  
  167. int DFdiput(tag, ref)
  168. uint16 tag, ref;
  169. {
  170.     register char *p;
  171.  
  172.     if (Ndi>=Dinlist) {
  173.         DFerror = DFE_NOTENOUGH;
  174.         return(-1);
  175.     }
  176.  
  177. #ifdef DF_STRUCTOK
  178.     Dilist[Ndi].tag = tag;
  179.     Dilist[Ndi++].ref = ref;
  180. #else /*DF_STRUCTOK*/
  181.     /* compute address of Ndi'th di to put tag/ref in */
  182.     p = (char *) Dilist + 4 * Ndi++;
  183.     UINT16WRITE(p, tag);
  184.     UINT16WRITE(p, ref);
  185. #endif /*DF_STRUCTOK*/
  186.  
  187.     return(0);
  188. }
  189.  
  190. /*-----------------------------------------------------------------------------
  191.  * Name:    DFdiwrite
  192.  * Purpose: Write DI list out to HDF file
  193.  * Inputs:  dfile: HDF file pointer
  194.  *          tag, ref: tag and ref of group whose contents is the list
  195.  * Returns: 0 on success, -1 on failure with DFerror set
  196.  * Users:   HDF systems programmers, DF8putrig, other routines
  197.  * Invokes: none
  198.  * Remarks: frees storage for Dilist
  199.  *---------------------------------------------------------------------------*/
  200.  
  201. int DFdiwrite(dfile, tag, ref)
  202. DF *dfile;
  203. uint16 tag, ref;
  204. {
  205.     int ret;            /* return value */
  206.  
  207.     if (DFIcheck(dfile))
  208.         return(-1);
  209.  
  210.     ret = DFputelement(dfile, tag, ref, (char*)Dilist,(int32)Ndi*4);
  211.                 /* 4==sizeof(DFdi) */
  212.     DFIfreespace((char*)Dilist);
  213.     Dilist = NULL;        /* flag value */
  214.     Dinlist = Ndi = 0;
  215.     return(ret);
  216. }
  217.  
  218. /*-----------------------------------------------------------------------------
  219.  * Name:    DFDIgetgroup
  220.  * Purpose: Read array of tag/refs from file
  221.  * Inputs:  filename: name of HDF file to read from
  222.  *          diarray: array to put tag/refs in
  223.  *          maxdis: maximum number of DIs that may be returned
  224.  *          groupdi: tag/ref of group to read
  225.  * Returns: number of DIs read on success, -1 on failure with DFerror set
  226.  * Users:   HDF systems programmers, other routines
  227.  * Invokes: none
  228.  * Remarks: none
  229.  *---------------------------------------------------------------------------*/
  230.  
  231. int DFDIgetgroup(filename, diarray, maxdis, groupdi)
  232. char *filename;
  233. int maxdis;
  234.  DFdi diarray[], *groupdi;
  235. {
  236.     DF *dfile;
  237.     int cdd, ret;
  238.     DFdle *dlep;
  239.     
  240.     DFerror = DFE_NOERROR;
  241.  
  242.     if (!filename[0]) {
  243.         DFerror = DFE_BADPTR;
  244.         return(-1);
  245.     }
  246.  
  247.     dfile = DFopen(filename, DFACC_ALL, -1);
  248.     if (dfile==NULL) return(-1);
  249.  
  250.     if (DFIfind(dfile, groupdi->tag, groupdi->ref, 1, 0, 0, &dlep, &cdd)<0)
  251.         return(DFIerr(dfile));
  252.  
  253.     if (DFaccess(dfile, groupdi->tag, groupdi->ref, "r")<0)
  254.         return(DFIerr(dfile));
  255.  
  256.     ret = dlep->dd[cdd].length / 4; /* 4==sizeof(DFdi) */
  257.     if (maxdis < ret) ret = maxdis;
  258.  
  259. #ifdef DF_STRUCTOK
  260.     if (DFread(dfile, diarray, (int32) (ret * sizeof( DFdi)))<0)
  261.         return(DFIerr(dfile));
  262. #else /*DF_STRUCTOK*/
  263.     {
  264.         int i;
  265.         char *p;
  266.  
  267.         p = (char *) DFtbuf;
  268.         if (DFread(dfile, p, (int32) ret*4)<0)
  269.             return(DFIerr(dfile));
  270.  
  271.         for (i=0; i<ret; i++) {
  272.             UINT16READ(p, diarray[i].tag);
  273.             UINT16READ(p, diarray[i].ref);
  274.         }
  275.     }
  276. #endif /*DF_STRUCTOK*/
  277.     
  278.     if (ret<maxdis) {
  279.         DFerror = DFE_NOTENOUGH;
  280.         return(DFIerr(dfile));
  281.     }
  282.     return(DFclose(dfile));
  283. }
  284.     
  285. /*-----------------------------------------------------------------------------
  286.  * Name:    DFDIputgroup
  287.  * Purpose: Write array of tag/refs to file
  288.  * Inputs:  filename: name of HDF file to write to
  289.  *          diarray: array of tag/refs to write out
  290.  *          ndis: number of DIs in array
  291.  *          groupdi: tag/ref of group to write array as
  292.  * Returns: 0 on success, -1 on failure with DFerror set
  293.  * Users:   HDF systems programmers, other routines
  294.  * Invokes: none
  295.  * Remarks: The group is always appended to an existing file
  296.  *---------------------------------------------------------------------------*/
  297.  
  298. int DFDIputgroup(filename, diarray, ndis, groupdi)
  299. char *filename;
  300. int ndis;
  301. DFdi diarray[], *groupdi;
  302. {
  303.     DF *dfile;
  304.     int ret;
  305.     
  306.     DFerror = DFE_NOERROR;
  307.  
  308.     if (!filename[0]) {
  309.         DFerror = DFE_BADPTR;
  310.         return(-1);
  311.     }
  312.  
  313.     dfile = DFopen(filename, DFACC_ALL, -1);
  314.     if (dfile==NULL) return(-1);
  315.  
  316. #ifdef DF_STRUCTOK
  317.     ret = DFputelement(dfile, groupdi->tag, groupdi->ref, diarray,
  318.                (int32) (ndis * 4));
  319. #else /*DF_STRUCTOK*/
  320.     {
  321.         int i;
  322.         char *p;
  323.  
  324.         p = (char *) DFtbuf;
  325.         for (i=0; i<ndis; i++) {
  326.             UINT16WRITE(p, diarray[i].tag);
  327.             UINT16WRITE(p, diarray[i].ref);
  328.         }
  329.         ret = DFputelement(dfile, groupdi->tag, groupdi->ref, p,
  330.                (int32)ndis*sizeof(DFdi));
  331.     }
  332. #endif /*DF_STRUCTOK*/
  333.     
  334.     if (ret<0) return(DFIerr(dfile));
  335.     return(DFclose(dfile));
  336. }
  337.