MdeModulePkg/Universal/RegularExpressionDxe/Oniguruma/utf16_le.c

   1 /**********************************************************************
   2   utf16_le.c -  Oniguruma (regular expression library)
   3 **********************************************************************/
   4 /*-
   5  * Copyright (c) 2002-2018  K.Kosako  <sndgk393 AT ybb DOT ne DOT jp>
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29 #include "regint.h"  /* for USE_CALLOUT */
  30
  31 static int
  32 init(void)
  33 {
  34 #ifdef USE_CALLOUT
  35
  36     int id;
  37     OnigEncoding enc;
  38     char* name;
  39     unsigned int args[4];
  40     OnigValue    opts[4];
  41
  42     enc = ONIG_ENCODING_UTF16_LE;
  43
  44     name = "F\000A\000I\000L\000\000\000";            BC0_P(name, fail);
  45     name = "M\000I\000S\000M\000A\000T\000C\000H\000\000\000"; BC0_P(name, mismatch);
  46
  47     name = "M\000A\000X\000\000\000";
  48     args[0] = ONIG_TYPE_TAG | ONIG_TYPE_LONG;
  49     args[1] = ONIG_TYPE_CHAR;
  50     opts[0].c = 'X';
  51     BC_B_O(name, max, 2, args, 1, opts);
  52
  53     name = "E\000R\000R\000O\000R\000\000\000";
  54     args[0] = ONIG_TYPE_LONG; opts[0].l = ONIG_ABORT;
  55     BC_P_O(name, error, 1, args, 1, opts);
  56
  57     name = "C\000O\000U\000N\000T\000\000\000";
  58     args[0] = ONIG_TYPE_CHAR; opts[0].c = '>';
  59     BC_B_O(name, count, 1, args, 1, opts);
  60
  61     name = "T\000O\000T\000A\000L\000_\000C\000O\000U\000N\000T\000\000\000";
  62     args[0] = ONIG_TYPE_CHAR; opts[0].c = '>';
  63     BC_B_O(name, total_count, 1, args, 1, opts);
  64
  65     name = "C\000M\000P\000\000\000";
  66     args[0] = ONIG_TYPE_TAG | ONIG_TYPE_LONG;
  67     args[1] = ONIG_TYPE_STRING;
  68     args[2] = ONIG_TYPE_TAG | ONIG_TYPE_LONG;
  69     BC_P(name, cmp, 3, args);
  70
  71 #endif /* USE_CALLOUT */
  72
  73   return ONIG_NORMAL;
  74 }
  75
  76 static const int EncLen_UTF16[] = {
  77   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  78   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  79   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  80   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  81   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  82   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  83   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  84   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  85   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  86   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  87   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  88   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  89   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  90   2, 2, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, 2, 2, 2, 2,
  91   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  92   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
  93 };
  94
  95 static int
  96 utf16le_code_to_mbclen(OnigCodePoint code)
  97 {
  98   return (code > 0xffff ? 4 : 2);
  99 }
 100
 101 static int
 102 utf16le_mbc_enc_len(const UChar* p)
 103 {
 104   return EncLen_UTF16[*(p+1)];
 105 }
 106
 107 static int
 108 is_valid_mbc_string(const UChar* p, const UChar* end)
 109 {
 110   const UChar* end1 = end - 1;
 111
 112   while (p < end1) {
 113     p += utf16le_mbc_enc_len(p);
 114   }
 115
 116   if (p != end)
 117     return FALSE;
 118   else
 119     return TRUE;
 120 }
 121
 122 static int
 123 utf16le_is_mbc_newline(const UChar* p, const UChar* end)
 124 {
 125   if (p + 1 < end) {
 126     if (*p == 0x0a && *(p+1) == 0x00)
 127       return 1;
 128 #ifdef USE_UNICODE_ALL_LINE_TERMINATORS
 129     if ((
 130 #ifndef USE_CRNL_AS_LINE_TERMINATOR
 131          *p == 0x0d ||
 132 #endif
 133          *p == 0x85) && *(p+1) == 0x00)
 134       return 1;
 135
 136     if (*(p+1) == 0x20 && (*p == 0x29 || *p == 0x28))
 137       return 1;
 138 #endif
 139   }
 140   return 0;
 141 }
 142
 143 static OnigCodePoint
 144 utf16le_mbc_to_code(const UChar* p, const UChar* end ARG_UNUSED)
 145 {
 146   OnigCodePoint code;
 147   UChar c0 = *p;
 148   UChar c1 = *(p+1);
 149
 150   if (UTF16_IS_SURROGATE_FIRST(c1)) {
 151     code = ((((c1 - 0xd8) << 2) + ((c0  & 0xc0) >> 6) + 1) << 16)
 152          + ((((c0 & 0x3f) << 2) + (p[3] - 0xdc)) << 8)
 153          + p[2];
 154   }
 155   else {
 156     code = c1 * 256 + p[0];
 157   }
 158   return code;
 159 }
 160
 161 static int
 162 utf16le_code_to_mbc(OnigCodePoint code, UChar *buf)
 163 {
 164   UChar* p = buf;
 165
 166   if (code > 0xffff) {
 167     unsigned int plane, high;
 168
 169     plane = (code >> 16) - 1;
 170     high = (code & 0xff00) >> 8;
 171
 172     *p++ = ((plane & 0x03) << 6) + (high >> 2);
 173     *p++ = (plane >> 2) + 0xd8;
 174     *p++ = (UChar )(code & 0xff);
 175     *p   = (high & 0x03) + 0xdc;
 176     return 4;
 177   }
 178   else {
 179     *p++ = (UChar )(code & 0xff);
 180     *p++ = (UChar )((code & 0xff00) >> 8);
 181     return 2;
 182   }
 183 }
 184
 185 static int
 186 utf16le_mbc_case_fold(OnigCaseFoldType flag,
 187                       const UChar** pp, const UChar* end, UChar* fold)
 188 {
 189   const UChar* p = *pp;
 190
 191   if (ONIGENC_IS_ASCII_CODE(*p) && *(p+1) == 0) {
 192 #ifdef USE_UNICODE_CASE_FOLD_TURKISH_AZERI
 193     if ((flag & ONIGENC_CASE_FOLD_TURKISH_AZERI) != 0) {
 194       if (*p == 0x49) {
 195         *fold++ = 0x31;
 196         *fold   = 0x01;
 197         (*pp) += 2;
 198         return 2;
 199       }
 200     }
 201 #endif
 202
 203     *fold++ = ONIGENC_ASCII_CODE_TO_LOWER_CASE(*p);
 204     *fold   = 0;
 205     *pp += 2;
 206     return 2;
 207   }
 208   else
 209     return onigenc_unicode_mbc_case_fold(ONIG_ENCODING_UTF16_LE, flag, pp, end,
 210                                          fold);
 211 }
 212
 213 #if 0
 214 static int
 215 utf16le_is_mbc_ambiguous(OnigCaseFoldType flag, const UChar** pp,
 216                          const UChar* end)
 217 {
 218   const UChar* p = *pp;
 219
 220   (*pp) += EncLen_UTF16[*(p+1)];
 221
 222   if (*(p+1) == 0) {
 223     int c, v;
 224
 225     if (*p == 0xdf && (flag & INTERNAL_ONIGENC_CASE_FOLD_MULTI_CHAR) != 0) {
 226       return TRUE;
 227     }
 228
 229     c = *p;
 230     v = ONIGENC_IS_UNICODE_ISO_8859_1_BIT_CTYPE(c,
 231                        (BIT_CTYPE_UPPER | BIT_CTYPE_LOWER));
 232     if ((v | BIT_CTYPE_LOWER) != 0) {
 233       /* 0xaa, 0xb5, 0xba are lower case letter, but can't convert. */
 234       if (c >= 0xaa && c <= 0xba)
 235         return FALSE;
 236       else
 237         return TRUE;
 238     }
 239     return (v != 0 ? TRUE : FALSE);
 240   }
 241
 242   return FALSE;
 243 }
 244 #endif
 245
 246 static UChar*
 247 utf16le_left_adjust_char_head(const UChar* start, const UChar* s)
 248 {
 249   if (s <= start) return (UChar* )s;
 250
 251   if ((s - start) % 2 == 1) {
 252     s--;
 253   }
 254
 255   if (UTF16_IS_SURROGATE_SECOND(*(s+1)) && s > start + 1)
 256     s -= 2;
 257
 258   return (UChar* )s;
 259 }
 260
 261 static int
 262 utf16le_get_case_fold_codes_by_str(OnigCaseFoldType flag,
 263     const OnigUChar* p, const OnigUChar* end, OnigCaseFoldCodeItem items[])
 264 {
 265   return onigenc_unicode_get_case_fold_codes_by_str(ONIG_ENCODING_UTF16_LE,
 266                                                     flag, p, end, items);
 267 }
 268
 269 OnigEncodingType OnigEncodingUTF16_LE = {
 270   utf16le_mbc_enc_len,
 271   "UTF-16LE",   /* name */
 272   4,            /* max enc length */
 273   2,            /* min enc length */
 274   utf16le_is_mbc_newline,
 275   utf16le_mbc_to_code,
 276   utf16le_code_to_mbclen,
 277   utf16le_code_to_mbc,
 278   utf16le_mbc_case_fold,
 279   onigenc_unicode_apply_all_case_fold,
 280   utf16le_get_case_fold_codes_by_str,
 281   onigenc_unicode_property_name_to_ctype,
 282   onigenc_unicode_is_code_ctype,
 283   onigenc_utf16_32_get_ctype_code_range,
 284   utf16le_left_adjust_char_head,
 285   onigenc_always_false_is_allowed_reverse_match,
 286   init,
 287   0, /* is_initialized */
 288   is_valid_mbc_string,
 289   ENC_FLAG_UNICODE,
 290   0, 0
 291 };