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 (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 (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 (c, 0xD800u, 0xDFFFu)))

    72             goto error;

    73           text += 2;

    74         }

    75         else

    76           goto error;

    77       }

    78       else if (hb_in_range (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 (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 (c, 0xD800u, 0xDFFFu)))

   144     {

   145       *unicode = c;

   146       return text;

   147     }

   148 

   149     if (likely (hb_in_range (c, 0xD800u, 0xDBFFu)))

   150     {

   151       /* High-surrogate in c */

   152       hb_codepoint_t l;

   153       if (text < end && ((l = *text), likely (hb_in_range (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     const uint16_t *end = text--;

   174     hb_codepoint_t c = *text;

   175 

   176     if (likely (!hb_in_range (c, 0xD800u, 0xDFFFu)))

   177     {

   178       *unicode = c;

   179       return text;

   180     }

   181 

   182     if (likely (start < text && hb_in_range (c, 0xDC00u, 0xDFFFu)))

   183       text--;

   184 

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

   186       return text;

   187 

   188     *unicode = replacement;

   189     return end - 1;

   190   }

   191 

   192 

   193   static inline unsigned int

   194   strlen (const uint16_t *text)

   195   {

   196     unsigned int l = 0;

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

   198     return l;

   199   }

   200 };

   201 

   202 

   203 template <bool validate=true>

   204 struct hb_utf32_t

   205 {

   206   typedef uint32_t codepoint_t;

   207 

   208   static inline const uint32_t *

   209   next (const uint32_t *text,

   210         const uint32_t *end HB_UNUSED,

   211         hb_codepoint_t *unicode,

   212         hb_codepoint_t replacement)

   213   {

   214     hb_codepoint_t c = *text++;

   215     if (validate && unlikely (c > 0x10FFFFu || hb_in_range (c, 0xD800u, 0xDFFFu)))

   216       goto error;

   217     *unicode = c;

   218     return text;

   219 

   220   error:

   221     *unicode = replacement;

   222     return text;

   223   }

   224 

   225   static inline const uint32_t *

   226   prev (const uint32_t *text,

   227         const uint32_t *start HB_UNUSED,

   228         hb_codepoint_t *unicode,

   229         hb_codepoint_t replacement)

   230   {

   231     next (text - 1, text, unicode, replacement);

   232     return text - 1;

   233   }

   234 

   235   static inline unsigned int

   236   strlen (const uint32_t *text)

   237   {

   238     unsigned int l = 0;

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

   240     return l;

   241   }

   242 };

   243 

   244 

   245 struct hb_latin1_t

   246 {

   247   typedef uint8_t codepoint_t;

   248 

   249   static inline const uint8_t *

   250   next (const uint8_t *text,

   251         const uint8_t *end HB_UNUSED,

   252         hb_codepoint_t *unicode,

   253         hb_codepoint_t replacement HB_UNUSED)

   254   {

   255     *unicode = *text++;

   256     return text;

   257   }

   258 

   259   static inline const uint8_t *

   260   prev (const uint8_t *text,

   261         const uint8_t *start HB_UNUSED,

   262         hb_codepoint_t *unicode,

   263         hb_codepoint_t replacement)

   264   {

   265     *unicode = *--text;

   266     return text;

   267   }

   268 

   269   static inline unsigned int

   270   strlen (const uint8_t *text)

   271   {

   272     unsigned int l = 0;

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

   274     return l;

   275   }

   276 };

   277 

   278 #endif /* HB_UTF_PRIVATE_HH */