home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / amiga / hdf / hdf.lha / DFSD.C < prev    next >
Encoding:
C/C++ Source or Header  |  1980-02-06  |  91.6 KB  |  2,784 lines
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF version 3.10r2
  4. *                July 1, 1990
  5. *
  6. * NCSA HDF Version 3.10r2 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.12 $"
  24. #endif
  25. /*
  26. $Header: /pita/work/HDF/dev/RCS/src/dfsd.c,v 3.12 90/09/20 11:04:32 clow beta $
  27. $Log:    dfsd.c,v $
  28.  * Revision 3.12  90/09/20  11:04:32  clow
  29.  * Changed DFSDIgetslice to call DFIseek and DFIread
  30.  * (internal routines without the overhead of checking)
  31.  * in lieu of DFseek and DFread in its loops.
  32.  * This shaves a little off the reading time.
  33.  * 
  34.  * Revision 3.11  90/08/31  12:41:58  clow
  35.  * fixed problems with the getslice routine so that
  36.  * it now reads in only as much as is needed;
  37.  * is smart about contigueous chunks;
  38.  * does the proper seek for all contigueous chunks.
  39.  * 
  40.  * Revision 3.10  90/07/11  09:48:25  clow
  41.  * Modified so that we could do inquiry after doing a getdata.
  42.  * 
  43.  * Revision 3.9  90/07/05  14:06:03  clow
  44.  * Fix bug where transposition is used in getslice
  45.  * 
  46.  * Revision 3.8  90/06/29  17:35:52  clow
  47.  * Fixed bug in DFSDIgetdata and DFSDreadref where the new sdg info is
  48.  * not read.
  49.  * 
  50.  * Revision 3.7  90/06/29  16:49:12  clow
  51.  * Added some spaces before the #pragma line so that the SGI's c compiler
  52.  * will not complain.  Sigh.
  53.  * 
  54.  * Revision 3.6  90/06/28  13:49:12  clow
  55.  * fix bug on DFSDIgetslice and DFSDputslice when the dimensions are collapse
  56.  * 
  57.  * Revision 3.5  90/06/21  10:39:45  clow
  58.  * Fixed bug in Iputslice which calculates the pointer to the data wrongly
  59.  * 
  60.  * Revision 3.4  90/06/13  16:17:38  clow
  61.  * added DFSDreadref that will set the ref of the next SD read in.
  62.  * 
  63.  * Revision 3.3  90/06/07  17:40:02  clow
  64.  * new, faster put/getslice routines done by john walder
  65.  * fixed bug in the getslice routine where the slice is from the
  66.  * wrong coordinates
  67.  * 
  68. */
  69. /*-----------------------------------------------------------------------------
  70.  File:  dfsd.c
  71.  
  72.  Purpose:
  73.     Routines for input and output of scientific data
  74.  
  75.  Invokes:
  76.     df.c dfgroup.c dfkit.c dfi.h df.h dfsd.h
  77.  
  78.  Public functions:
  79.     DFSDgetdims - get rank and dim sizes
  80.     DFSDgetdatastrs - get label, unit, format and coord system of data
  81.     DFSDgetdimstrs - get label, unit and format for a dimension
  82.     DFSDgetdimscale - get scale for a dimension
  83.     DFSDgetmaxmin - get max and min of data
  84.     DFSDgetdata - get data values
  85.     DFSDsetlengths - set lengths of label, unit, format strings on gets
  86.     DFSDsetdims - set rank and dim sizes
  87.     DFSDsetdatastrs - set data label, unit, format and coord system
  88.     DFSDsetdimstrs - set dim labels, units and formats
  89.     DFSDsetdimscale - set scale for a dimension
  90.     DFSDsetmaxmin - get max and min of data
  91.     DFSDputdata - output data, data info, and display info
  92.     DFSDrestart - forget info about last file accessed - restart from beginning
  93.     DFSDnumber - return number of SDGs in file
  94.     DFSDclear - forget all info set
  95.     DFSDlastref - get reference number of last SDG read or written
  96.     DFSDsettype - set output data type, m/c format, number type and array order
  97.     DFSDgetslice - get part of the data, specified as a slice
  98.     DFSDstartslice - set up to write SD
  99.     DFSDputslice - write specified number of data items to file
  100.     DFSDendslice - end of series of writes, write out SDG
  101.  
  102. Lower level functions:
  103.     DFSDgetsdg - read SDG into struct
  104.     DFSDputsdg - read SDG into struct
  105.  
  106. Private functions:
  107.     DFSDIopen - open or reopen file
  108.     DFSDIsdginfo - find next sdg in file
  109.     DFSDIclear - clear sdg data structure of all info
  110.     DFSDIgetdata - read data from file
  111.     DFSDIputdata - write data to file
  112.     DFSDIgetslice - get slice
  113.  
  114. Fortran stub functions:
  115.     dsisdas_ - set data label, unit, format and coord system
  116.     dsisdis_ - set dim labels, units and formats
  117.  
  118.  Remarks: 
  119.     An SDG stores actual data from scietific computations, which are
  120.       subsequently to be converted to images.
  121.     This version assumes that all the values are floating point.
  122.  *---------------------------------------------------------------------------*/
  123.  
  124.  
  125. #include "df.h"
  126. /* #include "dfconvert.h" */
  127.  
  128. #ifdef DF_CAPFNAMES
  129. #   define dsisdas_ DSISDAS
  130. #   define dsisdis_ DSISDIS
  131. #endif /* DF_CAPFNAMES */                                            
  132.  
  133. #define LABEL   0
  134. #define UNIT    1
  135. #define FORMAT  2
  136. #define COORDSYS 3
  137.  
  138. static DFSsdg Readsdg =        /* struct for reading */
  139. { {0, 0}, 0, NULL, NULL, { NULL, NULL, NULL },
  140.   { NULL, NULL, NULL }, NULL, 0.0, 0.0 },
  141.  
  142.     Writesdg =            /* struct for writing */
  143. { {0, 0}, 0, NULL, NULL, { NULL, NULL, NULL },
  144.   { NULL, NULL, NULL }, NULL, 0.0, 0.0 };
  145.  
  146. static  uint16  Writeref=0;    /* ref of next SDG to write to file */
  147. static int Newdata=(-1);    /* Values in Readsdg fresh? */
  148.                 /* -1 : no descriptor read */
  149.                 /* 1 : descriptor read */
  150. static int Nextsdg = 1;        /* Signal if DFSDgetdata should get the */
  151.                 /* next sdg */
  152. static DF *Sdfile=NULL;        /* pointer to file for slice writes */
  153. static int32  *Sddims;        /*dims written so far in slice write */
  154.  
  155. static struct {            /* Indicators of status (s) of info:    */
  156.     int dims;            /* s = -1: there is no info in this category */
  157.     int nt;            /* s = 0: info was set, but not yet written */
  158.     int coordsys;        /* s>0:info was set and written with ref no.s*/
  159.     int luf[3];
  160.     int scales;
  161.     int maxmin;
  162.     int transpose;
  163. } Ref = {  -1, -1, -1, { -1, -1, -1 }, -1, -1 , -1};
  164.     
  165. static int Maxstrlen[4] = { DFS_MAXLEN, DFS_MAXLEN, DFS_MAXLEN, DFS_MAXLEN };
  166. static int Ismaxmin = 0;    /* is there a max/min value on read? */
  167. static int FileTranspose = 0;    /* is the data in column major order? */
  168. static int Fortorder = 0;    /* should data be written col major? */
  169.  
  170. static int fileNT=DFNTF_IEEE,    /* default: all IEEE */
  171.            fileNTsize=4,    /* size of IEEE in bytes */
  172.            outNT=DFNTF_IEEE,    /* default output: IEEE */
  173.            outNTsize=4,        /* size of IEEE in bytes */
  174.            userNT=DFNTF_IEEE;    /* default */
  175. static int Readref = 0;
  176.  
  177. static char Lastfile[DF_MAXFNLEN] = "";    /* last file opened */
  178. static uint16 Lastref = 0;
  179.  
  180. /*-----------------------------------------------------------------------------
  181.  * Name:    DFSDgetdims
  182.  * Purpose: Get dimensions of data in next SDG
  183.  * Inputs:  filename: name of HDF file to use
  184.  *          prank: pointer to integer for returning rank (no of dimensions)
  185.  *          sizes: array of integers for returning size of each dimension
  186.  *          maxrank: size of array for returning dimensions
  187.  * Returns: 0 on success, -1 on failure with DFerror set
  188.  * Outputs: rank in prank, size of each dimension in sizes
  189.  *          If rank > maxrank, rank is set, and -1 is returned
  190.  * Users:   HDF users, utilities, other routines
  191.  * Invokes: DFSDIopen, DFIerr, DFclose, DFSDIsdginfo
  192.  * Method:  Opens file, calls DFSDIsdginfo to get SDG, copies rank etc, closes
  193.  *          file, returns
  194.  * Remarks: Always sequences to next SDG in file
  195.  *          User specifies maxrank, and allocates sizes as an array of integers
  196.  *          with dimension maxrank
  197.  *---------------------------------------------------------------------------*/
  198.  
  199. int DFSDgetdims(filename, prank, sizes, maxrank)
  200. char *filename;
  201. int *prank;
  202. int32 sizes[];
  203. int maxrank;
  204. {
  205.     int i;
  206.     DF *dfile;
  207.  
  208.     DFerror = DFE_NOERROR;
  209.     if (!prank) {        /* check if ptr is valid */
  210.         DFerror = DFE_BADPTR;
  211.         return(-1);
  212.     }
  213.  
  214.     dfile = DFSDIopen(filename, DFACC_READ); /* open/reopen file */
  215.     if (dfile == NULL) return(-1);
  216.  
  217.     if (DFSDIsdginfo(dfile)<0)    /* reads next SDG from file */
  218.         return(DFIerr(dfile));    /* on error, close file and return -1 */
  219.  
  220.     *prank = Readsdg.rank;    /* copy rank, dimensions */
  221.     if (maxrank<*prank) {    /* if not all dimensions copied */
  222.         DFerror = DFE_NOTENOUGH;
  223.         return(DFIerr(dfile));
  224.     }
  225.     for (i=0; i<*prank; i++)
  226.         sizes[i] = Readsdg.dimsizes[i];
  227.     Nextsdg = 0;
  228.     return(DFclose(dfile));
  229. }
  230.  
  231. /*-----------------------------------------------------------------------------
  232.  * Name:    DFSDgetdatastrs
  233.  * Purpose: Get information about data: label, units, format
  234.  * Inputs:  label: string to return label in, length Maxstrlen[LABEL]
  235.  *          unit: string to return unit in, length Maxstrlen[UNIT]
  236.  *          format: string to return format in, length Maxstrlen[FORMAT]
  237.  *          coordsys: string to return coord system, length Maxstrlen[COORDSYS]
  238.  * Returns: 0 on success, -1 on failure with DFerror set
  239.  * Outputs: label, unit, format, coord system in the appropriate arguments
  240.  * Users:   HDF users, utilities, other routines
  241.  * Invokes: none
  242.  * Method:  get values from struct Readsdg
  243.  * Remarks: none
  244.  *---------------------------------------------------------------------------*/
  245.  
  246. int DFSDgetdatastrs(label, unit, format, coordsys)
  247. char *label, *unit, *format, *coordsys;
  248. {
  249.     int32 luf;
  250.     char *lufp;
  251.  
  252.     DFerror = DFE_NOERROR;
  253.     
  254.     if (Newdata<0) {
  255.         DFerror = DFE_BADCALL;
  256.         return(-1);
  257.     }
  258.  
  259.     /* copy label, unit, format */
  260.     for (luf=LABEL; luf<=FORMAT; luf++) {
  261.         lufp = (luf==LABEL) ? label : (luf==UNIT) ? unit : format;
  262.         if (lufp)
  263.             if (Readsdg.dataluf[luf])
  264.                 DFIstrncpy(lufp, Readsdg.dataluf[luf], Maxstrlen[luf]);
  265.     }
  266.     /* copy coordsys */
  267.     if (coordsys)
  268.         if (Readsdg.coordsys)
  269.             DFIstrncpy(coordsys, Readsdg.coordsys, Maxstrlen[COORDSYS]);
  270.         else coordsys[0] = '\0';
  271.     return(0);
  272. }
  273.  
  274. /*-----------------------------------------------------------------------------
  275.  * Name:    DFSDgetdimstrs
  276.  * Purpose: Get information about a dimension: label, units, format
  277.  * Inputs:  dim: no of dimension to get information about
  278.  *          label: string to return label in, max length Maxstrlen[LABEL]
  279.  *          unit: string to return unit in, max length Maxstrlen[UNIT]
  280.  *          format: string to return format in, max length Maxstrlen[FORMAT]
  281.  * Returns: 0 on success, -1 on failure with DFerror set
  282.  * Outputs: label, unit, format in the appropriate arguments
  283.  *          NULL string if no value for the arguments
  284.  * Users:   HDF users, utilities, other routines
  285.  * Invokes: none
  286.  * Method:  get values from struct Readsdg
  287.  * Remarks: none
  288.  *---------------------------------------------------------------------------*/
  289.  
  290. int DFSDgetdimstrs(dim, label, unit, format)
  291. int dim;
  292. char *label, *unit, *format;
  293. {
  294.     int luf, rdim;
  295.     char *lufp;
  296.  
  297.     DFerror = DFE_NOERROR;
  298.     
  299.     if (Newdata<0) {
  300.         DFerror = DFE_BADCALL;
  301.         return(-1);
  302.     }
  303.  
  304.     rdim = dim-1;        /* translate dim to zero origin */
  305.     if ((rdim>=Readsdg.rank) || (rdim<0)) {
  306.         DFerror = DFE_BADDIM;
  307.         return(-1);
  308.     }
  309.  
  310.     /* copy labels etc */
  311.     for (luf=LABEL; luf<=FORMAT; luf++) {
  312.         lufp = (luf==LABEL) ? label : (luf==UNIT) ? unit : format;
  313.         if (lufp) {
  314.             if (!Readsdg.dimluf) { /* no labels etc */
  315.                 *lufp = '\0';
  316.                 continue;
  317.             }
  318.             if (Readsdg.dimluf[luf])
  319.                 DFIstrncpy(lufp, Readsdg.dimluf[luf][rdim], Maxstrlen[luf]);
  320.         }
  321.     }
  322.     return(0);
  323. }
  324.                 
  325. /*-----------------------------------------------------------------------------
  326.  * Name:    DFSDgetdatalen()
  327.  * Purpose: Get actual length of label, unit, format, coordsys strings
  328.  *          Called from FORTRAN
  329.  * Inputs:  llabel, lunit, lformat, lcoordsys - for returning lengths
  330.  * Globals: Readsdg
  331.  * Returns: 0 on success, -1 on error with DFerror set
  332.  * Users:   HDF users, utilities, other routines
  333.  * Invokes: none
  334.  * Method:  get lengths from Readsdg
  335.  *---------------------------------------------------------------------------*/
  336.  
  337. int DFSDgetdatalen(llabel, lunit, lformat, lcoordsys)
  338. int *llabel, *lunit, *lformat, *lcoordsys;
  339. {
  340.  
  341.     DFerror = DFE_NOERROR;
  342.  
  343.     if (Newdata<0) {
  344.         DFerror = DFE_BADCALL;
  345.         return(-1);
  346.     }
  347.     *llabel =  Readsdg.dataluf[LABEL] ? strlen(Readsdg.dataluf[LABEL]) : 0;
  348.     *lunit =  Readsdg.dataluf[UNIT] ? strlen(Readsdg.dataluf[UNIT]) : 0;
  349.     *lformat =  Readsdg.dataluf[FORMAT] ? strlen(Readsdg.dataluf[FORMAT]) : 0;
  350.     *lcoordsys =  Readsdg.coordsys ? strlen(Readsdg.coordsys) : 0;
  351.     return(0);
  352. }
  353.     
  354.  
  355. /*-----------------------------------------------------------------------------
  356.  * Name:    DFSDgetdimlen()
  357.  * Purpose: Get actual length of label, unit, format strings
  358.  *          Called from FORTRAN
  359.  * Inputs:  dim. llabel, lunit, lformat - for returning lengths
  360.  * Globals: Readsdg
  361.  * Returns: 0 on success, -1 on error with DFerror set
  362.  * Users:   HDF users, utilities, other routines
  363.  * Invokes: none
  364.  * Method:  get lengths from Readsdg
  365.  *---------------------------------------------------------------------------*/
  366.  
  367. int DFSDgetdimlen(dim, llabel, lunit, lformat)
  368. int dim;
  369. int *llabel, *lunit, *lformat;
  370. {
  371.  
  372.     DFerror = DFE_NOERROR;
  373.  
  374.     if (Newdata<0) {
  375.         DFerror = DFE_BADCALL;
  376.         return(-1);
  377.     }
  378.     if (dim>Readsdg.rank) {
  379.         DFerror = DFE_BADDIM;
  380.         return(-1);
  381.     }
  382.     *llabel =  Readsdg.dimluf[dim-1][LABEL] ?
  383.     strlen(Readsdg.dimluf[dim-1][LABEL]) : 0;
  384.     *lunit =  Readsdg.dimluf[dim-1][UNIT] ?
  385.     strlen(Readsdg.dimluf[dim-1][UNIT]) : 0;
  386.     *lformat =  Readsdg.dimluf[dim-1][FORMAT] ?
  387.     strlen(Readsdg.dimluf[dim-1][FORMAT]) : 0;
  388.     return(0);
  389. }
  390.  
  391. /*-----------------------------------------------------------------------------
  392.  * Name:    DFSDgetdimscale
  393.  * Purpose: Get dimension scale
  394.  * Inputs:  dim: no of dimension to get scale for
  395.  *          size: size of scale array
  396.  *          scale: array to return scale in
  397.  * Returns: 0 on success, -1 on failure with DFerror set
  398.  * Outputs: scale if present, else -1
  399.  * Users:   HDF users, utilities, other routines
  400.  * Invokes: none
  401.  * Method:  get values from struct Readsdg
  402.  * Remarks: none
  403.  *---------------------------------------------------------------------------*/
  404.  
  405. int DFSDgetdimscale(dim, maxsize, scale)
  406. int dim;
  407. int32 maxsize;
  408. float32 scale[];
  409. {
  410.     int32 i;
  411.     int rdim;
  412.  
  413.     DFerror = DFE_NOERROR;
  414.     
  415.     if (Newdata<0) {
  416.         DFerror = DFE_BADCALL;
  417.         return(-1);
  418.     }
  419.  
  420.     rdim = dim-1;        /* translate dim to zero origin */
  421.     if ((rdim>=Readsdg.rank) || (rdim<0)) {
  422.         DFerror = DFE_BADDIM;
  423.         return(-1);
  424.     }
  425.  
  426.     if (maxsize < Readsdg.dimsizes[rdim]) {
  427.         DFerror = DFE_NOSPACE;
  428.         return(-1);
  429.     }
  430.  
  431.     if (!scale) {
  432.         DFerror = DFE_BADPTR;
  433.         return(-1);
  434.     }
  435.  
  436.     if (!Readsdg.dimscales || !Readsdg.dimscales[rdim]) { /* no scale */
  437.         DFerror = DFE_NOVALS;
  438.         return(-1);
  439.     }
  440.  
  441.     for (i=0; i<Readsdg.dimsizes[rdim]; i++) /* copy scale */
  442.         scale[i] = Readsdg.dimscales[rdim][i];
  443.  
  444.     return(0);
  445. }
  446.  
  447. /*-----------------------------------------------------------------------------
  448.  * Name:    DFSDgetmaxmin()
  449.  * Purpose: Get maximum and minimum data values
  450.  * Inputs:  pmax: pointer to float32 to return maximum value in
  451.  *          pmin: pointer to float32 to return minimum value in
  452.  * Globals: Ismaxmin
  453.  * Returns: 0 on success, -1 if no maxmin values or if error, with DFerror set
  454.  * Users:   HDF users, utilities, other routines
  455.  * Invokes: none
  456.  * Method:  Retrieves values from Readsdg
  457.  * Remarks: none
  458.  *---------------------------------------------------------------------------*/
  459.  
  460. int DFSDgetmaxmin(pmax, pmin)
  461. float32 *pmax, *pmin;
  462. {
  463.  
  464.     DFerror = DFE_NOERROR;
  465.     
  466.     if (Newdata<0) {
  467.         DFerror = DFE_BADCALL;
  468.         return(-1);
  469.     }
  470.  
  471.     if (Ismaxmin) {
  472.         *pmax = Readsdg.max_data;
  473.         *pmin = Readsdg.min_data;
  474.         return(0);
  475.     } else {
  476.         DFerror = DFE_NOVALS;
  477.         return(-1);
  478.     }
  479. }
  480.  
  481. /*-----------------------------------------------------------------------------
  482.  * Name:    DFSDgetdata
  483.  * Purpose: Get data from SDG.  Will sequence to next SDG if DFSDgetdims not
  484.  *          called.
  485.  * Inputs:  filename: name of HDF file to use
  486.  *          rank: no of dimensions of array "data"
  487.  *          maxsizes: actual dimensions of array "data"
  488.  *          data: data for returning scientific data
  489.  * Returns: 0 on success, -1 on failure with DFerror set
  490.  * Outputs: actual scientific data in array
  491.  * Users:   HDF users, utilities, other routines
  492.  * Invokes: DFSDIgetdata
  493.  * Method:  call DFSDIgetdata
  494.  * Remarks: maxsizes may be larger than actual size.  In that event, the actual
  495.  *          data may not be contiguous in the array "data"
  496.  *          User sets maxsizes before call.
  497.  *          It is not necessary to call DFSDgetdata first if the dimensions
  498.  *          are correct
  499.  *---------------------------------------------------------------------------*/
  500.  
  501. int DFSDgetdata(filename, rank, maxsizes, data)
  502. char *filename;
  503. int rank;
  504. int32 maxsizes[];
  505. float32 data[];
  506. {
  507.     return(DFSDIgetdata(filename, rank, maxsizes, data, 0));    /* 0 == C */
  508. }
  509.                 
  510.  
  511. /*-----------------------------------------------------------------------------
  512.  * Name:    DFSDsetlengths()
  513.  * Purpose: Set maximum length for label, unit, format, coordsys strings
  514.  * Inputs:  maxlen_label, maxlen_format, maxlen_unit, maxlen_coordsys:
  515.  *              maximum length of each string.
  516.  * Globals: Maxstrlen
  517.  * Returns: 0 on success, -1 on error with DFerror set
  518.  * Users:   HDF users, utilities, other routines
  519.  * Invokes: none
  520.  * Method:  Stores values in global Maxstrlen
  521.  * Remarks: The get routines assume the array passed in by user is of this len
  522.  *          If this routine is not called, the lengths default to DFS_MAXLEN
  523.  *          The length includes the string terminator NULL byte
  524.  *---------------------------------------------------------------------------*/
  525.  
  526. int DFSDsetlengths(maxlen_label, maxlen_unit, maxlen_format, maxlen_coordsys)
  527. int maxlen_label, maxlen_unit, maxlen_format, maxlen_coordsys;
  528. {
  529.  
  530.     if (maxlen_label>0) Maxstrlen[LABEL] = maxlen_label;
  531.     if (maxlen_unit>0) Maxstrlen[UNIT] = maxlen_unit;
  532.     if (maxlen_format>0) Maxstrlen[FORMAT] = maxlen_format;
  533.     if (maxlen_coordsys>0) Maxstrlen[COORDSYS] = maxlen_coordsys;
  534.     return(0);
  535. }
  536.     
  537.  
  538. /*-----------------------------------------------------------------------------
  539.  * Name:    DFSDsetdims()
  540.  * Purpose: Set rank and sizes for subsequent SDGs
  541.  * Inputs:  rank: rank of array that holds the raw data
  542.  *          dimsizes: sizes of all of the dimensions
  543.  * Globals: Writesdg, Ref
  544.  * Returns: 0 on success, -1 on error with DFerror set
  545.  * Users:   HDF users, utilities, other routines
  546.  * Invokes: DFSDclear
  547.  * Method:  Stores values in global structure Writesdg
  548.  * Remarks: If dimensions change, all previous "set"s are cleared
  549.  *          This routine must be called before DFSDsetdimstrs and
  550.  *          DFSDsetdimscales.  It need not be called if these routines are
  551.  *          not called, and the correct dimensions are supplied to DFSDputdata
  552.  *          or DFSDadddata
  553.  *---------------------------------------------------------------------------*/
  554.  
  555. int DFSDsetdims(rank, dimsizes)
  556. int16 rank;
  557. int32  dimsizes[];
  558. {
  559.     int i;
  560.  
  561.     DFerror = DFE_NOERROR;
  562.  
  563.     if (Sdfile!=NULL) {
  564.         DFerror = DFE_BADCALL;
  565.         return(-1);
  566.     }
  567.  
  568.     if (Writesdg.rank == rank)    /* check if dimensions same */
  569.         if (Writesdg.dimsizes) {
  570.             for (i=0; i<rank; i++)
  571.                 if (Writesdg.dimsizes[i] != dimsizes[i]) break;
  572.             if (i == rank) return(0); /* Dimensions same as before */
  573.         }   
  574.     
  575.     /* forget all attributes set previously */
  576.     if (DFSDIclear(&Writesdg)<0) return(-1);
  577.  
  578.     /* allocate dimensions */
  579.     Writesdg.dimsizes = (int32 *) DFIgetspace((unsigned)(rank*sizeof(int32)));
  580.     if (Writesdg.dimsizes==NULL) return(-1);
  581.  
  582.     /* copy dimensions */
  583.     Writesdg.rank = rank;
  584.     for (i=0; i<rank; i++)
  585.         Writesdg.dimsizes[i] = dimsizes[i];
  586.  
  587.     /* Note dimensions modified */
  588.     Ref.dims = 0;
  589.     return(0);
  590. }
  591.  
  592. /*-----------------------------------------------------------------------------
  593.  * Name:    DFSDsetdatastrs()
  594.  * Purpose: Set label, unit and format for displaying subsequent SDGs
  595.  * Inputs:  label: label to be used to describe data
  596.  *          unit: unit corresponding to data values
  597.  *          format: format to be used in displaying data values
  598.  *          coordsys: type of coordinate system
  599.  * Globals: Writesdg, Ref
  600.  * Returns: 0 on success, -1 on failure with DFerror set
  601.  * Users:   HDF users, utilities, other routines
  602.  * Invokes: none
  603.  * Method:  Stores values in global structure Writesdg
  604.  * Remarks: should we validate coordsys? proposed strings: "cartesian",
  605.  *          "polar" (="spherical") and "cylindrical".  Do "spherical" and
  606.  *          "cylindrical" make sense for 2D?
  607.  *---------------------------------------------------------------------------*/
  608.  
  609. int DFSDsetdatastrs(label, unit, format, coordsys)
  610. char *label, *unit, *format, *coordsys;
  611. {
  612.     int luf;            /* takes values LABEL, UNIT, FORMAT */
  613.                 /* in succession */
  614.     char *lufp;            /* points to label, unit, format */
  615.                 /* in succession */
  616.     DFerror = DFE_NOERROR;
  617.  
  618.     for (luf=LABEL; luf<=FORMAT; luf++) {
  619.     /* set lufp to point to label etc. as apppropriate */
  620.         lufp = (luf==LABEL) ? label : (luf==UNIT) ? unit : format;
  621.  
  622.     /* free space if allocated */
  623.         Writesdg.dataluf[luf] = DFIfreespace(Writesdg.dataluf[luf]);
  624.  
  625.     /* copy string */
  626.         if (lufp) {
  627.             Writesdg.dataluf[luf] = DFIgetspace((unsigned) strlen(lufp)+1);
  628.             if (Writesdg.dataluf[luf]==NULL) return(-1);
  629.             strcpy(Writesdg.dataluf[luf], lufp);
  630.         }
  631.     }
  632.  
  633.     Writesdg.coordsys = DFIfreespace(Writesdg.coordsys);
  634.  
  635.     if (coordsys) {
  636.         Writesdg.coordsys = DFIgetspace((unsigned) strlen(coordsys)+1);
  637.         if (Writesdg.coordsys==NULL) return(-1);
  638.         strcpy(Writesdg.coordsys, coordsys);
  639.     }
  640.  
  641.     /* indicate that label, unit, format and coordsys info modified */
  642.     Ref.luf[LABEL] = Ref.luf[UNIT] = Ref.luf[FORMAT] = Ref.coordsys = 0;
  643.  
  644.     return(0);
  645. }
  646.  
  647. /*-----------------------------------------------------------------------------
  648.  * Name:    DFSDsetdimstrs()
  649.  * Purpose: For the given dimension, set label, unit, format
  650.  *          This routine needs to be called once for each dimension whose 
  651.  *          values the user wants to set.
  652.  * Inputs:  dim: the dimension that this info applies to
  653.  *          label: label to be used to describe this dimension
  654.  *          unit: units for dimension
  655.  *          format: format to be used in displaying
  656.  * Globals: Writesdg, Ref
  657.  * Returns: 0 on success, -1 on failure with DFerror set
  658.  * Users:   HDF users, utilities, other routines
  659.  * Invokes: none
  660.  * Method:  Stores values in global structure Writesdg
  661.  *---------------------------------------------------------------------------*/
  662.  
  663. int DFSDsetdimstrs(dim, label, unit, format)
  664. int dim;
  665. char *label, *unit, *format;
  666. {
  667.  
  668.     int i, rdim;
  669.     int luf;            /* takes values LABEL, UNIT, FORMAT */
  670.                 /* in succession */
  671.     char *lufp;            /* points to label, unit, format */
  672.                 /* in succession */
  673.     DFerror = DFE_NOERROR;
  674.  
  675.     rdim = dim-1;        /* translate from 1 to 0 origin */
  676.  
  677.     if ((rdim>=Writesdg.rank) || (rdim<0)) {
  678.         DFerror = DFE_BADDIM;
  679.         return(-1);
  680.     }
  681.  
  682.     for (luf=LABEL; luf<=FORMAT; luf++) {
  683.     /* set lufp to point to label etc. as apppropriate */
  684.         lufp = (luf==LABEL) ? label : (luf==UNIT) ? unit : format;
  685.  
  686.     /* allocate space if necessary */
  687.         if (!Writesdg.dimluf[luf]) {
  688.             Writesdg.dimluf[luf] =
  689.                 (char **) DFIgetspace((unsigned) Writesdg.rank * sizeof(char *));
  690.             if (Writesdg.dimluf[luf]==NULL) return(-1);
  691.             for (i=0; i<Writesdg.rank; i++) /* set allocated pointers to NULL*/
  692.                 Writesdg.dimluf[luf][i] = NULL;
  693.         }
  694.  
  695.     /* free string space if allocated */
  696.         Writesdg.dimluf[luf][rdim] = DFIfreespace(Writesdg.dimluf[luf][rdim]);
  697.  
  698.     /* copy string */
  699.         if (lufp) {
  700.             Writesdg.dimluf[luf][rdim] = DFIgetspace((unsigned) strlen(lufp)+1);
  701.             if (Writesdg.dimluf[luf][rdim]==NULL) return(-1);
  702.             strcpy(Writesdg.dimluf[luf][rdim], lufp);
  703.         }
  704.     }
  705.     /* Indicate that this info has not been written to file */
  706.     Ref.luf[LABEL] = Ref.luf[UNIT] = Ref.luf[FORMAT] = 0;
  707.  
  708.     return(0);
  709. }
  710.  
  711. /*-----------------------------------------------------------------------------
  712.  * Name:    DFSDsetdimscale()
  713.  * Purpose: For the given dimension, set scale values
  714.  *          This routine needs to be called once for each dimension whose 
  715.  *          values the user wants to set.
  716.  * Inputs:  dim: the dimension that this info applies to
  717.  *          dimsize: number of points in the scale
  718.  *          scale: array of numbers that will make up the scale
  719.  * Globals: Writesdg, Ref
  720.  * Returns: 0 on success, -1 on failure with DFerror set
  721.  * Users:   HDF users, utilities, other routines
  722.  * Invokes: none
  723.  * Method:  Stores values in global structure Writesdg
  724.  *---------------------------------------------------------------------------*/
  725.  
  726. int DFSDsetdimscale(dim, dimsize, scale)
  727. int dim;
  728. int32   dimsize;
  729. float32 scale[];
  730. {
  731.  
  732.     int i, rdim;
  733.     DFerror = DFE_NOERROR;
  734.  
  735.     rdim = dim-1;        /* translate from 1 to 0 origin */
  736.  
  737.     if (!Writesdg.dimsizes) {
  738.         DFerror = DFE_BADCALL;
  739.         return(-1);
  740.     }
  741.     if ((rdim>=Writesdg.rank) || (rdim<0) /* check dimensions */
  742.     || (dimsize!=Writesdg.dimsizes[rdim])) {
  743.         DFerror = DFE_BADDIM;
  744.         return(-1);
  745.     }
  746.  
  747.     if (!scale) {        /* No scale for this dimension */
  748.         if (Writesdg.dimscales)
  749.             Writesdg.dimscales[rdim] =
  750.         (float32 *) DFIfreespace((char*) Writesdg.dimscales[rdim]);
  751.         Ref.scales = 0;
  752.         return(0);
  753.     }
  754.         
  755.     /* allocate space for dimscales if necessary */
  756.     if (!Writesdg.dimscales) {
  757.         Writesdg.dimscales =
  758.         (float32 **) DFIgetspace((unsigned)Writesdg.rank * sizeof(float32 *));
  759.         if (Writesdg.dimscales==NULL) return(-1);
  760.         for (i=0; i<Writesdg.rank; i++) /* set allocated pointers to NULL */
  761.             Writesdg.dimscales[i] = NULL;
  762.     }
  763.  
  764.     if (!Writesdg.dimscales[rdim]) {
  765.     /* allocate dimension scale space if necessary */
  766.         Writesdg.dimscales[rdim] =
  767.         (float32 *) DFIgetspace((unsigned) dimsize*sizeof(float32));
  768.         if (Writesdg.dimscales[rdim]==NULL) return(-1);
  769.     }
  770.  
  771.     for (i=0; i<dimsize; i++)    /* copy scale */
  772.         Writesdg.dimscales[rdim][i] = scale[i];
  773.  
  774.     /* Indicate scales modified */
  775.     Ref.scales = 0;
  776.  
  777.     return(0);
  778. }
  779.  
  780. /*-----------------------------------------------------------------------------
  781.  * Name:    DFSDsetmaxmin()
  782.  * Purpose: Set maximum and minimum data values
  783.  * Inputs:  maxi: maximum value
  784.  *          mini: minimum value
  785.  * Globals: Ref
  786.  * Returns: 0 on success, -1 if no maxmin values or if error, with DFerror set
  787.  * Users:   HDF users, utilities, other routines
  788.  * Invokes: none
  789.  * Method:  Modify Writesdg, set Ref
  790.  * Remarks: Automatically cleared after call to DFSDputdata or DFSDadddata
  791.  *---------------------------------------------------------------------------*/
  792.  
  793. int DFSDsetmaxmin(maxi, mini)
  794. float32 maxi, mini;
  795. {
  796.  
  797.     DFerror = DFE_NOERROR;
  798.     
  799.     Writesdg.max_data = maxi;
  800.     Writesdg.min_data = mini;
  801.     Ref.maxmin = 0;
  802.  
  803.     return(0);
  804. }
  805.  
  806.  
  807. /*-----------------------------------------------------------------------------
  808.  * Name:    DFSDputdata
  809.  * Purpose: Calls DFSDIputdata to write data and SDG to file
  810.  * Inputs:  filename: name of HDF file to use
  811.  *          rank: rank of data array
  812.  *          dimsizes: sizes of the dimensions of data array
  813.  *          data: array that holds data
  814.  * Globals: Writeref
  815.  * Returns: 0 on success, -1 on failure with DFerror set
  816.  * Users:   HDF users, utilities, other routines
  817.  * Invokes: DFSDIputdata
  818.  * Method:  Invoke DFSDIputdata
  819.  *---------------------------------------------------------------------------*/
  820.  
  821. int DFSDputdata(filename, rank, dimsizes, data)
  822. char *filename;
  823. int16 rank;
  824. int32 dimsizes[];
  825. float32 *data;
  826. {
  827.  
  828.     /* 0, 0 specify create mode, C style array (row major) */
  829.     return(DFSDIputdata(filename, rank, dimsizes, data, 0, 0));
  830. }
  831.  
  832. /*-----------------------------------------------------------------------------
  833.  * Name:    DFSDadddata
  834.  * Purpose: Calls DFSDIputdata to append data and SDG to file
  835.  * Inputs:  filename: name of HDF file to use
  836.  *          rank: rank of data array
  837.  *          dimsizes: sizes of the dimensions of data array
  838.  *          data: array that holds data
  839.  * Globals: Writeref
  840.  * Returns: 0 on success, -1 on failure with DFerror set
  841.  * Users:   HDF users, utilities, other routines
  842.  * Invokes: DFSDIputdata
  843.  * Method:  Invoke DFSDIputdata
  844.  *---------------------------------------------------------------------------*/
  845.  
  846. int DFSDadddata(filename, rank, dimsizes, data)
  847. char *filename;
  848. int16 rank;
  849. int32 dimsizes[];
  850. float32 *data;
  851. {
  852.  
  853.     /* 1, 0 specifies append mode, C style array (row major) */
  854.     return(DFSDIputdata(filename, rank, dimsizes, data, 1, 0));
  855. }
  856.  
  857.  
  858. /*-----------------------------------------------------------------------------
  859.  * Name:    DFSDrestart
  860.  * Purpose: Do not remember info about file - get again from first data set
  861.  * Inputs:  none
  862.  * Returns: 0 on success
  863.  * Users:   HDF programmers
  864.  * Remarks: Just reset Lastfile to NULL
  865.  *          Subsequent gets will starts from first image
  866.  *          Next put will write all "set" info to file
  867.  *---------------------------------------------------------------------------*/
  868.  
  869. int DFSDrestart()
  870. {
  871.     Lastfile[0] = '\0';
  872.     Readref = 0;
  873.     return(0);
  874. }
  875.     
  876.  
  877. /*-----------------------------------------------------------------------------
  878.  * Name:    DFSDnumber
  879.  * Purpose: Return number of SDGs in file
  880.  * Inputs:  filename - name of HDF file
  881.  * Globals: none
  882.  * Returns: number of SDGs on success, -1 on error with DFerror set
  883.  * Users:   HDF users, utilities, other routines
  884.  * Invokes: DFSDIopen, DFclose, DFnumber
  885.  * Method:  open file, invoke DFnumber, close file
  886.  * Remarks: none
  887.  *---------------------------------------------------------------------------*/
  888.  
  889. int DFSDnumber(filename)
  890. char *filename;
  891. {
  892.     DF *dfile;
  893.     int nsdgs=0;
  894.  
  895.     DFerror = DFE_NOERROR;
  896.  
  897.     /* should use reopen if same file as last time - more efficient */
  898.     dfile = DFSDIopen(filename, DFACC_READ);
  899.     if (dfile==NULL) return(-1);
  900.  
  901.     nsdgs = DFnumber(dfile, DFTAG_SDG);       /* count number of SDGs */
  902.     if (DFclose(dfile)<0) return(-1);
  903.     return(nsdgs);
  904. }
  905.  
  906.  
  907. /*-----------------------------------------------------------------------------
  908.  * Name:    DFSDclear
  909.  * Purpose: Clear all "set" values
  910.  * Inputs:  none
  911.  * Globals: Writesdg, Ref
  912.  * Returns: 0 on success, -1 on error with DFerror set
  913.  * Users:   HDF users, utilities, other routines
  914.  * Invokes: DFSDIclear
  915.  * Method:  Invoke DFSDIclear
  916.  * Remarks: none
  917.  *---------------------------------------------------------------------------*/
  918.  
  919. int DFSDclear()
  920. {
  921.     return(DFSDIclear(&Writesdg));
  922. }
  923.  
  924.  
  925. /*-----------------------------------------------------------------------------
  926.  * Name:    DFSDlastref
  927.  * Purpose: Return last ref written or read
  928.  * Inputs:  none
  929.  * Globals: Lastref
  930.  * Returns: ref on success, -1 on error with DFerror set
  931.  * Users:   HDF users, utilities, other routines
  932.  * Invokes: none
  933.  * Method:  return Lastref
  934.  * Remarks: none
  935.  *---------------------------------------------------------------------------*/
  936.  
  937. int DFSDlastref()
  938. {
  939.     return((int) Lastref);
  940. }
  941.  
  942. /*-----------------------------------------------------------------------------
  943.  * Name:    DFR8readref
  944.  * Purpose: Set ref of image to get next
  945.  * Inputs:  filename: file to which this applies
  946.  *          ref: reference number of next get
  947.  * Returns: 0 on success, -1 on failure
  948.  * Users:   HDF programmers, other routines and utilities
  949.  * Invokes: DFR8Iopen, DFIfind
  950.  * Remarks: checks if image with this ref exists
  951.  *---------------------------------------------------------------------------*/
  952.  
  953.     int
  954. DFSDreadref(filename, ref)
  955.     char *filename;
  956.     uint16 ref;
  957. {
  958.     DF *dfile;
  959.     int cdd;
  960.     DFdle *dlep;
  961.  
  962.     DFerror = DFE_NOERROR;
  963.     dfile = DFSDIopen(filename, DFACC_READ);
  964.     if (!dfile) return (-1);
  965.     if (DFIfind(dfile, DFTAG_SDG, ref,1,0,0, &dlep, &cdd) < 0)
  966.     return (DFIerr(dfile));
  967.     Readref = ref;
  968.     Newdata = -1;
  969.     return DFclose(dfile);
  970. }
  971.  
  972. /*-----------------------------------------------------------------------------
  973.  * Name:    DFSDgetslice
  974.  * Purpose: Get slice of data from SDG.  Will sequence to next SDG if
  975.  *          DFSDgetdims, DFSDgetdata or DFSDgetslice not called earlier.
  976.  * Inputs:  filename: name of HDF file to use
  977.  *          winst: array of size = rank of data, containing start of slice
  978.  *          windims: array of size rank, containing end of slice
  979.  *          data: array for returning slice
  980.  *          dims: dimensions of array data
  981.  * Returns: 0 on success, -1 on failure with DFerror set
  982.  * Outputs: slice of data in data
  983.  * Users:   DFSDIgetdata
  984.  * Invokes: DFSDIgetslice
  985.  * Method:  call DFSDIgetslice
  986.  * Remarks: dims may be larger than size of slice.  In that event, the actual
  987.  *          data may not be contiguous in the array "data".
  988.  *          User sets dims before call.
  989.  *---------------------------------------------------------------------------*/
  990.  
  991. int DFSDgetslice(filename, winst, windims, data, dims)
  992. char *filename;
  993. int32 winst[], windims[];
  994. int32 dims[];
  995. float32 data[];
  996. {
  997.     return(DFSDIgetslice(filename, winst, windims, data, dims, 0));
  998. }
  999.  
  1000. /*-----------------------------------------------------------------------------
  1001.  * Name:    DFSDstartslice
  1002.  * Purpose: Set up to write slice of data to SDG.
  1003.  * Inputs:  filename: name of HDF file to write to
  1004.  * Returns: 0 on success, -1 on failure with DFerror set
  1005.  * Users:   DFSDIputdata
  1006.  * Invokes: DFSDIopen, DFnewref, DFaccess
  1007.  * Method:  call DFSDIputslice
  1008.  * Remarks: DFSDsetdims must have been called first
  1009.  *          No call which needs a file open may be made after this
  1010.  *          till DFSDendslice is called
  1011.  *---------------------------------------------------------------------------*/
  1012.  
  1013. int DFSDstartslice(filename)
  1014. char *filename;
  1015. {
  1016.     int i;
  1017.  
  1018.     DFerror = DFE_NOERROR;
  1019.  
  1020.     if (!Writesdg.rank) {    /* dimensions not set */
  1021.         DFerror = DFE_BADDIM;
  1022.         return(-1);
  1023.     }
  1024.  
  1025.     Sdfile = DFSDIopen(filename, DFACC_WRITE);
  1026.     if (Sdfile == NULL) return(-1);
  1027.  
  1028.     if (!Writeref) Writeref = DFnewref(Sdfile);
  1029.     if (!Writeref) return(-1);
  1030.  
  1031.     Writesdg.data.tag = DFTAG_SD;
  1032.     Writesdg.data.ref = Writeref;
  1033.  
  1034.         /* set up to write image */
  1035.     if (DFaccess(Sdfile, DFTAG_SD, Writeref, "w")<0)
  1036.             return(DFIerr(Sdfile));
  1037.  
  1038.     /* allocate array for keeping track of dims written */
  1039.     Sddims = (int32 *) DFIgetspace((unsigned) Writesdg.rank * sizeof(int32));
  1040.     if (Sddims==NULL) return(DFIerr(Sdfile));
  1041.     
  1042.     for (i=0; i<Writesdg.rank; i++)
  1043.         Sddims[i] = 0;        /* nothing written so far */
  1044.  
  1045.     return(0);
  1046. }
  1047.  
  1048.  
  1049. /*-----------------------------------------------------------------------------
  1050.  * Name:    DFSDputslice
  1051.  * Purpose: Put slice of data to SDG.
  1052.  * Inputs:  winend: array of size rank, containing end of slice
  1053.  *          data: array containing slice
  1054.  *          dims: dimensions of array data
  1055.  * Returns: 0 on success, -1 on failure with DFerror set
  1056.  * Users:   DFSDIputdata
  1057.  * Invokes: DFSDIputslice
  1058.  * Method:  call DFSDIputslice
  1059.  * Remarks: dims may be larger than size of slice.  In that event, the actual
  1060.  *          data may not be contiguous in the array "data".
  1061.  *          DFSDstartslice must have been called first
  1062.  *---------------------------------------------------------------------------*/
  1063.  
  1064. int DFSDputslice(winend, data, dims)
  1065. int32 winend[];
  1066. int32 dims[];
  1067. float32 data[];
  1068. {
  1069.  
  1070.     return(DFSDIputslice(winend, data, dims, 0));
  1071. }
  1072.  
  1073.  
  1074. /*-----------------------------------------------------------------------------
  1075.  * Name:    DFSDendslice
  1076.  * Purpose: Write of data to SDG completed, write SDG and close file
  1077.  * Inputs:  none
  1078.  * Returns: 0 on success, -1 on failure with DFerror set
  1079.  * Users:   DFSDIputdata
  1080.  * Invokes: DFSDputsdg, DFclose, DFIerr
  1081.  * Method:  call DFSDputsdg, close Sdfile
  1082.  * Remarks: checks that slice writes were completed.
  1083.  *---------------------------------------------------------------------------*/
  1084.  
  1085. int DFSDendslice()
  1086. {
  1087.     int i, ret;
  1088.  
  1089.     DFerror = DFE_NOERROR;
  1090.  
  1091.     if (!Sdfile) {
  1092.         DFerror = DFE_BADCALL;
  1093.         return(-1);
  1094.     }
  1095.  
  1096.     /* check if slice writes complete */
  1097.     for (i=0; i<Writesdg.rank; i++) {
  1098.         if (!Fortorder && (i==0) && (Sddims[i]==Writesdg.dimsizes[i]))continue;
  1099.         if (Fortorder && (i==Writesdg.rank-1) &&
  1100.         (Sddims[i] == Writesdg.dimsizes[i])) continue;
  1101.         if((Fortorder || i>0) && (!Fortorder || i<Writesdg.rank-1)
  1102.        && (Sddims[i] == 0)) continue;
  1103.         DFerror = DFE_BADCALL;
  1104.         return(-1);
  1105.     }
  1106.  
  1107.  
  1108.     if (DFSDputsdg(Sdfile, Writeref, &Writesdg)<0) return(DFIerr(Sdfile));
  1109.  
  1110.     Lastref = Writeref;        /* remember ref written */
  1111.     Writeref=0;            /* don't know ref to write next */
  1112.  
  1113.     ret = DFclose(Sdfile);
  1114.     Sdfile = NULL;        /* partial write complete */
  1115.     Sddims = (int32 *) DFIfreespace((char*) Sddims);
  1116.  
  1117.     return(ret);
  1118. }
  1119.  
  1120.  
  1121. /*-----------------------------------------------------------------------------
  1122.  * Name:    DFSDsettype
  1123.  * Purpose: Set data type, machine type, number type and array order for output
  1124.  * Inputs:  datatype: only DFNT_FLOAT currently supported
  1125.  *          machine type: only the local machine type is supported
  1126.  *          number type: only local float number type and DFNTF_IEEE supported
  1127.  *          array order: may be either C or Fortran order
  1128.  * Returns: 0 on success, -1 on failure with DFerror set
  1129.  * Outputs: none
  1130.  * Users:   HDF users
  1131.  * Invokes: none
  1132.  * Method:  set globals
  1133.  * Remarks: Setting array order may not work if partial writes are attempted
  1134.  *          Sometimes call may accept types which later cause errors when
  1135.  *          conversion is attempted.
  1136.  *---------------------------------------------------------------------------*/
  1137.  
  1138. int DFSDsettype(datatype, machinetype, numbertype, arrayorder)
  1139. int datatype, machinetype, numbertype, arrayorder;
  1140. {
  1141.     if (Sdfile !=NULL) {    /* cannot set type during slice writes */
  1142.         DFerror = DFE_BADCALL;
  1143.         return(-1);
  1144.     }
  1145.  
  1146.     if (datatype && (datatype != DFNT_FLOAT)) {
  1147.         DFerror = DFE_BADDATATYPE;
  1148.         return(-1);
  1149.     }
  1150.  
  1151.     if (machinetype) {
  1152.         outNT = (machinetype>>8) & 0x0f;
  1153.         if ((machinetype!=DF_MT) && (outNT!=DFNTF_IEEE)) {
  1154.             DFerror = DFE_BADMCTYPE;
  1155.             return(-1);
  1156.         }
  1157.     }
  1158.  
  1159.     if (numbertype) outNT = numbertype;
  1160.     if (outNT == ((DF_MT>>8) & 0x0f)) outNTsize = sizeof(float32);
  1161.     else if (outNT == DFNTF_IEEE) outNTsize = 4; /* sizeof IEEE in bytes */
  1162.     else {
  1163.         DFerror = DFE_BADNUMTYPE;
  1164.         return(-1);
  1165.     }
  1166.  
  1167.     if (arrayorder==DFO_FORTRAN) {
  1168.     Fortorder = 1; 
  1169.     if (Ref.transpose<0) Ref.transpose = 0;
  1170.     }
  1171.     else if (arrayorder==DFO_C) {
  1172.     Fortorder = 0;
  1173.     if (Ref.transpose>=0) Ref.transpose = -1;
  1174.     }
  1175.     else if (arrayorder) {
  1176.         DFerror = DFE_BADORDER;
  1177.         return(-1);
  1178.     }
  1179.  
  1180.     return(0);
  1181. }
  1182.  
  1183. /******************************************************************************/
  1184. /*--------------------- Lower level routines --------------------------------*/
  1185. /******************************************************************************/
  1186.  
  1187. /*-----------------------------------------------------------------------------
  1188.  * Name:    DFSDgetsdg
  1189.  * Purpose: Reads in SDG
  1190.  * Inputs:  dfile: pointer to HDF file containing SDG
  1191.  *          ref: ref of SDG to read
  1192.  *          sdg: pointer to DFSsdg struct to read SDG into
  1193.  * Returns: 0 on success, -1 on failure with DFerror set
  1194.  * Users:   HDF programmers, DFSDgetdims, DFSDgetdata
  1195.  * Invokes: DFgetelement, DFdiread, DFdiget, DFaccess, DFread
  1196.  * Method:  Reads in SDG using DFdiread.  Gets each tag/ref using DFdiget.
  1197.  *          Reads in dimensions, labels, units, formats, scales, coordinate
  1198.  *          system using DFgetelement.  Mallocs space for these, freeing
  1199.  *          previously allocated space.
  1200.  * Remarks: This is specific to floating point data
  1201.  *---------------------------------------------------------------------------*/
  1202.  
  1203. int DFSDgetsdg(dfile, ref, sdg)
  1204. DF *dfile;
  1205. uint16 ref;
  1206. DFSsdg *sdg;
  1207. {
  1208.     int i, j, luf, cdd;
  1209.     int error;            /* used by DFconvert macro */
  1210.     DFdle *dlep;
  1211.     struct DFdi elmt, nt;
  1212.     register char *isscales;
  1213.     register char *buf, *p;
  1214.     char ntstring[4];
  1215.  
  1216.     DFerror = DFE_NOERROR;
  1217.  
  1218.     if (DFIcheck(dfile))
  1219.         return( -1);
  1220.  
  1221.     if (!ref) {
  1222.         DFerror = DFE_BADREF;
  1223.         return(-1);
  1224.     }
  1225.  
  1226.     if (DFdiread(dfile, DFTAG_SDG, ref)<0) /* read RIG into memory */
  1227.         return(-1);
  1228.  
  1229.     userNT = (DF_MT>>8) & 0x0f;    /* get third nibble from right */
  1230.  
  1231.     DFSDIclear(sdg);
  1232.     Ismaxmin = 0;
  1233.  
  1234.     while (!DFdiget(&elmt)) {    /* get next tag/ref from RIG */
  1235.         luf = -1;        /* flag value for label/unit format gets */
  1236.         switch (elmt.tag) {    /* process tag/ref */
  1237.  
  1238.             case DFTAG_SD:    /* data tag/ref */
  1239.                 sdg->data.tag = elmt.tag; /* put tag/ref in struct */
  1240.                 sdg->data.ref = elmt.ref;
  1241.                 break;
  1242.  
  1243.             case DFTAG_SDD:    /* dimension */
  1244.                 if (DFaccess(dfile, elmt.tag, elmt.ref, "r")<0) return(-1);
  1245.  
  1246.                 /* read rank */
  1247. #ifdef DF_STRUCTOK
  1248.                 if (DFread(dfile, &sdg->rank, (int32) 2)<0) return(-1);
  1249. #else /*DF_STRUCTOK*/
  1250.                 if (DFread(dfile, DFtbuf, (int32) 2)<0) return(-1);
  1251.                 {
  1252.                     register char *p;
  1253.                     p = DFtbuf;
  1254.                     INT16READ(p, sdg->rank);
  1255.                 }
  1256. #endif /*DF_STRUCTOK*/
  1257.  
  1258.         /* get space for dimensions */
  1259.                 sdg->dimsizes = (int32 *) DFIgetspace((unsigned) sdg->rank *
  1260.                               sizeof(int32));
  1261.                 if (sdg->dimsizes==NULL) return(-1);
  1262.  
  1263.         /* read dimension record */
  1264. #ifdef DF_STRUCTOK
  1265.                 if (DFread(dfile, sdg->dimsizes, (int32) 4*sdg->rank)<0)
  1266.                                                                     return(-1);
  1267.                             /* read NT */
  1268.                 if (DFread(dfile, &nt, (int32) 4)<0) return(-1);
  1269.  
  1270. #else /*DF_STRUCTOK*/
  1271.                 if (DFread(dfile, DFtbuf, (int32) 4*sdg->rank)<0) return(-1);
  1272.                 {
  1273.                     register char *p;
  1274.                     p = DFtbuf;
  1275.                     for (i=0; i<sdg->rank; i++)
  1276.                         INT32READ(p, sdg->dimsizes[i]);
  1277.  
  1278.                             /* read NT */
  1279.                     if (DFread(dfile, DFtbuf, (int32) 4)<0) return(-1);
  1280.                     p = DFtbuf;
  1281.                     UINT16READ(p, nt.tag);
  1282.                     UINT16READ(p, nt.ref);
  1283.                 }
  1284. #endif /*DF_STRUCTOK*/
  1285.                             /* read NT */
  1286.                 if (DFgetelement(dfile, nt.tag, nt.ref, ntstring)<0)
  1287.                     return(-1);
  1288.  
  1289.                             /* check float data */
  1290.                 if (ntstring[1] != DFNT_FLOAT) {
  1291.                     DFerror = DFE_BADCALL;
  1292.                     return(-1);
  1293.                 }
  1294.  
  1295.                             /* set NT info */
  1296.                 fileNT = ntstring[3];
  1297.                 fileNTsize = ntstring[2] / 8;
  1298.  
  1299.                             /* read and check all scale NTs */
  1300.                 for (i=0; i<sdg->rank; i++) {
  1301. #ifdef DF_STRUCTOK
  1302.                             /* read NT tag/ref */
  1303.                     if (DFread(dfile, &nt, (int32) 4)<0) return(-1);
  1304.  
  1305. #else /*DF_STRUCTOK*/
  1306.                     if (DFread(dfile, DFtbuf, (int32) 4)<0) return(-1);
  1307.                     {
  1308.                         register char *p;
  1309.                         p = DFtbuf;
  1310.                         UINT16READ(p, nt.tag);
  1311.                         UINT16READ(p, nt.ref);
  1312.                     }
  1313. #endif /*DF_STRUCTOK*/
  1314.                             /* read NT itself */
  1315.                     if (DFgetelement(dfile, nt.tag,nt.ref, ntstring)<0)
  1316.                         return(-1);
  1317.  
  1318.                             /* check float data */
  1319.                     if (ntstring[1] != DFNT_FLOAT) {
  1320.                         DFerror = DFE_BADCALL;
  1321.                         return(-1);
  1322.                     }
  1323.                 }
  1324.  
  1325.                 break;
  1326.  
  1327.             case DFTAG_SDL:     /* labels */
  1328.                 if (luf==(-1)) luf = LABEL;
  1329.  
  1330.             case DFTAG_SDU:     /* units */
  1331.                 if (luf==(-1)) luf = UNIT;
  1332.  
  1333.             case DFTAG_SDF:     /* formats */
  1334.                 if (luf==(-1)) luf = FORMAT;
  1335.  
  1336.                 if (!sdg->dimsizes) {           /* internal error */
  1337.                     DFerror = DFE_CORRUPT;
  1338.                     return(-1);
  1339.                 }
  1340.  
  1341.                         /* get needed size of buffer, allocate */
  1342.                 if (DFIfind(dfile, elmt.tag, elmt.ref, 1, (uint16) 0,
  1343.                 (uint16) 0, &dlep, &cdd)<0)
  1344.                     return(-1);
  1345.                 buf = DFIgetspace((unsigned) dlep->dd[cdd].length);
  1346.                 if (buf==NULL) return(-1);
  1347.  
  1348.                         /* read in luf */
  1349.                 if (DFgetelement(dfile, elmt.tag, elmt.ref, buf)<0) {
  1350.                     buf = DFIfreespace(buf);
  1351.                     return(-1);
  1352.                 }
  1353.                 p = buf;
  1354.                         /* allocate data luf space */
  1355.                 sdg->dataluf[luf] = DFIgetspace((unsigned) strlen(p)+1);
  1356.                 if (sdg->dataluf[luf]==NULL) {
  1357.                     buf = DFIfreespace(buf);
  1358.                     return(-1);
  1359.                 }
  1360.  
  1361.         /* extract data luf */
  1362.                 strcpy(sdg->dataluf[luf], p);
  1363.                 p += strlen(sdg->dataluf[luf])+1;
  1364.  
  1365.         /* get space for dimluf array */
  1366.                 sdg->dimluf[luf] =
  1367.             (char **) DFIgetspace((unsigned) sdg->rank * sizeof(char *));
  1368.                 if (sdg->dimluf[luf]==NULL) {
  1369.                     buf = DFIfreespace(buf);
  1370.                     return(-1);
  1371.                 }
  1372.  
  1373.                                 /* extract dimension lufs */
  1374.                 for (i=0; i<sdg->rank; i++) {
  1375.                     sdg->dimluf[luf][i] = DFIgetspace((unsigned) strlen(p)+1);
  1376.                     if (sdg->dimluf[luf][i]==NULL) {
  1377.                         buf = DFIfreespace(buf);
  1378.                         return(-1);
  1379.                     }
  1380.                     strcpy(sdg->dimluf[luf][i], p);
  1381.                     p += strlen(sdg->dimluf[luf][i])+1;
  1382.                 }
  1383.                 buf = DFIfreespace(buf);
  1384.                 break;
  1385.  
  1386.             case DFTAG_SDS:     /* scales */
  1387.                 if (!sdg->dimsizes) {           /* internal error */
  1388.                     DFerror = DFE_CORRUPT;
  1389.                     return(-1);
  1390.                 }
  1391.         /* set up to read scale */
  1392.                 if (DFaccess(dfile, elmt.tag, elmt.ref, "r")<0) return(-1);
  1393.  
  1394.         /* read isscales */
  1395.                 isscales = DFIgetspace((unsigned) sdg->rank);
  1396.                 if (isscales==NULL) return(-1);
  1397.                 if (DFread(dfile, isscales, (int32) sdg->rank)<0) return(-1);
  1398.  
  1399.         /* allocate scale pointers */
  1400.                 sdg->dimscales =
  1401.                     (float32 **) DFIgetspace((unsigned) sdg->rank *
  1402.                          sizeof(float32 *));
  1403.                 if (sdg->dimscales==NULL) {
  1404.                     isscales = DFIfreespace(isscales);
  1405.                     return(-1);
  1406.                 }
  1407.  
  1408.                             /* read scales */
  1409.                 for (i=0; i<sdg->rank; i++) {
  1410.                     sdg->dimscales[i] = NULL;       /* default */
  1411.                     if (!isscales[i]) continue;
  1412.  
  1413.                             /* space for scale */
  1414.                     sdg->dimscales[i] = (float32 *)
  1415.             DFIgetspace((unsigned) sdg->dimsizes[i] *
  1416.                     sizeof(float32));
  1417.                     if (sdg->dimscales[i]==NULL) {
  1418.                         isscales = DFIfreespace(isscales);
  1419.                         return(-1);
  1420.                     }
  1421.  
  1422.                     if (userNT == fileNT) {     /* no conversion needed */
  1423.                         if (DFread(dfile, (char*) sdg->dimscales[i], 
  1424.                                 (int32) (sdg->dimsizes[i]*fileNTsize))<0) {
  1425.                             isscales = DFIfreespace(isscales);
  1426.                             return(-1);
  1427.                         }
  1428.                     }
  1429.  
  1430.                     else {                      /* conversion necessary */
  1431.                         register char *p;
  1432.  
  1433.                                 /* allocate conversion buffer */
  1434.                         buf = DFIgetspace((unsigned) sdg->dimsizes[i] *
  1435.                       fileNTsize);
  1436.                         if (buf==NULL) {
  1437.                             isscales = DFIfreespace(isscales);
  1438.                             return(-1);
  1439.                         }
  1440.  
  1441.                                 /* read scale from file */
  1442.                         if (DFread(dfile, buf,
  1443.                                 (int32) (sdg->dimsizes[i]*fileNTsize))<0) {
  1444.                             buf = DFIfreespace(buf);
  1445.                             isscales = DFIfreespace(isscales);
  1446.                             return(-1);
  1447.                         }
  1448.                             
  1449.                         p = buf;
  1450.                 /* convert, all at once */
  1451.                         DFconvert(p, (char*) sdg->dimscales[i], DFNT_FLOAT,
  1452.                                  fileNT, userNT, sdg->dimsizes[i], error);
  1453.  
  1454.                         buf = DFIfreespace(buf);
  1455.                     }
  1456.                 }
  1457.                 isscales = DFIfreespace(isscales);
  1458.                 break;
  1459.  
  1460.             case DFTAG_SDC:    /* coordsys */
  1461.         /* find and allocate necessary space */
  1462.                 if (DFIfind(dfile, elmt.tag, elmt.ref, 1, 0, 0, &dlep, &cdd)<0)
  1463.                     return(-1);
  1464.                 sdg->coordsys = DFIgetspace((unsigned) dlep->dd[cdd].length);
  1465.                 if (sdg->coordsys==NULL) return(-1);
  1466.  
  1467.         /* read coordsys */
  1468.                 if (DFgetelement(dfile, elmt.tag, elmt.ref, sdg->coordsys)<0)
  1469.                     return(-1);
  1470.                 break;
  1471.  
  1472.             case DFTAG_SDM:    /* max/min */
  1473.                 if (fileNT==userNT) {       /* no conversion */
  1474.                     if (DFgetelement(dfile, elmt.tag, elmt.ref,
  1475.                      (char*) &sdg->max_data)<0)
  1476.                         return(-1);
  1477.                 }
  1478.                 else {
  1479.                         /* allocate buffer */
  1480. #ifndef CVT_BUG
  1481.             float32 mm[2];
  1482. #endif
  1483.                     buf = DFIgetspace((unsigned) 2 * fileNTsize);
  1484.                     if (buf==NULL) return(-1);
  1485.  
  1486.                         /* read and convert max/min */
  1487.                     if (DFgetelement(dfile, elmt.tag, elmt.ref, buf)<0)
  1488.                         return(-1);
  1489. #ifdef CVT_BUG
  1490.                     DFconvert(buf, (char*) &sdg->max_data, DFNT_FLOAT, fileNT,
  1491.                   userNT, 1, error);
  1492.                     DFconvert(buf+fileNTsize, (char*) &sdg->min_data,
  1493.                   DFNT_FLOAT, fileNT, userNT, 1, error);
  1494. #else
  1495.             DFconvert(buf, (char*)mm, DFNT_FLOAT,
  1496.                   fileNT, userNT, 2, error);
  1497.             sdg->max_data = mm[0];
  1498.             sdg->min_data = mm[1];
  1499. #endif
  1500.                     buf = DFIfreespace(buf);
  1501.                 }
  1502.                 Ismaxmin = 1;
  1503.                 break;
  1504.                     
  1505.             case DFTAG_SDT:
  1506.                 FileTranspose = 1;
  1507.                 break;
  1508.             default:            /* ignore unknown tags */
  1509.                 break;
  1510.         }
  1511.     }
  1512.     return(0);
  1513. }
  1514.  
  1515.  
  1516. /*-----------------------------------------------------------------------------
  1517.  * Name:    DFSDputsdg
  1518.  * Purpose: Write SDG out to HDF file
  1519.  * Inputs:  dfile: HDF file pointer
  1520.  *          ref: ref to put SDG with
  1521.  *          sdg: struct containing SDG info to put
  1522.  * Returns: 0 on success, -1 on failure with DFerror set
  1523.  * Users:   HDF programmers, utilities, DFSDputdata, other routines
  1524.  * Invokes: DFIcheck, DFdistart, DFdiadd, DFdiend, DFputelement, DFaccess,
  1525.  *          DFwrite
  1526.  * Remarks: Writes out NTs
  1527.  *---------------------------------------------------------------------------*/
  1528.  
  1529. int DFSDputsdg(dfile, ref, sdg)
  1530. DF *dfile;
  1531. uint16 ref;
  1532. DFSsdg *sdg;
  1533. {
  1534.     int i,j, localNT, luf;
  1535.     int error;            /* used by DFConvert macro */
  1536.     uint16 luftag;
  1537.     char ntstring[4];
  1538.     char *buf, *Isscales=NULL;
  1539.     DFdi nt;
  1540.  
  1541.     DFerror = DFE_NOERROR;
  1542.  
  1543.     if (DFIcheck(dfile))
  1544.         return( -1);
  1545.  
  1546.     if (!ref) {
  1547.         DFerror = DFE_BADREF;
  1548.         return(-1);
  1549.     }
  1550.  
  1551.     localNT = (DF_MT>>8) & 0x0f;            /* get third nibble from right */
  1552.  
  1553.         /* prepare to start writing sdg */
  1554.     if (DFdisetup(10)<0) return(-1);        /* max 10 tag/refs in set */
  1555.  
  1556.     if (DFdiput(sdg->data.tag, sdg->data.ref) < 0) return(-1);
  1557.  
  1558.     if (Ref.nt<=0) {
  1559.             /* construct and write out NT */
  1560.         ntstring[0] = DFNT_VERSION;         /* version */
  1561.         ntstring[1] = DFNT_FLOAT;           /* type */
  1562.         ntstring[2] = outNTsize*8;          /* width of float class in bits */
  1563.         ntstring[3] = outNT;                /* class: IEEE floating point */
  1564.         if (DFputelement(dfile, DFTAG_NT, ref, ntstring, (int32) 4) <0)
  1565.             return(-1);
  1566.         Ref.nt = ref;
  1567.     }
  1568.  
  1569.     if (Ref.dims<=0) {
  1570.         if (DFaccess(dfile, DFTAG_SDD, ref, "w")<0) return(-1);
  1571.  
  1572.                 /* write rank, dimensions */
  1573. #ifdef DF_STRUCTOK
  1574.         if (DFwrite(dfile, &sdg->rank, 2)<0) return(-1);
  1575.         if (DFwrite(dfile, sdg->dimsizes, 4 * sdg->rank)<0) return(-1);
  1576. #else /*DF_STRUCTOK*/
  1577.         {
  1578.             register char *p;
  1579.             p = DFtbuf;
  1580.             UINT16WRITE(p, sdg->rank);
  1581.             for (i=0; i<sdg->rank; i++)
  1582.                 INT32WRITE(p, sdg->dimsizes[i]);
  1583.             if (DFwrite(dfile, DFtbuf, (int32) (p-DFtbuf))<0)
  1584.                 return(-1);
  1585.         }
  1586. #endif /*DF_STRUCTOK*/
  1587.  
  1588.                 /* write data NT and scale NTs */
  1589.         nt.tag = DFTAG_NT;
  1590.         nt.ref = Ref.nt;                /* same NT for scales too */
  1591.  
  1592.             /* <= used to write 1 data  NT + rank scale NTs */
  1593.         for (i=0; i<=sdg->rank; i++)    /* scale NTs written even if no scale!*/
  1594.  
  1595. #ifdef DF_STRUCTOK
  1596.             if (DFwrite(dfile, &nt, (int32) 4)<0) return(-1);
  1597. #else /*DF_STRUCTOK*/
  1598.         {
  1599.             register char *p;
  1600.             p = DFtbuf;
  1601.             UINT16WRITE(p, nt.tag);
  1602.             UINT16WRITE(p, nt.ref);
  1603.             if (DFwrite(dfile, DFtbuf, (int32) (p-DFtbuf))<0)
  1604.                 return(-1);
  1605.         }
  1606. #endif /*DF_STRUCTOK*/
  1607.             
  1608.         Ref.dims = ref;
  1609.     }
  1610.     /* write dimension tag/ref */
  1611.     if (DFdiput(DFTAG_SDD,(uint16) Ref.dims) < 0) return(-1);
  1612.  
  1613.             /* write out label/unit/format */
  1614.     for (luf=LABEL; luf<=FORMAT; luf++) {
  1615.         luftag = (luf==LABEL) ? DFTAG_SDL : (luf==UNIT) ? DFTAG_SDU : DFTAG_SDF;
  1616.  
  1617.             /* this block of code checks if luf is NULL, else writes it */
  1618.         if (!Ref.luf[luf]) {            /* if luf was set */
  1619.             Ref.luf[luf] = -1;          /* assume it is NULL */
  1620.             for (i=0; i<sdg->rank; i++) {
  1621.                 if ((sdg->dataluf[luf] && sdg->dataluf[luf][0]) ||
  1622.                     (sdg->dimluf[luf] && sdg->dimluf[luf][i]
  1623.                                       && sdg->dimluf[luf][i][0])) {
  1624.                             /* if luf is non-NULL */
  1625.  
  1626.                             /* set up to write */
  1627.                     if (DFaccess(dfile, luftag, ref, "w")<0) return(-1);
  1628.  
  1629.                             /* write data luf */
  1630.                     if (sdg->dataluf[luf]) {
  1631.                         if (DFwrite(dfile, sdg->dataluf[luf],
  1632.                             (int32) strlen(sdg->dataluf[luf])+1)<0) return(-1);
  1633.                     }
  1634.                     else {  /* write NULL */
  1635.                         if (DFwrite(dfile, "", (int32) 1)<0) return(-1);
  1636.                     }
  1637.                         
  1638.  
  1639.                             /* write dim lufs */
  1640.                     for (j=0; j<sdg->rank; j++)
  1641.                       if (sdg->dimluf[luf] && sdg->dimluf[luf][j]) {
  1642.                         if (DFwrite(dfile, sdg->dimluf[luf][j],
  1643.                            (int32) strlen(sdg->dimluf[luf][j])+1)<0) return(-1);
  1644.                       }
  1645.                       else {    /* write NULL */
  1646.                         if (DFwrite(dfile, "", (int32) 1)<0) return(-1);
  1647.                       }
  1648.                     
  1649.                     Ref.luf[luf] = ref;    /* remember ref */
  1650.                     break;
  1651.                 }
  1652.             }
  1653.         }
  1654.     /* write luf tag/ref */
  1655.         if (Ref.luf[luf]>0) if (DFdiput(luftag, (uint16)Ref.luf[luf]) < 0)
  1656.         return(-1);
  1657.     }
  1658.  
  1659.     /* check if there is a scale and write it out */
  1660.     if (!Ref.scales) {        /* if scale set */
  1661.         Isscales = DFIgetspace((unsigned) sdg->rank);
  1662.         if (Isscales==NULL) return(-1);
  1663.         Ref.scales = (-1);                  /* assume there is no scale */
  1664.  
  1665.                     /* set up Isscales array */
  1666.         for (i=0; i<sdg->rank; i++) {
  1667.             if (sdg->dimscales && sdg->dimscales[i]) {  /* a scale exists */
  1668.                 Isscales[i] = 1;
  1669.                 Ref.scales = 0;             /* flag: write out scales */
  1670.             }
  1671.             else Isscales[i] = 0;
  1672.         }
  1673.     }
  1674.  
  1675.     if (!Ref.scales) {      /* write out scale */
  1676.         if (DFaccess(dfile, DFTAG_SDS, ref, "w")<0) {
  1677.             Isscales = DFIfreespace(Isscales);
  1678.             return(-1);
  1679.         }
  1680.                             /* write Isscales */
  1681.         if (DFwrite(dfile, Isscales, (int32) sdg->rank)<0) {
  1682.             Isscales = DFIfreespace(Isscales);
  1683.             return(-1);
  1684.         }
  1685.                             /* Write scales */
  1686.         for (j=0; j<sdg->rank; j++) {
  1687.             if (!Isscales[j]) continue;
  1688.             if (localNT==outNT) {       /* no conversion needed */
  1689.                 if (DFwrite(dfile, (char*) sdg->dimscales[j],
  1690.                             (int32) (sizeof(float32) * sdg->dimsizes[j]))<0) {
  1691.                     Isscales = DFIfreespace(Isscales);
  1692.                     return(-1);
  1693.                 }
  1694.             }
  1695.             else {              /* convert and write */
  1696.                         /* allocate buffer */
  1697.                 buf = DFIgetspace((unsigned) (outNTsize * sdg->dimsizes[j]));
  1698.                 if (buf==NULL) {
  1699.                     Isscales = DFIfreespace(Isscales);
  1700.                     return(-1);
  1701.                 }
  1702.  
  1703.                         /* convert, all at once */
  1704.                 DFconvert((char*) sdg->dimscales[j], buf, DFNT_FLOAT,
  1705.               localNT, outNT, sdg->dimsizes[j], error);
  1706.                         /* write it all out */
  1707.                 if (DFwrite(dfile, buf,
  1708.                 (int32) (outNTsize * sdg->dimsizes[j]))<0) {
  1709.                     Isscales = DFIfreespace(Isscales);
  1710.                     buf = DFIfreespace(buf);
  1711.                     return(-1);
  1712.                 }
  1713.                 buf = DFIfreespace(buf);
  1714.             }
  1715.         }
  1716.         Ref.scales = ref;
  1717.     }
  1718.     Isscales = DFIfreespace(Isscales);
  1719.     if (Ref.scales>0) if (DFdiput(DFTAG_SDS, (uint16) Ref.scales) < 0)
  1720.     return(-1);
  1721.  
  1722.     /* write coordsys */
  1723.     if (!sdg->coordsys || !sdg->coordsys[0]) Ref.coordsys = (-1);
  1724.     if (!Ref.coordsys) {
  1725.         if (DFputelement(dfile, DFTAG_SDC, ref, sdg->coordsys,
  1726.                             (int32) (strlen(sdg->coordsys)+1))<0) return(-1);
  1727.         Ref.coordsys = ref;
  1728.     }
  1729.     if (Ref.coordsys>0) if (DFdiput(DFTAG_SDC, (uint16) Ref.coordsys) < 0)
  1730.     return(-1);
  1731.         
  1732.     /* write max/min */
  1733.     if (!Ref.maxmin) {
  1734.         if (localNT == outNT) {     /* no conversion */
  1735.             if (DFputelement(dfile, DFTAG_SDM, ref, (char*) &sdg->max_data,
  1736.                  (int32) (2 * sizeof(float32)))<0) return(-1);
  1737.             Ref.maxmin = ref;
  1738.         }
  1739.         else {
  1740.         /* allocate buffer */
  1741. #ifndef CVT_BUG
  1742.         float32 mm[2];
  1743.         mm[0] = sdg->max_data;
  1744.         mm[1] = sdg->min_data;
  1745. #endif
  1746.             buf = DFIgetspace((unsigned) 2*outNTsize); /* max/min is 8 bytes */
  1747.             if (buf==NULL) return(-1);
  1748.  
  1749.         /* convert */
  1750. #ifndef CVT_BUG
  1751.         DFconvert((char*) mm, buf, DFNT_FLOAT, localNT, outNT,2, error);
  1752. #else
  1753.             DFconvert((char*) &sdg->max_data, buf, DFNT_FLOAT, localNT, outNT,
  1754.                       1, error);
  1755.             DFconvert((char*) &sdg->min_data, buf+outNTsize, DFNT_FLOAT,
  1756.               localNT, outNT, 1, error);
  1757. #endif
  1758.         /* write */
  1759.             if (DFputelement(dfile, DFTAG_SDM, ref, buf,
  1760.                  (int32) (2*outNTsize))<0) {
  1761.                 buf = DFIfreespace(buf);
  1762.                 return(-1);
  1763.             }
  1764.             Ref.maxmin = ref;
  1765.             buf = DFIfreespace(buf);
  1766.         }
  1767.     }
  1768.     if (Ref.maxmin>0) if (DFdiput(DFTAG_SDM, (uint16) Ref.maxmin) < 0)
  1769.     return(-1);
  1770.     Ref.maxmin = (-1);        /* max/min should be reset for each data set */
  1771.  
  1772.     if (!Ref.transpose) {
  1773.         if (DFaccess(dfile, DFTAG_SDT, ref, "w")<0) return(-1);
  1774.         Ref.transpose = ref;
  1775.     }
  1776.         
  1777.     if (Ref.transpose>0) if (DFdiput(DFTAG_SDT, (uint16) Ref.transpose) < 0)
  1778.     return(-1);
  1779.  
  1780.     /* write out SDG */
  1781.     return(DFdiwrite(dfile, DFTAG_SDG, ref));
  1782. }
  1783.  
  1784.  
  1785. /******************************************************************************/
  1786. /*----------------------- Internal routines ---------------------------------*/
  1787. /******************************************************************************/
  1788.  
  1789. /*-----------------------------------------------------------------------------
  1790.  * Name:    DFSDIopen
  1791.  * Purpose: open or reopen a file
  1792.  * Inputs:  filename: name of file to open
  1793.  *          access : access mode
  1794.  * Returns: file pointer on success, NULL on failure with DFerror set
  1795.  * Users:   HDF systems programmers, many SD routines
  1796.  * Invokes: DFopen
  1797.  * Remarks: This is a hook for someday providing more efficient ways to
  1798.  *          reopen a file, to avoid re-reading all the headers
  1799.  *---------------------------------------------------------------------------*/
  1800.  
  1801. DF *DFSDIopen(filename, access)
  1802. char *filename;
  1803. int access;
  1804. {
  1805.  
  1806.     DF *dfile;
  1807.  
  1808.     if (Sdfile!=NULL) {     /* in the middle of a partial write */
  1809.         DFerror = DFE_ALROPEN;
  1810.         return(NULL);
  1811.     }
  1812.  
  1813.         /* use reopen if same file as last time - more efficient */
  1814.     if (strncmp(Lastfile,filename,DF_MAXFNLEN) || (access==DFACC_CREATE)) {
  1815.                                     /* treat create as different file */
  1816.         if (!(dfile = DFopen(filename, access, -1))) return(NULL);
  1817.         Newdata = (-1);         /* data in Readsdg is not fresh */
  1818.         Readsdg.data.ref = 0;   /* No SDG read yet */
  1819.  
  1820.                     /* remember no info written to file */
  1821.         Ref.scales  = (Ref.scales  >= 0) ? 0 : Ref.scales;
  1822.         Ref.luf[LABEL]  = (Ref.luf[LABEL]  >= 0) ? 0 : Ref.luf[LABEL];
  1823.         Ref.luf[UNIT]   = (Ref.luf[UNIT]   >= 0) ? 0 : Ref.luf[UNIT];
  1824.         Ref.luf[FORMAT] = (Ref.luf[FORMAT] >= 0) ? 0 : Ref.luf[FORMAT];
  1825.         Ref.dims    = (Ref.dims    >= 0) ? 0 : Ref.dims;
  1826.         Ref.coordsys = (Ref.coordsys >= 0) ? 0 : Ref.coordsys;
  1827.         Ref.maxmin = (Ref.maxmin >= 0) ? 0 : Ref.maxmin;
  1828.         Ref.nt = (Ref.nt >= 0) ? 0 : Ref.nt;
  1829.     }
  1830.     else
  1831.         if (!(dfile = DFopen(filename, access, -1))) return(NULL);
  1832.  
  1833.     strncpy(Lastfile, filename, DF_MAXFNLEN); 
  1834.             /* remember filename, so reopen may be used next time if same file*/
  1835.  
  1836.     return(dfile);
  1837. }
  1838.  
  1839.  
  1840. /*-----------------------------------------------------------------------------
  1841.  * Name:    DFSDIsdginfo
  1842.  * Purpose: Locates next sdg in file
  1843.  * Inputs:  dfile: pointer to DF file
  1844.  * Returns: 0 on success, -1 on failure with DFerror set
  1845.  * Users:   HDF systems programmers, DFSDgetdims, DFSDgetdata
  1846.  * Invokes: DFIfind, DFSDgetsdg
  1847.  * Method:  Call DFIfind to find SDG, then DFSDgetsdg to read it in to Readsdg
  1848.  * Remarks: none
  1849.  *---------------------------------------------------------------------------*/
  1850.  
  1851. DFSDIsdginfo(dfile)
  1852. DF *dfile;
  1853. {
  1854.     DFdle *dlep;
  1855.     int cdd;
  1856.  
  1857.     if (DFIcheck(dfile)) {
  1858.         DFerror = DFE_BADCALL;
  1859.         return(-1);
  1860.     }
  1861.         
  1862.     /* find next sdg */
  1863.     if ((!Readref
  1864.      && DFIfind(dfile, DFTAG_SDG, DFREF_WILDCARD, !Readsdg.data.ref,
  1865.         DFTAG_SDG, Readsdg.data.ref, &dlep, &cdd) <0)
  1866.     ||
  1867.     (Readref
  1868.      && DFIfind(dfile, DFTAG_SDG, Readref, 1, 0, 0, &dlep, &cdd) < 0)) {
  1869.         Newdata = (-1);
  1870.         DFerror = DFE_NOMATCH;
  1871.         return(-1);
  1872.     }
  1873.     if (DFSDgetsdg(dfile, dlep->dd[cdd].ref, &Readsdg)<0) return(-1);
  1874.  
  1875.     Lastref = dlep->dd[cdd].ref; /* remember ref read */
  1876.  
  1877.     /* now Readsdg is fresh */
  1878.     Newdata=1;
  1879.     Readref = 0;
  1880.  
  1881.     return(0);
  1882. }
  1883.  
  1884.  
  1885. /*-----------------------------------------------------------------------------
  1886.  * Name:    DFSDIclear
  1887.  * Purpose: Reset all "set" values, free allocated space
  1888.  * Inputs:  sdg: pointer to sdg struct to clear
  1889.  * Globals: Ref
  1890.  * Returns: 0 on success, -1 on error with DFerror set
  1891.  * Users:   HDF users, utilities, other routines
  1892.  * Invokes: none
  1893.  * Method:  Release space in sdg
  1894.  * Remarks: none
  1895.  *---------------------------------------------------------------------------*/
  1896.  
  1897. int DFSDIclear(sdg)
  1898. DFSsdg *sdg;
  1899. {
  1900.     int luf, i;
  1901.  
  1902.     DFerror = DFE_NOERROR;
  1903.  
  1904.     if (Sdfile !=NULL) {                /* cannot clear during slice writes */
  1905.         DFerror = DFE_BADCALL;
  1906.         return(-1);
  1907.     }
  1908.  
  1909.     sdg->dimsizes = (int32 *) DFIfreespace((char*) sdg->dimsizes);
  1910.  
  1911.     sdg->coordsys = DFIfreespace(sdg->coordsys);
  1912.  
  1913.         /* free label/unit/format pointers */
  1914.     for (luf=LABEL; luf<=FORMAT; luf++) {
  1915.         if (sdg->dimluf[luf])       /* free strings */
  1916.             for (i=0; i<sdg->rank; i++)
  1917.                 sdg->dimluf[luf][i] = DFIfreespace(sdg->dimluf[luf][i]);
  1918.  
  1919.     /* free string pointers */
  1920.         sdg->dimluf[luf] = (char **) DFIfreespace((char*) sdg->dimluf[luf]);
  1921.  
  1922.     /* free data string */
  1923.         sdg->dataluf[luf] = DFIfreespace(sdg->dataluf[luf]);
  1924.     }
  1925.  
  1926.     /* free scale pointers */
  1927.     if (sdg->dimscales)
  1928.         for (i=0; i<sdg->rank; i++)
  1929.             sdg->dimscales[i] = (float32 *)
  1930.         DFIfreespace((char*) sdg->dimscales[i]);
  1931.  
  1932.     /* free array of scale pointers */
  1933.     sdg->dimscales = (float32 **) DFIfreespace((char*)sdg->dimscales);
  1934.  
  1935.     sdg->rank = 0;
  1936.  
  1937.     Ref.dims = -1;
  1938.     Ref.scales = Ref.luf[LABEL] = Ref.luf[UNIT] = Ref.luf[FORMAT] = (-1);
  1939.     Ref.coordsys = Ref.maxmin = (-1);
  1940.     return(0);
  1941. }
  1942.  
  1943.  
  1944. /*-----------------------------------------------------------------------------
  1945.  * Name:    DFSDIgetdata
  1946.  * Purpose: Get data from SDG.  Will sequence to next SDG if DFSDgetdims not
  1947.  *          called.
  1948.  * Inputs:  filename: name of HDF file to use
  1949.  *          rank: no of dimensions of array "data"
  1950.  *          maxsizes: actual dimensions of array "data"
  1951.  *          data: data for returning scientific data
  1952.  *          isfortran : 0 if called from C, 1 when called from FORTRAN
  1953.  * Returns: 0 on success, -1 on failure with DFerror set
  1954.  * Outputs: actual scientific data in array
  1955.  * Users:   DFSDgetdata
  1956.  * Invokes: DFSDIgetslice, DFIgetspace, DFIfreespace, DFSDIopen, DFclose,
  1957.  *          DFIerr, DFSDIsdginfo
  1958.  * Method:  Open file, call DFSDIsdginfo to read sdg if necessary, set up
  1959.  *          window start and end arrays, call DFSDIgetslice.
  1960.  * Remarks: maxsizes may be larger than actual size.  In that event, the actual
  1961.  *          data may not be contiguous in the array "data"
  1962.  *          User sets maxsizes before call.
  1963.  *---------------------------------------------------------------------------*/
  1964.  
  1965.  
  1966. int DFSDIgetdata(filename, rank, maxsizes, data, isfortran)
  1967. char *filename;
  1968. int rank;
  1969. int32 maxsizes[];
  1970. float32 data[];
  1971. int isfortran;
  1972. {
  1973.     int32 *winst, *windims;
  1974.     int ret, i;
  1975.     DF *dfile;
  1976.  
  1977.     DFerror = DFE_NOERROR;
  1978.  
  1979.     if (Newdata!=1 || Nextsdg) { /* if Readsdg not fresh */
  1980.         dfile = DFSDIopen(filename, DFACC_READ);
  1981.         if (dfile == NULL) return(-1);
  1982.         if (DFSDIsdginfo(dfile)<0) /* reads next SDG from file */
  1983.             return(DFIerr(dfile));
  1984.         if (DFclose(dfile)<0) return(-1);
  1985.     }
  1986.  
  1987.     winst = (int32 *) DFIgetspace((unsigned) Readsdg.rank * sizeof(int32));
  1988.     if (winst==NULL) return(-1);
  1989.     windims = (int32 *) DFIgetspace((unsigned) Readsdg.rank * sizeof(int32));
  1990.     if (windims==NULL) {
  1991.         DFIfreespace((char*) winst);
  1992.         return(-1);
  1993.     }
  1994.  
  1995.     for (i=0; i<rank; i++) {
  1996.         winst[i] = 1;
  1997.         windims[i] = Readsdg.dimsizes[i];
  1998.     }
  1999.  
  2000.     ret = DFSDIgetslice(filename, winst, windims, data, maxsizes,
  2001.             isfortran);
  2002.     winst = (int32 *) DFIfreespace((char*) winst);
  2003.     windims = (int32 *) DFIfreespace((char*) windims);
  2004.     Nextsdg = 1;
  2005.     return(ret);
  2006. }
  2007.  
  2008.  
  2009. /*-----------------------------------------------------------------------------
  2010.  * Name:    DFSDIputdata
  2011.  * Purpose: Writes entire SDG to file
  2012.  * Inputs:  filename: name of HDF file to use
  2013.  *          rank: rank of data array
  2014.  *          dimsizes: sizes of the dimensions of data array
  2015.  *          data: array that holds data
  2016.  *          accmode: 0 if write to new file, 1 if append to file
  2017.  *          isfortran: 0 if C, 1 if FORTRAN
  2018.  * Globals: Writeref
  2019.  * Returns: 0 on success, -1 on failure with DFerror set
  2020.  * Users:   HDF users, utilities, other routines
  2021.  * Invokes: DFSDIopen, DFclose, DFIgetspace, DFIfreespace, DFSDIputslice,
  2022.  *          DFSDstartslice, DFSDendslice
  2023.  * Method:  Create file if necessary, allocate arrays, call slice routines
  2024.  *---------------------------------------------------------------------------*/
  2025.  
  2026. int DFSDIputdata(filename, rank, dimsizes, data, accmode, isfortran)
  2027. char *filename;
  2028. int16  rank;
  2029. int32   *dimsizes;
  2030. float32 *data;
  2031. int accmode;
  2032. int isfortran;
  2033. {
  2034.     int ret;
  2035.     DF *dfile;
  2036.  
  2037.     DFerror = DFE_NOERROR;
  2038.  
  2039.     if (!accmode) {                             /* new file */
  2040.         dfile = DFSDIopen(filename, DFACC_CREATE);
  2041.         if (dfile == NULL) return(-1);
  2042.         if (DFclose(dfile)<0) return(-1);
  2043.     }
  2044.  
  2045.     if (Ref.dims)       /* don't call setdims if already called */
  2046.         if (DFSDsetdims(rank, dimsizes)<0) return(-1);
  2047.  
  2048.     if (DFSDstartslice(filename)<0) return(-1);
  2049.  
  2050.     if ((ret=DFSDIputslice(Writesdg.dimsizes, data, dimsizes, isfortran)) <0)
  2051.     return ret;
  2052.  
  2053.     return DFSDendslice();
  2054. }
  2055.  
  2056. /*----------------------------------------------------------------------------
  2057.  * Name:    DFSDIgetslice
  2058.  * Purpose: Get slice of data from SDG.  Will sequence to next SDG if
  2059.  *          DFSDgetdims, DFSDgetdata or DFSDgetslice not called earlier.
  2060.  * Inputs:  filename: name of HDF file to use
  2061.  *          winst: array of size = rank of data, containing start of slice
  2062.  *          windims: array of size rank, containing size of slice
  2063.  *          data: array for returning slice
  2064.  *          dims: dimensions of array data
  2065.  *          isfortran : 0 if called from C, 1 when called from FORTRAN
  2066.  * Returns: 0 on success, -1 on failure with DFerror set
  2067.  * Outputs: slice of data in data
  2068.  * Users:   DFSDIgetdata
  2069.  * Invokes: DFSDIopen, DFclose, DFIerr, DFSDIsdginfo, DFaccess, DFread
  2070.  * Method:  Open file, call DFSDIsdginfo to read sdg if necessary, read the
  2071.  *          data, convert types if necessary, place in data as appropriate
  2072.  *          data is assumed column major for FORTRAN, row major for C
  2073.  * Remarks: dims may be larger than size of slice.  In that event, the actual
  2074.  *          data may not be contiguous in the array "data".
  2075.  *          User sets dims before call.
  2076.  *--------------------------------------------------------------------------*/
  2077.  
  2078. int DFSDIgetslice(filename, winst, windims, data, dims, isfortran)
  2079.     char    *filename;
  2080.     int32    winst[];    /* array containing starting dimensions */
  2081.                 /* of the slice    */
  2082.     int32    windims[];    /* array containing the size of the slice */
  2083.     int32    dims[];        /* array containing the dimensions of data[] */
  2084.     float32    data[];        /* array to hold the floating point data read*/
  2085.     int        isfortran;    /* true if called from Fortran */
  2086.  
  2087. {
  2088.     int
  2089.     rank,            /* number of dimensions in data[] */
  2090.     leastsig,        /* fastest varying subscript in the array */
  2091.     error;            /* flag if an error occurred */
  2092.                 /* used by DFconvert macro */
  2093.     int
  2094.     convert,        /* true if machine NT = NT to be read */
  2095.     done,            /* true if we are at end of the slice */
  2096.     transposed;        /* true if we must transpose */
  2097.                 /* the data before writing */
  2098.     int32
  2099.     i, j,            /* temporaries */
  2100.     numfloats,        /* number of floats to read at once */
  2101.     readsize,        /* number of bytes to read at once */ 
  2102.     stride,            /* number of floats in one row of data[] */
  2103.     *dimsleft,        /* array for tracking the current position */
  2104.                 /* in data[] */
  2105.     *offset,        /* array for accessing the next element */
  2106.                 /* in data[] */
  2107.     *foffset,        /* array for accessing the next element */
  2108.                 /* from the file   */
  2109.     fileoffset,        /* offset into the current dataset */
  2110.                 /* in the file          */
  2111.     *wstart,        /* tmp array containing starting slice dims */
  2112.     *wdims,            /* tmp array containing the slice size */
  2113.     *adims,            /* tmp array containing the dimensions */
  2114.                 /* of data[] */
  2115.     *fdims;            /* tmp array containing the */
  2116.                 /* dataset dimensions */
  2117.             
  2118.     float32
  2119.     *datap,            /* ptr into data[] at starting offset */
  2120.                 /* of current block */
  2121.     *dp,            /* ptr into data[] at an element */
  2122.                 /* of the current row */
  2123.     *scatterbuf;        /* buffer to hold the */
  2124.                 /* current row contiguously */
  2125.     char
  2126.     *buf;            /* buffer containing the */
  2127.                 /* converted current row */
  2128.     DF    *dfile;            /* HDF file pointer */
  2129.  
  2130.     DFerror = DFE_NOERROR;
  2131.  
  2132.     if (!data) {
  2133.         DFerror = DFE_BADPTR;
  2134.         return(-1);
  2135.     }
  2136.  
  2137.     dfile = DFSDIopen(filename, DFACC_READ);
  2138.     if (dfile == NULL) return(-1);
  2139.  
  2140.     if (Newdata!=1) {        /* if Readsdg not fresh */
  2141.         if (DFSDIsdginfo(dfile)<0) /* reads next SDG from file */
  2142.             return(DFIerr(dfile));
  2143.     }
  2144.  
  2145.     rank = Readsdg.rank;
  2146.  
  2147.     /* get dimensions of slice to extract, set nwindims. also err check */
  2148.     for (i=0; i<rank; i++) {
  2149.         /* check validity for the dimension ranges */
  2150.         if ((windims[i]<=0) || (winst[i]<=0)
  2151.         || (winst[i]+windims[i]-1 > Readsdg.dimsizes[i])) {
  2152.         DFerror = DFE_BADDIM;
  2153.         return(DFIerr(dfile));
  2154.     }
  2155.     /* check if space allocated is sufficient */
  2156.     if (dims[i]<windims[i]) {
  2157.             DFerror = DFE_NOTENOUGH;
  2158.             return(DFIerr(dfile));
  2159.         }
  2160.     }
  2161.  
  2162.     /* allocate buffers */
  2163.     wstart = (int32 *) DFIgetspace((unsigned) 4 * rank * sizeof(int32));
  2164.     if (wstart == NULL) {
  2165.     DFerror = DFE_NOSPACE;
  2166.         return(DFIerr(dfile));
  2167.     }
  2168.     wdims = wstart + rank;
  2169.     adims = wdims + rank;
  2170.     fdims = adims + rank;
  2171.  
  2172.     /* copy arrays to private workspace (so that they are in row major order)*/
  2173.     for (i=0; i<rank; i++) {
  2174.     int ii = isfortran ? rank-i-1 : i;
  2175.     adims[i] = dims[ii];
  2176.     ii = FileTranspose ? rank-i-1 : i;
  2177.     wstart[i] = winst[ii]-1; /* translate to 0 origin */
  2178.     wdims[i] = windims[ii];
  2179.     fdims[i] = Readsdg.dimsizes[ii];
  2180.     }
  2181.  
  2182.     userNT     = (DF_MT>>8) & 0x0f; /* get third nibble from right*/
  2183.     convert    = (fileNT != userNT); /* is conversion necessary */
  2184.     transposed = isfortran ^ FileTranspose; /* is transposition needed */
  2185.  
  2186.     /*
  2187.      * Note that if the data is transposed we must work on a row by row
  2188.      * basis and cannot collapse dimensions.
  2189.      */
  2190.     if (!transposed) {
  2191.     /* collapse dimensions if contiguous both in the file and in memory */
  2192.     for (i=rank-1; i>0; i--) { /* stop before most sig dim */
  2193.         if (adims[i] > wdims[i] /* not all of data[] will be filled */
  2194.         || wstart[i] != 0 /* reading only part of the dataset */
  2195.         || wdims[i] < fdims[i])
  2196.         break;
  2197.         wstart[i-1] = wstart[i-1] * wdims[i];
  2198.         wdims[i-1] *= wdims[i];
  2199.         adims[i-1] = fdims[i-1] = wdims[i-1];
  2200.         rank--;
  2201.     }
  2202.     }
  2203.     leastsig = rank-1;        /* which is least sig dim */
  2204.  
  2205.     /* position at start of image */
  2206.     if (DFaccess(dfile, Readsdg.data.tag, Readsdg.data.ref, "r") < 0) {
  2207.     DFIfreespace((char *)wstart);
  2208.         return(DFIerr(dfile));
  2209.     }
  2210.  
  2211.     error = 0;
  2212.     if (rank==1 && !convert) {
  2213.     /* all data is contiguous with no conversions */
  2214.     readsize = adims[0] * sizeof(float32);
  2215.     if (DFIseek(dfile, wstart[0]*fileNTsize) < 0 ||
  2216.         readsize != DFread(dfile, (char *)data, readsize))
  2217.         error=1;
  2218.     } else {
  2219.     /*
  2220.      * The data must be further manipulated.
  2221.      * It may be transposed, may need conversion, may not be contiguous, or
  2222.      * any combination of these.
  2223.      */
  2224.     numfloats  = wdims[leastsig];
  2225.     readsize = numfloats * fileNTsize;
  2226.  
  2227.     /* allocate 1 row buffers */
  2228.     if (convert) {
  2229.         if ((buf = DFIgetspace((unsigned) readsize)) == NULL) {
  2230.         DFIfreespace((char *)wstart);
  2231.         DFerror = DFE_NOSPACE;
  2232.         return(DFIerr(dfile));
  2233.         }
  2234.     } else buf = NULL;
  2235.  
  2236.     if (transposed) {
  2237.         scatterbuf = (float32 *)DFIgetspace((unsigned) numfloats
  2238.                         *sizeof(float32));
  2239.         if (scatterbuf == NULL) {
  2240.         DFIfreespace((char *)wstart);
  2241.         DFIfreespace(buf);
  2242.         DFerror = DFE_NOSPACE;
  2243.         return(DFIerr(dfile));
  2244.         }
  2245.     } else scatterbuf = NULL;
  2246.  
  2247.     offset = (int32 *) DFIgetspace((unsigned)3 * rank * sizeof(int32));
  2248.     if (offset==NULL) {
  2249.         DFIfreespace((char *)wstart);
  2250.         DFIfreespace(buf);
  2251.         DFIfreespace((char *)scatterbuf);
  2252.         DFerror = DFE_NOSPACE;
  2253.         return(DFIerr(dfile));
  2254.     }
  2255.     foffset = offset + rank;
  2256.     dimsleft = foffset + rank;
  2257.  
  2258.     /* compute initial position in the data */
  2259.     for (i=leastsig; i>=0; i--)
  2260.         dimsleft[i] = wdims[i];
  2261.  
  2262.     /* compute offsets in the source array */
  2263.     if (transposed) {
  2264.         offset[0] = 1;
  2265.         for (i=0; i<leastsig; i++)
  2266.         offset[i+1] = offset[i] * adims[leastsig - i];
  2267.     } else {
  2268.         offset[leastsig] = 1;
  2269.         for (i = leastsig; i>0; i--)
  2270.         offset[i-1] = offset[i] * adims[i];
  2271.     }
  2272.     stride = offset[leastsig];
  2273.  
  2274.     /* compute offsets in the file */
  2275.     for (i=leastsig, foffset[i]=1*fileNTsize; i>0; i--)
  2276.         foffset[i-1] = foffset[i] * fdims[i];
  2277.  
  2278.     /*
  2279.      * Compute starting position in file
  2280.      * All file reads are done relative to this starting offset.
  2281.      * Cumulative offset is from most sig to next to least sig dim.
  2282.      */
  2283.     for (i=0, fileoffset=0; i<leastsig; i++) 
  2284.         fileoffset = (fileoffset+wstart[i]) * fdims[i+1];
  2285.     fileoffset += wstart[leastsig]; /* adjust for last dim */
  2286.     fileoffset *= fileNTsize; /* convert to bytes */
  2287.  
  2288.     datap = data;
  2289.     done = 0;
  2290.  
  2291.     /* -- now read in the data */
  2292.     do {
  2293.         /* move to the next data element in the file */
  2294.         if (DFIseek(dfile, fileoffset) < 0) {
  2295.         error=1;
  2296.         break;
  2297.         }
  2298.  
  2299.         /* read and convert one contiguous block of data */
  2300.         if (convert) {
  2301.         if (readsize != DFIread(dfile, buf, readsize)) {
  2302.             error=1;
  2303.             break;
  2304.         }
  2305.         DFconvert(buf, transposed ? (char *)scatterbuf : (char *)datap,
  2306.               DFNT_FLOAT, fileNT, userNT, numfloats, error);
  2307.         }
  2308.         else
  2309.         if (readsize != DFIread(dfile, transposed ?
  2310.                        (char *)scatterbuf :
  2311.                        (char *)datap, readsize)) {
  2312.             error=1;
  2313.             break;
  2314.         }
  2315.  
  2316.         if (transposed) {
  2317.         /* scatter out the elements of one row */
  2318. #ifdef UNICOS
  2319. #pragma ivdep
  2320. #endif
  2321.         for (dp=datap, i=0; i<numfloats; i++) {
  2322.             *dp = scatterbuf[i];
  2323.             dp += stride;
  2324.         }
  2325.         }
  2326.  
  2327.         /*
  2328.          * Find starting place of the next row/block.
  2329.          * Note that all moves are relative:
  2330.          *   this preserves the starting offsets of each dimension 
  2331.          */
  2332.         for (i=leastsig-1; i>=0; i--) {
  2333.         if (--dimsleft[i] > 0) {
  2334.             /* move to next element in the current dimension */
  2335.             datap += offset[i];
  2336.             fileoffset += foffset[i];
  2337.             break;
  2338.         } else {
  2339.             dimsleft[i] = wdims[i];
  2340.             /*
  2341.              * Note that we are still positioned at the beginning of
  2342.              * the last element in the current dimension 
  2343.              */
  2344.             /* move back to the beginning of dimension i */
  2345.             datap -= offset[i] * (wdims[i]-1);
  2346.             /* move back to beginning read position of dimension i */
  2347.             fileoffset -= foffset[i] * (wdims[i]-1);
  2348.             if (i==0) done = 1;
  2349.         }
  2350.         }
  2351.     } while (!done && leastsig > 0);
  2352.  
  2353.     DFIfreespace(buf);
  2354.     DFIfreespace((char *)scatterbuf);
  2355.     DFIfreespace((char *)offset);
  2356.     }
  2357.  
  2358.     DFIfreespace((char *)wstart);
  2359.     return( error ? DFIerr(dfile) : DFclose(dfile) );
  2360. }
  2361.  
  2362. /*----------------------------------------------------------------------------
  2363.  * Name:    DFSDIputslice
  2364.  * Purpose: Put slice of data to SDG.
  2365.  * Inputs:  windims: array of size rank, containing size of slice
  2366.  *          data: array containing slice
  2367.  *          dims: dimensions of array data
  2368.  *            isfortran: 0 for C, 1 for Fortran
  2369.  * Returns: 0 on success, -1 on failure with DFerror set
  2370.  * Users:   DFSDputslice
  2371.  * Invokes: DFwrite, DFIgetspace, DFIfreespace
  2372.  * Method:  check dimensions for contiguity, convert types if necessary
  2373.  *          write to file
  2374.  * Remarks: dims may be larger than size of slice.  In that event, the actual
  2375.  *          data may not be contiguous in the array "data".
  2376.  *          DFSDstartslice must have been called first
  2377.  *          Note, writes must be contiguous - successive calls to putslice
  2378.  *          must write out array consecutively, according to the setting
  2379.  *          of the Fortorder variable - row major if 0, column major if 1
  2380.  *--------------------------------------------------------------------------*/
  2381.  
  2382. int DFSDIputslice(windims, data, dims, isfortran)
  2383.  
  2384.     int32    windims[];    /* array containing dimensions of the slice */
  2385.     int32    dims[];        /* array containing the dimensions of data[] */
  2386.     float32    data[];        /* array of the floating point data to write */
  2387.     int        isfortran;    /* true if called from Fortran */
  2388. {
  2389.     int
  2390.     rank,            /* number of dimensions in data[] */
  2391.     ret,            /* return code from DFwrite */
  2392.     leastsig;        /* fastest varying subscript in the array */
  2393.     int
  2394.     convert,        /* true if machine NT = NT to be written */
  2395.     done,            /* true if we are at end of the slice */
  2396.     transposed,        /* true if we must transpose */
  2397.                 /* the data before writing    */
  2398.     contiguous;        /* true if there are no gaps */
  2399.                 /* in the data to be written    */
  2400.     int error;            /* used by DFconvert macro */
  2401.     int32
  2402.     i, j,            /* temporaries */
  2403.     numfloats,        /* number of floats to write out per row */
  2404.     writesize,        /* number of bytes to write out per row */
  2405.     stride,            /* number of bytes in one row of data[] */
  2406.     *dimsleft,        /* array for tracking the */
  2407.                 /* current position in data[]    */
  2408.     *offset;        /* array for accessing the */
  2409.                 /* next element in data[] */
  2410.     float32
  2411.     *datap,            /* pointer into data[] at */
  2412.                 /* the start of the current row    */
  2413.     *dp,            /* pointer into data[] to an element */
  2414.                 /* of the current row */
  2415.     *gatherbuf;        /* buffer to hold the current row */
  2416.                 /* contiguously */
  2417.     char
  2418.     *buf,            /* buffer containing the */
  2419.                 /* converted current row */
  2420.     *outbufp;        /* pointer to the buffer containing */
  2421.                 /* the data to write */
  2422.  
  2423.     DFerror = DFE_NOERROR;
  2424.  
  2425.     if (!data) {
  2426.         DFerror = DFE_BADPTR;
  2427.         return(-1);
  2428.     }
  2429.  
  2430.     if (!Sdfile) {
  2431.         DFerror = DFE_BADCALL;
  2432.         return(-1);
  2433.     }
  2434.  
  2435.     rank = Writesdg.rank;
  2436.  
  2437.     for (i=0; i<rank; i++) {
  2438.         /* check validity for the dimension ranges */
  2439.         if ((windims[i]<=0) || (windims[i]>Writesdg.dimsizes[i])) {
  2440.             DFerror = DFE_BADDIM;
  2441.             return(-1);
  2442.         }
  2443.     /* check if space allocated is sufficient */
  2444.     if (dims[i] < windims[i]) {
  2445.         DFerror = DFE_NOTENOUGH;
  2446.         return(-1);
  2447.     }
  2448.     }
  2449.  
  2450.     /* check to see if the slices fit together */
  2451.     if (Fortorder) {
  2452.     /* find the first significant dimension */
  2453.     for (i=rank-1; windims[i] == 1 && i>0; i--)
  2454.         ;
  2455.     /* check that all 'lesser' dims match */
  2456.     for (j=i-1; j>=0; j--)
  2457.         if (dims[j] != windims[j]) {
  2458.         DFerror = DFE_BADDIM;
  2459.         return (-1);
  2460.         }
  2461.     /* update Sddims to reflect new write */
  2462.     Sddims[i] += windims[i];
  2463.     for (; i<rank-1 && Sddims[i] >= dims[i]; i++) {
  2464.         Sddims[i+1] += Sddims[i] / dims[i]; /* promote the unit */
  2465.         Sddims[i] %= dims[i];
  2466.     }
  2467.     } else {
  2468.     /* find the first significant dimension */
  2469.     for (i=0; windims[i] == 1 && i<rank-1; i++)
  2470.         ;
  2471.     /* check that all 'lesser' dims match */
  2472.     for (j=i+1; j<rank; j++)
  2473.         if (dims[j] != windims[j]) {
  2474.         DFerror = DFE_BADDIM;
  2475.         return (-1);
  2476.         }
  2477.     /* update Sddims to reflect new write */
  2478.     Sddims[i] += windims[i];
  2479.     for (;i>0 && Sddims[i] >= dims[i]; i--) {
  2480.         Sddims[i-1] += Sddims[i] / dims[i]; /* promote the unit */
  2481.         Sddims[i] %= dims[i];
  2482.     }
  2483.     }
  2484.  
  2485.     leastsig = Fortorder ? 0 : rank-1; /* which is least sig dim */
  2486.     userNT = (DF_MT>>8) & 0x0f;    /* get third nibble from right */
  2487.     convert = (outNT != userNT); /* is conversion necessary */
  2488.     transposed = isfortran ^ Fortorder;    /* is data transposition needed */
  2489.  
  2490.     contiguous = !transposed;
  2491.     for (i=0; contiguous && i<rank; i++) {
  2492.     /* check if data at the start of the users array will be contiguous */
  2493.     /* NOTE: do this if a winstart[] array is ever added */
  2494.  
  2495.     /* check if data at the end of the users array will be contiguous */
  2496.     if (dims[i] > Writesdg.dimsizes[i])
  2497.         contiguous = 0;
  2498.     }
  2499.  
  2500.     /*
  2501.      *    3 Factors that determine how we write (in order of importance)
  2502.      *    transposed, conversion, contiguous
  2503.      */
  2504.  
  2505.     if (!transposed) {
  2506.     if (!convert && contiguous) {
  2507.         /* compute total number of floats to write */
  2508.         for (i=0, numfloats=1; i<rank; i++) numfloats *= windims[i];
  2509.         writesize = numfloats * sizeof(float32);
  2510.         if ((ret = DFwrite(Sdfile, (char *)data, writesize)) < 0)
  2511.         return(DFIerr(Sdfile));
  2512.     }
  2513.     else {            /* must step through the data */
  2514.         /* compute number of occurrences of the least sig dim */
  2515.         if (Fortorder)
  2516.         for (i=rank-1, j=1; i>0; i--) j *= windims[i];
  2517.         else
  2518.         for (i=0, j=1; i<rank-1; i++) j *= windims[i];
  2519.         numfloats = windims[leastsig];
  2520.         writesize = numfloats * outNTsize;
  2521.         stride = dims[leastsig];
  2522.         if (convert) { 
  2523.         buf = DFIgetspace((unsigned) writesize);
  2524.         if (buf == NULL) return(DFIerr(Sdfile));
  2525.         for (i=0; i<j; i++, data+=stride) {
  2526.             DFconvert((char *)data, buf, DFNT_FLOAT,
  2527.                   userNT, outNT, numfloats, error);
  2528.             if ((ret = DFwrite(Sdfile, buf, writesize)) < 0) {
  2529.             DFIfreespace(buf);
  2530.             return(DFIerr(Sdfile));
  2531.             }
  2532.         }
  2533.         DFIfreespace(buf);
  2534.         }
  2535.         else {
  2536.         for (i=0; i<j; i++, data+=stride)
  2537.             if ((ret = DFwrite(Sdfile, (char *)data, writesize)) < 0)
  2538.             return(DFIerr(Sdfile));
  2539.         }
  2540.     }
  2541.     } else {            /* transposed */
  2542.     numfloats = windims[leastsig];
  2543.     writesize = numfloats * outNTsize;
  2544.  
  2545.     /* allocate 1 row buffers */
  2546.     if (!convert) buf = NULL;
  2547.     else {
  2548.         if ((buf = DFIgetspace((unsigned) writesize)) == NULL) {
  2549.         DFerror = DFE_NOSPACE;
  2550.         return(-1);
  2551.         }
  2552.     }
  2553.     gatherbuf = (float32 *)DFIgetspace((unsigned) numfloats
  2554.                        *sizeof(float32));
  2555.     offset = (int32 *) DFIgetspace((unsigned) 2 * rank * sizeof(int32));
  2556.     dimsleft = offset + rank;
  2557.     if (gatherbuf==NULL || offset==NULL) {
  2558.         DFIfreespace(buf);
  2559.         DFIfreespace((char *)gatherbuf);
  2560.         DFIfreespace((char *)offset);
  2561.         DFerror = DFE_NOSPACE;
  2562.         return(-1);
  2563.     }
  2564.  
  2565.     /* initialize the dimension counter */
  2566.     for (i=0; i<rank; i++)
  2567.         dimsleft[i] = windims[i];
  2568.  
  2569.     datap = data;
  2570.     done = 0;
  2571.     outbufp = convert ? buf : (char *)gatherbuf;
  2572.  
  2573.     /* -- now write out the data */
  2574.  
  2575.     /* compute offsets in the source array */
  2576.     if (isfortran)
  2577.         for (i=0, offset[0]=1; i<rank-1; i++)
  2578.         offset[i+1] = offset[i]*dims[i];
  2579.     else
  2580.         for (i=rank-1, offset[i]=1; i > 0; i--)
  2581.         offset[i-1] = offset[i]*dims[i];
  2582.     stride = offset[leastsig];
  2583.  
  2584.     /* step thru the data on a row by row basis */
  2585.     do {
  2586.         /* gather the elements of one row together */
  2587. #ifdef UNICOS
  2588. #pragma ivdep
  2589. #endif
  2590.         for (dp=datap, i=0; i<numfloats; i++) {
  2591.         gatherbuf[i] = *dp;
  2592.         dp += stride;
  2593.         }
  2594.  
  2595.         /* convert and write the row */
  2596.         if (convert)
  2597.         DFconvert((char *)gatherbuf, buf, DFNT_FLOAT,
  2598.               userNT, outNT, numfloats, error);
  2599.         ret = DFwrite(Sdfile, outbufp, writesize);
  2600.  
  2601.         /* find the start of the next row */
  2602.         if (Fortorder) {
  2603.         for (i=1; i<rank; i++) {
  2604.             if (--dimsleft[i] > 0) {
  2605.             /* move to next element in the current dimension */
  2606.             datap += offset[i];
  2607.             break;
  2608.             }
  2609.             else {    /* move back to the beginning of dimension i */
  2610.             datap -= offset[i]*(dimsleft[i] = windims[i]);
  2611.             datap += offset[i];
  2612.             if (i == rank-1) done = 1;
  2613.             }
  2614.         }
  2615.         } else {        /* !Fortorder */
  2616.         for (i=rank-2; i>=0; i--) {
  2617.             if (--dimsleft[i] > 0) {
  2618.             /* move to next element in the current dimension */
  2619.             datap += offset[i];
  2620.             break;
  2621.             }
  2622.             else {    /* move back to the beginning of dimension i */
  2623.             datap -= offset[i]*(dimsleft[i] = windims[i]);
  2624.             datap += offset[i];
  2625.             if (i == 0) done = 1;
  2626.             }
  2627.         }
  2628.         }
  2629.     } while (!done && ret >= 0 && rank > 1);
  2630.  
  2631.     DFIfreespace(buf);
  2632.     DFIfreespace((char *)gatherbuf);
  2633.     DFIfreespace((char *)offset);
  2634.     }
  2635.  
  2636.     return(ret>=0 ? 0 : -1);
  2637. }
  2638.  
  2639. /******************************************************************************/
  2640. /*----------------------- Internal routines ---------------------------------*/
  2641. /******************************************************************************/
  2642.  
  2643. /*-----------------------------------------------------------------------------
  2644.  * Name:    dsisdas_
  2645.  * Purpose: Set label, unit and format for displaying subsequent SDGs
  2646.  * Inputs:  label: label to be used to describe data
  2647.  *          unit: unit corresponding to data values
  2648.  *          format: format to be used in displaying data values
  2649.  *          coordsys: type of coordinate system
  2650.  *          isfortran: 1 if called from Fortran, 0 if called from C
  2651.  *          llabel, lunit, lformat, lcoordsys: lengths of correspoding strings
  2652.  * Globals: Writesdg, Ref
  2653.  * Returns: 0 on success, -1 on failure with DFerror set
  2654.  * Users:   HDF users, utilities, other routines
  2655.  * Invokes: none
  2656.  * Method:  Stores values in global structure Writesdg
  2657.  * Remarks: none
  2658.  *---------------------------------------------------------------------------*/
  2659.  
  2660.     FCALLKEYW int
  2661. dsisdas_(label, unit, format, coordsys, isfortran, llabel, lunit,
  2662.      lformat, lcoordsys)
  2663.     char *label, *unit, *format, *coordsys;
  2664.     int *isfortran;
  2665.     int *llabel, *lunit, *lformat, *lcoordsys;
  2666. {
  2667.  
  2668.     int luf;                /* takes values LABEL, UNIT, FORMAT in succession */
  2669.     char *lufp;             /* points to label, unit, format in succession */
  2670.     int luflen;             /* length of luf */
  2671.  
  2672.     DFerror = DFE_NOERROR;
  2673.  
  2674.     for (luf=LABEL; luf<=FORMAT; luf++) {
  2675.     /* set lufp to point to label etc. as apppropriate */
  2676.         lufp = (luf==LABEL) ? label : (luf==UNIT) ? unit : format;
  2677.         if (*isfortran)
  2678.             luflen = (luf==LABEL) ? *llabel : (luf==UNIT) ? *lunit : *lformat;
  2679.         else luflen = strlen(lufp);
  2680.  
  2681.     /* free space if allocated */
  2682.         Writesdg.dataluf[luf] = DFIfreespace(Writesdg.dataluf[luf]);
  2683.  
  2684.     /* copy string */
  2685.         if (lufp) {
  2686.             Writesdg.dataluf[luf] = DFIgetspace((unsigned) luflen+1);
  2687.             if (Writesdg.dataluf[luf]==NULL) return(-1);
  2688.             strncpy(Writesdg.dataluf[luf], lufp, luflen);
  2689.             Writesdg.dataluf[luf][luflen] = '\0';
  2690.         }
  2691.     }
  2692.  
  2693.     Writesdg.coordsys = DFIfreespace(Writesdg.coordsys);
  2694.     luflen = *isfortran ? *lcoordsys : strlen(coordsys);
  2695.  
  2696.     if (coordsys) {
  2697.         Writesdg.coordsys = DFIgetspace((unsigned) luflen+1);
  2698.         if (Writesdg.coordsys==NULL) return(-1);
  2699.         strncpy(Writesdg.coordsys, coordsys, luflen);
  2700.         Writesdg.coordsys[luflen] = '\0';
  2701.     }
  2702.  
  2703.     /* indicate that label, unit, format and coordsys info modified */
  2704.     Ref.luf[LABEL] = Ref.luf[UNIT] = Ref.luf[FORMAT] = Ref.coordsys = 0;
  2705.  
  2706.     return(0);
  2707. }
  2708.  
  2709.  
  2710. /*-----------------------------------------------------------------------------
  2711.  * Name:    dsisdis_
  2712.  * Purpose: For the given dimension, set label, unit, format
  2713.  *          This routine needs to be called once for each dimension whose 
  2714.  *          values the user wants to set.
  2715.  * Inputs:  dim: the dimension that this info applies to
  2716.  *          label: label to be used to describe this dimension
  2717.  *          unit: units for dimension
  2718.  *          format: format to be used in displaying
  2719.  *          isfortran: 1 if called from Fortran, 0 otherwise
  2720.  *          llabel, lunit, lformat: lengths of corresponding strings
  2721.  * Globals: Writesdg, Ref
  2722.  * Returns: 0 on success, -1 on failure with DFerror set
  2723.  * Users:   HDF users, utilities, other routines
  2724.  * Invokes: none
  2725.  * Method:  Stores values in global structure Writesdg
  2726.  *---------------------------------------------------------------------------*/
  2727.  
  2728.     FCALLKEYW int
  2729. dsisdis_(dim, label, unit, format, isfortran, llabel, lunit, lformat)
  2730.     int *dim;
  2731.     char    *label, *unit, *format;
  2732.     int *isfortran;
  2733.     int *llabel, *lunit, *lformat;
  2734. {
  2735.  
  2736.     int i, rdim;
  2737.     int luf;                /* takes values LABEL, UNIT, FORMAT in succession */
  2738.     char *lufp;             /* points to label, unit, format in succession */
  2739.     int luflen;             /* length of lufp */
  2740.  
  2741.     DFerror = DFE_NOERROR;
  2742.  
  2743.     rdim = *dim-1;      /* translate from 1 to 0 origin */
  2744.  
  2745.     if ((rdim>=Writesdg.rank) || (rdim<0)) {
  2746.         DFerror = DFE_BADDIM;
  2747.         return(-1);
  2748.     }
  2749.  
  2750.     for (luf=LABEL; luf<=FORMAT; luf++) {
  2751.             /* set lufp to point to label etc. as apppropriate */
  2752.         lufp = (luf==LABEL) ? label : (luf==UNIT) ? unit : format;
  2753.         if (*isfortran)
  2754.             luflen = (luf==LABEL) ? *llabel : (luf==UNIT) ? *lunit : *lformat;
  2755.         else luflen = strlen(lufp);
  2756.  
  2757.             /* allocate space if necessary */
  2758.         if (!Writesdg.dimluf[luf]) {
  2759.             Writesdg.dimluf[luf] =
  2760.                 (char **) DFIgetspace((unsigned)Writesdg.rank * sizeof(char *));
  2761.             if (Writesdg.dimluf[luf]==NULL) return(-1);
  2762.             for (i=0; i<Writesdg.rank; i++) /* set allocated pointers to NULL */
  2763.                 Writesdg.dimluf[luf][i] = NULL;
  2764.         }
  2765.  
  2766.     /* free string space if allocated */
  2767.         Writesdg.dimluf[luf][rdim] = DFIfreespace(Writesdg.dimluf[luf][rdim]);
  2768.  
  2769.     /* copy string */
  2770.         if (lufp) {
  2771.             Writesdg.dimluf[luf][rdim] = DFIgetspace((unsigned) luflen+1);
  2772.             if (Writesdg.dimluf[luf][rdim]==NULL) return(-1);
  2773.             strncpy(Writesdg.dimluf[luf][rdim], lufp, luflen);
  2774.             Writesdg.dimluf[luf][rdim][luflen] = '\0';
  2775.         }
  2776.     }
  2777.  
  2778.     /* Indicate that this info has not been written to file */
  2779.     Ref.luf[LABEL] = Ref.luf[UNIT] = Ref.luf[FORMAT] = 0;
  2780.  
  2781.     return(0);
  2782. }
  2783.  
  2784.