home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / UIFlow 1.0.1 / UIFlow Source / VSet2.0 / Src / vconv.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-04-20  |  20.2 KB  |  870 lines  |  [TEXT/????]
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF Vset release 2.1
  4. *                    May 1991
  5. *
  6. * NCSA HDF Vset release 2.1 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. *******************************************************************************
  21. * Likkai Ng NCSA May 91
  22. *
  23. * vconv.c
  24. * Part of the HDF Vset interface.
  25.  
  26.   conversion routines
  27.   -------------------
  28.  
  29.   Routines here convert an array of numbers to and from IEEE format.
  30.   Numbers do not have to be contiguous within array: specify the
  31.   step as the distance (in bytes) between consecutive numbers.
  32.  
  33. Description of arguments:
  34.  
  35.     machfp - pointer to buffer for machine data
  36.     ieeefp - pointer to data for IEEE data.
  37.     mstep  - distance betwn consecutive data in machine buffer.
  38.     istep  - distance betwn consecutive data in IEEE buffer.
  39.     n        - no of numbers to convert)
  40.  
  41. These routines always return 1.
  42.  
  43. ************************************************************************/
  44.  
  45.  
  46. #include "vg.h"
  47.  
  48. /* ============================================================== */
  49. /* ================== S T U B for unimplemented conversions ===== */
  50. /* ============================================================== */
  51. nolongfn()                            /*@@*/
  52. {
  53.   fprintf(stderr,"This long conversion fn not implemented\n");
  54. }
  55.  
  56.  
  57. /* ============================================================== */
  58. /* ================== U N T Y P E D ============================= */
  59. /* ============================================================== */
  60. /* 
  61.     the data is stored unconverted, ie stored in local machine 
  62.     represention. such files are NOT portable, and are of use
  63.     only to applications on the same machine.  Of course, sun-like
  64.     machines may be able to share such files among themselves if
  65.     they are lucky. No guarantees.  
  66.  
  67.    there are only 2 routines: DIRECTtoIEEE and DIRECTfromIEEE 
  68. */
  69.  
  70. int DIRECTtoIEEE (machfp, ieeefp, mstep, istep, n)        /*@@*/
  71.  
  72. unsigned char *machfp, *ieeefp;
  73. int mstep, istep, n;
  74. {
  75.     int ret;
  76.  
  77.     ret = istep;
  78.     if(vjv) {
  79.         sprintf(sjs,"#in DIRECTtoIEEE: which invokes bytetoIEEE\n");
  80.         zj;
  81.     }
  82.     ret = bytetoIEEE(machfp, ieeefp, mstep, mstep, n);
  83.  
  84.     return(ret);
  85.  
  86. } /* DIRECTtoIEEE */
  87.  
  88.  
  89. int DIRECTfromIEEE (ieeefp, machfp, istep, mstep, n)        /*@@*/
  90.  
  91. unsigned char *machfp, *ieeefp;
  92. int mstep, istep, n;
  93. {
  94.     int ret;
  95.  
  96.     if(vjv) {
  97.         sprintf(sjs,"#in DIRECTfromIEEE: which invokes bytefromIEEE\n");
  98.         zj;
  99.     }
  100.     ret = bytefromIEEE(ieeefp, machfp, istep, mstep, n);
  101.  
  102.     return(ret);
  103.  
  104. } /* DIRECTfromIEEE */
  105.  
  106.  
  107. /* ============================================================== */
  108. /* ==================== B Y T E S =============================== */
  109. /* ============================================================== */
  110.  
  111. /* there are only 2 routines: bytetoIEEE and bytefromIEEE  */
  112.  
  113. int bytetoIEEE (machfp, ieeefp, mstep, istep, n)        /*@@*/
  114.  
  115. unsigned char *machfp, *ieeefp;
  116. int mstep, istep, n;
  117. {
  118.     int j,t;
  119.     register unsigned char *mfp, *ifp, *i, *m;
  120.  
  121.     if(vjv) {
  122.         sprintf(sjs,"# in bytetoIEEE\n");
  123.         zj;
  124.     }
  125.  
  126.     mfp = machfp;
  127.     ifp = ieeefp;
  128.     for (j=0;j<n;j++) {
  129.         for (i=ifp, m=mfp, t=0;t<4;t++) *i++ = *m++;
  130.         mfp += mstep;
  131.         ifp += istep;
  132.     }
  133.  
  134.     return(1);
  135.  
  136. } /* bytetoIEEE */
  137.  
  138. int bytefromIEEE (ieeefp, machfp, istep, mstep, n)        /*@@*/
  139.  
  140. unsigned char *machfp, *ieeefp;
  141. int mstep, istep, n;
  142. {
  143.     int t,j;
  144.     register unsigned char *mfp, *ifp, *i, *m;
  145.  
  146.     if(vjv) {
  147.         sprintf(sjs,"# in bytefromIEEE\n");
  148.         zj;
  149.     }
  150.  
  151.     mfp = machfp;
  152.     ifp = ieeefp;
  153.     for (j=0;j<n;j++) {
  154.         for (i=ifp, m=mfp, t=0;t<4;t++) *m++ = *i++;
  155.         mfp += mstep;
  156.         ifp += istep;
  157.     }
  158.  
  159.     return(1);
  160.  
  161. } /* bytefromIEEE */
  162.  
  163.  
  164. /* ============================================================== */
  165. /* ================= I N T E G E R S ============================ */
  166. /* ============================================================== */
  167.  
  168.  
  169. /* src are on this machine , dst are IEEE */
  170.  
  171. int inttoIEEE (src,dst,sdelta,ddelta,n)            /*@@*/
  172.  
  173. unsigned char *src, *dst;
  174. int      n, sdelta, ddelta;
  175. {
  176.     int temp,i,j,sdel,ddel;
  177.     register unsigned char *s, *ss, *d, *dd;
  178.     register unsigned char *t;
  179.  
  180.     sdel = sdelta;
  181.     ddel = ddelta;
  182.     ss = src;
  183.     dd = dst;
  184.  
  185.     if(vjv){
  186.         sprintf(sjs,"#in inttoIEEE sdel=%d, ddel=%d, n=%d\n", sdel,ddel,n);
  187.         zj;
  188.     }
  189.  
  190.     for (i=0;i<n;i++) {
  191.         t = (unsigned char*) &temp;
  192.         s = ss;
  193.         for(j=0;j<sizeof(temp);j++) *t++ = *s++;
  194.  
  195.         d = dd;
  196.         INT16WRITE(d,temp);
  197.  
  198.         ss += sdel;
  199.         dd += ddel;
  200.     }
  201.  
  202.     return(1);
  203.  
  204. } /* inttoIEEE */
  205.  
  206. /* -------------------------------------------------------------- */
  207. /* src are IEEE , dst are on this machine */
  208.  
  209. int intfromIEEE (src,dst,sdelta,ddelta,n)            /*@@*/
  210.  
  211. unsigned char *src,*dst;
  212. int     n,sdelta,ddelta;
  213. {
  214.     register unsigned char *s, *ss, *d, *dd;
  215.     register unsigned char *t;
  216.     int                    temp,i,j,sdel,ddel;
  217.  
  218.     sdel = sdelta;
  219.     ddel = ddelta;
  220.     ss = src;
  221.     dd = dst;
  222.     if(vjv){
  223.         sprintf(sjs,"#in intfromIEEE sdel=%d, ddel=%d, n=%d\n", sdel,ddel,n);
  224.         zj;
  225.     }
  226.  
  227.     for(i=0;i<n;i++) {
  228.         s = ss;
  229.         INT16READ(s,temp);
  230.  
  231.         t = (unsigned char*) &temp;
  232.         d = dd;
  233.         for (j=0;j<sizeof(temp);j++) *d++ = *t++;
  234.  
  235.         ss += sdel;
  236.         dd += ddel;
  237.     }
  238.  
  239.     return(1);
  240.  
  241. } /* intfromIEEE */
  242.  
  243.  
  244. /* ============================================================== */
  245. /* ================= L O N G S ================================== */
  246. /* ============================================================== */
  247.  
  248. /* src are on this machine , dst are IEEE */
  249.  
  250. int longtoIEEE (src,dst,sdelta,ddelta,n)            /*@@*/
  251.  
  252. unsigned char *src, *dst;
  253. int      n, sdelta, ddelta;
  254. {
  255.     int temp,i,j,sdel,ddel;
  256.     register unsigned char *s, *ss, *d, *dd;
  257.     register unsigned char *t;
  258.  
  259.     sdel = sdelta;
  260.     ddel = ddelta;
  261.     ss = src;
  262.     dd = dst;
  263.  
  264.     if(vjv){
  265.         sprintf(sjs,"#in longtoIEEE sdel=%d, ddel=%d, n=%d\n", sdel,ddel,n);
  266.         zj;
  267.     }
  268.     printf("#in longtoIEEE sdel=%d, ddel=%d, n=%d\n", sdel,ddel,n);
  269.  
  270.     for (i=0;i<n;i++) {
  271.         t = (unsigned char*) &temp;
  272.         s = ss;
  273.         for(j=0;j<sizeof(temp);j++) *t++ = *s++;
  274.  
  275.         d = dd;
  276.         INT32WRITE(d,temp);
  277.  
  278.         ss += sdel;
  279.         dd += ddel;
  280.     }
  281.  
  282.     return(1);
  283.  
  284. } /* longtoIEEE */
  285.  
  286. /* -------------------------------------------------------------- */
  287. /* src are IEEE , dst are on this machine */
  288.  
  289. int longfromIEEE (src,dst,sdelta,ddelta,n)            /*@@*/
  290.  
  291. unsigned char *src,*dst;
  292. int     n,sdelta,ddelta;
  293. {
  294.     register unsigned char *s, *ss, *d, *dd;
  295.     register unsigned char *t;
  296.     int                    temp,i,j,sdel,ddel;
  297.  
  298.     sdel = sdelta;
  299.     ddel = ddelta;
  300.     ss = src;
  301.     dd = dst;
  302.     if(vjv){
  303.         sprintf(sjs,"#in intfromIEEE sdel=%d, ddel=%d, n=%d\n", sdel,ddel,n);
  304.         zj;
  305.     }
  306.     printf("#in longfromIEEE sdel=%d, ddel=%d, n=%d\n", sdel,ddel,n);
  307.  
  308.     for(i=0;i<n;i++) {
  309.         s = ss;
  310.         INT32READ(s,temp);
  311.  
  312.         t = (unsigned char*) &temp;
  313.         d = dd;
  314.         for (j=0;j<sizeof(temp);j++) *d++ = *t++;
  315.  
  316.         ss += sdel;
  317.         dd += ddel;
  318.     }
  319.  
  320.     return(1);
  321.  
  322. } /* longfromIEEE */
  323.  
  324. /* ============================================================== */
  325. /* ==================== F L O A T S ============================= */
  326. /* ============================================================== */
  327.  
  328. /* 
  329.     floats are very machine specific. 
  330.     There will always be  a set of 2 routines (XXXtoIEEE and XXXfromIEEE)
  331.     for each machine that is special.
  332.    So far, 2 sets are written specifically for the Cray and Vax.
  333.     A third set is written for all other supported machines. These 
  334.     machines use IEEE format (MAC, Sun, etc).
  335.     One set, written for IEEE machines, is used by all other machines 
  336.     (assumed to be IEEE) 
  337.     
  338. */
  339.  
  340. #ifdef CRAY
  341.  
  342. /* ------------------ C R A Y ------------------------------------------ */
  343.  
  344. #define MINEXP    0x3f81000000000000  /* min valid Cray masked exponent */
  345. #define MAXEXP    0x407e000000000000  /* max valid Cray masked exponent */
  346.  
  347. #define C_FMASK   0x00007fffff000000  /* Cray fraction mask (1st 23 bits)*/
  348. #define C_EMASK   0x7fff000000000000  /* Cray exponent mask */
  349. #define C_SMASK   0x8000000000000000  /* Cray sign mask */
  350. #define C_IMPLICIT 0x0000800000000000 /* Cray implicit bit */
  351.  
  352. #define I_FMASK   0x007fffff          /* IEEE fraction mask */
  353. #define I_EMASK   0x7f800000          /* IEEE exponent mask */
  354. #define I_SMASK   0x80000000          /* IEEE sign mask     */
  355.  
  356. #define IEEE_BIAS 0177
  357. #define CRAY_BIAS 040000
  358.  
  359.  
  360. /*
  361. convert from Cray2 floating point format to IEEE format
  362. */
  363.  
  364. int crayFtoIEEE (crayfp, ieeefp, cstep, istep, n)        /*@@*/
  365.  
  366. unsigned char *crayfp, *ieeefp;
  367. int cstep, istep, n;
  368. {
  369.     long tmp, C2I_diff;
  370.     long craylong;
  371.     register int i,j,c;
  372.  
  373.     if(vjv) {
  374.         sprintf(sjs,"#in crayFtoIEEE cstep=%d istep=%d n=%d\n",cstep,istep,n);
  375.         zj;
  376.     }
  377.  
  378.     c=0; 
  379.     i=0;
  380.     for (j=0;j<n;j++) {
  381.         movebytes ((unsigned char*) &crayfp[c],(unsigned char*) &craylong,sizeof(long));
  382.         /* ============================== */
  383.         if (craylong == 0)  {
  384.             tmp = 0;
  385.         }
  386.         else {
  387.             tmp = (C_EMASK & craylong);
  388.             if (tmp < MINEXP || tmp > MAXEXP)  return(-1);
  389.             C2I_diff = (IEEE_BIAS - CRAY_BIAS - 1) << 48;
  390.             tmp = (( tmp + C2I_diff ) << 7)
  391.                 | ( (craylong  & C_FMASK) << 8 )
  392.                 | ( (craylong  & C_SMASK));
  393.         }
  394.         /* ============================== */
  395.         movebytes(unsigned &tmp, unsigned &ieeefp[i], 4);
  396.         c += cstep; 
  397.         i += istep;
  398.     }
  399.     return(0);
  400.  
  401. } /* crayFtoIEEE */
  402.  
  403. /* -------------------------------------------------------------- */
  404.  
  405. /*
  406. Conversion from IEEE floating point format to Cray format 
  407. */
  408.  
  409. int crayFfromIEEE (ieeefp, crayfp, istep, cstep, n)        /*@@*/
  410.  
  411. unsigned char *crayfp, *ieeefp;
  412. int cstep, istep, n;
  413. {
  414.  
  415.     register int c,i,j;
  416.     long tmp;
  417.     long I2C_diff;
  418.     long craylong;
  419.  
  420.     if(vjv) {
  421.         sprintf(sjs,"#in crayFfromIEEE cstep=%d, istep=%d, n=%d\n", 
  422.             cstep,istep,n);
  423.         zj;
  424.     }
  425.  
  426.     c=0; 
  427.     i=0;
  428.     for (j=0;j<n;j++) {
  429.         tmp = 0;
  430.         movebytes (unsigned char*) &ieeefp[i],((unsigned char *) &tmp)+4, 4); /* right 4 bytes of tmp */
  431.  
  432.         /* ================================== */
  433.         craylong  = (tmp & I_EMASK);
  434.         if (craylong != 0) {
  435.             I2C_diff   = (CRAY_BIAS - IEEE_BIAS + 1) << 23;
  436.             craylong  += I2C_diff;
  437.             craylong   = (craylong<< 25)
  438.                 | ( (tmp & I_FMASK) << 24)
  439.                 | ( (tmp & I_SMASK) << 32)
  440.                 | C_IMPLICIT;
  441.         }
  442.         /* ================================== */
  443.  
  444.         movebytes ((unsigned char*) &craylong,(unsigned char*) &crayfp[c],sizeof(long));
  445.         c += cstep;
  446.         i += istep;
  447.     }
  448.     return (0);
  449. } /* crayFfromIEEE */
  450. #endif
  451.  
  452.  
  453. #ifdef VMS
  454. /* ------------------ V A X --------------------------------------------- */
  455.  
  456. /*
  457. Conversion from VAx format IEEE floating point format.
  458. */
  459.  
  460. int vaxFtoIEEE (vaxfp, ieeefp, vstep, istep, n)        /*@@*/
  461.  
  462. unsigned char *vaxfp, *ieeefp;
  463. int vstep, istep, n;
  464. {
  465.     { sprintf(sjs,"@%c vaxFtoIEEE unimplemeted yet\n",7);
  466.     zj; 
  467. }
  468.  
  469. } /* vaxFtoIEEE */
  470.  
  471. /*
  472. Conversion from IEEE floating point format to Vax format.
  473. */
  474.  
  475. int
  476. vaxFfromIEEE (ieeefp, vaxfp, istep, vstep, n)        /*@@*/
  477.  
  478. unsigned char *vaxfp, *ieeefp;
  479. int vstep, istep, n;
  480. {
  481.     { sprintf(sjs,"@%c vaxFfromIEEE unimplemeted yet\n",7);
  482.     zj; 
  483. }
  484.  
  485. } /* vaxFfromIEEE */
  486. #endif
  487.  
  488.  
  489. /* -------------------------------------------------------------- */
  490. /* ----------- A L L   O T H E R    M A C H I N E S ------------- */
  491. /* -------------------------------------------------------------- */
  492.  
  493. int floattoIEEE (machfp, ieeefp, mstep, istep, n)        /*@@*/
  494.  
  495. unsigned char *machfp, *ieeefp;
  496. int mstep, istep, n;
  497. {
  498.     int ret;
  499.     if(vjv)  {
  500.         sprintf(sjs,"#in floattoIEEE: which invokes bytetoIEEE\n");
  501.         zj;
  502.     }
  503.     ret = bytetoIEEE(machfp, ieeefp, mstep, istep, n);
  504.  
  505.     return(ret);
  506.  
  507. } /* floattoIEEE */
  508.  
  509.  
  510. int floatfromIEEE (ieeefp, machfp, istep, mstep, n)        /*@@*/
  511.  
  512. unsigned char *machfp, *ieeefp;
  513. int mstep, istep, n;
  514. {
  515.     int ret;
  516.     if(vjv)  {
  517.         sprintf(sjs,"#in floatfromIEEE: which invokes bytefromIEEE\n");
  518.         zj;
  519.     }
  520.     ret = bytefromIEEE(ieeefp, machfp, istep, mstep, n);
  521.     return(ret);
  522. } /* floatfromIEEE */
  523.  
  524. /* -------------------------------------------------------------- */
  525.  
  526. /* move n bytes of from ss to dd */
  527. int movebytes (ss,dd,n)        /*@@*/
  528.  
  529. unsigned char *ss, *dd;
  530. int n;
  531. {
  532.     register unsigned char *d,*s;
  533.     register int i;
  534.     for (d=dd,s=ss,i=0;i<n;i++) *d++ = *s++;
  535.  
  536.     return(1);
  537.  
  538. } /* movebytes */
  539. /* -------------------------------------------------------------- */
  540.  
  541.  
  542.  
  543. /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  544. /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  545. /*                                                                    */ 
  546. /* routines for converting from vsets in v1.0 to v2.x                 */
  547. /*                                                                    */ 
  548. /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  549. /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  550.  
  551. #define INT16SIZE 2
  552. #define INT32SIZE 4
  553.  
  554. /* ------------------------------------------------------------------ */
  555.  
  556. /*
  557. *  this routine checks that the given OPENED file is compatible with
  558. *    version 2.0 or later of the HDF Vset library .
  559. *  returns 1 if file already compatible with r2.
  560. *          0 if not compatible.
  561. *          -1 if error.
  562. */
  563.  
  564. int vicheckcompat(f) DF * f; {
  565.  
  566.     DFdesc    desc;
  567.     int         foundold, foundnew;
  568.  
  569.     foundold = 0;
  570.     foundnew = 0;
  571.  
  572.     /* locate any OLD vgs */
  573.         DFsetfind(f, OLD_VGDESCTAG, DFTAG_WILDCARD);
  574.         if ( DFfind(f, &desc)  == 0) foundold++; 
  575.                 
  576.     /* locate any OLD vdatas */
  577.         DFsetfind(f, OLD_VSDESCTAG, DFTAG_WILDCARD);
  578.         if ( DFfind(f, &desc)  == 0) foundold++; 
  579.                 
  580.     /* locate any NEW vgs */
  581.         DFsetfind(f, NEW_VGDESCTAG, DFTAG_WILDCARD);
  582.         if ( DFfind(f, &desc)  == 0) foundnew++; 
  583.                 
  584.     /* locate any NEW vdatas */
  585.         DFsetfind(f, NEW_VSDESCTAG, DFTAG_WILDCARD);
  586.         if ( DFfind(f, &desc)  == 0) foundnew++; 
  587.  
  588.     if ( foundold == 0 ) /* has no old vset elements */
  589.         return (1); /* just assume compatible */
  590.  
  591.     if ( foundnew > 0 ) 
  592.         return (1); /* file is already compatible */
  593.     else
  594.         return (0); /* file is not compatible */
  595. } /* vicheckcompat */
  596.  
  597. /* ------------------------------------------------------------------ */
  598. /*
  599. * This routine will modify a given OPENED file so that is becomes compatible
  600. * with version 2.0 or later of the HDF Vset library.
  601. * Note that the file is assumed to be not compatible to begin with.
  602. * This routine will not check to see if the file is already compatible,
  603. * but it is harmless to run an already-compatible file through again.
  604. *
  605. * However, be aware that each time, the file gets larger.
  606. * Also, file must be opened with DFACC_ALL access.
  607. *
  608. * returns  1 if successful. if error, returns 0
  609. */
  610.  
  611.  
  612. int vimakecompat(f)  DF *f; {
  613.  
  614.     VGROUP     tempvgroup;
  615.     VDATA        tempvdata;
  616.  
  617.     VGROUP    * vg = &tempvgroup;
  618.     VDATA        *vs = &tempvdata;
  619.     unsigned char buf[5000];
  620.     int         i, dum, bsize;
  621.     DFdesc    desc;
  622.  
  623.     /* =============================================  */
  624.     /* --- read all vgs and convert each --- */
  625.  
  626.     dum = 0;
  627.     DFsetfind (f, OLD_VGDESCTAG, DFTAG_WILDCARD);
  628.     while ( DFfind(f, &desc) == 0) {
  629.         if ( -1 == (bsize = DFgetelement (f, OLD_VGDESCTAG, desc.ref, buf)) ) {
  630.              fprintf(stderr,"getvgroup_old. getelement err. DFerror=%d\n",DFerror);
  631.             exit(0);
  632.             }
  633.  
  634.         oldunpackvg (vg, buf, &bsize);
  635.         /* add new items */
  636.             vg->vgclass[0] = '\0';
  637.             vg->extag = 0;
  638.             vg->exref = 0;
  639.             vg->version = 2; /* version 2 */
  640.             vg->more = 0;
  641.         /* inside each vgroup, change the old tags to new */
  642.             for(i=0;i<vg->nvelt;i++)
  643.                 if (vg->tag[i] == OLD_VGDESCTAG) vg->tag[i] = NEW_VGDESCTAG;
  644.                 else if (vg->tag[i] == OLD_VSDESCTAG) vg->tag[i] = NEW_VSDESCTAG;
  645.                 else { fprintf( stderr,"vimakecompat: unknown tag %d] in vgroup!\n",
  646.                                 vg->tag[i]);
  647.                         }
  648.         vpackvg (vg, buf, &bsize);
  649.  
  650.         if ( -1 == DFputelement (f, VGDESCTAG, desc.ref, buf, bsize)) {
  651.           fprintf(stderr,"put vgroup desc error. DFerror=%d\n",DFerror);
  652.             exit(0);
  653.             }    
  654.  
  655.         dum++;
  656.         }
  657.  
  658.     /* =============================================  */
  659.     /* --- read all vdata descs  and convert each --- */
  660.     /* --- then dup a tag for each vdata data elt --- */
  661.  
  662.     dum = 0;
  663.     DFsetfind (f, OLD_VSDESCTAG, DFTAG_WILDCARD);
  664.     while ( DFfind(f, &desc) == 0) {
  665.         if ( -1 == (bsize = DFgetelement (f, OLD_VSDESCTAG, desc.ref, buf)) ) {
  666.              fprintf(stderr,"getvdata_old. getelement err. DFerror=%d\n",DFerror);
  667.             exit(0);
  668.             }
  669.  
  670.         oldunpackvs (vs, buf, &bsize);
  671.         /* add new items */
  672.             vs->vsclass[0] = '\0';
  673.             vs->extag = 0;
  674.             vs->exref = 0;
  675.             vs->version = 2; /* version 2 */
  676.             vs->more = 0;
  677.         vpackvs (vs, buf, &bsize);
  678.  
  679.         if ( -1 == DFputelement (f, VSDESCTAG, desc.ref, buf, bsize)) {
  680.           fprintf(stderr,"put vdata desc error. DFerror=%d\n",DFerror);
  681.             exit(0);
  682.             }    
  683.  
  684.         /* duplicate a tag to point to vdata vdata */
  685.  
  686.             if ( DFdup(f, NEW_VSDATATAG, desc.ref, OLD_VSDATATAG, desc.ref) < 0) {
  687.                 fprintf(stderr,"DFdup - cannot duplicate. DFerror=%d\n",DFerror);
  688.                 exit(0);
  689.                 }
  690.  
  691.         dum++;
  692.         }
  693.  
  694.     return(1);
  695.  
  696. } /* vimakecompat */
  697.  
  698.  
  699. /* ================================================================== */
  700. /*
  701. *  this routine checks that the given file is compatible with
  702. *    version 2.0 or later of the HDF Vset library .
  703. *
  704. *  All it does is to open the file, call vicheckcompat to do all the
  705. *  checking, and then closes it.
  706. *    See comments for vicheckcompat().
  707.  
  708. *  returns 1 if file already compatible with r2.
  709. *          0 if not compatible.
  710. *          -1 if error.
  711. */
  712.  
  713. int vcheckcompat(fs) char * fs; {
  714.  
  715.     DF            * f;
  716.     int         stat;
  717.  
  718.    if (NULL==(f=DFopen(fs,DFACC_READ,0))) {
  719.         fprintf(stderr,"vcheckcompat: cannot open %s\n",fs);
  720.         return(-1);
  721.         }         
  722.     stat = vicheckcompat(f); 
  723.     DFclose (f);    
  724.  
  725.     return (stat);
  726. } /* vcheckcompat */
  727.  
  728. /* ================================================================== */
  729. /*
  730. * This routine will modify a given file so that is becomes compatible
  731. * with version 2.0 or later of the HDF Vset library.
  732. *
  733. * All this routine does is to open the file, call vimakecompat to
  734. * do all the conversion, and then to close the file.
  735. * See comments for vimakecompat().
  736. *
  737. * returns  1 if successful. if error, returns 0
  738. */
  739.  
  740. int vmakecompat(fs) char * fs; {
  741.     DF * f;
  742.     int stat;
  743.  
  744.    if (NULL==(f=DFopen(fs,DFACC_ALL,0))) {
  745.         fprintf(stderr,"vmakecompat: cannot open %s\n",fs);
  746.         return(0);
  747.         }         
  748.     stat = vimakecompat(f);
  749.     DFclose(f);
  750.  
  751. } /* vmakecompat */
  752.  
  753. /* ==================================================================== */
  754.  
  755. oldunpackvg (vg,buf,size)          /*@@*/
  756.  
  757. VGROUP*              vg;        /* vgroup to be loaded with file data */
  758. unsigned char     buf[];     /* must contain a VGDESCTAG data object from file */
  759.  
  760. int*              size;      /* ignored, but included to look like packvg() */
  761.  
  762. {
  763.  
  764.     unsigned char    *b, *bb;
  765.     int                 i;
  766.  
  767.     i = *size; /* dummy, so that compiler thinks it is used  */
  768.  
  769.     bb = &buf[0];
  770.  
  771.     /* retrieve nvelt */
  772.     b = bb;
  773.     INT16READ(b,vg->nvelt);
  774.     bb+=INT16SIZE;
  775.  
  776.     /* retrieve the tags */
  777.     for (i=0;i<vg->nvelt;i++) {
  778.         b= bb;
  779.         INT16READ(b,vg->tag[i]);
  780.         bb +=INT16SIZE;
  781.     }
  782.  
  783.     /* retrieve the refs */
  784.     for (i=0;i<vg->nvelt;i++) {
  785.         b= bb;
  786.         INT16READ(b,vg->ref[i]);
  787.         bb +=INT16SIZE;
  788.     }
  789.  
  790.     /* retrieve vgname */
  791.     strcpy(vg->vgname, (char*) bb);
  792.     bb += ( strlen(vg->vgname)+1 );
  793.  
  794.     if (vjv) {
  795.         sprintf(sjs,"unpackvg: vgname is [%s]\n",vg->vgname);
  796.         zj;
  797.     }
  798.  
  799. } /* unpackvg */
  800.  
  801. /* ================================================================= */
  802.  
  803.  
  804. oldunpackvs (vs,buf,size)       /*@@*/
  805.  
  806. VDATA *vs;
  807. int   *size;            /* UNUSED, but retained for compatibility with packvs */
  808. unsigned char buf[];
  809. {
  810.     unsigned char *b, *bb;
  811.     int            i;
  812.  
  813.     i = *size; /* dum */
  814.  
  815.     bb = &buf[0];
  816.  
  817.     b = bb;
  818.     INT16READ(b,vs->interlace);
  819.     bb += INT16SIZE;
  820.  
  821.     b = bb;
  822.     INT32READ(b,vs->nvertices);
  823.     bb += INT32SIZE;
  824.  
  825.     b = bb;
  826.     INT16READ(b,vs->wlist.ivsize);
  827.     bb += INT16SIZE;
  828.  
  829.     b = bb;
  830.     INT16READ(b,vs->wlist.n);
  831.     bb += INT16SIZE;
  832.  
  833.     for (i=0;i<vs->wlist.n;i++)  { /* retrieve the type */
  834.         b = bb;
  835.         INT16READ(b,vs->wlist.type[i]);
  836.         bb += INT16SIZE;
  837.     }
  838.  
  839.     for (i=0;i<vs->wlist.n;i++)  { /* retrieve the isize */
  840.         b = bb;
  841.         INT16READ(b,vs->wlist.isize[i]);
  842.         bb += INT16SIZE;
  843.     }
  844.     for (i=0;i<vs->wlist.n;i++)  { /* retrieve the off */
  845.         b = bb;
  846.         INT16READ(b,vs->wlist.off[i]);
  847.         bb += INT16SIZE;
  848.     }
  849.     for (i=0;i<vs->wlist.n;i++)  { /* retrieve the order */
  850.         b = bb;
  851.         INT16READ(b,vs->wlist.order[i]);
  852.         bb += INT16SIZE;
  853.     }
  854.     for (i=0;i<vs->wlist.n;i++) {
  855.         strcpy(vs->wlist.name[i],  (char*) bb);
  856.         bb += ( strlen(vs->wlist.name[i]) + 1 );
  857.     }
  858.  
  859.     strcpy(vs->vsname, (char*) bb);
  860.     bb += ( strlen(vs->vsname) + 1);
  861.  
  862.     /* **EXTRA**  fill in the machine-dependent size fields */
  863.     for (i=0;i<vs->wlist.n;i++) {
  864.         vs->wlist.esize[i] = vs->wlist.order[i] * SIZEOF(vs->wlist.type[i]);
  865.     }
  866.  
  867. } /* unpackvs */
  868.  
  869. /* ------------------------------------------------------------------ */
  870.