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 / vmake.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-04-20  |  10.5 KB  |  439 lines  |  [TEXT/????]
  1.  
  2. /*****************************************************************************
  3. *
  4. * vmake.c
  5. *
  6. *    HDF Vset utility.
  7. *
  8. *    vmake:  utility creates vsets. May be used in 3 ways:
  9. *            (1)    add a new vgroup.
  10. *            (2)    add a new vdata from ascii data.
  11. *            (3)    link vgroups and vdatas to a vgroup.
  12. *
  13. *    USAGE:
  14. *            (1)     vmake file vgname
  15. *            (2)    vmake file vsname {format} {ascii data stream}
  16. *            (3)    vmake file -l vgref v1 v2 ... vn
  17. *
  18. *
  19. *****************************************************************************
  20. * 
  21. *              NCSA HDF Vset release 2.1
  22. *                    May 1991
  23. *                 Jason Ng May 1991 NCSA
  24. *
  25. * NCSA HDF Vset release 2.1 source code and documentation are in the public
  26. * domain.  Specifically, we give to the public domain all rights for future
  27. * licensing of the source code, all resale rights, and all publishing rights.
  28. * 
  29. * We ask, but do not require, that the following message be included in all
  30. * derived works:
  31. * 
  32. * Portions developed at the National Center for Supercomputing Applications at
  33. * the University of Illinois at Urbana-Champaign.
  34. * 
  35. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  36. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  37. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  38. * 
  39. ******************************************************************************/
  40.  
  41. #include "vg.h"
  42.  
  43. #ifdef MAC
  44.  int show_help_msg(void);
  45.  int vgadd(char *, char *);
  46.  int vsadd(char *,char *, char *);
  47.  int vsetlink (char *, int, int*, int);
  48.  int scanit (char*, char***, int**, int**);
  49.  int getdata ( unsigned char**);  
  50.  int compact (char *,char *);
  51.  int savfld (char *,int, int);
  52.  int savtype (char *,int, int);
  53.  int separate(char *ss, char *, int*);
  54.  
  55. #endif
  56.  
  57. main(ac,av) int ac; char**av; {
  58.  
  59.   char  *hfile, *vgname, *vsname, *fmt;
  60.  
  61.   if (ac <3 ) {
  62.         show_help_msg();
  63.         exit(0);
  64.         }
  65.   else if (ac==3)  {
  66.       if (!strcmp(av[2],"-l")) { show_help_msg() ; exit(0); }
  67.           hfile  = av[1];
  68.           vgname = av[2];
  69.          vgadd(hfile,vgname);
  70.         }
  71.  
  72.   else if (ac==4)  {
  73.       if (!strcmp(av[2],"-l")) { show_help_msg() ; exit(0); }
  74.           hfile    = av[1];
  75.           vsname   = av[2];
  76.           fmt      = av[3];
  77.          vsadd(hfile,vsname,fmt);
  78.         }
  79.  
  80.   else if (!strcmp(av[2],"-l")) {
  81.  
  82.          int i, n, vgref,ids[50];
  83.           hfile     = av[1];
  84.         sscanf(av[3],"%d",&vgref);
  85.         for(n=0,i=4;i<ac;i++,n++) { sscanf(av[i],"%d",&ids[n]); }
  86.         vsetlink(hfile,vgref,ids,n);
  87.         }
  88.  
  89.   else {
  90.         show_help_msg();
  91.         exit(0);
  92.         }
  93.  
  94.   } /* main */
  95.   
  96. int show_help_msg()  {
  97.  
  98.     printf("\nvmake: creates vsets.\n");
  99.     printf("\nUSAGE:\n");
  100.  
  101.   printf(" (1) vmake file vgname             (adds a new vgroup)\n");
  102.   printf(" (2) vmake file vsname format      (adds a new vdata)\n");
  103.   printf(" (3) vmake file -l vgref v1 .. vn  (links v1 v2 .. vn into vgref)\n");
  104.                                                                                                         
  105.     printf("\nwhere\n");
  106.      printf("  vgref is the ref of a vgroup\n");
  107.      printf("  v1,..,vn are refs of vgroups and vdatas\n");
  108.     printf("  format is <field=fmt,field=fmt,..>\n");
  109.     printf("    field is any text string\n");
  110.     printf("    fmt is one of [d,l,f,c] optionally preceded by a decimal.\n");
  111.     printf("\nTo create a vdata, vmake reads ascii data from stdin\n");
  112.  
  113.     printf("EXAMPLES:\n");
  114.      printf("\t cat dat.txt | vmake hh.hdf \"triangles\" \"PLIST3=3d\"\n");
  115.      printf("\t vmake abc.hdf \"xyvals\" \"X=d,Y=f\" < abc.dat\n");
  116.      printf("\n");
  117.  
  118.      return (1);
  119.  
  120.  } /* show_help_msg */
  121.  
  122. /* ------------------------------------------------------- */
  123.  
  124. int vsetlink  (hfile,vgid,ids,n)
  125. char * hfile;
  126. int vgid, n, ids[];
  127. {
  128.   DF * f;
  129.   VGROUP * vgmain, *vg;
  130.   VDATA * vs;
  131.   int err=0;
  132.   int i;
  133.  
  134.   if ( (f=DFopen(hfile,DFACC_ALL,0))==NULL) {
  135.       fprintf(stderr,"cannot open %s. DFerror=%d \n",hfile,DFerror); exit(0); 
  136.       }
  137.  
  138.   vgmain = (VGROUP*) Vattach(f,vgid,"w");
  139.   if(vgmain==NULL) { fprintf(stderr, "0\n"); DFclose(f); exit(-1);}
  140.  
  141.   for(i=0;i<n;i++) {
  142.       if     ( -1 != vexistvg(f,ids[i])) {
  143.             if ((vg=(VGROUP*) Vattach(f,ids[i],"r")) != NULL)  {
  144.              if (Vinsert(vgmain,(VDATA*) vg)  == -1)  { /*  is really VGROUP* */
  145.                     err = 1; 
  146.                    fprintf(stderr,"insert a vg (%d)fails!!\n",ids[i]);    
  147.                     }
  148.               Vdetach(vg);
  149.               }
  150.          }
  151.      else if ( -1 != vexistvs(f,ids[i])) {
  152.            if ((vs= (VDATA*) VSattach(f,ids[i],"r")) != NULL) { 
  153.              if (Vinsert(vgmain,(VDATA*) vs) == -1) { 
  154.                     err = 1;
  155.                    fprintf(stderr,"insert a vs (%d)fails!!\n",ids[i]);    
  156.                     }
  157.               VSdetach(vs);
  158.               }
  159.          }
  160.      else { fprintf(stderr,"no such vgroup or vdata [%d]\n",ids[i]);  err= 1; }
  161.       }
  162.  
  163.   Vdetach(vgmain);
  164.   DFclose(f);
  165.  
  166.   if (err) exit(-1); 
  167.   else fprintf(stderr,"1\n"); /* success */
  168.   return (1);
  169. } /* vsetlink */
  170.  
  171. /* ------------------------------------------------------- */
  172. /* 
  173. add a (new) vgroup to the file 
  174. */
  175.  
  176. int vgadd (hfile,vgname) 
  177. char * hfile;
  178. char * vgname;
  179. {
  180.   DF * f;
  181.   int ref; 
  182.   VGROUP * vg;
  183.  
  184.   if ( (f=DFopen(hfile,DFACC_ALL,0))==NULL) {
  185.       fprintf(stderr,"cannot open %s. DFerror=%d \n",hfile,DFerror); exit(0); 
  186.       }
  187.  
  188.   vg = (VGROUP*) Vattach(f,-1,"w");
  189.   if (vg==NULL) { fprintf(stderr,"cannot attach vg\n"); exit(0); }
  190.   ref = vg->oref;
  191.   Vsetname(vg,vgname);
  192.   Vdetach(vg);
  193.  
  194.   DFclose(f);
  195.   fprintf(stderr,"%d\n",ref);
  196.   return(1);
  197.  
  198. } /* vgadd */
  199.  
  200. /* ------------------------------------------------------- */
  201. /*
  202.  add a (new) vdata to the file.
  203.  Data will be ascii and will come in from stdin
  204.  according to the format (c-style).
  205. */
  206. vsadd (hfile,vsname,format)
  207. char * hfile;
  208. char * vsname;
  209. char * format;
  210.  
  211. {
  212.   int stat, i,n, nwritten;
  213.   unsigned char *buf;
  214.   char **fields;
  215.   int *type, *order, nfld;
  216.   char allfields[100];
  217.   DF * f;
  218.   VDATA *vs;
  219.   int ref,ftype;
  220.  
  221.   nfld = scanit(format,&fields,&type,&order);
  222.   if (nfld < 1) { fprintf(stderr,"bad fields\n"); exit(-1); }
  223.  
  224.   if ( (f=DFopen(hfile,DFACC_ALL,0))==NULL) {
  225.       fprintf(stderr,"cannot open %s. DFerror=%d \n",hfile,DFerror); exit(-1); 
  226.       }
  227.  
  228.   vs = (VDATA*) VSattach(f,-1,"w");
  229.   ref = vs->oref;
  230.  
  231. printf("vsadd: ref is %d\n",ref);
  232.  
  233.   allfields[0] = '\0';
  234.   for (i=0;i<nfld;i++) {
  235.       switch (type[i]) {
  236.           case 'd': ftype = LOCAL_INTTYPE;   break;
  237.           case 'f': ftype = LOCAL_FLOATTYPE; break;
  238.           case 'c': ftype = LOCAL_CHARTYPE;  break;
  239.           case 'l': ftype = LOCAL_LONGTYPE;  break;
  240.           default:  fprintf(stderr,"bad type [%c]\n",type[i]); exit(-1); break;
  241.           }
  242.       stat = VSfdefine(vs,fields[i],ftype,order[i]);
  243.       strcat(allfields,fields[i]);
  244.       strcat(allfields,",");
  245.      }
  246.  
  247.   i=strlen(allfields); allfields[i-1]='\0'; /* remove last comma */
  248.  
  249.   VSsetname(vs,vsname);
  250.   stat = VSsetfields(vs,allfields);
  251.  
  252.   nwritten = 0;
  253.   while( (n = getdata(&buf)) > 0) {
  254.      /*  printf("getdata rets n=%d .. ",n); */
  255.     stat = VSwrite(vs,buf,n,FULL_INTERLACE);
  256.      printf("+%d",stat); 
  257.      nwritten +=n;
  258.      if (stat < 1) fprintf(stderr,"Vswrite stat=%d\n",stat);
  259.      }
  260.   VSdetach(vs);
  261.  
  262.   DFclose(f);
  263.   fprintf(stderr,"%d\n",ref,nwritten);
  264.   return (1);
  265.  
  266. } /* vsadd */
  267.  
  268. /* ------------------------------------------------------------------ */
  269. /* This part of the code deals with formatting stdin input data.      */
  270. /* ------------------------------------------------------------------ */
  271.  
  272. #include <stdio.h>
  273.  
  274.  
  275. #define MAXVAR 32
  276. static char *fldptr[MAXVAR];
  277. static char flds[MAXVAR][100];
  278. static char fmts[MAXVAR]; 
  279. static int  fords[MAXVAR]; 
  280. static int  ftyp[MAXVAR]; 
  281. static int  ntotal = 0;
  282.  
  283.  
  284. /* scanf functions */
  285. static int getint  (x) int  *x; { return(scanf ("%d ",x)); }
  286. static int getfloat(x) float*x; { return(scanf ("%f ",x)); }
  287. static int getbyte (x) char *x; { return(scanf ("%c ",x)); }
  288. static int getlong (x) long *x; { return(scanf ("%ld ",x)); }
  289.  
  290. /* printf functions */
  291. static int putbyte (x) char *x; { putchar(*x);    return (1);   }
  292. static int putint  (x) int  *x; { printf("%d ",*x); return (1);}
  293. static int putfloat(x) float*x; { printf("%f ",*x); return (1);}
  294. static int putlong (x) long *x; { printf("%ld ",*x); return (1);}
  295.  
  296.  
  297. #define BUFSIZE 40000
  298.  
  299. int getdata (bp) unsigned char**bp; { 
  300.   int totalsize, nread, t,i,j,k;
  301.   unsigned char *b;
  302.   int maxrec;
  303.   int (*getfn[MAXVAR])();
  304.   int (*putfn[MAXVAR])();
  305.   int getsiz[MAXVAR];
  306.   unsigned char getbuffer[BUFSIZE];
  307.  
  308.      for(i=0;i<ntotal;i++) {
  309.         switch(fmts[i]) {
  310.            case 'd':
  311.              putfn[i] = putint; getfn[i]  = getint; getsiz[i] = sizeof(int);
  312.               break;
  313.            case 'f':
  314.               putfn[i] = putfloat; getfn[i]  = getfloat; getsiz[i] = sizeof(float);
  315.               break;
  316.            case 'c':
  317.               putfn[i]  = putbyte; getfn[i]  = getbyte; getsiz[i] = sizeof(char);
  318.               break;
  319.            case 'l':
  320.               putfn[i]  = putlong; getfn[i]  = getlong; getsiz[i] = sizeof(long);
  321.               break;
  322.            } 
  323.         }
  324.      for (totalsize=0, i=0;i<ntotal;i++) totalsize  += (fords[i]*getsiz[i]); 
  325.       maxrec = BUFSIZE/totalsize - 1; 
  326.  
  327.   /* begin reading in the ascii data from stdin */
  328.  
  329.     *bp = b = getbuffer;
  330.    for (nread=0, j=0;j<maxrec;j++,nread++) {
  331.       for(i=0;i<ntotal;i++) {
  332.            for(k=0;k<fords[i];k++) {
  333.               t = (getfn[i])(b);  
  334.             if (t==EOF)  return(nread); 
  335.               b+=getsiz[i];
  336.               }
  337.            }
  338.       }
  339.  
  340.    return (nread); /* no of recs read */
  341.  
  342. } /* getdata */
  343.  
  344.  int scanit (string,fields,type,order)
  345.  char *   string;
  346.  char *** fields;
  347.  int  **  type;
  348.  int  **  order;
  349.  {
  350.   int ns,i;
  351.   int p1,p2;
  352.   char ss[300];
  353.   int c;
  354.  
  355.  
  356.  compact(string,ss);
  357.  ns = strlen(ss); ss[ns++] = ','; 
  358.  
  359.  p1 = p2 = 0;
  360.  for(i=0;i<ns;i++) {
  361.      c = ss[i];
  362.      if(c== '=') {
  363.          p2 = i;
  364.          savfld(ss,p1,p2-1);
  365.          p1 = p2+1;
  366.          }
  367.      else if(c== ',') {
  368.          p2 = i;
  369.          savtype(ss,p1,p2-1);
  370.          p1 = p2+1;
  371.          }
  372.      }
  373.    for(i=0;i<ntotal;i++) {
  374.       fldptr[i] = flds[i];
  375.       switch(fmts[i]) {
  376.           case 'd':
  377.                 ftyp[i]   = 'd';
  378.                 break;
  379.           case 'f':
  380.                 ftyp[i]   = 'f';
  381.                 break;
  382.           case 'c':
  383.                 ftyp[i]   = 'c';
  384.                 break;
  385.           case 'l':
  386.                 ftyp[i]   = 'l';
  387.                 break;
  388.           } 
  389.       }
  390.  
  391.    *type   =  ftyp;
  392.    *order  =  fords;
  393.     *fields =  fldptr;
  394.    return (ntotal);
  395.  
  396.  } /* scanit */
  397.  
  398.  int compact (ss,dd) char *ss, *dd; {
  399.     int i,t,n = strlen(ss);
  400.     for(t=0,i=0;i<n;i++) if(ss[i]!=' ') { dd[t++] = ss[i]; }
  401.     dd[t] = '\0';
  402.     return (1);
  403.     }
  404.  
  405. /* ------------------------------------------------------------------ */
  406.  
  407. int savfld (ss,p1,p2) char *ss; int p1,p2; {
  408.   int t=p2-p1+1;
  409.   strncpy(flds[ntotal],&ss[p1],t);
  410.   flds[ntotal][t] = '\0';
  411.   return (1);
  412.  
  413.  } /* savfld */
  414.  
  415. int savtype (ss,p1,p2) char *ss; int p1,p2; {
  416.   char temp[20];
  417.   int t=p2-p1+1;
  418.   strncpy(temp,&ss[p1],p2-p1+1); temp[t] = '\0';
  419.   separate(temp,&fmts[ntotal],&fords[ntotal]);
  420.   ntotal++;
  421.   return (1);
  422.  
  423.   }
  424.  
  425. int separate(ss,fmt,num) char *ss; char *fmt; int*num; {
  426.     int i,n;
  427.     i=0;
  428.     n=strlen(ss);
  429.     while(i<n) {
  430.       if(ss[i]<'0' ||  ss[i] >'9') break; 
  431.       i++;
  432.       }
  433.     if(i>0) sscanf(ss,"%d",num); else *num= 1;
  434.     *fmt  = ss[i];
  435.     return (1);
  436.   }
  437.  
  438. /* ------------------------------------------------------------------ */
  439.