enc/utf_16be.c

   1 /**********************************************************************
   2   utf_16be.c -  Oniguruma (regular expression library)
   3 **********************************************************************/
   4 /*-
   5  * Copyright (c) 2002-2007  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
  30 #include "regenc.h"
  31
  32 #define UTF16_IS_SURROGATE_FIRST(c)    (((c) & 0xfc) == 0xd8)
  33 #define UTF16_IS_SURROGATE_SECOND(c)   (((c) & 0xfc) == 0xdc)
  34 #define UTF16_IS_SURROGATE(c)          (((c) & 0xf8) == 0xd8)
  35
  36 static const int EncLen_UTF16[] = {
  37   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  38   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  39   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  40   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  41   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  42   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  43   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  44   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  45   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  46   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  47   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  48   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  49   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  50   2, 2, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, 2, 2, 2, 2,
  51   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  52   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
  53 };
  54
  55 static int
  56 utf16be_mbc_enc_len(const UChar* p, const OnigUChar* e ARG_UNUSED,
  57                     OnigEncoding enc ARG_UNUSED)
  58 {
  59   int byte = p[0];
  60   if (!UTF16_IS_SURROGATE(byte)) {
  61     if (2 <= e-p)
  62       return ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(2);
  63     else
  64       return ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(1);
  65   }
  66   if (UTF16_IS_SURROGATE_FIRST(byte)) {
  67     switch (e-p) {
  68       case 1: return ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(3);
  69       case 2: return ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(2);
  70       case 3:
  71         if (UTF16_IS_SURROGATE_SECOND(p[2]))
  72           return ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(1);
  73         break;
  74       default:
  75         if (UTF16_IS_SURROGATE_SECOND(p[2]))
  76           return ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(4);
  77         break;
  78     }
  79   }
  80   return ONIGENC_CONSTRUCT_MBCLEN_INVALID();
  81 }
  82
  83 static int
  84 utf16be_is_mbc_newline(const UChar* p, const UChar* end,
  85                        OnigEncoding enc)
  86 {
  87   if (p + 1 < end) {
  88     if (*(p+1) == 0x0a && *p == 0x00)
  89       return 1;
  90 #ifdef USE_UNICODE_ALL_LINE_TERMINATORS
  91     if ((
  92 #ifndef USE_CRNL_AS_LINE_TERMINATOR
  93          *(p+1) == 0x0d ||
  94 #endif
  95          *(p+1) == 0x85) && *p == 0x00)
  96       return 1;
  97     if (*p == 0x20 && (*(p+1) == 0x29 || *(p+1) == 0x28))
  98       return 1;
  99 #endif
 100   }
 101   return 0;
 102 }
 103
 104 static OnigCodePoint
 105 utf16be_mbc_to_code(const UChar* p, const UChar* end ARG_UNUSED,
 106                     OnigEncoding enc)
 107 {
 108   OnigCodePoint code;
 109
 110   if (UTF16_IS_SURROGATE_FIRST(*p)) {
 111     code = ((((p[0] - 0xd8) << 2) + ((p[1] & 0xc0) >> 6) + 1) << 16)
 112          + ((((p[1] & 0x3f) << 2) + (p[2] - 0xdc)) << 8)
 113          + p[3];
 114   }
 115   else {
 116     code = p[0] * 256 + p[1];
 117   }
 118   return code;
 119 }
 120
 121 static int
 122 utf16be_code_to_mbclen(OnigCodePoint code,
 123                        OnigEncoding enc)
 124 {
 125   return (code > 0xffff ? 4 : 2);
 126 }
 127
 128 static int
 129 utf16be_code_to_mbc(OnigCodePoint code, UChar *buf,
 130                     OnigEncoding enc)
 131 {
 132   UChar* p = buf;
 133
 134   if (code > 0xffff) {
 135     unsigned int high = (code >> 10) + 0xD7C0;
 136     unsigned int low = (code & 0x3FF) + 0xDC00;
 137     *p++ = (high >> 8) & 0xFF;
 138     *p++ = high & 0xFF;
 139     *p++ = (low >> 8) & 0xFF;
 140     *p++ = low & 0xFF;
 141     return 4;
 142   }
 143   else {
 144     *p++ = (UChar )((code & 0xff00) >> 8);
 145     *p++ = (UChar )(code & 0xff);
 146     return 2;
 147   }
 148 }
 149
 150 static int
 151 utf16be_mbc_case_fold(OnigCaseFoldType flag,
 152                       const UChar** pp, const UChar* end, UChar* fold,
 153                       OnigEncoding enc)
 154 {
 155   const UChar* p = *pp;
 156
 157   if (ONIGENC_IS_ASCII_CODE(*(p+1)) && *p == 0) {
 158     p++;
 159 #ifdef USE_UNICODE_CASE_FOLD_TURKISH_AZERI
 160     if ((flag & ONIGENC_CASE_FOLD_TURKISH_AZERI) != 0) {
 161       if (*p == 0x49) {
 162         *fold++ = 0x01;
 163         *fold   = 0x31;
 164         (*pp) += 2;
 165         return 2;
 166       }
 167     }
 168 #endif
 169
 170     *fold++ = 0;
 171     *fold   = ONIGENC_ASCII_CODE_TO_LOWER_CASE(*p);
 172     *pp += 2;
 173     return 2;
 174   }
 175   else
 176     return onigenc_unicode_mbc_case_fold(enc, flag,
 177                                          pp, end, fold);
 178 }
 179
 180 #if 0
 181 static int
 182 utf16be_is_mbc_ambiguous(OnigCaseFoldType flag, const UChar** pp, const UChar* end)
 183 {
 184   const UChar* p = *pp;
 185
 186   (*pp) += EncLen_UTF16[*p];
 187
 188   if (*p == 0) {
 189     int c, v;
 190
 191     p++;
 192     if (*p == 0xdf && (flag & INTERNAL_ONIGENC_CASE_FOLD_MULTI_CHAR) != 0) {
 193       return TRUE;
 194     }
 195
 196     c = *p;
 197     v = ONIGENC_IS_UNICODE_ISO_8859_1_BIT_CTYPE(c,
 198                 (BIT_CTYPE_UPPER | BIT_CTYPE_LOWER));
 199
 200     if ((v | BIT_CTYPE_LOWER) != 0) {
 201       /* 0xaa, 0xb5, 0xba are lower case letter, but can't convert. */
 202       if (c >= 0xaa && c <= 0xba)
 203         return FALSE;
 204       else
 205         return TRUE;
 206     }
 207     return (v != 0 ? TRUE : FALSE);
 208   }
 209
 210   return FALSE;
 211 }
 212 #endif
 213
 214 static UChar*
 215 utf16be_left_adjust_char_head(const UChar* start, const UChar* s,
 216                               OnigEncoding enc ARG_UNUSED)
 217 {
 218   if (s <= start) return (UChar* )s;
 219
 220   if ((s - start) % 2 == 1) {
 221     s--;
 222   }
 223
 224   if (UTF16_IS_SURROGATE_SECOND(*s) && s > start + 1)
 225     s -= 2;
 226
 227   return (UChar* )s;
 228 }
 229
 230 static int
 231 utf16be_get_case_fold_codes_by_str(OnigCaseFoldType flag,
 232                                    const OnigUChar* p, const OnigUChar* end,
 233                                    OnigCaseFoldCodeItem items[],
 234                                    OnigEncoding enc)
 235 {
 236   return onigenc_unicode_get_case_fold_codes_by_str(enc,
 237                                                     flag, p, end, items);
 238 }
 239
 240 OnigEncodingDefine(utf_16be, UTF_16BE) = {
 241   utf16be_mbc_enc_len,
 242   "UTF-16BE",   /* name */
 243   4,            /* max byte length */
 244   2,            /* min byte length */
 245   utf16be_is_mbc_newline,
 246   utf16be_mbc_to_code,
 247   utf16be_code_to_mbclen,
 248   utf16be_code_to_mbc,
 249   utf16be_mbc_case_fold,
 250   onigenc_unicode_apply_all_case_fold,
 251   utf16be_get_case_fold_codes_by_str,
 252   onigenc_unicode_property_name_to_ctype,
 253   onigenc_unicode_is_code_ctype,
 254   onigenc_utf16_32_get_ctype_code_range,
 255   utf16be_left_adjust_char_head,
 256   onigenc_always_false_is_allowed_reverse_match
 257 };
 258 ENC_ALIAS("UCS-2BE", "UTF-16BE")