src/hb-utf-private.hh

   1 /*
   2  * Copyright © 2011,2012  Google, Inc.
   3  *
   4  *  This is part of HarfBuzz, a text shaping library.
   5  *
   6  * Permission is hereby granted, without written agreement and without
   7  * license or royalty fees, to use, copy, modify, and distribute this
   8  * software and its documentation for any purpose, provided that the
   9  * above copyright notice and the following two paragraphs appear in
  10  * all copies of this software.
  11  *
  12  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  13  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  14  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  15  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  16  * DAMAGE.
  17  *
  18  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  19  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  20  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  21  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  22  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  23  *
  24  * Google Author(s): Behdad Esfahbod
  25  */
  26
  27 #ifndef HB_UTF_PRIVATE_HH
  28 #define HB_UTF_PRIVATE_HH
  29
  30 #include "hb-private.hh"
  31
  32
  33 /* UTF-8 */
  34
  35 #define HB_UTF8_COMPUTE(Char, Mask, Len) \
  36   if (Char < 128) { Len = 1; Mask = 0x7f; } \
  37   else if ((Char & 0xe0) == 0xc0) { Len = 2; Mask = 0x1f; } \
  38   else if ((Char & 0xf0) == 0xe0) { Len = 3; Mask = 0x0f; } \
  39   else if ((Char & 0xf8) == 0xf0) { Len = 4; Mask = 0x07; } \
  40   else Len = 0;
  41
  42 static inline const uint8_t *
  43 hb_utf_next (const uint8_t *text,
  44              const uint8_t *end,
  45              hb_codepoint_t *unicode)
  46 {
  47   hb_codepoint_t c = *text, mask;
  48   unsigned int len;
  49
  50   /* TODO check for overlong sequences? */
  51
  52   HB_UTF8_COMPUTE (c, mask, len);
  53   if (unlikely (!len || (unsigned int) (end - text) < len)) {
  54     *unicode = -1;
  55     return text + 1;
  56   } else {
  57     hb_codepoint_t result;
  58     unsigned int i;
  59     result = c & mask;
  60     for (i = 1; i < len; i++)
  61       {
  62         if (unlikely ((text[i] & 0xc0) != 0x80))
  63           {
  64             *unicode = -1;
  65             return text + 1;
  66           }
  67         result <<= 6;
  68         result |= (text[i] & 0x3f);
  69       }
  70     *unicode = result;
  71     return text + len;
  72   }
  73 }
  74
  75 static inline const uint8_t *
  76 hb_utf_prev (const uint8_t *text,
  77              const uint8_t *start,
  78              hb_codepoint_t *unicode)
  79 {
  80   const uint8_t *end = text--;
  81   while (start < text && (*text & 0xc0) == 0x80 && end - text < 4)
  82     text--;
  83
  84   hb_codepoint_t c = *text, mask;
  85   unsigned int len;
  86
  87   /* TODO check for overlong sequences? */
  88
  89   HB_UTF8_COMPUTE (c, mask, len);
  90   if (unlikely (!len || (unsigned int) (end - text) != len)) {
  91     *unicode = -1;
  92     return end - 1;
  93   } else {
  94     hb_codepoint_t result;
  95     unsigned int i;
  96     result = c & mask;
  97     for (i = 1; i < len; i++)
  98       {
  99         result <<= 6;
 100         result |= (text[i] & 0x3f);
 101       }
 102     *unicode = result;
 103     return text;
 104   }
 105 }
 106
 107
 108 static inline unsigned int
 109 hb_utf_strlen (const uint8_t *text)
 110 {
 111   return strlen ((const char *) text);
 112 }
 113
 114
 115 /* UTF-16 */
 116
 117 static inline const uint16_t *
 118 hb_utf_next (const uint16_t *text,
 119              const uint16_t *end,
 120              hb_codepoint_t *unicode)
 121 {
 122   hb_codepoint_t c = *text++;
 123
 124   if (unlikely (hb_in_range<hb_codepoint_t> (c, 0xd800, 0xdbff)))
 125   {
 126     /* high surrogate */
 127     hb_codepoint_t l;
 128     if (text < end && ((l = *text), likely (hb_in_range<hb_codepoint_t> (l, 0xdc00, 0xdfff))))
 129     {
 130       /* low surrogate */
 131       *unicode = (c << 10) + l - ((0xd800 << 10) - 0x10000 + 0xdc00);
 132        text++;
 133     } else
 134       *unicode = -1;
 135   } else
 136     *unicode = c;
 137
 138   return text;
 139 }
 140
 141 static inline const uint16_t *
 142 hb_utf_prev (const uint16_t *text,
 143              const uint16_t *start,
 144              hb_codepoint_t *unicode)
 145 {
 146   hb_codepoint_t c = *--text;
 147
 148   if (unlikely (hb_in_range<hb_codepoint_t> (c, 0xdc00, 0xdfff)))
 149   {
 150     /* low surrogate */
 151     hb_codepoint_t h;
 152     if (start < text && ((h = *(text - 1)), likely (hb_in_range<hb_codepoint_t> (h, 0xd800, 0xdbff))))
 153     {
 154       /* high surrogate */
 155       *unicode = (h << 10) + c - ((0xd800 << 10) - 0x10000 + 0xdc00);
 156        text--;
 157     } else
 158       *unicode = -1;
 159   } else
 160     *unicode = c;
 161
 162   return text;
 163 }
 164
 165
 166 static inline unsigned int
 167 hb_utf_strlen (const uint16_t *text)
 168 {
 169   unsigned int l = 0;
 170   while (*text++) l++;
 171   return l;
 172 }
 173
 174
 175 /* UTF-32 */
 176
 177 static inline const uint32_t *
 178 hb_utf_next (const uint32_t *text,
 179              const uint32_t *end HB_UNUSED,
 180              hb_codepoint_t *unicode)
 181 {
 182   *unicode = *text++;
 183   return text;
 184 }
 185
 186 static inline const uint32_t *
 187 hb_utf_prev (const uint32_t *text,
 188              const uint32_t *start HB_UNUSED,
 189              hb_codepoint_t *unicode)
 190 {
 191   *unicode = *--text;
 192   return text;
 193 }
 194
 195 static inline unsigned int
 196 hb_utf_strlen (const uint32_t *text)
 197 {
 198   unsigned int l = 0;
 199   while (*text++) l++;
 200   return l;
 201 }
 202
 203
 204 #endif /* HB_UTF_PRIVATE_HH */