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 / rerr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-15  |  5.4 KB  |  143 lines
  1. /*****************************************************************************
  2.    MODULE: rerr.c
  3.   PURPOSE: recio error functions
  4. COPYRIGHT: (C) 1994 William Pierpoint
  5.  COMPILER: Borland C Version 3.1
  6.        OS: MSDOS Version 6.2
  7.   VERSION: 2.00
  8.   RELEASE: April 15, 1994
  9. *****************************************************************************/
  10.  
  11. #include <errno.h>
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15.  
  16. #include "recio.h"
  17.  
  18. /* private macros */
  19. #define rflags(rp)       ((rp)->r_flags)
  20.  
  21. /* private module variables */
  22. static void (*_r_errfn)(REC *) = NULL; /* ptr to error function */
  23.  
  24. /****************************************************************************/
  25. char *                       /* returns pointer to field string             */
  26.     _rerrs(                  /* get field string if errfn() cleared error   */
  27.         REC *rp,             /* record pointer                              */
  28.         int  errnum)         /* error number                                */
  29. /****************************************************************************/
  30. {
  31.     char *fldp=NULL;         /* pointer to field string */
  32.  
  33.     if (!rseterr(rp, errnum)) fldp = rflds(rp);
  34.     return (fldp);
  35. }
  36.  
  37. /****************************************************************************/
  38. void                           /* returns nothing                           */
  39.     rseterrfn(                 /* registers a call-back error function      */
  40.         void(*rerrfn)(REC *rp))/* pointer to error function                 */
  41. /****************************************************************************/
  42. {
  43.     _r_errfn = rerrfn;         /* point to call back function */
  44. }
  45.  
  46. /****************************************************************************/
  47. void                         /* returns nothing                             */
  48.     rclearerr(               /* clears eof and error indicators             */
  49.         REC *rp)             /* record pointer                              */
  50. /****************************************************************************/
  51. {
  52.     if (risvalid(rp)) {
  53.         errno = 0;
  54.         rflags(rp) &= ~_R_EOF;
  55.         rflags(rp) &= ~(_R_ERR * _R_ERRMASK);
  56.     } else {
  57.         rseterr(NULL, EINVAL);
  58.     }
  59. }
  60.  
  61. /****************************************************************************/
  62. int                          /* returns error number (0=no error)           */
  63.     rerror(                  /* gets error number for record stream         */
  64.         REC *rp)             /* record pointer                              */
  65. /****************************************************************************/
  66. {
  67.     int errnum;              /* return error number */
  68.  
  69.     if (risvalid(rp)) {
  70.          errnum = rflags(rp) / _R_ERR;
  71.          errnum &= _R_ERRMASK;
  72.     } else {
  73.         errnum = rseterr(NULL, EINVAL);
  74.     }
  75.     return (errnum);
  76. }
  77.  
  78. /****************************************************************************/
  79. int                          /* returns possibly modified error number      */
  80.     rseterr(                 /* sets error number and calls error function  */
  81.         REC *rp,             /* record pointer                              */
  82.         int errnum)          /* error number                                */
  83. /****************************************************************************/
  84. {
  85.     /* if valid record pointer and stream error number clear */
  86.     if (risvalid(rp)) {
  87.         if (!rerror(rp)) {
  88.  
  89.             /* set error number on stream */
  90.             rflags(rp) |= _R_ERR * (errnum & _R_ERRMASK);
  91.  
  92.             /* invoke callback error function */
  93.             if (_r_errfn) _r_errfn(rp);
  94.  
  95.             /* find out if errfn() cleared error */
  96.             errnum = rerror(rp);
  97.         }
  98.  
  99.     /* else invalid record pointer */
  100.     } else {
  101.  
  102.         /* set global error number */
  103.         errno = errnum;
  104.  
  105.         /* invoke callback error function */
  106.         if (_r_errfn) _r_errfn(rp);
  107.  
  108.         /* find out if errfn() cleared error */
  109.         errnum = errno;
  110.     }
  111.  
  112.     /* if errfn cleared error, 0 returned */
  113.     return (errnum);
  114. }
  115.  
  116. /****************************************************************************/
  117. char *                       /* returns error message                       */
  118.     rstrerror(               /* gets error message for rerror number        */
  119.         int errnum)          /* error number                                */
  120. /****************************************************************************/
  121. {
  122.     switch (errnum) {
  123.     case 0:         return ("no error");
  124.     case R_EINVAL:  return ("invalid argument");
  125.     case R_EINVDAT: return ("invalid data");
  126.     case R_EINVMOD: return ("invalid mode");
  127.     case R_EMISDAT: return ("missing data");
  128.     case R_ENOMEM:  return ("out of memory");
  129.     case R_ENOPUT:  return ("unable to put data");
  130.     case R_ERANGE:  return ("data out of range");
  131.     }
  132.     return ("unknown error");
  133. }
  134.  
  135. /****************************************************************************/
  136. char *                       /* returns error message                       */
  137.     rerrstr(                 /* gets error message for record stream        */
  138.         REC *rp)             /* record pointer                              */
  139. /****************************************************************************/
  140. {
  141.     return (risvalid(rp) ? rstrerror(rerror(rp)) : rstrerror(R_EINVAL));
  142. }
  143.