Ruby  2.0.0p247(2013-06-27revision41674)
regerror.c
Go to the documentation of this file.
00001 /**********************************************************************
00002   regerror.c -  Onigmo (Oniguruma-mod) (regular expression library)
00003 **********************************************************************/
00004 /*-
00005  * Copyright (c) 2002-2007  K.Kosako  <sndgk393 AT ybb DOT ne DOT jp>
00006  * Copyright (c) 2011       K.Takata  <kentkt AT csc DOT jp>
00007  * All rights reserved.
00008  *
00009  * Redistribution and use in source and binary forms, with or without
00010  * modification, are permitted provided that the following conditions
00011  * are met:
00012  * 1. Redistributions of source code must retain the above copyright
00013  *    notice, this list of conditions and the following disclaimer.
00014  * 2. Redistributions in binary form must reproduce the above copyright
00015  *    notice, this list of conditions and the following disclaimer in the
00016  *    documentation and/or other materials provided with the distribution.
00017  *
00018  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
00019  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00020  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00021  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
00022  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
00023  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
00024  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
00025  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
00026  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
00027  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
00028  * SUCH DAMAGE.
00029  */
00030 
00031 #include "regint.h"
00032 #include <stdio.h> /* for vsnprintf() */
00033 
00034 #ifdef HAVE_STDARG_PROTOTYPES
00035 #include <stdarg.h>
00036 #define va_init_list(a,b) va_start(a,b)
00037 #else
00038 #include <varargs.h>
00039 #define va_init_list(a,b) va_start(a)
00040 #endif
00041 
00042 extern UChar*
00043 onig_error_code_to_format(OnigPosition code)
00044 {
00045   const char *p;
00046 
00047   if (code >= 0) return (UChar* )0;
00048 
00049   switch (code) {
00050   case ONIG_MISMATCH:
00051     p = "mismatch"; break;
00052   case ONIG_NO_SUPPORT_CONFIG:
00053     p = "no support in this configuration"; break;
00054   case ONIGERR_MEMORY:
00055     p = "failed to allocate memory"; break;
00056   case ONIGERR_MATCH_STACK_LIMIT_OVER:
00057     p = "match-stack limit over"; break;
00058   case ONIGERR_TYPE_BUG:
00059     p = "undefined type (bug)"; break;
00060   case ONIGERR_PARSER_BUG:
00061     p = "internal parser error (bug)"; break;
00062   case ONIGERR_STACK_BUG:
00063     p = "stack error (bug)"; break;
00064   case ONIGERR_UNDEFINED_BYTECODE:
00065     p = "undefined bytecode (bug)"; break;
00066   case ONIGERR_UNEXPECTED_BYTECODE:
00067     p = "unexpected bytecode (bug)"; break;
00068   case ONIGERR_DEFAULT_ENCODING_IS_NOT_SET:
00069     p = "default multibyte-encoding is not set"; break;
00070   case ONIGERR_SPECIFIED_ENCODING_CANT_CONVERT_TO_WIDE_CHAR:
00071     p = "can't convert to wide-char on specified multibyte-encoding"; break;
00072   case ONIGERR_INVALID_ARGUMENT:
00073     p = "invalid argument"; break;
00074   case ONIGERR_END_PATTERN_AT_LEFT_BRACE:
00075     p = "end pattern at left brace"; break;
00076   case ONIGERR_END_PATTERN_AT_LEFT_BRACKET:
00077     p = "end pattern at left bracket"; break;
00078   case ONIGERR_EMPTY_CHAR_CLASS:
00079     p = "empty char-class"; break;
00080   case ONIGERR_PREMATURE_END_OF_CHAR_CLASS:
00081     p = "premature end of char-class"; break;
00082   case ONIGERR_END_PATTERN_AT_ESCAPE:
00083     p = "end pattern at escape"; break;
00084   case ONIGERR_END_PATTERN_AT_META:
00085     p = "end pattern at meta"; break;
00086   case ONIGERR_END_PATTERN_AT_CONTROL:
00087     p = "end pattern at control"; break;
00088   case ONIGERR_META_CODE_SYNTAX:
00089     p = "invalid meta-code syntax"; break;
00090   case ONIGERR_CONTROL_CODE_SYNTAX:
00091     p = "invalid control-code syntax"; break;
00092   case ONIGERR_CHAR_CLASS_VALUE_AT_END_OF_RANGE:
00093     p = "char-class value at end of range"; break;
00094   case ONIGERR_CHAR_CLASS_VALUE_AT_START_OF_RANGE:
00095     p = "char-class value at start of range"; break;
00096   case ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS:
00097     p = "unmatched range specifier in char-class"; break;
00098   case ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED:
00099     p = "target of repeat operator is not specified"; break;
00100   case ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID:
00101     p = "target of repeat operator is invalid"; break;
00102   case ONIGERR_NESTED_REPEAT_OPERATOR:
00103     p = "nested repeat operator"; break;
00104   case ONIGERR_UNMATCHED_CLOSE_PARENTHESIS:
00105     p = "unmatched close parenthesis"; break;
00106   case ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS:
00107     p = "end pattern with unmatched parenthesis"; break;
00108   case ONIGERR_END_PATTERN_IN_GROUP:
00109     p = "end pattern in group"; break;
00110   case ONIGERR_UNDEFINED_GROUP_OPTION:
00111     p = "undefined group option"; break;
00112   case ONIGERR_INVALID_POSIX_BRACKET_TYPE:
00113     p = "invalid POSIX bracket type"; break;
00114   case ONIGERR_INVALID_LOOK_BEHIND_PATTERN:
00115     p = "invalid pattern in look-behind"; break;
00116   case ONIGERR_INVALID_REPEAT_RANGE_PATTERN:
00117     p = "invalid repeat range {lower,upper}"; break;
00118   case ONIGERR_INVALID_CONDITION_PATTERN:
00119     p = "invalid conditional pattern"; break;
00120   case ONIGERR_TOO_BIG_NUMBER:
00121     p = "too big number"; break;
00122   case ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE:
00123     p = "too big number for repeat range"; break;
00124   case ONIGERR_UPPER_SMALLER_THAN_LOWER_IN_REPEAT_RANGE:
00125     p = "upper is smaller than lower in repeat range"; break;
00126   case ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS:
00127     p = "empty range in char class"; break;
00128   case ONIGERR_MISMATCH_CODE_LENGTH_IN_CLASS_RANGE:
00129     p = "mismatch multibyte code length in char-class range"; break;
00130   case ONIGERR_TOO_MANY_MULTI_BYTE_RANGES:
00131     p = "too many multibyte code ranges are specified"; break;
00132   case ONIGERR_TOO_SHORT_MULTI_BYTE_STRING:
00133     p = "too short multibyte code string"; break;
00134   case ONIGERR_TOO_BIG_BACKREF_NUMBER:
00135     p = "too big backref number"; break;
00136   case ONIGERR_INVALID_BACKREF:
00137 #ifdef USE_NAMED_GROUP
00138     p = "invalid backref number/name"; break;
00139 #else
00140     p = "invalid backref number"; break;
00141 #endif
00142   case ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED:
00143     p = "numbered backref/call is not allowed. (use name)"; break;
00144   case ONIGERR_TOO_BIG_WIDE_CHAR_VALUE:
00145     p = "too big wide-char value"; break;
00146   case ONIGERR_TOO_SHORT_DIGITS:
00147     p = "too short digits"; break;
00148   case ONIGERR_TOO_LONG_WIDE_CHAR_VALUE:
00149     p = "too long wide-char value"; break;
00150   case ONIGERR_INVALID_CODE_POINT_VALUE:
00151     p = "invalid code point value"; break;
00152   case ONIGERR_EMPTY_GROUP_NAME:
00153     p = "group name is empty"; break;
00154   case ONIGERR_INVALID_GROUP_NAME:
00155     p = "invalid group name <%n>"; break;
00156   case ONIGERR_INVALID_CHAR_IN_GROUP_NAME:
00157 #ifdef USE_NAMED_GROUP
00158     p = "invalid char in group name <%n>"; break;
00159 #else
00160     p = "invalid char in group number <%n>"; break;
00161 #endif
00162   case ONIGERR_UNDEFINED_NAME_REFERENCE:
00163     p = "undefined name <%n> reference"; break;
00164   case ONIGERR_UNDEFINED_GROUP_REFERENCE:
00165     p = "undefined group <%n> reference"; break;
00166   case ONIGERR_MULTIPLEX_DEFINED_NAME:
00167     p = "multiplex defined name <%n>"; break;
00168   case ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL:
00169     p = "multiplex definition name <%n> call"; break;
00170   case ONIGERR_NEVER_ENDING_RECURSION:
00171     p = "never ending recursion"; break;
00172   case ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY:
00173     p = "group number is too big for capture history"; break;
00174   case ONIGERR_INVALID_CHAR_PROPERTY_NAME:
00175     p = "invalid character property name {%n}"; break;
00176   case ONIGERR_NOT_SUPPORTED_ENCODING_COMBINATION:
00177     p = "not supported encoding combination"; break;
00178   case ONIGERR_INVALID_COMBINATION_OF_OPTIONS:
00179     p = "invalid combination of options"; break;
00180   case ONIGERR_OVER_THREAD_PASS_LIMIT_COUNT:
00181     p = "over thread pass limit count"; break;
00182 
00183   default:
00184     p = "undefined error code"; break;
00185   }
00186 
00187   return (UChar* )p;
00188 }
00189 
00190 static void sprint_byte(char* s, unsigned int v)
00191 {
00192   sprintf(s, "%02x", (v & 0377));
00193 }
00194 
00195 static void sprint_byte_with_x(char* s, unsigned int v)
00196 {
00197   sprintf(s, "\\x%02x", (v & 0377));
00198 }
00199 
00200 static int to_ascii(OnigEncoding enc, UChar *s, UChar *end,
00201                     UChar buf[], int buf_size, int *is_over)
00202 {
00203   int len;
00204   UChar *p;
00205   OnigCodePoint code;
00206 
00207   if (ONIGENC_MBC_MINLEN(enc) > 1) {
00208     p = s;
00209     len = 0;
00210     while (p < end) {
00211       code = ONIGENC_MBC_TO_CODE(enc, p, end);
00212       if (code >= 0x80) {
00213         if (code > 0xffff && len + 10 <= buf_size) {
00214           sprint_byte_with_x((char*)(&(buf[len])), (unsigned int)(code >> 24));
00215           sprint_byte((char*)(&(buf[len+4])),      (unsigned int)(code >> 16));
00216           sprint_byte((char*)(&(buf[len+6])),      (unsigned int)(code >>  8));
00217           sprint_byte((char*)(&(buf[len+8])),      (unsigned int)code);
00218           len += 10;
00219         }
00220         else if (len + 6 <= buf_size) {
00221           sprint_byte_with_x((char*)(&(buf[len])), (unsigned int)(code >> 8));
00222           sprint_byte((char*)(&(buf[len+4])),      (unsigned int)code);
00223           len += 6;
00224         }
00225         else {
00226           break;
00227         }
00228       }
00229       else {
00230         buf[len++] = (UChar )code;
00231       }
00232 
00233       p += enclen(enc, p, end);
00234       if (len >= buf_size) break;
00235     }
00236 
00237     *is_over = ((p < end) ? 1 : 0);
00238   }
00239   else {
00240     len = (int )MIN((end - s), buf_size);
00241     xmemcpy(buf, s, (size_t )len);
00242     *is_over = ((buf_size < (end - s)) ? 1 : 0);
00243   }
00244 
00245   return len;
00246 }
00247 
00248 
00249 /* for ONIG_MAX_ERROR_MESSAGE_LEN */
00250 #define MAX_ERROR_PAR_LEN   30
00251 
00252 extern int
00253 #ifdef HAVE_STDARG_PROTOTYPES
00254 onig_error_code_to_str(UChar* s, OnigPosition code, ...)
00255 #else
00256 onig_error_code_to_str(s, code, va_alist)
00257   UChar* s;
00258   OnigPosition code;
00259   va_dcl
00260 #endif
00261 {
00262   UChar *p, *q;
00263   OnigErrorInfo* einfo;
00264   size_t len;
00265   int is_over;
00266   UChar parbuf[MAX_ERROR_PAR_LEN];
00267   va_list vargs;
00268 
00269   va_init_list(vargs, code);
00270 
00271   switch (code) {
00272   case ONIGERR_UNDEFINED_NAME_REFERENCE:
00273   case ONIGERR_UNDEFINED_GROUP_REFERENCE:
00274   case ONIGERR_MULTIPLEX_DEFINED_NAME:
00275   case ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL:
00276   case ONIGERR_INVALID_GROUP_NAME:
00277   case ONIGERR_INVALID_CHAR_IN_GROUP_NAME:
00278   case ONIGERR_INVALID_CHAR_PROPERTY_NAME:
00279     einfo = va_arg(vargs, OnigErrorInfo*);
00280     len = to_ascii(einfo->enc, einfo->par, einfo->par_end,
00281                    parbuf, MAX_ERROR_PAR_LEN - 3, &is_over);
00282     q = onig_error_code_to_format(code);
00283     p = s;
00284     while (*q != '\0') {
00285       if (*q == '%') {
00286         q++;
00287         if (*q == 'n') { /* '%n': name */
00288           xmemcpy(p, parbuf, len);
00289           p += len;
00290           if (is_over != 0) {
00291             xmemcpy(p, "...", 3);
00292             p += 3;
00293           }
00294           q++;
00295         }
00296         else
00297           goto normal_char;
00298       }
00299       else {
00300       normal_char:
00301         *p++ = *q++;
00302       }
00303     }
00304     *p = '\0';
00305     len = p - s;
00306     break;
00307 
00308   default:
00309     q = onig_error_code_to_format(code);
00310     len = onigenc_str_bytelen_null(ONIG_ENCODING_ASCII, q);
00311     xmemcpy(s, q, len);
00312     s[len] = '\0';
00313     break;
00314   }
00315 
00316   va_end(vargs);
00317   return (int )len;
00318 }
00319 
00320 void
00321 onig_vsnprintf_with_pattern(UChar buf[], int bufsize, OnigEncoding enc,
00322                            UChar* pat, UChar* pat_end, const UChar *fmt, va_list args)
00323 {
00324   size_t need;
00325   int n, len;
00326   UChar *p, *s, *bp;
00327   UChar bs[6];
00328 
00329   n = xvsnprintf((char* )buf, bufsize, (const char* )fmt, args);
00330 
00331   need = (pat_end - pat) * 4 + 4;
00332 
00333   if (n + need < (size_t )bufsize) {
00334     strcat((char* )buf, ": /");
00335     s = buf + onigenc_str_bytelen_null(ONIG_ENCODING_ASCII, buf);
00336 
00337     p = pat;
00338     while (p < pat_end) {
00339       if (*p == '\\') {
00340         *s++ = *p++;
00341         len = enclen(enc, p, pat_end);
00342         while (len-- > 0) *s++ = *p++;
00343       }
00344       else if (*p == '/') {
00345         *s++ = (unsigned char )'\\';
00346         *s++ = *p++;
00347       }
00348       else if (ONIGENC_IS_MBC_HEAD(enc, p, pat_end)) {
00349         len = enclen(enc, p, pat_end);
00350         if (ONIGENC_MBC_MINLEN(enc) == 1) {
00351           while (len-- > 0) *s++ = *p++;
00352         }
00353         else { /* for UTF16 */
00354           int blen;
00355 
00356           while (len-- > 0) {
00357             sprint_byte_with_x((char* )bs, (unsigned int )(*p++));
00358             blen = onigenc_str_bytelen_null(ONIG_ENCODING_ASCII, bs);
00359             bp = bs;
00360             while (blen-- > 0) *s++ = *bp++;
00361           }
00362         }
00363       }
00364       else if (!ONIGENC_IS_CODE_PRINT(enc, *p) &&
00365                !ONIGENC_IS_CODE_SPACE(enc, *p)) {
00366         sprint_byte_with_x((char* )bs, (unsigned int )(*p++));
00367         len = onigenc_str_bytelen_null(ONIG_ENCODING_ASCII, bs);
00368         bp = bs;
00369         while (len-- > 0) *s++ = *bp++;
00370       }
00371       else {
00372         *s++ = *p++;
00373       }
00374     }
00375 
00376     *s++ = '/';
00377     *s   = '\0';
00378   }
00379 }
00380 
00381 void
00382 #ifdef HAVE_STDARG_PROTOTYPES
00383 onig_snprintf_with_pattern(UChar buf[], int bufsize, OnigEncoding enc,
00384                            UChar* pat, UChar* pat_end, const UChar *fmt, ...)
00385 #else
00386 onig_snprintf_with_pattern(buf, bufsize, enc, pat, pat_end, fmt, va_alist)
00387     UChar buf[];
00388     int bufsize;
00389     OnigEncoding enc;
00390     UChar* pat;
00391     UChar* pat_end;
00392     const UChar *fmt;
00393     va_dcl
00394 #endif
00395 {
00396   va_list args;
00397   va_init_list(args, fmt);
00398   onig_vsnprintf_with_pattern(buf, bufsize, enc,
00399           pat, pat_end, fmt, args);
00400   va_end(args);
00401 }
00402 
00403