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 / vg.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-04-20  |  15.0 KB  |  680 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 1991
  22. *
  23. * vg.c
  24. * Part of the HDF VSet interface
  25. * This file contains routine to handle VDATAs.
  26. *
  27. * Most routines return -1 (FAIL) on error. 
  28. * VSattach returns NULL on error.
  29. *
  30. * PRIVATE functions manipulate vsdir and are used only within this file.
  31. * PRIVATE data structures in here pertain to vdata in vsdir only.
  32. *
  33. **************************************************************************/
  34.  
  35. #include <ctype.h> 
  36. #include "vg.h"
  37.  
  38. PRIVATE int newref_count = -1; /* used by Vnewref only */
  39.  
  40. /* ------------------------------------------------------------------
  41. *    Vnewref
  42. *    utility routine. returns a unique reference number.
  43. *
  44. *    NOTE: should be modified to call DFnewref!!!
  45. *  currently looks once in vsdir and vgdir, and find the highest ref.
  46. *    also, the parameter f isn't used right now.
  47. *
  48. *    RETURNS a unique ref (+ve integer) ,
  49. *    RETURNS -1 if error
  50. *
  51. *  undocumented
  52. *
  53. */
  54.  
  55. int vnewref (f)            /*@@*/
  56.  
  57. DF  *f;
  58. {
  59. #if 0
  60.     int t;
  61.  
  62.  
  63.     if (f==NULL) return(FAIL);
  64.     if (newref_count == -1) {
  65.         for(t=1;t<65300;t++) {
  66.             if      ( -1 != vexistvg(f,t))   continue;
  67.             else if ( -1 != vexistvs(f,t))   continue;
  68.             else break;
  69.         }
  70.         newref_count = t;
  71.     }
  72.  
  73.     newref_count++;
  74.     if (newref_count > 65300) return(FAIL);
  75.  
  76.     return( newref_count - 1 );
  77. #endif
  78.  
  79. #if 1
  80.     return( DFnewref(f) );
  81. #endif
  82.  
  83. } /* vnewref */
  84.  
  85. /* ================================================================== */
  86.  
  87. /* matchnocase -  (PRIVATE) compares 2 strings, ignoring case 
  88. *                   returns 1 if match, else 0
  89. */
  90.  
  91. PRIVATE int matchnocase (strx,stry)     /*@@*/
  92.  
  93. char *strx,*stry;
  94. {
  95.     int     i,nx,ny,tx,ty;
  96.     char     *sx, *sy;
  97.  
  98.     nx = strlen(strx);
  99.     ny = strlen(stry);
  100.     if ( nx != ny) return(0);  /* different lengths */
  101.  
  102.     for (sx=strx, sy=stry, i=0;i<nx;i++,sx++,sy++) {
  103.         tx= *sx; 
  104.         ty= *sy;
  105.         if (islower(tx)) tx=toupper(tx);
  106.         if (islower(ty)) ty=toupper(ty);
  107.         if (tx != ty)       return(0);
  108.     }
  109.  
  110.     return(1);
  111.  
  112. } /* matchnocase */
  113.  
  114.  
  115.  
  116. /* ------------------------------------------------------------------
  117. * VSelts
  118. * returns the number of elements in the VDATA vs 
  119. * returns -1  on error.
  120. *
  121. * undocumented
  122. * 28-MAR-91 Jason NG NCSA
  123. *
  124. */
  125.  
  126. PUBLIC int32 VSelts (vs)                       /*@-@*/
  127.  
  128. VDATA *vs;
  129. {
  130.     return( (vs->otag==VSDESCTAG) ?  vs->nvertices : -1);
  131.  
  132. } /* VSelts */
  133.  
  134.  
  135.  
  136. /* ------------------------------------------------------------------
  137. *    VSgetinterlace 
  138. *  returns the interlace (in the file) of the vdata vs.
  139. *  returns -1 on error.
  140. *
  141. *  undocumented
  142. *
  143. */
  144.  
  145. PUBLIC int VSgetinterlace (vs)              /*@-@*/
  146.  
  147. VDATA *vs;
  148. {
  149.     return( (vs==NULL) ? FAIL : vs->interlace );
  150.  
  151. } /* VSgetinterlace */
  152.  
  153.  
  154.  
  155. /* ------------------------------------------------------------------
  156. *    VSsetinterlace 
  157. *     sets the vdata's interlace to full or none.
  158. *    returns -1 on error.
  159. */
  160.  
  161. PUBLIC int VSsetinterlace (vs, interlace)      /*@-@*/
  162.  
  163. VDATA *vs;
  164. int interlace;
  165. {
  166.     if (vs==NULL)
  167.         return(FAIL);
  168.     if ( vs->access == 'r' ||            /* only for write-only files */
  169.     vs->nvertices > 0)             /*may not change interlace if data exists*/
  170.         return(FAIL);
  171.  
  172.     /* currently only 2 kinds allowed */
  173.  
  174.     if ( interlace==FULL_INTERLACE || 
  175.         interlace==NO_INTERLACE ) {
  176.         vs->interlace = interlace;
  177.         return(1); /* ok */
  178.     }
  179.     else 
  180.         return(FAIL);                            /* bad interlace type */
  181.  
  182. } /* VSsetinterlace */
  183.  
  184.  
  185. /* ------------------------------------------------------------------
  186. *    VSgetfields 
  187. *  returns the fieldnames in a vdata.
  188. *  RETURNS  -1 on error, else the no of fields in the vdata.
  189. *
  190. *    undocumented
  191. *
  192. */
  193.  
  194. PUBLIC int VSgetfields (vs,fields)        /*@-@*/
  195.  
  196. VDATA *vs;
  197. char  *fields;                            /* fieldnames are returned in this var */
  198. {
  199.     int i;
  200.     if (vs==NULL) return(FAIL);
  201.  
  202.     fields[0] = '\0';
  203.     for (i=0;i<vs->wlist.n;i++) { /* build the comma-separated string */
  204.         strcat(fields,vs->wlist.name[i]);
  205.         if ( i < vs->wlist.n - 1 )
  206.             strcat(fields,",");
  207.     }
  208.  
  209.     return(vs->wlist.n);
  210.  
  211. } /* VSgetfields */
  212.  
  213. /* ------------------------------------------------------------------
  214. *    VSfexist
  215. *     tests for existence of 1 or more fields in a vdata.
  216. *
  217. *    RETURNS -1 if flase, or error
  218. *    RETURNS 1 if true
  219. */
  220.  
  221. PUBLIC int VSfexist (vs, fields)          /*@-@*/
  222.  
  223. VDATA *vs;
  224. char    *fields;
  225. {
  226.     char           **av, *s;
  227.     int            ac,i,j,found;
  228.     VWRITELIST    *w;
  229.  
  230.     if (vs==NULL) return(FAIL);
  231.  
  232.     /* call scanattrs to parse the string */
  233.  
  234.     if (scanattrs(fields,&ac,&av) < 0) return(FAIL); /* bad attrs string */
  235.     if (ac<1) return(FAIL);                                 /* no attrs */
  236.  
  237.     /* now check in vs's field table */
  238.  
  239.     w = &vs->wlist;
  240.     for (i=0;i<ac;i++) {
  241.         for (found=0,s=av[i],j=0;j<w->n;j++) {
  242.             if ( matchnocase(s,w->name[j]) ) {
  243.                 found=1;
  244.                 break;
  245.             }
  246.         }
  247.         if (!found) return(FAIL);
  248.     }
  249.  
  250.     return(1);
  251.  
  252. } /* VSfexist */
  253.  
  254.  
  255. /* ================================================================== */
  256. /*
  257. *    VSsizeof - computes the byte size of the field(s) of a vdata.
  258. *             - Note that the size is the actual size for the local machine.
  259. *
  260. *                - RETURNS -1 on error, else the field(s) size (+ve integer).
  261. */
  262.  
  263. PUBLIC int VSsizeof (vs, fields)           /*@-@*/
  264.  
  265. VDATA *vs;
  266. char  *fields;
  267. {
  268.     int     totalsize, ac, i,j,found;
  269.     char   **av;
  270.  
  271.     if (vs==NULL)                              return(FAIL);
  272.  
  273.     if (scanattrs(fields,&ac,&av) < 0) return(FAIL);     /* bad attrs string */
  274.     if (ac<1)                                  return(FAIL);     /* no attrs */
  275.  
  276.     if (vjv) { 
  277.         sprintf(sjs,"#VSsizeof: fields are [%s]\n",fields);
  278.         zj; 
  279.     }
  280.  
  281.     totalsize=0;
  282.     for (i=0;i<ac;i++) {
  283.         for (found=0,j=0;j<vs->wlist.n;j++)
  284.             if (!strcmp(av[i], vs->wlist.name[j])) {  /* check fields in vs */
  285.                 totalsize += vs->wlist.esize[j];
  286.                 found=1;
  287.                 break;
  288.             }
  289.  
  290.         if (!found) {
  291.             sprintf(sjs,"@VSsizeof:[%s] not in vs\n",av[i]);
  292.             zj;
  293.             return(FAIL);
  294.         }
  295.     }
  296.  
  297.     return(totalsize);
  298.  
  299. } /* VSsizeof */
  300.  
  301.  
  302. /* ================================================================== */
  303.  
  304. /*
  305. *    VSdump - prints contents of a vdata (for debugging) 
  306. *                no return codes.
  307. */
  308.  
  309. void VSdump (vs)                           /*@@*/
  310.  
  311. VDATA *vs;
  312. {
  313.     VWRITELIST    *w;
  314.     int             i;
  315.  
  316.     if (vs==NULL) {
  317.         sprintf(sjs,"@VSdump: vs is null\n");
  318.         zj;
  319.         return;
  320.     }
  321.  
  322.     sprintf(sjs,"@tag=%d ref=%d i=%d ",vs->otag, vs->oref,vs->interlace);
  323.     zj;
  324.     sprintf(sjs,"@nv=%d\n ",vs->nvertices);
  325.     zj;
  326.  
  327.     w = (VWRITELIST*) &vs->wlist;
  328.     sprintf(sjs,"@vsize(HDF)=%d fields=%d [%s]\n",w->ivsize,w->n,vs->vsname);
  329.     zj;
  330.  
  331.     for (i=0;i<w->n;i++)
  332.     { 
  333.         sprintf(sjs,"@<%s>      type:%d esize=%d isize=%d off=%d\n",
  334.             w->name[i], w->type[i], w->esize[i],w->isize[i],w->off[i]);
  335.         zj;
  336.     }
  337.  
  338.     sprintf(sjs,"\n");
  339.     zj;
  340.  
  341. } /* VSdump */
  342.  
  343.  
  344. /* ======================================================= */
  345. /*
  346. *    VSsetname - give a name to a vdata.
  347. *              - NO RETURN VALUES
  348. *              - truncates to max length of VSNAMELENMAX
  349. *      
  350. */
  351.  
  352. PUBLIC void VSsetname (vs, vsname)           /*@-@*/
  353.  
  354. VDATA *vs;
  355. char    *vsname;
  356.  
  357. {
  358.     if (vs == NULL) return;
  359.     if ( strlen(vsname) > VSNAMELENMAX) {
  360.         strncpy(vs->vsname, vsname,VSNAMELENMAX);
  361.         vs->vsname[VSNAMELENMAX]='\0';
  362.     }
  363.     else 
  364.         strcpy(vs->vsname, vsname);
  365.     vs->marked = 1;
  366.     return;
  367.  
  368. } /* VSsetname */
  369.  
  370. /* ======================================================= */
  371. /*
  372. *    VSsetclass- assigns a class name to a vdata.
  373. *              - NO RETURN VALUES
  374. *              - truncates to max length of VSNAMELENMAX
  375. *      
  376. */
  377.  
  378. PUBLIC void VSsetclass (vs, vsclass)           /*@-@*/
  379.  
  380. VDATA *vs;
  381. char    *vsclass;
  382.  
  383. {
  384.     if (vs == NULL) return;
  385.     if ( strlen(vsclass) > VSNAMELENMAX) {
  386.         strncpy(vs->vsclass, vsclass,VSNAMELENMAX);
  387.         vs->vsclass[VSNAMELENMAX]='\0';
  388.     }
  389.     else 
  390.         strcpy(vs->vsclass, vsclass);
  391.     vs->marked = 1;
  392.     return;
  393.  
  394. } /* VSsetclass*/
  395.  
  396. /* ======================================================= */
  397.  
  398. /*
  399. *    VSgetname - gets the vdata's name.
  400. *                 - NO RETURN VALUES
  401. */
  402.  
  403. PUBLIC void VSgetname (vs, vsname)           /*@-@*/
  404.  
  405. VDATA *vs;
  406. char    *vsname;
  407. {
  408.     if (vs != NULL) strcpy(vsname, vs->vsname);
  409.     return;
  410.  
  411. } /* VSgetname */
  412.  
  413. /* ======================================================= */
  414.  
  415. /*
  416. *    VSgetclass - gets the vdata's class name.
  417. *                 - NO RETURN VALUES
  418. */
  419.  
  420. PUBLIC void VSgetclass (vs, vsclass)           /*@-@*/
  421.  
  422. VDATA *vs;
  423. char    *vsclass;
  424. {
  425.     if (vs != NULL) strcpy(vsclass, vs->vsclass);
  426.     return;
  427.  
  428. } /* VSgetclass */
  429.  
  430.  
  431. /* ================================================================== */
  432. /*
  433. *    VSinquire - gets info about a vdata vs:
  434. *
  435. *                  nvertices:     no of vertices in it.
  436. *                  interlace:     its interlcae
  437. *                  fields :         a comma separated string listing the field(s). 
  438. *                                    (eg "PX,PY")
  439. *                  eltsize:        size of element (all field(s)) on local machine.
  440. *                  vsname:         vdata's name, if any.
  441. *
  442. *    RETURNS -1 if error
  443. *    RETURNS 1 if ok
  444. *
  445. */
  446.  
  447.  
  448. PUBLIC int VSinquire (vs, nelt, interlace, fields, eltsize, vsname)   /*@-@*/
  449.  
  450. VDATA     *vs;
  451. char      *fields, *vsname;
  452. int         *nelt, *interlace, *eltsize;
  453.  
  454. {
  455.     if (vs==NULL) return(FAIL);
  456.     VSgetfields (vs,fields);
  457.  
  458.     *nelt       = vs->nvertices;
  459.     *interlace  = vs->interlace;
  460.     *eltsize    =  VSsizeof (vs,fields);
  461.     strcpy(vsname,vs->vsname);
  462.  
  463.     return(1); /* ok */
  464.  
  465.  
  466. } /* VSinquire */
  467.  
  468. /* ================================================================== */
  469. /*
  470. * VSlone - returns an array of refs of all lone vdatas in the file.
  471. *           - returns -1 if error
  472. *          - otherwise returns the total number of lone vdatas in the file 
  473. *
  474. *            If idarray is too small, routine will only fill idarray with up
  475. *             to asize worth of refs.
  476. *
  477. *            INPUT idarray: user supplies  an int array.
  478. *           INPUT asize: integer specifying how many ints in idarray[];
  479. *            INPUT f: HDF file pointer.
  480. *
  481. */
  482.  
  483. PUBLIC int VSlone(f, idarray, asize) 
  484.  
  485. DF * f;
  486. int idarray[];             /* array to contain the refs */
  487. int asize;            /* input: size of idarray */
  488. {
  489. int      * lonevdata; /* local working area: stores flags of vdatas */
  490. int         i,vgid, vsid, vstag;
  491. VGROUP     * vg;
  492. int         dum;
  493. int         nlone; /* total number of lone vdatas */
  494.  
  495.  
  496. /* -- allocate space for vdata refs, init to zeroes -- */
  497. if (NULL == (lonevdata = (int*) DFIgetspace( 65000 * sizeof(int)))) 
  498.    RTNEG ("VSlone: space too low. VSlone not executed\n");
  499. for(i=0;i<65000;i++) lonevdata[i] = 0;
  500.  
  501. /* -- look for all vdatas in the file, and flag (1) each -- */
  502. vsid = -1;
  503. dum=0;
  504. while(1) {
  505.     if ( -1 == (vsid = VSgetid (f, vsid))) break; /* no more vdatas */
  506.     lonevdata[vsid ] = 1;
  507.     }
  508.  
  509. /* -- Look through all vgs, searching for vdatas -- */
  510. /* -- increment its index in lonevdata if found -- */
  511. dum=0;
  512. vgid = -1;
  513. while(1) {
  514.     if ( -1 == (vgid = Vgetid (f, vgid))) break; /* no more vgroups */
  515.     vg = (VGROUP*) Vattach(f,vgid,"r");
  516.     for (i=0; i< Vntagrefs(vg); i++) {
  517.         Vgettagref (vg, i, &vstag, &vsid);
  518.         if (vstag==VSDESCTAG) 
  519.             { lonevdata[vsid]++; dum++;  }
  520.         }
  521.     Vdetach(vg);
  522.     }
  523.  
  524. /* -- check in lonevdata: it's a lone vdata if its flag is still 1 -- */
  525. nlone = 0;
  526. for(i=0;i<65000;i++) {
  527.     if (1 == lonevdata[i]) {
  528.          if (nlone < asize) { /* insert into idarray up till asize */
  529.             idarray[nlone] = i;
  530.             }
  531.         nlone ++;
  532.         }
  533.    }
  534. DFIfreespace(lonevdata);
  535.  
  536. return(nlone); /* return the TOTAL # of lone vdatas */
  537.  
  538. } /* VSlone */
  539.  
  540. /* ================================================================== */
  541. /*
  542. * Vlone  - returns an array of refs of all lone vgroups in the file.
  543. *           - returns -1 if error
  544. *          - otherwise returns the total number of lone vgroups in the file 
  545. *
  546. *            If idarray is too small, routine will only fill idarray with up
  547. *             to asize worth of refs.
  548. *
  549. *            INPUT idarray: user supplies  an int array.
  550. *           INPUT asize: integer specifying how many ints in idarray[];
  551. *            INPUT f: HDF file pointer.
  552. *
  553. */
  554.  
  555. PUBLIC int Vlone(f, idarray, asize) 
  556.  
  557. DF * f;
  558. int idarray[];             /* array to contain the refs */
  559. int asize;            /* input: size of idarray */
  560. {
  561. int         * lonevg; /* local working area: stores flags of vgroups */
  562. int        i;
  563. int         vgid, vstag, id;
  564. VGROUP     * vg;
  565. int         dum;
  566. int         nlone; /* total number of lone vgroups */
  567.  
  568.  
  569. /* -- allocate space for vgroup refs, init to zeroes -- */
  570. if (NULL == (lonevg = (int*) DFIgetspace( 65000 * sizeof(int)))) 
  571.    RTNEG ("Vlone: space too low. Vlone not executed\n");
  572. for(i=0;i<65000;i++) lonevg[i] = 0;
  573.  
  574. /* -- look for all vgroups in the file, and flag (1) each -- */
  575. id = -1;
  576. dum=0;
  577. while(1) {
  578.     if ( -1 == (id = Vgetid (f, id))) break; /* no more vgroups */
  579.     lonevg[ id ] = 1;
  580.     }
  581.  
  582. /* -- Look through all vgs, searching for vgroups -- */
  583. /* -- increment its index in lonevg if found -- */
  584. dum=0;
  585. vgid = -1;
  586. while(1) {
  587.     if ( -1 == (vgid = Vgetid (f, vgid))) break; /* no more vgroups */
  588.    printf("Vlone: vgid=%d..attach",vgid);
  589.     vg = (VGROUP*) Vattach(f,vgid,"r");
  590.    printf("..attach done\n");
  591.     id = -1;
  592.     for (i=0; i< Vntagrefs(vg); i++) {
  593.         Vgettagref (vg, i, &vstag, &id);
  594.         if (vstag==VGDESCTAG) { lonevg[id]++; dum++;  }
  595.         }
  596.     Vdetach(vg);
  597.     }
  598.  
  599. /* -- check in lonevg: it's a lone vgroup if its flag is still 1 -- */
  600. nlone = 0;
  601. for(i=0;i<65000;i++) {
  602.     if (1 == lonevg[i]) {
  603.          if (nlone < asize) { /* insert into idarray up till asize */
  604.             idarray[nlone] = i;
  605.             }
  606.         nlone ++;
  607.         }
  608.    }
  609. DFIfreespace(lonevg);
  610.  
  611. return(nlone); /* return the TOTAL # of lone vgroups */
  612.  
  613. } /* Vlone */
  614.  
  615.  
  616. /* ================================================================== */
  617. /* new jan 3 1991 */
  618. /* looks in the file and returns the ref of the vgroup with name vgname */
  619. /* 
  620. * returns -1 if not found, or error.
  621. * otherwise, returns the vgroup's ref (a +ve integer).
  622. */
  623.  
  624. int Vfind (f, vgname)
  625. DF * f;
  626. char * vgname;
  627. {
  628.   int vgid = -1;
  629.   VGROUP* vg;
  630.   char name[512];
  631.  
  632.     while ( -1 != (vgid=Vgetid(f, vgid)) ) {
  633.         vg = (VGROUP*) Vattach(f,vgid,"r");
  634.         if (vg==NULL) return(-1);             /* error */
  635.         Vgetname(vg, name);
  636.         Vdetach (vg);
  637.         if (!strcmp(vgname,name)) return (vg->oref);  /* found the vgroup */
  638.       }
  639.       return(-1); /* not found */
  640.  
  641. } /* Vfind */
  642.  
  643. /* ================================================================== */
  644. /* new jan 3 1991 */
  645. /* looks in the file and returns the ref of the vdata with name vsname */
  646. /* 
  647. * returns -1 if not found, or error.
  648. * otherwise, returns the vdata's ref (a +ve integer).
  649. */
  650.  
  651. int VSfind (f, vsname)
  652. DF * f;
  653. char * vsname;
  654. {
  655.   int vsid = -1;
  656.   VDATA * vs;
  657.   char name[512];
  658.  
  659.     while ( -1 != (vsid=VSgetid(f, vsid)) ) {
  660.         vs = (VDATA*) VSattach(f,vsid,"r");
  661.         if (vs==NULL) return(-1);             /* error */
  662.         VSgetname(vs, name);
  663.         VSdetach (vs);
  664.         if (!strcmp(vsname, name)) return (vs->oref);  /* found the vdata */
  665.       }
  666.       return(-1); /* not found */
  667.  
  668. } /* VSfind */
  669.  
  670. /* ================================================================== */
  671.  
  672. /*
  673. * Vsetzap: Useless now. Maintained for back compatibility.
  674. */
  675.  
  676. Vsetzap() {
  677.     if (vjv) { sprintf(sjs,"Vsetzap: defunct\n"); zj; }
  678. }
  679. /* ================================================================== */
  680.