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