home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 300-399 / ff391.lzh / ListPlot / Csrc / input.c < prev    next >
C/C++ Source or Header  |  1990-10-27  |  5KB  |  260 lines
  1. /*
  2.  * input.c
  3.  *
  4.  *    Gets data to be plotted
  5.  */
  6. #include <stdio.h>
  7. #include <errno.h>
  8. extern int errno;
  9. #include <assert.h>
  10. #include <ctype.h>
  11. #include "datatypes.h"
  12.  
  13.  
  14. FLOAT    **
  15. GetData(Fp, m, n)
  16. FILE    *Fp;
  17. int    *m, *n;
  18. {
  19. #ifdef    ANSI_C
  20.     FLOAT    **GetDataMem(FILE *fp, int *M, int *N);
  21. #else
  22.     FLOAT    **GetDataMem();
  23. #endif
  24.  
  25.     return(GetDataMem(Fp, m, n));
  26. }
  27.  
  28.  
  29. bool
  30. Append(L, Ptr)
  31. register LIST    *L;
  32. generic    *Ptr;
  33. {
  34.     register LATOM    *A;
  35.  
  36.     assert(L != (LIST *)NULL);
  37.     assert(L->list_n >= 0);
  38.  
  39.     if ((A = (LATOM *)calloc(1, sizeof(LATOM))) == (LATOM *)NULL) {
  40.         perror("(AppendDbl) ");
  41.         ErrorExit();
  42.     }
  43.     A->la_p = Ptr;
  44.     A->la_next = (LATOM *)NULL;
  45.  
  46.     if (L->list_n == 0) {
  47.         /* empty list */
  48.         assert(L->list_head == (LATOM *)NULL);
  49.         assert(L->list_tail == (LATOM *)NULL);
  50.         L->list_head = A;
  51.         L->list_tail = A;
  52.         L->list_n = 1;
  53.     } else {
  54.         assert(L->list_head != (LATOM *)NULL);
  55.         assert(L->list_tail != (LATOM *)NULL);
  56.         L->list_tail->la_next = A;
  57.         L->list_tail = A;
  58.         L->list_n++;
  59.     }
  60.     return(TRUE);
  61. }
  62.  
  63.  
  64. FLOAT    **
  65. GetDataMem(Fp, m, n)
  66. FILE    *Fp;
  67. int    *m, *n;
  68. {
  69.     int    i;
  70.     int    C;
  71.     int    NTuples, TupleSize;
  72.     double    D;
  73.     FLOAT    *F;
  74.     FLOAT    *Tuple;
  75.     FLOAT    **Data;
  76.     LIST    TupleL1;
  77.     LIST    TupleList;
  78.     LATOM    *A;
  79. #ifdef    ANSI_C
  80.     bool GetNextDbl(FILE *, double *, int *);
  81. #else
  82.     bool GetNextDbl();
  83. #endif
  84.     
  85.     TupleL1.list_n = 0;
  86.     TupleL1.list_head = (LATOM *)NULL;
  87.     TupleL1.list_tail = (LATOM *)NULL;
  88.  
  89.     /* read first line to determine tuple size    */
  90.     NTuples = 0;
  91.     i = 0;
  92.     do {
  93.         if (GetNextDbl(Fp, &D, &C) == TRUE) {
  94.             if ((F = (FLOAT *)calloc(1, sizeof(FLOAT))) == (FLOAT *)NULL) {
  95.                 perror("(GetDataMem) ");
  96.                 ErrorExit();
  97.             }
  98.             *F = D;
  99.             Append(&TupleL1, (generic *)F);
  100.             ++i;
  101.         } else {
  102.             break;
  103.         }
  104.     } while(C != '\n' && C != EOF);
  105.  
  106.     TupleSize = i;
  107.     if ((Tuple=(FLOAT *)calloc(TupleSize, sizeof(FLOAT))) == (FLOAT *)NULL) {
  108.         perror("(GetDataMem) ");
  109.         ErrorExit();
  110.     }
  111.     for (A=TupleL1.list_head,i=0; i<TupleSize; i++,A=A->la_next) {
  112.         Tuple[i] = *((FLOAT *)(A->la_p));
  113.     }
  114.  
  115.     /* initialize list of tuples    */
  116.     TupleList.list_n = 0;
  117.     TupleList.list_head = (LATOM *)NULL;
  118.     TupleList.list_tail = (LATOM *)NULL;
  119.     Append(&TupleList, (generic *)Tuple);
  120.  
  121.     /* get remaining tuples    */
  122.     i = 1;
  123.     do {
  124.         if ((Tuple=(FLOAT *)calloc(TupleSize, sizeof(FLOAT))) == (FLOAT *)NULL) {
  125.             perror("(GetDataMem) ");
  126.             ErrorExit();
  127.         }
  128.         if (GetNextTuple(Fp, Tuple, TupleSize, &C) == TRUE) {
  129.             Append(&TupleList, (generic *)Tuple);
  130.             ++i;
  131.         }
  132.     } while(!feof(Fp));
  133.  
  134.     if ( C != EOF ) {
  135.         fprintf(stderr,"Error encountered while trying to read data stream...\n");
  136.         ErrorExit();
  137.     } else {
  138.         NTuples = i;
  139.     }
  140.  
  141.  
  142.     /* convert to list of tuples to vectorized array */
  143.     if ((Data = (FLOAT **)calloc(NTuples, sizeof(FLOAT *))) == (FLOAT **)NULL) {
  144.         perror("(GetDataMem) ");
  145.         ErrorExit();
  146.     }
  147.  
  148.     for (A=TupleList.list_head,i=0; i<NTuples; i++,A=A->la_next) {
  149.         Data[i] = (FLOAT *)A->la_p;
  150.     }
  151.  
  152.     *m = NTuples;
  153.     *n = TupleSize;
  154.     return(Data);
  155. }
  156.  
  157.  
  158. bool
  159. GetNextTuple(Fp, Tuple, n, C)
  160. FILE    *Fp;
  161. FLOAT    *Tuple;
  162. int    n;
  163. register int    *C;
  164. {
  165.     register int    j;
  166.     double        D;
  167. #ifdef    ANSI_C
  168.     bool GetNextDbl(FILE *, double *, int *);
  169. #else
  170.     bool GetNextDbl();
  171. #endif
  172.  
  173.     for (*C=' ',j=0; j<n && isspace((char)(*C)) && *C != EOF && *C != '\n'; ) {
  174.         if (GetNextDbl(Fp, &D, C) == TRUE) {
  175.             Tuple[j++] = D;
  176.         }
  177.     }
  178.     /* strip trailing any trailing characters */
  179.     for (; *C != '\n' && *C != EOF; )
  180.         *C = fgetc(Fp);
  181.     
  182.     if ( j>0 && j<(n-1) ) {
  183.         /* error */
  184.         if (*C == EOF) {
  185.             fprintf(stderr,"Unexpected EOF while reading data!\n");
  186.         } else if (*C == '\n') {
  187.             fprintf(stderr, "Unexpected EOL while reading tuple...\n");
  188.         } else {
  189.             fprintf(stderr, "Unable to interpret data stream...\n");
  190.         }
  191.         ErrorExit();
  192.     }
  193.     return(j==n? TRUE : FALSE);
  194. }
  195.  
  196. bool
  197. GetNextDbl(Fp, D, C)
  198. FILE    *Fp;
  199. double     *D;
  200. register int    *C;
  201. /* returns next uninterpreted character in C and
  202.  *    TRUE if found double else FALSE.
  203.  */
  204. {
  205.     register int    i;
  206.     register char    *cp;
  207.     char        s[64];
  208.     int        flag;
  209.  
  210.     for (flag=0,i=0,cp=s; i<sizeof(s)-1; ) {
  211.         if ((*C = fgetc(Fp))  == EOF) {
  212.             if (flag) {
  213.                 *cp = (char)NULL;
  214.                 if (sscanf(s, "%lf", D) == 1) {
  215.                     return(TRUE);
  216.                 } else {
  217.                     /* error */
  218.                     fprintf(stderr,"Encountered nonnumeric item in data stream...\n");
  219.                     ErrorExit();
  220.                 }
  221.             } else {
  222.                 return(FALSE);
  223.             }
  224.         } else if (*C == '\n') {
  225.             if (flag) {
  226.                 *cp = (char)NULL;
  227.                 if (sscanf(s, "%lf", D) == 1) {
  228.                     return(TRUE);
  229.                 } else {
  230.                     /* error */
  231.                     fprintf(stderr,"Encountered nonnumeric item in data stream...\n");
  232.                     ErrorExit();
  233.                 }
  234.             } else {
  235.                 return(FALSE);
  236.             }
  237.         } else if (isspace(*C)) {
  238.             if (flag) {
  239.                 *cp = (char)NULL;
  240.                 if (sscanf(s, "%lf", D) == 1) {
  241.                     return(TRUE);
  242.                 } else {
  243.                     /* error */
  244.                     fprintf(stderr,"Encountered nonnumeric item in data stream...\n");
  245.                     ErrorExit();
  246.                 }
  247.             } else {
  248.                 continue;
  249.             }
  250.         } else {
  251.             flag = 1;
  252.             *cp++ = (char)(*C);
  253.             ++i;
  254.         }
  255.     }
  256.     fprintf(stderr,"Possible internal error...\nEncountered data item greater than %d characters!\n", sizeof(s)-1);
  257.     
  258.     ErrorExit();
  259. }
  260.