home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / recio213.zip / testchg.c < prev    next >
C/C++ Source or Header  |  1995-09-05  |  10KB  |  299 lines
  1. /* testchg.c - tests character delimited get functions */
  2. /* recio version 2.13, release September 4, 1995 */
  3. /* Copyright (C) 1994-1995, 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. #include <time.h>
  13.  
  14. #include "recio.h"
  15.  
  16. /* errors normally to stderr; but for test purposes, stdout */
  17. #define errout  stdout
  18.  
  19. /****************************************************************************/
  20. void                         /* return nothing                              */
  21.     rfixnum(                 /* fix number                                  */
  22.         REC *rp,             /* record pointer                              */
  23.         int  errnum,         /* error number                                */
  24.         void (*rfix)(REC *)) /* rfix function pointer                       */
  25. /****************************************************************************/
  26. {
  27.   switch (errnum) {
  28.   case R_EMISDAT:
  29.     fprintf(errout, "...substituting zero\n");
  30.     rsetfldstr(rp, "0");
  31.     break;
  32.   default:
  33.     fprintf(errout, "...substituting best guess\n");
  34.     rfix(rp);
  35.     break;
  36.   }
  37. }
  38.  
  39. /****************************************************************************/
  40. void                         /* return nothing                              */
  41.     rfixtime(                /* fix time                                   */
  42.         REC *rp,             /* record pointer                              */
  43.         int  errnum,         /* error number                                */
  44.         void (*rfix)(REC *)) /* rfix function pointer                       */
  45. /****************************************************************************/
  46. {
  47.   switch (errnum) {
  48.   case R_EMISDAT:
  49.     fprintf(errout, "...substituting 1/1/70 00:00:00\n");
  50.     rsetfldstr(rp, "1/1/70 0:0:0");
  51.     break;
  52.   default:
  53.     fprintf(errout, "...substituting best guess\n");
  54.     rfix(rp);
  55.     break;
  56.   }
  57. }
  58.  
  59. /****************************************************************************/
  60. void                         /* return nothing                              */
  61.     rfixchar(                /* fix character                               */
  62.         REC *rp,             /* record pointer                              */
  63.         int  errnum,         /* error number                                */
  64.         void (*rfix)(REC *)) /* rfix function pointer                       */
  65. /****************************************************************************/
  66. {
  67.   switch (errnum) {
  68.   case R_EMISDAT:
  69.     fprintf(errout, "...substituting the letter N\n");
  70.     rsetfldstr(rp, "N");
  71.     break;
  72.   default:
  73.     fprintf(errout, "...substituting best guess\n");
  74.     rfix(rp);
  75.     break;
  76.   }
  77. }
  78.  
  79. /****************************************************************************/
  80. void                         /* returns nothing                             */
  81.     rwarnfn(                 /* recio callback warning function             */
  82.         REC *rp)             /* record pointer                              */
  83. /****************************************************************************/
  84. {
  85.   if (risvalid(rp)) {
  86.     switch (rwarning(rp)) {
  87.     case R_WNOREG:   /* atexit() full */
  88.       fprintf (errout, "WARNING %s\n", rwarnstr(rp));
  89.       break;
  90.     case R_WEMPSTR:  /* empty data string */
  91.     case R_WTMFMT:   /* time data incomplete */
  92.       fprintf(errout, "WARNING reading %s at record %lu and field %u -- %s\n", 
  93.        rnames(rp), rrecno(rp), rfldno(rp), rwarnstr(rp));
  94.       break;
  95.     }
  96.   }
  97. }
  98.  
  99. /****************************************************************************/
  100. void                         /* returns nothing                             */
  101.      errnofn(                /* errno callback error function               */
  102.         void)                /* no parameters                               */
  103. /****************************************************************************/
  104. {
  105.   switch (errno) {
  106.  
  107.   /* non-fatal errors */
  108.   case EACCES:
  109.   case EMFILE:
  110.     fprintf(errout, "ERROR: %s\n", strerror(errno));
  111.     break;
  112.  
  113.   /* fatal errors (EINVAL, ENOMEM) */
  114.   default:
  115.     fprintf(errout, "FATAL ERROR: %s\n", strerror(errno));
  116.     exit(EXIT_FAILURE);
  117.     break;
  118.   }
  119. }
  120.  
  121. /****************************************************************************/
  122. void                         /* returns nothing                             */
  123.     rerrfn(                  /* recio callback error function               */
  124.         REC *rp)             /* record pointer                              */
  125. /****************************************************************************/
  126. {
  127.   int errnum;       /* error number */
  128.  
  129.   if (risvalid(rp)) {
  130.   
  131.     /* if reof indicator set */
  132.     if (reof(rp)) { 
  133.       fprintf(errout, "ERROR reading %s: "
  134.        "tried to read past end of file\n", rnames(rp));
  135.     
  136.     /* else rerror indicator set */
  137.     } else {
  138.  
  139.       /* determine cause of error */
  140.       errnum = rerror(rp);
  141.       switch (errnum) {
  142.  
  143.       /* data errors */
  144.       case R_EDOM:     /* data out of domain */
  145.       case R_ERANGE:   /* data out of range */
  146.       case R_EINVDAT:  /* invalid data */
  147.       case R_EMISDAT:  /* missing data */
  148.         fprintf(errout, "DATA ERROR reading %s at record %lu and field %u "
  149.          "-- %s\n", rnames(rp), rrecno(rp), rfldno(rp), rerrstr(rp));
  150.           
  151.         /* determine context */
  152.         switch (rcxtno(rp)) {
  153.         case RECIN:
  154.           
  155.           /* determine field */
  156.           switch (rfldno(rp)) {
  157.           case 1:  /* the integer field i */
  158.             rfixnum(rp, errnum, rfixi);
  159.             break;
  160.           
  161.           case 2:  /* the unsigned integer field ui */
  162.             rfixnum(rp, errnum, rfixui);
  163.             break;
  164.  
  165.            case 3:  /* the long field l */
  166.             rfixnum(rp, errnum, rfixl);
  167.             break;
  168.  
  169.            case 4:  /* the unsigned long field ul */
  170.             rfixnum(rp, errnum, rfixul);
  171.             break;
  172.  
  173.            case 5:  /* the float field f */
  174.             rfixnum(rp, errnum, rfixf);
  175.             break;
  176.  
  177.           case 6:  /* the double field d */
  178.             rfixnum(rp, errnum, rfixd);
  179.             break;
  180.  
  181.           case 7: /* the character field ch */
  182.             rfixchar(rp, errnum, rfixc);
  183.             break;
  184.  
  185.           case 9: /* the time field t */
  186.             rfixtime(rp, errnum, rfixt);
  187.             break;
  188.  
  189.           default: /* programming error - no case for field */
  190.             fprintf(errout, "FATAL ERROR %s -- code missing for field %u\n",
  191.                              rnames(rp), rfldno(rp));
  192.             exit(EXIT_FAILURE);
  193.             break;
  194.           }
  195.           break;
  196.         
  197.         default:  /* programming error - missing context number */
  198.           fprintf (errout, "FATAL ERROR in %s -- missing context number\n", 
  199.                             rnames(rp));
  200.           exit(EXIT_FAILURE);
  201.           break;
  202.         }
  203.         break;
  204.         
  205.       /* fatal errors (R_EINVMOD, R_EINVAL, R_ENOMEM) */
  206.       default:
  207.         fprintf(errout, "FATAL ERROR in %s -- %s\n", rnames(rp), rerrstr(rp));
  208.         exit(EXIT_FAILURE);
  209.         break;
  210.       }
  211.     }
  212.   
  213.   /* invalid record pointer */
  214.   } else {
  215.     errnofn();
  216.   }
  217. }
  218.  
  219. /****************************************************************************
  220. main
  221. *****************************************************************************/
  222. #include <io.h>
  223.  
  224. int main()
  225. {
  226.   int i;                        /* integer field */
  227.   unsigned int ui;              /* unsigned integer field */
  228.   long l;                       /* long field */
  229.   unsigned long ul;             /* unsigned long field */
  230.   float f;                      /* float field */
  231.   double d;                     /* double field */
  232.   int ch;                       /* character field */
  233.   char *str = NULL;             /* string field */
  234.   time_t t;                     /* time field */
  235.   
  236.   /* install error and warning functions */
  237.   rinit(rerrfn, rwarnfn);
  238.   
  239.   /* set field and text delimiters */
  240.   rsetfldch(recin, ',');
  241.   rsettxtch(recin, '"');
  242.   rsettmfmt(recin, "%m/%d/%y %H:%M:%S");
  243.   
  244.   /* if input not redirected */
  245.   if (isatty(fileno(stdin))) {
  246.     /* print instructions */
  247.     puts("TESTCHG version 2.13 Copyright (C) 1994-1995, William Pierpoint");
  248.     puts("Tests recio character delimited get functions.");
  249.     puts("It reads nine fields, separated by commas, from the console.");
  250.     puts("The field types are: int, unsigned int, long, unsigned long,");
  251.     puts("                     float, double, character, string, and time\n");
  252.     puts("Example:");
  253.     puts("-1,1,-99999,99999,3.14159,3.14159265,Y,\"Hello\",11/1/94 12:00:00\n");
  254.     puts("Press Ctrl-Z followed by the Enter key to exit program.");
  255.     puts("You may begin now.\n");
  256.   }
  257.   
  258.   /* loop through input */
  259.   while (rgetrec(recin)) {
  260.  
  261.     /* if input redirected, echo record contents */
  262.     if (!isatty(fileno(stdin))) puts(rrecs(recin));
  263.  
  264.     /* parse record */
  265.     i   = rgeti(recin);
  266.     ui  = rgetui(recin);
  267.     l   = rgetl(recin);
  268.     ul  = rgetul(recin);
  269.     f   = rgetf(recin);
  270.     d   = rgetd(recin);
  271.     ch  = rgetc(recin);
  272.     scpys(str, rgets(recin));
  273.     t   = rgett(recin);
  274.     
  275.     /* print results */
  276.     printf("\n");
  277.     printf("         Integer field: %d\n", i);
  278.     printf("Unsigned Integer field: %u\n", ui);
  279.     printf("            Long field: %ld\n", l);
  280.     printf("   Unsigned Long field: %lu\n", ul);
  281.     printf("           Float field: %.*e\n", FLT_DIG-1, f);
  282.     printf("          Double field: %.*e\n", DBL_DIG-1, d);
  283.     printf("       Character field: %c\n", ch);
  284.     printf("          String field: %s\n", str);
  285.     printf("            Time field: %s\n\n", ctime(&t));
  286.   }
  287.   
  288.   /* free dynamic string fields */
  289.   free (str);
  290.   
  291.   /* check stream for error */
  292.   if (rerror(recin)) { 
  293.     fprintf(errout, "ERROR reading %s: %s\n", 
  294.      rnames(recin), rerrstr(recin));
  295.     exit (EXIT_FAILURE);
  296.   }
  297.   return EXIT_SUCCESS;
  298. }
  299.