Branch data     Line data    Source code

       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                 :           7 : 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                 :           7 :         const struct rerr *r;
      66                 :           7 :         const char *msg;
      67                 :           7 :         char            convbuf[sizeof(unk) + 50];      /* 50 = plenty for int */
      68                 :           7 :         size_t          len;
      69                 :           7 :         int                     icode;
      70                 :             : 
      71      [ +  -  - ]:           7 :         switch (errcode)
      72                 :             :         {
      73                 :             :                 case REG_ATOI:                  /* convert name to number */
      74         [ #  # ]:           0 :                         for (r = rerrs; r->code >= 0; r++)
      75         [ #  # ]:           0 :                                 if (strcmp(r->name, errbuf) == 0)
      76                 :           0 :                                         break;
      77                 :           0 :                         sprintf(convbuf, "%d", r->code);   /* -1 for unknown */
      78                 :           0 :                         msg = convbuf;
      79                 :           0 :                         break;
      80                 :             :                 case REG_ITOA:                  /* convert number to name */
      81                 :           0 :                         icode = atoi(errbuf);   /* not our problem if this fails */
      82         [ #  # ]:           0 :                         for (r = rerrs; r->code >= 0; r++)
      83         [ #  # ]:           0 :                                 if (r->code == icode)
      84                 :           0 :                                         break;
      85         [ #  # ]:           0 :                         if (r->code >= 0)
      86                 :           0 :                                 msg = r->name;
      87                 :             :                         else
      88                 :             :                         {                                       /* unknown; tell him the number */
      89                 :           0 :                                 sprintf(convbuf, "REG_%u", (unsigned) icode);
      90                 :           0 :                                 msg = convbuf;
      91                 :             :                         }
      92                 :           0 :                         break;
      93                 :             :                 default:                                /* a real, normal error code */
      94         [ -  + ]:          68 :                         for (r = rerrs; r->code >= 0; r++)
      95         [ +  + ]:          68 :                                 if (r->code == errcode)
      96                 :           7 :                                         break;
      97         [ +  - ]:           7 :                         if (r->code >= 0)
      98                 :           7 :                                 msg = r->explain;
      99                 :             :                         else
     100                 :             :                         {                                       /* unknown; say so */
     101                 :           0 :                                 sprintf(convbuf, unk, errcode);
     102                 :           0 :                                 msg = convbuf;
     103                 :             :                         }
     104                 :           7 :                         break;
     105                 :             :         }
     106                 :             : 
     107                 :           7 :         len = strlen(msg) + 1;          /* space needed, including NUL */
     108         [ -  + ]:           7 :         if (errbuf_size > 0)
     109                 :             :         {
     110         [ +  - ]:           7 :                 if (errbuf_size > len)
     111                 :           7 :                         strcpy(errbuf, msg);
     112                 :             :                 else
     113                 :             :                 {                                               /* truncate to fit */
     114                 :           0 :                         memcpy(errbuf, msg, errbuf_size - 1);
     115                 :           0 :                         errbuf[errbuf_size - 1] = '\0';
     116                 :             :                 }
     117                 :           7 :         }
     118                 :             : 
     119                 :          14 :         return len;
     120                 :           7 : }