home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_400 / 423_01 / recio200 / testcog.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-15  |  10.6 KB  |  328 lines
  1. /* testcog.c - tests column delimited get functions */
  2. /* recio version 2.00, release April 15, 1994 */
  3. /* Copyright (C) 1994 William Pierpoint */
  4.  
  5. #include <ctype.h>
  6. #include <errno.h>
  7. #include <limits.h>
  8. #include <float.h>
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12.  
  13. #include "recio.h"
  14.  
  15. /* errors normally to stderr; but for test purposes, stdout */
  16. #define errout  stdout
  17.  
  18. /****************************************************************************
  19. Dynamic string copy function, kludged for use with recio.  This 
  20. function is not part of recio nor was rseterr() designed to work 
  21. with it, but you get the idea. 
  22. Precondition: set dst to null ptr when declaring it, e.g. char *dst=NULL;
  23. Obligation: free dst when finished with it.
  24. *****************************************************************************/
  25. char *                  /* return dst                                       */
  26.     scopys(             /* copy string dynamically                          */
  27.         char *dst,      /* destination string pointer                       */
  28.         char *src)      /* source string pointer                            */
  29. /****************************************************************************/
  30. {                       
  31.   size_t dlen;          /* strlen of dst */
  32.   size_t slen;          /* strlen of src */
  33.   int errnum;           /* error number */
  34.  
  35.   /* if null src pointer */
  36.   if (!src) {
  37.     rseterr(NULL, EINVAL);
  38.     dst = NULL;
  39.     goto done;
  40.   }
  41.   
  42.   if (dst) {
  43.     dlen = strlen(dst);
  44.     slen = strlen(src);
  45.     if (dlen < slen) {
  46.       do {
  47.         dst = (char *) realloc(dst, slen+1);
  48.         if (!dst) {
  49.           errnum = rseterr(NULL, ENOMEM);
  50.           if (errnum) goto done;
  51.         }
  52.       } while (!dst);
  53.     }
  54.     strcpy(dst, src);
  55.   } else {
  56.      do {
  57.        dst = strdup(src);
  58.        if (!dst) {
  59.          errnum = rseterr(NULL, ENOMEM);
  60.          if (errnum) goto done;
  61.        }
  62.      } while (!dst);
  63.    }
  64. done:
  65.   return dst;
  66. }
  67.  
  68. /****************************************************************************/
  69. void                         /* return nothing                              */
  70.     rfixnumber(              /* fix number                                  */
  71.         REC *rp,             /* record pointer                              */
  72.         int  errnum,         /* error number                                */
  73.         int (*rfix)(REC *))  /* rfix function pointer                       */
  74. /****************************************************************************/
  75. {
  76.   switch (errnum) {
  77.   case R_EMISDAT:
  78.     fprintf(errout, "...substituting zero\n");
  79.     rsetfldstr(rp, "0");
  80.     break;
  81.   case R_EINVDAT:
  82.   case R_ERANGE:
  83.     fprintf(errout, "...substituting best guess\n");
  84.     rfix(rp);
  85.     break;
  86.   }
  87. }
  88.  
  89. /****************************************************************************/
  90. void                         /* return nothing                              */
  91.     rfixchar(                /* fix character                               */
  92.         REC *rp,             /* record pointer                              */
  93.         int  errnum,         /* error number                                */
  94.         int (*rfix)(REC *))  /* rfix function pointer                       */
  95. /****************************************************************************/
  96. {
  97.   switch (errnum) {
  98.   case R_EMISDAT:
  99.     fprintf(errout, "...substituting the letter N\n");
  100.     rsetfldstr(rp, "N");
  101.     break;
  102.   case R_EINVDAT:
  103.     fprintf(errout, "...substituting best guess\n");
  104.     rfix(rp);
  105.     break;
  106.   }
  107. }
  108.  
  109. /****************************************************************************/
  110. void                         /* returns nothing                             */
  111.     rwarnfn(                 /* recio callback warning function             */
  112.         REC *rp)             /* record pointer                              */
  113. /****************************************************************************/
  114. {
  115.   if (risvalid(rp)) {
  116.     switch (rwarning(rp)) {
  117.     case R_WNOREG:   /* atexit() full */
  118.       fprintf (errout, "WARNING %s\n", rwarnstr(rp));
  119.       break;
  120.     case R_WEMPSTR:  /* empty data string */
  121.       fprintf(errout, "WARNING reading %s at record %lu and field %u -- %s\n", 
  122.        rnames(rp), rrecno(rp), rfldno(rp), rwarnstr(rp));
  123.       break;
  124.     }
  125.   }
  126. }
  127.  
  128. /****************************************************************************/
  129. void                         /* returns nothing                             */
  130.     rerrfn(                  /* recio callback error function               */
  131.         REC *rp)             /* record pointer                              */
  132. /****************************************************************************/
  133. {
  134.   int errnum;       /* error number */
  135.  
  136.   if (risvalid(rp)) {
  137.   
  138.     /* if reof indicator set */
  139.     if (reof(rp)) { 
  140.       fprintf(errout, "ERROR reading %s: "
  141.        "tried to read past end of file\n", rnames(rp));
  142.     
  143.     /* else rerror indicator set */
  144.     } else {
  145.  
  146.       /* determine cause of error */
  147.       errnum = rerror(rp);
  148.       switch (errnum) {
  149.  
  150.       /* data errors */
  151.       case R_ERANGE:   /* data out of range */
  152.       case R_EINVDAT:  /* invalid data */
  153.       case R_EMISDAT:  /* missing data */
  154.         fprintf(errout, "DATA ERROR reading %s at record %lu and field %u "
  155.          "-- %s\n", rnames(rp), rrecno(rp), rfldno(rp), rerrstr(rp));
  156.             
  157.         /* determine context */
  158.         switch (rcxtno(rp)) {
  159.         case RECIN:
  160.           
  161.           /* determine field */
  162.           switch (rfldno(rp)) {
  163.           case 1:  /* the integer field i */
  164.             rfixnumber(rp, errnum, rfixi);
  165.             break;
  166.           
  167.           case 2:  /* the unsigned integer field ui */
  168.             rfixnumber(rp, errnum, rfixui);
  169.             break;
  170.  
  171.            case 3:  /* the long field l */
  172.             rfixnumber(rp, errnum, rfixl);
  173.             break;
  174.  
  175.            case 4:  /* the unsigned long field ul */
  176.             rfixnumber(rp, errnum, rfixul);
  177.             break;
  178.  
  179.            case 5:  /* the float field f */
  180.             rfixnumber(rp, errnum, rfixf);
  181.             break;
  182.  
  183.             case 6:  /* the double field d */
  184.             rfixnumber(rp, errnum, rfixd);
  185.             break;
  186.           
  187.           case 7: /* the character field ch */
  188.             rfixchar(rp, errnum, rfixc);
  189.             break;
  190.  
  191.           default: /* programming error - no case for field */
  192.             fprintf(errout, "FATAL ERROR %s -- code missing for field %u\n",
  193.              rnames(rp), rfldno(rp));
  194.             break;
  195.           }
  196.           break;
  197.         
  198.         default:  /* programming error - missing context number */
  199.           fprintf(errout, "FATAL ERROR %s -- missing context number\n", 
  200.            rnames(rp));
  201.           abort();
  202.           break;
  203.         }
  204.         break;
  205.         
  206.       /* fatal errors (R_EINVMOD, R_EINVAL, R_ENOMEM) */
  207.       default:
  208.         fprintf(errout, "FATAL ERROR %s -- %s\n", rnames(rp), rerrstr(rp));
  209.         abort();
  210.         break;
  211.       }
  212.     }
  213.   
  214.   /* invalid record pointer */
  215.   } else {
  216.     switch (errno) {
  217.  
  218.     /* non-fatal errors */
  219.     case EACCES:
  220.     case EMFILE:
  221.       fprintf(errout, "WARNING: %s\n", strerror(errno));
  222.       break;
  223.  
  224.     /* fatal errors (EINVAL, ENOMEM) */
  225.     default:
  226.       fprintf(errout, "FATAL ERROR: %s\n", strerror(errno));
  227.       abort();
  228.       break;
  229.     }
  230.     errno = 0;
  231.   }
  232. }
  233.  
  234. /****************************************************************************/
  235. void putcolnumbers(void)
  236. /****************************************************************************/
  237. {
  238. puts("         1         2         3         4         5         6         7");
  239. puts("1234567890123456789012345678901234567890123456789012345678901234567890");
  240. }
  241.  
  242. /****************************************************************************
  243. main
  244. *****************************************************************************/
  245. #include <io.h>
  246.  
  247. int main()
  248. {
  249.   int i;                        /* integer field */
  250.   unsigned int ui;              /* unsigned integer field */
  251.   long l;                       /* long field */
  252.   unsigned long ul;             /* unsigned long field */
  253.   float f;                      /* float field */
  254.   double d;                     /* double field */
  255.   int ch;                       /* character field */
  256.   char *str = NULL;             /* string field */
  257.   
  258.   /* install warning and error functions */
  259.   rsetwarnfn(rwarnfn);
  260.   rseterrfn(rerrfn);
  261.   
  262.   /* set beginning column number to 1 */
  263.   rsetbegcolno(recin, 1);
  264.   
  265.   /* if input not redirected */
  266.   if (isatty(fileno(stdin))) {
  267.     /* print instructions */
  268.     puts("TESTCOG version 2.00 Copyright (C) 1994 William Pierpoint");
  269.     puts("Tests recio column delimited get functions.");
  270.     puts("It reads eight fields from the console.\n");
  271.     puts("Field type           Columns");
  272.     puts("----------------    ---------");
  273.     puts("Integer............  1 to  5");
  274.     puts("Unsigned Integer...  6 to 10");
  275.     puts("Long............... 11 to 20");
  276.     puts("Unsigned Long...... 21 to 30");
  277.     puts("Float.............. 31 to 40");
  278.     puts("Double............. 41 to 50");
  279.     puts("Character..........    51   ");
  280.     puts("String............. 52 to 70");
  281.     puts("\nPress Ctrl-Z followed by the Enter key to exit program.");
  282.     puts("You may begin now.\n");
  283.   }
  284.   
  285.   putcolnumbers();
  286.  
  287.   /* loop through input */
  288.   while (rgetrec(recin)) {
  289.  
  290.     /* if input redirected, echo record contents */
  291.     if (!isatty(fileno(stdin))) puts(rrecs(recin));
  292.  
  293.     /* parse record */
  294.     i   = rcgeti(recin,   1,  5);
  295.     ui  = rcgetui(recin,  6, 10);
  296.     l   = rcgetl(recin,  11, 20);
  297.     ul  = rcgetul(recin, 21, 30);
  298.     f   = rcgetf(recin,  31, 40);
  299.     d   = rcgetd(recin,  41, 50);
  300.     ch  = rcgetc(recin,  51);
  301.     str = scopys(str, rcgets(recin, 52, 70));
  302.  
  303.     /* print results */
  304.     printf("\n");
  305.     printf("         Integer field: %d\n", i);
  306.     printf("Unsigned Integer field: %u\n", ui);
  307.     printf("            Long field: %ld\n", l);
  308.     printf("   Unsigned Long field: %lu\n", ul);
  309.     printf("           Float field: %.*e\n", FLT_DIG-1, f);
  310.     printf("          Double field: %.*e\n", DBL_DIG-1, d);
  311.     printf("       Character field: %c\n", ch);
  312.     printf("          String field: %s\n\n", str);
  313.     
  314.     putcolnumbers();
  315.   }
  316.   
  317.   /* free string fields */
  318.   free (str);
  319.   
  320.   /* check stream for error */
  321.   if (rerror(recin)) { 
  322.     fprintf(errout, "ERROR reading %s: %s\n", 
  323.      rnames(recin), rerrstr(recin));
  324.     exit (EXIT_FAILURE);
  325.   }
  326.   return EXIT_SUCCESS;
  327. }
  328.