home *** CD-ROM | disk | FTP | other *** search
/ Fish 'n' More 2 / fishmore-publicdomainlibraryvol.ii1991xetec.iso / disks / disk373.lzh / Multiplot / source / mplot_src / src.zoo / old_getdat.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-08-03  |  11.5 KB  |  344 lines
  1. #include <stdio.h>
  2. #include <ctype.h>
  3. #include <exec/types.h>
  4. #include <exec/memory.h>
  5. #include <intuition/intuition.h>
  6. #include "mp.h"
  7. #include "struct.h"
  8.  
  9. #define MAXCOLUMNS 10
  10.  
  11. extern int debug;
  12. extern int MAXHORIZ;
  13. extern int MAXVERT;
  14.  
  15.  
  16. extern char *getwrd();
  17. extern void trch();
  18. extern int same(), numeric();
  19. extern struct Window *FrontWindow;
  20. extern struct NewScreen newscreen;
  21. extern struct Screen *screen;
  22. struct Plot *GetStructPlot();
  23.  
  24. /***************************************************************************
  25. *     GetDat finds numeric data in a text file and stores it in arrays.
  26. *
  27. *     GetDat reads a text file whose handle is pointed to by 'fp'.  In
  28. *  this file are expected to be lines containing "words" [of arbitrary
  29. *  length, delimited by blanks, tabs, or commas.] In each line, the first
  30. *  word will be pointed to by 'wp[0]'; the user thinks of this
  31. *  word as being in column 1.  'wp[1]' will point to the next word,
  32. *  etc.  GetDat is primarily interested in those words which look like
  33. *  numbers.
  34. *
  35. *     The user has assigned column numbers to the variables x, y, and e.
  36. *  She wants GetDat to find all the lines which contain numbers in those
  37. *  columns and save the numbers in the arrays 'x[]', 'y[]', 'e[]'.
  38. *  Further, successive lines which contain numbers in the columns of
  39. *  interest are to be treated as a list [possibly delimited by lines
  40. *  which don't contain numbers in the columns of interest.]
  41. *  Finally, the number of lists and the numbers of lines
  42. *  in each list are to be saved in the data structure pointed to by the
  43. *  argument 'Pict'.
  44. *
  45. *     Special handling: If the column associated with 'x[]' is given as 0,
  46. *  the 'x[]' array is to be filled as if the x-columns of each list
  47. *  contained [0,1,2...].  If the column associated with 'e[]' is 0, the
  48. *  'e[]' array is not to be filled at all.
  49. *
  50. *     Lines which begin with "*SCALFACT*" contain scale factors by which
  51. *  collected data is to be multiplied.  Scale factor columns map to data
  52. *  columns after the keyword "*SCALFACT*" is discarded.
  53. *
  54. *     Lines which begin with "*TITLE*", "*XLABEL*", and "*YLABEL*" are
  55. *  interpreted as text to be stored in the structure pointed to by
  56. *  'Pict'.  The keyword "*...*" and the blanks, tabs, or commas following
  57. *  it are discarded.
  58. *
  59. *     Lines which begin with *LEGEND* should contain
  60. *  following text which will be a label for the following set.
  61. *
  62. *************************************/
  63.  
  64. #define COLUMN_OK(z) (z<0 ? TRUE : numeric(wp[z]))
  65. #define LINE_IS_DATA (COLUMN_OK(xcol) && COLUMN_OK(ycol) && COLUMN_OK(ecol))
  66. #define DATA(z) (fact[(z)]*atoFFP(wp[(z)]))
  67. #define PLOT_OPENED (Plot->NPts && !PlotClosed)
  68.  
  69. FFP fact[MAXCOLUMNS];                /* SCALE FACTORS */
  70. short maxcol;                        /* LARGEST OF ARGS: XCOL, YCOL, ECOL */
  71. short xcoord;
  72. short PlotClosed, Continued;
  73. short SCRIPT_ON;
  74.  
  75.  
  76. /********************************************/
  77. void GetDat(fp, xcol, ycol, ecol, Pict)
  78. FILE *fp;
  79. int xcol, ycol, ecol;   /* column numbers to be inspected */
  80. struct Pict *Pict;      /* contains info for plotting this data */
  81. {
  82.    short i;
  83.    char cbuf[100], *cb, *wp[MAXCOLUMNS];
  84.    struct Plot *Plot, *PrevPlot;
  85.    FFP *x, *y, *e;
  86.  
  87.       /*** INITIALIZE ***/
  88.    PlotClosed = FALSE; Continued = FALSE;  xcoord = 0;
  89.  
  90.    SCRIPT_ON=FALSE;
  91.  
  92.  
  93.       /* TRANSLATE from user column numbers to array indices, FIND max */
  94.    xcol--; ycol--; ecol--; maxcol = max(xcol,max(ycol,ecol));
  95.    for (i=0; i<=maxcol; i++) fact[i] = 1.;   /* init scale factors */
  96.    Pict->NPlt = 0;
  97.    Pict->Plot = GetStructPlot();
  98.    Plot = Pict->Plot;
  99.    x = Plot->x; y = Plot->y; e = Plot->e;
  100.  
  101. /*** GET DATA ***/
  102.  
  103.    /* FIND list(s) of numbers in file, GET numbers in x,y(,e) arrays */
  104.    while (cb = fgets(cbuf,100,fp)) {
  105.  
  106.       trch('\n',0,cb); trch('\t',' ',cbuf); trch(',',' ',cbuf); trch('\r',' ',cbuf);
  107.  
  108.       if (KeyWord(fp,cb,Pict,Plot)) ; /* Do nothing else */
  109.  
  110.       else if (same(cb,"*LEGEND*",8))
  111.         {
  112.             if (PlotClosed) {
  113.                /* allocate, link, SET UP FOR NEW PLOT */
  114.                if (!(Plot->NextPlot = GetStructPlot()))
  115.                   {
  116.                      ErrorAlert(0);
  117.                      FreeMemory(Pict);          /*** DEALLOCATE MEMORY ***/
  118.                      CloseScreen(screen);
  119.                      sexit(FALSE);
  120.                   }
  121.                else Plot = Plot->NextPlot;
  122.                x = Plot->x; y = Plot->y; e = Plot->e;
  123.                PlotClosed = FALSE; xcoord = 0;
  124.             }
  125.             cb+=8; while(*cb==' ') cb++; stccpy(Plot->Legend->String,cb,79);
  126.             Plot->Legend->x = Plot->Legend->y = NULL;
  127.         }
  128.       else
  129.         {
  130.          for (i=0; i<=maxcol; i++) wp[i] = getwrd(&cb);
  131.          if (LINE_IS_DATA) {
  132.             if (PlotClosed) {
  133.                /* allocate, link, SET UP FOR NEW PLOT */
  134.                if (!(Plot->NextPlot = GetStructPlot()))
  135.                   {
  136.                      ErrorAlert(0);
  137.                      FreeMemory(Pict);          /*** DEALLOCATE MEMORY ***/
  138.                      CloseScreen(screen);
  139.                      sexit(FALSE);
  140.                   }
  141.                else Plot = Plot->NextPlot;
  142.                x = Plot->x; y = Plot->y; e = Plot->e;
  143.                PlotClosed = FALSE; xcoord = 0;
  144.             }
  145.             else if (Plot->NPts == MAXPOINTS) {
  146.                /* allocate, link, SET UP FOR CONTINUATION OF CURRENT PLOT */
  147.                Continued = TRUE; PrevPlot = Plot;
  148.                if (!(Plot->NextPlot = GetStructPlot()))
  149.                   {
  150.                      ErrorAlert(0);
  151.                      FreeMemory(Pict);          /*** DEALLOCATE MEMORY ***/
  152.                      CloseScreen(screen);
  153.                      sexit(FALSE);
  154.                   }
  155.                else Plot = Plot->NextPlot;
  156.                x = Plot->x; y = Plot->y; e = Plot->e;
  157.             }
  158.             else if (Continued) {PrevPlot->Continued = TRUE; Continued = FALSE;}
  159.  
  160.                    /*** PAYLOAD..  STORE data in arrays, COUNT points */
  161.             *(x++) = ( xcol>=0 ? DATA(xcol) : (FFP)(xcoord++));
  162.             *(y++) = DATA(ycol);
  163.             if (ecol>=0) *(e++) = DATA(ecol);
  164.             Plot->NPts++;
  165.          }
  166.          else {
  167.             /* line does not contain plottable data */
  168.             if (PLOT_OPENED) {
  169.                Pict->NPlt++;
  170.                PlotClosed = TRUE;
  171.             }
  172.          }
  173.       }
  174.    }
  175.  
  176.    if (PLOT_OPENED) Pict->NPlt++;
  177. }
  178.  
  179. int CheckDat(fp, xcol, ycol, ecol)
  180. FILE *fp;
  181. int xcol, ycol, ecol;   /* column numbers to be inspected */
  182. {
  183. char cbuf[100];
  184. int i=0;
  185.    maxcol = max(xcol,max(ycol,ecol));
  186.  
  187.    while ( fgets(cbuf,99,fp) && ( (i==0) || (i>=maxcol) ) )
  188.        {
  189.           strcat(cbuf,'\0');
  190.           i=countwords(&cbuf);
  191.        }
  192.     if ( (i<maxcol) && (i!=0) )
  193.       {
  194.          return(FALSE);
  195.       }
  196.   return(TRUE);
  197. }
  198.  
  199.  
  200. countwords(s)
  201. char *s;
  202. {
  203. int x=0;
  204.  
  205.  
  206.   while ((*s!='\n')&&(*s !='\0')&&(!isdigit(*s)))
  207.     {
  208.        if (isalpha(*s))   return(0);
  209.        s++;
  210.     }
  211.   while ((*s !='\n')&&(*s !='\0'))
  212.     {
  213.        if (isdigit(*s))
  214.          {
  215.             x++;
  216.             while (isalnum(*s)||ispunct(*s))  s++;
  217.          }
  218.        else s++;
  219.      }
  220.    return(x);
  221. }
  222.  
  223. extern short firstcall;
  224. extern struct TextBox *ExtraText;
  225. struct Remember *Key=NULL;
  226.  
  227. /******************/
  228. int KeyWord(fp,cb,Pict,Plot,x,y,e)
  229. FILE *fp;
  230. char *cb;
  231. struct Pict *Pict;
  232. struct Plot *Plot;
  233. FFP *x, *y, *e;
  234. {
  235. short i, tempLegX, tempLegY;
  236. double tempXmin, tempXmax, tempYmin, tempYmax;
  237. char cbuf[100];
  238. struct TextBox *TempText;
  239.  
  240.  
  241.    if (same(cb,"*",1)) {
  242.       if (same(cb,"*SCALFACT*",10)) {
  243.          (void)getwrd(&cb);
  244.          for (i=0; i<=maxcol; i++) {
  245.             fact[i] = atoFFP(getwrd(&cb));
  246.          }
  247.          return (TRUE);
  248.       }
  249.       else if (same(cb,"*TITLE*",7))
  250.           { cb+=7; while (*cb==' ') cb++; stccpy(Pict->Title->String,cb,79); return (TRUE); }
  251.       else if (same(cb,"*XLABEL*",8))
  252.           { cb+=8; while(*cb==' ') cb++; stccpy(Pict->XLabel->String,cb,79); return (TRUE); }
  253.       else if (same(cb,"*YLABEL*",8))
  254.           { cb+=8; while(*cb==' ') cb++; stccpy(Pict->YLabel->String,cb,79); return (TRUE); }
  255.       else if (same(cb,"*AUTOSCRIPT*",12))
  256.         {
  257.           getwrd(&cb);
  258.           if (SCRIPT_ON)
  259.             {
  260.                sscanf(cb,"%hd %hd %hd %hd %hd %hd %hd %hd",
  261.                   &(Plot->Color),&(Plot->PlotType),&(Plot->Lines),&(Plot->PointSize),&(Plot->PointType),&(Plot->Enabled),&tempLegX,&(Plot->Legend->y));
  262.                Plot->Legend->x=MAXHORIZ-tempLegX;
  263.             }
  264.           else
  265.             {
  266.                sscanf(cb,"%hd %hd %hd %hd %hd %hd %lf %lf %lf %lf",
  267.                      &(Pict->ErrBar),&(Pict->ShowErr),&(Pict->Grid),&(Pict->Tics->NX),
  268.                      &(Pict->Tics->NY),&(Pict->RMargin), &tempXmin, &tempXmax, &tempYmin, &tempYmax);
  269.                Pict->CurrReg->XMin=(FFP)tempXmin; Pict->CurrReg->XMax=(FFP)tempXmax;
  270.                Pict->CurrReg->YMin=(FFP)tempYmin; Pict->CurrReg->YMax=(FFP)tempYmax;
  271.                SCRIPT_ON=TRUE;
  272.             }
  273.           return(TRUE);
  274.         }
  275.       else if (same(cb,"*EXTRATEXT*",11)) {
  276.         while (cb = fgets(cbuf,100,fp)) {
  277.            trch('\n',0,cb); trch('\t',' ',cbuf); trch(',',' ',cbuf); trch('\r',' ',cbuf);
  278.            if (ExtraText)
  279.              {
  280.                  for (TempText=ExtraText;TempText->NextText;TempText=TempText->NextText);
  281.                  if (TempText->NextText=(struct TextBox *)AllocRemember(&Key,(sizeof(struct TextBox)),MEMF_CLEAR))
  282.                    {
  283.                       TempText=TempText->NextText;
  284.                       if (sscanf(cb,"%hd %hd",&tempLegX,&tempLegY))
  285.                         {
  286.                            TempText->x=MAXHORIZ-tempLegX;
  287.                            TempText->y=MAXVERT-tempLegY;
  288.                            getwrd(&cb); getwrd(&cb); while(*cb==' ') cb++;
  289.                         }
  290.                       stccpy(TempText->String,cb,79);
  291.                       TempText->NextText=NULL;
  292.                    }
  293.                  else Message("  Not enough memory for text");
  294.               }
  295.             else
  296.               {
  297.                  if (ExtraText=(struct TextBox *) AllocRemember(&Key,(sizeof(struct TextBox)),MEMF_CLEAR))
  298.                    {
  299.                       if (sscanf(cb,"%hd %hd",&tempLegX,&tempLegY))
  300.                         {
  301.                            ExtraText->x=MAXHORIZ-tempLegX;
  302.                            ExtraText->y=MAXVERT-tempLegY;
  303.                            getwrd(&cb); getwrd(&cb); while (*cb==' ') cb++;
  304.                         }
  305.                       stccpy(ExtraText->String,cb,79);
  306.                       ExtraText->NextText=NULL;
  307.                    }
  308.                  else Message("  Not enough memory for text");
  309.                }
  310.         }
  311.         return(TRUE);
  312.       }
  313.    }
  314.    return (FALSE);
  315. }
  316.  
  317.  
  318. /*************************************************************************/
  319.  
  320. struct Plot *GetStructPlot()
  321. {
  322.    struct Plot *P;
  323.  
  324.    if( (!(P     = (struct Plot *)AllocRemember(&Key,sizeof(struct Plot),MEMF_CLEAR)))
  325.    ||  (!(P->x  = (FFP *)AllocRemember(&Key,MAXPOINTS * sizeof(FFP),MEMF_CLEAR)))
  326.    ||  (!(P->y  = (FFP *)AllocRemember(&Key,MAXPOINTS * sizeof(FFP),MEMF_CLEAR)))
  327.    ||  (!(P->e  = (FFP *)AllocRemember(&Key,MAXPOINTS * sizeof(FFP),MEMF_CLEAR)))
  328.    ||  (!(P->xp = (short *)AllocRemember(&Key,MAXPOINTS * sizeof(short),MEMF_CLEAR)))
  329.    ||  (!(P->yp = (short *)AllocRemember(&Key,MAXPOINTS * sizeof(short),MEMF_CLEAR)))
  330.    ||  (!(P->ep = (short *)AllocRemember(&Key,MAXPOINTS * sizeof(short),MEMF_CLEAR)))
  331.    ||  (!(P->Legend = (struct TextBox *)AllocRemember(&Key,sizeof(struct TextBox),MEMF_CLEAR)))
  332.    ||  (!(P->Reg = (struct PlotRegion *) AllocRemember(&Key,sizeof(struct PlotRegion),MEMF_CLEAR))) )
  333.    return(NULL);
  334.    else return(P);
  335. }
  336.  
  337.  
  338. /*******************/
  339. void FreeStructPlot()
  340. {
  341.    FreeRemember(&Key,TRUE);
  342.    ExtraText=NULL;
  343. }
  344.