1 /*

     2  * Copyright © 2011,2012,2014  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 struct hb_utf8_t

    34 {

    35   typedef uint8_t codepoint_t;

    36 

    37   static inline const uint8_t *

    38   next (const uint8_t *text,

    39         const uint8_t *end,

    40         hb_codepoint_t *unicode,

    41         hb_codepoint_t replacement)

    42   {

    43     /* Written to only accept well-formed sequences.

    44      * Based on ideas from ICU's U8_NEXT.

    45      * Generates one "replacement" for each ill-formed byte. */

    46 

    47     hb_codepoint_t c = *text++;

    48 

    49     if (c > 0x7Fu)

    50     {

    51       if (hb_in_range<hb_codepoint_t> (c, 0xC2u, 0xDFu)) /* Two-byte */

    52       {

    53         unsigned int t1;

    54         if (likely (text < end &&

    55                     (t1 = text[0] - 0x80u) <= 0x3Fu))

    56         {

    57           c = ((c&0x1Fu)<<6) | t1;

    58           text++;

    59         }

    60         else

    61           goto error;

    62       }

    63       else if (hb_in_range<hb_codepoint_t> (c, 0xE0u, 0xEFu)) /* Three-byte */

    64       {

    65         unsigned int t1, t2;

    66         if (likely (1 < end - text &&

    67                     (t1 = text[0] - 0x80u) <= 0x3Fu &&

    68                     (t2 = text[1] - 0x80u) <= 0x3Fu))

    69         {

    70           c = ((c&0xFu)<<12) | (t1<<6) | t2;

    71           if (unlikely (c < 0x0800u || hb_in_range<hb_codepoint_t> (c, 0xD800u, 0xDFFFu)))

    72             goto error;

    73           text += 2;

    74         }

    75         else

    76           goto error;

    77       }

    78       else if (hb_in_range<hb_codepoint_t> (c, 0xF0u, 0xF4u)) /* Four-byte */

    79       {

    80         unsigned int t1, t2, t3;

    81         if (likely (2 < end - text &&

    82                     (t1 = text[0] - 0x80u) <= 0x3Fu &&

    83                     (t2 = text[1] - 0x80u) <= 0x3Fu &&

    84                     (t3 = text[2] - 0x80u) <= 0x3Fu))

    85         {

    86           c = ((c&0x7u)<<18) | (t1<<12) | (t2<<6) | t3;

    87           if (unlikely (!hb_in_range<hb_codepoint_t> (c, 0x10000u, 0x10FFFFu)))

    88             goto error;

    89           text += 3;

    90         }

    91         else

    92           goto error;

    93       }

    94       else

    95         goto error;

    96     }

    97 

    98     *unicode = c;

    99     return text;

   100 

   101   error:

   102     *unicode = replacement;

   103     return text;

   104   }

   105 

   106   static inline const uint8_t *

   107   prev (const uint8_t *text,

   108         const uint8_t *start,

   109         hb_codepoint_t *unicode,

   110         hb_codepoint_t replacement)

   111   {

   112     const uint8_t *end = text--;

   113     while (start < text && (*text & 0xc0) == 0x80 && end - text < 4)

   114       text--;

   115 

   116     if (likely (next (text, end, unicode, replacement) == end))

   117       return text;

   118 

   119     *unicode = replacement;

   120     return end - 1;

   121   }

   122 

   123   static inline unsigned int

   124   strlen (const uint8_t *text)

   125   {

   126     return ::strlen ((const char *) text);

   127   }

   128 };

   129 

   130 

   131 struct hb_utf16_t

   132 {

   133   typedef uint16_t codepoint_t;

   134 

   135   static inline const uint16_t *

   136   next (const uint16_t *text,

   137         const uint16_t *end,

   138         hb_codepoint_t *unicode,

   139         hb_codepoint_t replacement)

   140   {

   141     hb_codepoint_t c = *text++;

   142 

   143     if (likely (!hb_in_range<hb_codepoint_t> (c, 0xD800u, 0xDFFFu)))

   144     {

   145       *unicode = c;

   146       return text;

   147     }

   148 

   149     if (likely (c <= 0xDBFFu && text < end))

   150     {

   151       /* High-surrogate in c */

   152       hb_codepoint_t l = *text;

   153       if (likely (hb_in_range<hb_codepoint_t> (l, 0xDC00u, 0xDFFFu)))

   154       {

   155         /* Low-surrogate in l */

   156         *unicode = (c << 10) + l - ((0xD800u << 10) - 0x10000u + 0xDC00u);

   157          text++;

   158          return text;

   159       }

   160     }

   161 

   162     /* Lonely / out-of-order surrogate. */

   163     *unicode = replacement;

   164     return text;

   165   }

   166 

   167   static inline const uint16_t *

   168   prev (const uint16_t *text,

   169         const uint16_t *start,

   170         hb_codepoint_t *unicode,

   171         hb_codepoint_t replacement)

   172   {

   173     hb_codepoint_t c = *--text;

   174 

   175     if (likely (!hb_in_range<hb_codepoint_t> (c, 0xD800u, 0xDFFFu)))

   176     {

   177       *unicode = c;

   178       return text;

   179     }

   180 

   181     if (likely (c >= 0xDC00u && start < text))

   182     {

   183       /* Low-surrogate in c */

   184       hb_codepoint_t h = text[-1];

   185       if (likely (hb_in_range<hb_codepoint_t> (h, 0xD800u, 0xDBFFu)))

   186       {

   187         /* High-surrogate in h */

   188         *unicode = (h << 10) + c - ((0xD800u << 10) - 0x10000u + 0xDC00u);

   189         text--;

   190         return text;

   191       }

   192     }

   193 

   194     /* Lonely / out-of-order surrogate. */

   195     *unicode = replacement;

   196     return text;

   197   }

   198 

   199 

   200   static inline unsigned int

   201   strlen (const uint16_t *text)

   202   {

   203     unsigned int l = 0;

   204     while (*text++) l++;

   205     return l;

   206   }

   207 };

   208 

   209 

   210 template <bool validate=true>

   211 struct hb_utf32_t

   212 {

   213   typedef uint32_t codepoint_t;

   214 

   215   static inline const uint32_t *

   216   next (const uint32_t *text,

   217         const uint32_t *end HB_UNUSED,

   218         hb_codepoint_t *unicode,

   219         hb_codepoint_t replacement)

   220   {

   221     hb_codepoint_t c = *unicode = *text++;

   222     if (validate && unlikely (c >= 0xD800u && (c <= 0xDFFFu || c > 0x10FFFFu)))

   223       *unicode = replacement;

   224     return text;

   225   }

   226 

   227   static inline const uint32_t *

   228   prev (const uint32_t *text,

   229         const uint32_t *start HB_UNUSED,

   230         hb_codepoint_t *unicode,

   231         hb_codepoint_t replacement)

   232   {

   233     hb_codepoint_t c = *unicode = *--text;

   234     if (validate && unlikely (c >= 0xD800u && (c <= 0xDFFFu || c > 0x10FFFFu)))

   235       *unicode = replacement;

   236     return text;

   237   }

   238 

   239   static inline unsigned int

   240   strlen (const uint32_t *text)

   241   {

   242     unsigned int l = 0;

   243     while (*text++) l++;

   244     return l;

   245   }

   246 };

   247 

   248 

   249 struct hb_latin1_t

   250 {

   251   typedef uint8_t codepoint_t;

   252 

   253   static inline const uint8_t *

   254   next (const uint8_t *text,

   255         const uint8_t *end HB_UNUSED,

   256         hb_codepoint_t *unicode,

   257         hb_codepoint_t replacement HB_UNUSED)

   258   {

   259     *unicode = *text++;

   260     return text;

   261   }

   262 

   263   static inline const uint8_t *

   264   prev (const uint8_t *text,

   265         const uint8_t *start HB_UNUSED,

   266         hb_codepoint_t *unicode,

   267         hb_codepoint_t replacement)

   268   {

   269     *unicode = *--text;

   270     return text;

   271   }

   272 

   273   static inline unsigned int

   274   strlen (const uint8_t *text)

   275   {

   276     unsigned int l = 0;

   277     while (*text++) l++;

   278     return l;

   279   }

   280 };

   281 

   282 #endif /* HB_UTF_PRIVATE_HH */