home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / recio213.zip / testcog.c < prev    next >
C/C++ Source or Header  |  1995-09-05  |  11KB  |  322 lines
  1. /* testcog.c - tests column 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.     rfixnumber(              /* 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.     rfixchar(                /* fix character                               */
  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 the letter N\n");
  50.     rsetfldstr(rp, "N");
  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.     rfixtime(                /* fix time                                   */
  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 1/1/70 00:00:00\n");
  70.     rsetfldstr(rp, "1/1/70 0:0:0");
  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.       fprintf(errout, "WARNING reading %s at record %lu and field %u -- %s\n", 
  92.        rnames(rp), rrecno(rp), rfldno(rp), rwarnstr(rp));
  93.       break;
  94.     }
  95.   }
  96. }
  97.  
  98. /****************************************************************************/
  99. void                         /* returns nothing                             */
  100.      errnofn(                /* errno callback error function               */
  101.         void)                /* no parameters                               */
  102. /****************************************************************************/
  103. {
  104.   switch (errno) {
  105.  
  106.   /* non-fatal errors */
  107.   case EACCES:
  108.   case EMFILE:
  109.     fprintf(errout, "ERROR: %s\n", strerror(errno));
  110.     break;
  111.  
  112.   /* fatal errors (EINVAL, ENOMEM) */
  113.   default:
  114.     fprintf(errout, "FATAL ERROR: %s\n", strerror(errno));
  115.     exit(EXIT_FAILURE);
  116.     break;
  117.   }
  118. }
  119.  
  120. /****************************************************************************/
  121. void                         /* returns nothing                             */
  122.     rerrfn(                  /* recio callback error function               */
  123.         REC *rp)             /* record pointer                              */
  124. /****************************************************************************/
  125. {
  126.   int errnum;       /* error number */
  127.  
  128.   if (risvalid(rp)) {
  129.   
  130.     /* if reof indicator set */
  131.     if (reof(rp)) { 
  132.       fprintf(errout, "ERROR reading %s: "
  133.        "tried to read past end of file\n", rnames(rp));
  134.     
  135.     /* else rerror indicator set */
  136.     } else {
  137.  
  138.       /* determine cause of error */
  139.       errnum = rerror(rp);
  140.       switch (errnum) {
  141.  
  142.       /* data errors */
  143.       case R_EDOM:     /* data out of domain */
  144.       case R_ERANGE:   /* data out of range */
  145.       case R_EINVDAT:  /* invalid data */
  146.       case R_EMISDAT:  /* missing data */
  147.         fprintf(errout, "DATA ERROR reading %s at record %lu and field %u "
  148.          "-- %s\n", rnames(rp), rrecno(rp), rfldno(rp), rerrstr(rp));
  149.             
  150.         /* determine context */
  151.         switch (rcxtno(rp)) {
  152.         case RECIN:
  153.           
  154.           /* determine field */
  155.           switch (rfldno(rp)) {
  156.           case 1:  /* the integer field i */
  157.             rfixnumber(rp, errnum, rfixi);
  158.             break;
  159.           
  160.           case 2:  /* the unsigned integer field ui */
  161.             rfixnumber(rp, errnum, rfixui);
  162.             break;
  163.  
  164.            case 3:  /* the long field l */
  165.             rfixnumber(rp, errnum, rfixl);
  166.             break;
  167.  
  168.            case 4:  /* the unsigned long field ul */
  169.             rfixnumber(rp, errnum, rfixul);
  170.             break;
  171.  
  172.            case 5:  /* the float field f */
  173.             rfixnumber(rp, errnum, rfixf);
  174.             break;
  175.  
  176.             case 6:  /* the double field d */
  177.             rfixnumber(rp, errnum, rfixd);
  178.             break;
  179.           
  180.           case 7: /* the character field ch */
  181.             rfixchar(rp, errnum, rfixc);
  182.             break;
  183.             
  184.           case 9: /* the time field t */
  185.             rfixtime(rp, errnum, rfixt);
  186.             break;
  187.  
  188.           default: /* programming error - no case for field */
  189.             fprintf(errout, "FATAL ERROR %s -- code missing for field %u\n",
  190.              rnames(rp), rfldno(rp));
  191.             break;
  192.           }
  193.           break;
  194.         
  195.         default:  /* programming error - missing context number */
  196.           fprintf(errout, "FATAL ERROR %s -- missing context number\n", 
  197.                           rnames(rp));
  198.           exit(EXIT_FAILURE);
  199.           break;
  200.         }
  201.         break;
  202.         
  203.       /* fatal errors (R_EINVMOD, R_EINVAL, R_ENOMEM) */
  204.       default:
  205.         fprintf(errout, "FATAL ERROR %s -- %s\n", rnames(rp), rerrstr(rp));
  206.         exit(EXIT_FAILURE);
  207.         break;
  208.       }
  209.     }
  210.   
  211.   /* invalid record pointer */
  212.   } else {
  213.     errnofn();
  214.   }
  215. }
  216.  
  217. /****************************************************************************/
  218. void putcolnumbers(void)
  219. /****************************************************************************/
  220. {
  221. puts("         1         2         3         4         5         6         7");
  222. puts("1234567890123456789012345678901234567890123456789012345678901234567890123456789");
  223. }
  224.  
  225. /****************************************************************************
  226. main
  227. *****************************************************************************/
  228. #include <io.h>
  229.  
  230. int main()
  231. {
  232.   int i;                        /* integer field */
  233.   unsigned int ui;              /* unsigned integer field */
  234.   long l;                       /* long field */
  235.   unsigned long ul;             /* unsigned long field */
  236.   float f;                      /* float field */
  237.   double d;                     /* double field */
  238.   int ch;                       /* character field */
  239.   char *str = NULL;             /* string field */
  240.   time_t t;                     /* time field */
  241.   
  242.   /* install error and warning functions */
  243.   rinit(rerrfn, rwarnfn);
  244.   
  245.   /* set time format */
  246.   rsettmfmt(recin,  "%m/%d/%y");
  247.   rsettmfmt(recout, "%m/%d/%y");
  248.   
  249.   /* set recout to ignore field and text delimiters */
  250.   rsetfldch(recout, '\0');
  251.   rsettxtch(recout, '\0');
  252.   
  253.   /* set beginning column number to 1 */
  254.   rsetbegcolno(recin, 1);
  255.   
  256.   /* if input not redirected */
  257.   if (isatty(fileno(stdin))) {
  258.     /* print instructions */
  259.     puts("TESTCOG version 2.13 Copyright (C) 1994-1995, William Pierpoint");
  260.     puts("Tests recio column delimited get functions.");
  261.     puts("It reads eight fields from the console.\n");
  262.     puts("Field type           Columns");
  263.     puts("----------------    ---------");
  264.     puts("Integer............  1 to  5");
  265.     puts("Unsigned Integer...  6 to 10");
  266.     puts("Long............... 11 to 20");
  267.     puts("Unsigned Long...... 21 to 30");
  268.     puts("Float.............. 31 to 40");
  269.     puts("Double............. 41 to 50");
  270.     puts("Character..........    51   ");
  271.     puts("String............. 52 to 70");
  272.     puts("Time............... 71 to 79");
  273.     puts("\nPress Ctrl-Z followed by the Enter key to exit program.");
  274.     puts("You may begin now.\n");
  275.   }
  276.   
  277.   /* loop through input */
  278.   while (rgetrec(recin)) {
  279.  
  280.     putcolnumbers();
  281.    
  282.     /* if input redirected, echo record contents */
  283.     if (!isatty(fileno(stdin))) puts(rrecs(recin));
  284.  
  285.     /* parse record */
  286.     i   = rcgeti(recin,   1,  5);
  287.     ui  = rcgetui(recin,  6, 10);
  288.     l   = rcgetl(recin,  11, 20);
  289.     ul  = rcgetul(recin, 21, 30);
  290.     f   = rcgetf(recin,  31, 40);
  291.     d   = rcgetd(recin,  41, 50);
  292.     ch  = rcgetc(recin,  51);
  293.     scpys(str, rcgets(recin, 52, 70));
  294.     t   = rcgett(recin, 71, 79);
  295.  
  296.     /* print results */
  297.     puts("");
  298.     rputs(recout, "         Integer field: "); rputi(recout, i);   puts("");
  299.     rputs(recout, "Unsigned Integer field: "); rputui(recout, ui); puts("");
  300.     rputs(recout, "            Long field: "); rputl(recout, l);   puts("");
  301.     rputs(recout, "   Unsigned Long field: "); rputul(recout, ul); puts("");
  302.     rputs(recout, "           Float field: "); rputf(recout, f);   puts("");
  303.     rputs(recout, "          Double field: "); rputd(recout, d);   puts("");
  304.     rputs(recout, "       Character field: "); rputc(recout, ch);  puts("");
  305.     rputs(recout, "          String field: "); rputs(recout, str); puts("");
  306.     rputs(recout, "            Time field: "); rputt(recout, t);   puts("");
  307.     rputrec(recout);
  308.     puts("");
  309.   }
  310.   
  311.   /* free dynamic string fields */
  312.   free (str);
  313.   
  314.   /* check stream for error */
  315.   if (rerror(recin)) { 
  316.     fprintf(errout, "ERROR reading %s: %s\n", 
  317.      rnames(recin), rerrstr(recin));
  318.     exit (EXIT_FAILURE);
  319.   }
  320.   return EXIT_SUCCESS;
  321. }
  322.