src/backend/regex/regerror.c

   1 /*
   2  * regerror - error-code expansion
   3  *
   4  * Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
   5  *
   6  * Development of this software was funded, in part, by Cray Research Inc.,
   7  * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
   8  * Corporation, none of whom are responsible for the results.  The author
   9  * thanks all of them.
  10  *
  11  * Redistribution and use in source and binary forms -- with or without
  12  * modification -- are permitted for any purpose, provided that
  13  * redistributions in source form retain this entire copyright notice and
  14  * indicate the origin and nature of any modifications.
  15  *
  16  * I'd appreciate being given credit for this package in the documentation
  17  * of software which uses it, but that is not a requirement.
  18  *
  19  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  21  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
  22  * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  23  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  24  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  25  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  26  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  27  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  28  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  * src/backend/regex/regerror.c
  31  *
  32  */
  33
  34 #include "regex/regguts.h"
  35
  36 /* unknown-error explanation */
  37 static const char unk[] = "*** unknown regex error code 0x%x ***";
  38
  39 /* struct to map among codes, code names, and explanations */
  40 static const struct rerr
  41 {
  42         int                     code;
  43         const char *name;
  44         const char *explain;
  45 }                       rerrs[] =
  46
  47 {
  48         /* the actual table is built from regex.h */
  49 #include "regex/regerrs.h"
  50         {
  51                 -1, "", "oops"
  52         },                                                      /* explanation special-cased in code */
  53 };
  54
  55 /*
  56  * pg_regerror - the interface to error numbers
  57  */
  58 /* ARGSUSED */
  59 size_t                                                  /* actual space needed (including NUL) */
  60 pg_regerror(int errcode,                /* error code, or REG_ATOI or REG_ITOA */
  61                         const regex_t *preg,    /* associated regex_t (unused at present) */
  62                         char *errbuf,           /* result buffer (unless errbuf_size==0) */
  63                         size_t errbuf_size) /* available space in errbuf, can be 0 */
  64 {
  65         const struct rerr *r;
  66         const char *msg;
  67         char            convbuf[sizeof(unk) + 50];      /* 50 = plenty for int */
  68         size_t          len;
  69         int                     icode;
  70
  71         switch (errcode)
  72         {
  73                 case REG_ATOI:                  /* convert name to number */
  74                         for (r = rerrs; r->code >= 0; r++)
  75                                 if (strcmp(r->name, errbuf) == 0)
  76                                         break;
  77                         sprintf(convbuf, "%d", r->code);        /* -1 for unknown */
  78                         msg = convbuf;
  79                         break;
  80                 case REG_ITOA:                  /* convert number to name */
  81                         icode = atoi(errbuf);   /* not our problem if this fails */
  82                         for (r = rerrs; r->code >= 0; r++)
  83                                 if (r->code == icode)
  84                                         break;
  85                         if (r->code >= 0)
  86                                 msg = r->name;
  87                         else
  88                         {                                       /* unknown; tell him the number */
  89                                 sprintf(convbuf, "REG_%u", (unsigned) icode);
  90                                 msg = convbuf;
  91                         }
  92                         break;
  93                 default:                                /* a real, normal error code */
  94                         for (r = rerrs; r->code >= 0; r++)
  95                                 if (r->code == errcode)
  96                                         break;
  97                         if (r->code >= 0)
  98                                 msg = r->explain;
  99                         else
 100                         {                                       /* unknown; say so */
 101                                 sprintf(convbuf, unk, errcode);
 102                                 msg = convbuf;
 103                         }
 104                         break;
 105         }
 106
 107         len = strlen(msg) + 1;          /* space needed, including NUL */
 108         if (errbuf_size > 0)
 109         {
 110                 if (errbuf_size > len)
 111                         strcpy(errbuf, msg);
 112                 else
 113                 {                                               /* truncate to fit */
 114                         memcpy(errbuf, msg, errbuf_size - 1);
 115                         errbuf[errbuf_size - 1] = '\0';
 116                 }
 117         }
 118
 119         return len;
 120 }