MdeModulePkg: Regular expression protocol

[mirror_edk2.git] / MdeModulePkg / Universal / RegularExpressionDxe / Oniguruma / regerror.c

/**********************************************************************\r
  regerror.c -  Oniguruma (regular expression library)\r
**********************************************************************/\r
/*-\r
 * Copyright (c) 2002-2007  K.Kosako  <sndgk393 AT ybb DOT ne DOT jp>\r
 * All rights reserved.\r
 *\r
 * Copyright (c) 2015, Hewlett Packard Enterprise Development, L.P.<BR>\r
 *\r
 * Redistribution and use in source and binary forms, with or without\r
 * modification, are permitted provided that the following conditions\r
 * are met:\r
 * 1. Redistributions of source code must retain the above copyright\r
 *    notice, this list of conditions and the following disclaimer.\r
 * 2. Redistributions in binary form must reproduce the above copyright\r
 *    notice, this list of conditions and the following disclaimer in the\r
 *    documentation and/or other materials provided with the distribution.\r
 *\r
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND\r
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\r
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
 * SUCH DAMAGE.\r
 */\r
\r
#define HAVE_STDARG_PROTOTYPES\r
\r
#include "regint.h"\r
\r
#if 0\r
#include <stdio.h> /* for vsnprintf() */\r
\r
#ifdef HAVE_STDARG_PROTOTYPES\r
#include <stdarg.h>\r
#define va_init_list(a,b) va_start(a,b)\r
#else\r
#include <varargs.h>\r
#define va_init_list(a,b) va_start(a)\r
#endif\r
#endif\r
\r
extern UChar*\r
onig_error_code_to_format(int code)\r
{\r
  char *p;\r
\r
  if (code >= 0) return (UChar* )0;\r
\r
  switch (code) {\r
  case ONIG_MISMATCH:\r
    p = "mismatch"; break;\r
  case ONIG_NO_SUPPORT_CONFIG:\r
    p = "no support in this configuration"; break;\r
  case ONIGERR_MEMORY:\r
    p = "fail to memory allocation"; break;\r
  case ONIGERR_MATCH_STACK_LIMIT_OVER:\r
    p = "match-stack limit over"; break;\r
  case ONIGERR_TYPE_BUG:\r
    p = "undefined type (bug)"; break;\r
  case ONIGERR_PARSER_BUG:\r
    p = "internal parser error (bug)"; break;\r
  case ONIGERR_STACK_BUG:\r
    p = "stack error (bug)"; break;\r
  case ONIGERR_UNDEFINED_BYTECODE:\r
    p = "undefined bytecode (bug)"; break;\r
  case ONIGERR_UNEXPECTED_BYTECODE:\r
    p = "unexpected bytecode (bug)"; break;\r
  case ONIGERR_DEFAULT_ENCODING_IS_NOT_SETTED:\r
    p = "default multibyte-encoding is not setted"; break;\r
  case ONIGERR_SPECIFIED_ENCODING_CANT_CONVERT_TO_WIDE_CHAR:\r
    p = "can't convert to wide-char on specified multibyte-encoding"; break;\r
  case ONIGERR_INVALID_ARGUMENT:\r
    p = "invalid argument"; break;\r
  case ONIGERR_END_PATTERN_AT_LEFT_BRACE:\r
    p = "end pattern at left brace"; break;\r
  case ONIGERR_END_PATTERN_AT_LEFT_BRACKET:\r
    p = "end pattern at left bracket"; break;\r
  case ONIGERR_EMPTY_CHAR_CLASS:\r
    p = "empty char-class"; break;\r
  case ONIGERR_PREMATURE_END_OF_CHAR_CLASS:\r
    p = "premature end of char-class"; break;\r
  case ONIGERR_END_PATTERN_AT_ESCAPE:\r
    p = "end pattern at escape"; break;\r
  case ONIGERR_END_PATTERN_AT_META:\r
    p = "end pattern at meta"; break;\r
  case ONIGERR_END_PATTERN_AT_CONTROL:\r
    p = "end pattern at control"; break;\r
  case ONIGERR_META_CODE_SYNTAX:\r
    p = "invalid meta-code syntax"; break;\r
  case ONIGERR_CONTROL_CODE_SYNTAX:\r
    p = "invalid control-code syntax"; break;\r
  case ONIGERR_CHAR_CLASS_VALUE_AT_END_OF_RANGE:\r
    p = "char-class value at end of range"; break;\r
  case ONIGERR_CHAR_CLASS_VALUE_AT_START_OF_RANGE:\r
    p = "char-class value at start of range"; break;\r
  case ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS:\r
    p = "unmatched range specifier in char-class"; break;\r
  case ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED:\r
    p = "target of repeat operator is not specified"; break;\r
  case ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID:\r
    p = "target of repeat operator is invalid"; break;\r
  case ONIGERR_NESTED_REPEAT_OPERATOR:\r
    p = "nested repeat operator"; break;\r
  case ONIGERR_UNMATCHED_CLOSE_PARENTHESIS:\r
    p = "unmatched close parenthesis"; break;\r
  case ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS:\r
    p = "end pattern with unmatched parenthesis"; break;\r
  case ONIGERR_END_PATTERN_IN_GROUP:\r
    p = "end pattern in group"; break;\r
  case ONIGERR_UNDEFINED_GROUP_OPTION:\r
    p = "undefined group option"; break;\r
  case ONIGERR_INVALID_POSIX_BRACKET_TYPE:\r
    p = "invalid POSIX bracket type"; break;\r
  case ONIGERR_INVALID_LOOK_BEHIND_PATTERN:\r
    p = "invalid pattern in look-behind"; break;\r
  case ONIGERR_INVALID_REPEAT_RANGE_PATTERN:\r
    p = "invalid repeat range {lower,upper}"; break;\r
  case ONIGERR_TOO_BIG_NUMBER:\r
    p = "too big number"; break;\r
  case ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE:\r
    p = "too big number for repeat range"; break;\r
  case ONIGERR_UPPER_SMALLER_THAN_LOWER_IN_REPEAT_RANGE:\r
    p = "upper is smaller than lower in repeat range"; break;\r
  case ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS:\r
    p = "empty range in char class"; break;\r
  case ONIGERR_MISMATCH_CODE_LENGTH_IN_CLASS_RANGE:\r
    p = "mismatch multibyte code length in char-class range"; break;\r
  case ONIGERR_TOO_MANY_MULTI_BYTE_RANGES:\r
    p = "too many multibyte code ranges are specified"; break;\r
  case ONIGERR_TOO_SHORT_MULTI_BYTE_STRING:\r
    p = "too short multibyte code string"; break;\r
  case ONIGERR_TOO_BIG_BACKREF_NUMBER:\r
    p = "too big backref number"; break;\r
  case ONIGERR_INVALID_BACKREF:\r
#ifdef USE_NAMED_GROUP\r
    p = "invalid backref number/name"; break;\r
#else\r
    p = "invalid backref number"; break;\r
#endif\r
  case ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED:\r
    p = "numbered backref/call is not allowed. (use name)"; break;\r
  case ONIGERR_TOO_BIG_WIDE_CHAR_VALUE:\r
    p = "too big wide-char value"; break;\r
  case ONIGERR_TOO_LONG_WIDE_CHAR_VALUE:\r
    p = "too long wide-char value"; break;\r
  case ONIGERR_INVALID_CODE_POINT_VALUE:\r
    p = "invalid code point value"; break;\r
  case ONIGERR_EMPTY_GROUP_NAME:\r
    p = "group name is empty"; break;\r
  case ONIGERR_INVALID_GROUP_NAME:\r
    p = "invalid group name <%n>"; break;\r
  case ONIGERR_INVALID_CHAR_IN_GROUP_NAME:\r
#ifdef USE_NAMED_GROUP\r
    p = "invalid char in group name <%n>"; break;\r
#else\r
    p = "invalid char in group number <%n>"; break;\r
#endif\r
  case ONIGERR_UNDEFINED_NAME_REFERENCE:\r
    p = "undefined name <%n> reference"; break;\r
  case ONIGERR_UNDEFINED_GROUP_REFERENCE:\r
    p = "undefined group <%n> reference"; break;\r
  case ONIGERR_MULTIPLEX_DEFINED_NAME:\r
    p = "multiplex defined name <%n>"; break;\r
  case ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL:\r
    p = "multiplex definition name <%n> call"; break;\r
  case ONIGERR_NEVER_ENDING_RECURSION:\r
    p = "never ending recursion"; break;\r
  case ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY:\r
    p = "group number is too big for capture history"; break;\r
  case ONIGERR_INVALID_CHAR_PROPERTY_NAME:\r
    p = "invalid character property name {%n}"; break;\r
  case ONIGERR_NOT_SUPPORTED_ENCODING_COMBINATION:\r
    p = "not supported encoding combination"; break;\r
  case ONIGERR_INVALID_COMBINATION_OF_OPTIONS:\r
    p = "invalid combination of options"; break;\r
  case ONIGERR_OVER_THREAD_PASS_LIMIT_COUNT:\r
    p = "over thread pass limit count"; break;\r
\r
  default:\r
    p = "undefined error code"; break;\r
  }\r
\r
  return (UChar* )p;\r
}\r
\r
static void sprint_byte(char* s, unsigned int v)\r
{\r
  sprintf(s, "%02x", (v & 0377));\r
}\r
\r
static void sprint_byte_with_x(char* s, unsigned int v)\r
{\r
  sprintf(s, "\\x%02x", (v & 0377));\r
}\r
\r
static int to_ascii(OnigEncoding enc, UChar *s, UChar *end,\r
		    UChar buf[], int buf_size, int *is_over)\r
{\r
  int len;\r
  UChar *p;\r
  OnigCodePoint code;\r
\r
  if (ONIGENC_MBC_MINLEN(enc) > 1) {\r
    p = s;\r
    len = 0;\r
    while (p < end) {\r
      code = ONIGENC_MBC_TO_CODE(enc, p, end);\r
      if (code >= 0x80) {\r
	if (code > 0xffff && len + 10 <= buf_size) {\r
	  sprint_byte_with_x((char*)(&(buf[len])), (unsigned int)(code >> 24));\r
	  sprint_byte((char*)(&(buf[len+4])),      (unsigned int)(code >> 16));\r
	  sprint_byte((char*)(&(buf[len+6])),      (unsigned int)(code >>  8));\r
	  sprint_byte((char*)(&(buf[len+8])),      (unsigned int)code);\r
	  len += 10;\r
	}\r
	else if (len + 6 <= buf_size) {\r
	  sprint_byte_with_x((char*)(&(buf[len])), (unsigned int)(code >> 8));\r
	  sprint_byte((char*)(&(buf[len+4])),      (unsigned int)code);\r
	  len += 6;\r
	}\r
	else {\r
	  break;\r
	}\r
      }\r
      else {\r
	buf[len++] = (UChar )code;\r
      }\r
\r
      p += enclen(enc, p);\r
      if (len >= buf_size) break;\r
    }\r
\r
    *is_over = ((p < end) ? 1 : 0);\r
  }\r
  else {\r
    len = MIN((int)(end - s), buf_size);\r
    xmemcpy(buf, s, (size_t )len);\r
    *is_over = ((buf_size < (end - s)) ? 1 : 0);\r
  }\r
\r
  return len;\r
}\r
\r
\r
/* for ONIG_MAX_ERROR_MESSAGE_LEN */\r
#define MAX_ERROR_PAR_LEN   30\r
\r
extern int\r
#ifdef HAVE_STDARG_PROTOTYPES\r
onig_error_code_to_str(UChar* s, int code, ...)\r
#else\r
onig_error_code_to_str(s, code, va_alist)\r
  UChar* s;\r
  int code;\r
  va_dcl \r
#endif\r
{\r
  UChar *p, *q;\r
  OnigErrorInfo* einfo;\r
  int len, is_over;\r
  UChar parbuf[MAX_ERROR_PAR_LEN];\r
  va_list vargs;\r
\r
  va_init_list(vargs, code);\r
\r
  switch (code) {\r
  case ONIGERR_UNDEFINED_NAME_REFERENCE:\r
  case ONIGERR_UNDEFINED_GROUP_REFERENCE:\r
  case ONIGERR_MULTIPLEX_DEFINED_NAME:\r
  case ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL:\r
  case ONIGERR_INVALID_GROUP_NAME:\r
  case ONIGERR_INVALID_CHAR_IN_GROUP_NAME:\r
  case ONIGERR_INVALID_CHAR_PROPERTY_NAME:\r
    einfo = va_arg(vargs, OnigErrorInfo*);\r
    len = to_ascii(einfo->enc, einfo->par, einfo->par_end,\r
		   parbuf, MAX_ERROR_PAR_LEN - 3, &is_over);\r
    q = onig_error_code_to_format(code);\r
    p = s;\r
    while (*q != '\0') {\r
      if (*q == '%') {\r
	q++;\r
	if (*q == 'n') { /* '%n': name */\r
	  xmemcpy(p, parbuf, len);\r
	  p += len;\r
	  if (is_over != 0) {\r
	    xmemcpy(p, "...", 3);\r
	    p += 3;\r
	  }\r
	  q++;\r
	}\r
	else\r
	  goto normal_char;\r
      }\r
      else {\r
      normal_char:\r
	*p++ = *q++;\r
      }\r
    }\r
    *p = '\0';\r
    len = (int)(p - s);\r
    break;\r
\r
  default:\r
    q = onig_error_code_to_format(code);\r
    len = onigenc_str_bytelen_null(ONIG_ENCODING_ASCII, q);\r
    xmemcpy(s, q, len);\r
    s[len] = '\0';\r
    break;\r
  }\r
\r
  va_end(vargs);\r
  return len;\r
}\r
\r
\r
void\r
#ifdef HAVE_STDARG_PROTOTYPES\r
onig_snprintf_with_pattern(UChar buf[], int bufsize, OnigEncoding enc,\r
                           UChar* pat, UChar* pat_end, const UChar *fmt, ...)\r
#else\r
onig_snprintf_with_pattern(buf, bufsize, enc, pat, pat_end, fmt, va_alist)\r
    UChar buf[];\r
    int bufsize;\r
    OnigEncoding enc;\r
    UChar* pat;\r
    UChar* pat_end;\r
    const UChar *fmt;\r
    va_dcl\r
#endif\r
{\r
  int n, need, len;\r
  UChar *p, *s, *bp;\r
  UChar bs[6];\r
  va_list args;\r
\r
  va_init_list(args, fmt);\r
  n = xvsnprintf((char* )buf, bufsize, (const char* )fmt, args);\r
  va_end(args);\r
\r
  need = (int)(pat_end - pat) * 4 + 4;\r
\r
  if (n + need < bufsize) {\r
    strcat_s((char* )buf, bufsize, ": /");\r
    s = buf + onigenc_str_bytelen_null(ONIG_ENCODING_ASCII, buf);\r
\r
    p = pat;\r
    while (p < pat_end) {\r
      if (*p == '\\') {\r
	*s++ = *p++;\r
	len = enclen(enc, p);\r
	while (len-- > 0) *s++ = *p++;\r
      }\r
      else if (*p == '/') {\r
	*s++ = (unsigned char )'\\';\r
	*s++ = *p++;\r
      }\r
      else if (ONIGENC_IS_MBC_HEAD(enc, p)) {\r
        len = enclen(enc, p);\r
        if (ONIGENC_MBC_MINLEN(enc) == 1) {\r
          while (len-- > 0) *s++ = *p++;\r
        }\r
        else { /* for UTF16 */\r
          int blen;\r
\r
          while (len-- > 0) {\r
	    sprint_byte_with_x((char* )bs, (unsigned int )(*p++));\r
            blen = onigenc_str_bytelen_null(ONIG_ENCODING_ASCII, bs);\r
            bp = bs;\r
            while (blen-- > 0) *s++ = *bp++;\r
          }\r
        }\r
      }\r
      else if (!ONIGENC_IS_CODE_PRINT(enc, *p) &&\r
	       !ONIGENC_IS_CODE_SPACE(enc, *p)) {\r
	sprint_byte_with_x((char* )bs, (unsigned int )(*p++));\r
	len = onigenc_str_bytelen_null(ONIG_ENCODING_ASCII, bs);\r
        bp = bs;\r
	while (len-- > 0) *s++ = *bp++;\r
      }\r
      else {\r
	*s++ = *p++;\r
      }\r
    }\r
\r
    *s++ = '/';\r
    *s   = '\0';\r
  }\r
}\r