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