home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Spezial / SPEZIAL2_97.zip / SPEZIAL2_97.iso / ANWEND / EDITOR / NVI179B / NVI179B.ZIP / regex / regerror.c < prev    next >
C/C++ Source or Header  |  1994-03-19  |  6KB  |  181 lines
  1. /*-
  2.  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  3.  * Copyright (c) 1992, 1993, 1994
  4.  *    The Regents of the University of California.  All rights reserved.
  5.  *
  6.  * This code is derived from software contributed to Berkeley by
  7.  * Henry Spencer of the University of Toronto.
  8.  *
  9.  * Redistribution and use in source and binary forms, with or without
  10.  * modification, are permitted provided that the following conditions
  11.  * are met:
  12.  * 1. Redistributions of source code must retain the above copyright
  13.  *    notice, this list of conditions and the following disclaimer.
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in the
  16.  *    documentation and/or other materials provided with the distribution.
  17.  * 3. All advertising materials mentioning features or use of this software
  18.  *    must display the following acknowledgement:
  19.  *    This product includes software developed by the University of
  20.  *    California, Berkeley and its contributors.
  21.  * 4. Neither the name of the University nor the names of its contributors
  22.  *    may be used to endorse or promote products derived from this software
  23.  *    without specific prior written permission.
  24.  *
  25.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35.  * SUCH DAMAGE.
  36.  *
  37.  *    @(#)regerror.c    8.3 (Berkeley) 3/19/94
  38.  */
  39.  
  40. #if defined(LIBC_SCCS) && !defined(lint)
  41. static char sccsid[] = "@(#)regerror.c    8.3 (Berkeley) 3/19/94";
  42. #endif /* LIBC_SCCS and not lint */
  43.  
  44. #include <sys/types.h>
  45. #include <stdio.h>
  46. #include <string.h>
  47. #include <ctype.h>
  48. #include <limits.h>
  49. #include <stdlib.h>
  50. #include <regex.h>
  51.  
  52. #include "utils.h"
  53.  
  54. /* ========= begin header generated by ./mkh ========= */
  55. #ifdef __cplusplus
  56. extern "C" {
  57. #endif
  58.  
  59. /* === regerror.c === */
  60. static char *regatoi __P((const regex_t *preg, char *localbuf));
  61.  
  62. #ifdef __cplusplus
  63. }
  64. #endif
  65. /* ========= end header generated by ./mkh ========= */
  66. /*
  67.  = #define    REG_NOMATCH     1
  68.  = #define    REG_BADPAT     2
  69.  = #define    REG_ECOLLATE     3
  70.  = #define    REG_ECTYPE     4
  71.  = #define    REG_EESCAPE     5
  72.  = #define    REG_ESUBREG     6
  73.  = #define    REG_EBRACK     7
  74.  = #define    REG_EPAREN     8
  75.  = #define    REG_EBRACE     9
  76.  = #define    REG_BADBR    10
  77.  = #define    REG_ERANGE    11
  78.  = #define    REG_ESPACE    12
  79.  = #define    REG_BADRPT    13
  80.  = #define    REG_EMPTY    14
  81.  = #define    REG_ASSERT    15
  82.  = #define    REG_INVARG    16
  83.  = #define    REG_ATOI    255    // convert name to number (!)
  84.  = #define    REG_ITOA    0400    // convert number to name (!)
  85.  */
  86. static struct rerr {
  87.     int code;
  88.     char *name;
  89.     char *explain;
  90. } rerrs[] = {
  91.     REG_NOMATCH,    "REG_NOMATCH",    "regexec() failed to match",
  92.     REG_BADPAT,    "REG_BADPAT",    "invalid regular expression",
  93.     REG_ECOLLATE,    "REG_ECOLLATE",    "invalid collating element",
  94.     REG_ECTYPE,    "REG_ECTYPE",    "invalid character class",
  95.     REG_EESCAPE,    "REG_EESCAPE",    "trailing backslash (\\)",
  96.     REG_ESUBREG,    "REG_ESUBREG",    "invalid backreference number",
  97.     REG_EBRACK,    "REG_EBRACK",    "brackets ([ ]) not balanced",
  98.     REG_EPAREN,    "REG_EPAREN",    "parentheses not balanced",
  99.     REG_EBRACE,    "REG_EBRACE",    "braces not balanced",
  100.     REG_BADBR,    "REG_BADBR",    "invalid repetition count(s)",
  101.     REG_ERANGE,    "REG_ERANGE",    "invalid character range",
  102.     REG_ESPACE,    "REG_ESPACE",    "out of memory",
  103.     REG_BADRPT,    "REG_BADRPT",    "repetition-operator operand invalid",
  104.     REG_EMPTY,    "REG_EMPTY",    "empty (sub)expression",
  105.     REG_ASSERT,    "REG_ASSERT",    "\"can't happen\" -- you found a bug",
  106.     REG_INVARG,    "REG_INVARG",    "invalid argument to regex routine",
  107.     0,        "",        "*** unknown regexp error code ***",
  108. };
  109.  
  110. /*
  111.  - regerror - the interface to error numbers
  112.  = extern size_t regerror(int, const regex_t *, char *, size_t);
  113.  */
  114. /* ARGSUSED */
  115. size_t
  116. regerror(errcode, preg, errbuf, errbuf_size)
  117. int errcode;
  118. const regex_t *preg;
  119. char *errbuf;
  120. size_t errbuf_size;
  121. {
  122.     register struct rerr *r;
  123.     register size_t len;
  124.     register int target = errcode &~ REG_ITOA;
  125.     register char *s;
  126.     char convbuf[50];
  127.  
  128.     if (errcode == REG_ATOI)
  129.         s = regatoi(preg, convbuf);
  130.     else {
  131.         for (r = rerrs; r->code != 0; r++)
  132.             if (r->code == target)
  133.                 break;
  134.     
  135.         if (errcode®_ITOA) {
  136.             if (r->code != 0)
  137.                 (void) strcpy(convbuf, r->name);
  138.             else
  139.                 sprintf(convbuf, "REG_0x%x", target);
  140.             assert(strlen(convbuf) < sizeof(convbuf));
  141.             s = convbuf;
  142.         } else
  143.             s = r->explain;
  144.     }
  145.  
  146.     len = strlen(s) + 1;
  147.     if (errbuf_size > 0) {
  148.         if (errbuf_size > len)
  149.             (void) strcpy(errbuf, s);
  150.         else {
  151.             (void) strncpy(errbuf, s, errbuf_size-1);
  152.             errbuf[errbuf_size-1] = '\0';
  153.         }
  154.     }
  155.  
  156.     return(len);
  157. }
  158.  
  159. /*
  160.  - regatoi - internal routine to implement REG_ATOI
  161.  == static char *regatoi(const regex_t *preg, char *localbuf);
  162.  */
  163. static char *
  164. regatoi(preg, localbuf)
  165. const regex_t *preg;
  166. char *localbuf;
  167. {
  168.     register struct rerr *r;
  169.     register size_t siz;
  170.     register char *p;
  171.  
  172.     for (r = rerrs; r->code != 0; r++)
  173.         if (strcmp(r->name, preg->re_endp) == 0)
  174.             break;
  175.     if (r->code == 0)
  176.         return("0");
  177.  
  178.     sprintf(localbuf, "%d", r->code);
  179.     return(localbuf);
  180. }
  181.