/src/libunistring/lib/unistr/u8-mbtouc-unsafe-aux.c

Source (jump to first uncovered line)
/* Conversion UTF-8 to UCS-4.
   Copyright (C) 2001-2002, 2006-2007, 2009-2025 Free Software Foundation, Inc.
   Written by Bruno Haible <bruno@clisp.org>, 2001.

   This file is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as
   published by the Free Software Foundation; either version 2.1 of the
   License, or (at your option) any later version.

   This file is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */

#include <config.h>

/* Specification.  */
#include "unistr.h"

#if defined IN_LIBUNISTRING || HAVE_INLINE

int
u8_mbtouc_unsafe_aux (ucs4_t *puc, const uint8_t *s, size_t n)
{
  uint8_t c = *s;

  if (c >= 0xc2)
    {
      if (c < 0xe0)
        {
          if (n >= 2)
            {
              if ((s[1] ^ 0x80) < 0x40)
                {
                  *puc = ((unsigned int) (c & 0x1f) << 6)
                         | (unsigned int) (s[1] ^ 0x80);
                  return 2;
                }
              /* invalid multibyte character */
            }
          else
            {
              /* incomplete multibyte character */
              *puc = 0xfffd;
              return 1;
            }
        }
      else if (c < 0xf0)
        {
          if (n >= 3)
            {
              if ((s[1] ^ 0x80) < 0x40)
                {
                  if ((s[2] ^ 0x80) < 0x40)
                    {
                      if ((c >= 0xe1 || s[1] >= 0xa0)
                          && (c != 0xed || s[1] < 0xa0))
                        {
                          *puc = ((unsigned int) (c & 0x0f) << 12)
                                 | ((unsigned int) (s[1] ^ 0x80) << 6)
                                 | (unsigned int) (s[2] ^ 0x80);
                          return 3;
                        }
                      /* invalid multibyte character */
                      *puc = 0xfffd;
                      return 3;
                    }
                  /* invalid multibyte character */
                  *puc = 0xfffd;
                  return 2;
                }
              /* invalid multibyte character */
            }
          else
            {
              /* incomplete multibyte character */
              *puc = 0xfffd;
              if (n == 1 || (s[1] ^ 0x80) >= 0x40)
                return 1;
              else
                return 2;
            }
        }
      else if (c < 0xf8)
        {
          if (n >= 4)
            {
              if ((s[1] ^ 0x80) < 0x40)
                {
                  if ((s[2] ^ 0x80) < 0x40)
                    {
                      if ((s[3] ^ 0x80) < 0x40)
                        {
                          if ((c >= 0xf1 || s[1] >= 0x90)
                              && (c < 0xf4 || (c == 0xf4 && s[1] < 0x90))
                             )
                            {
                              *puc = ((unsigned int) (c & 0x07) << 18)
                                     | ((unsigned int) (s[1] ^ 0x80) << 12)
                                     | ((unsigned int) (s[2] ^ 0x80) << 6)
                                     | (unsigned int) (s[3] ^ 0x80);
                              return 4;
                            }
                          /* invalid multibyte character */
                          *puc = 0xfffd;
                          return 4;
                        }
                      /* invalid multibyte character */
                      *puc = 0xfffd;
                      return 3;
                    }
                  /* invalid multibyte character */
                  *puc = 0xfffd;
                  return 2;
                }
              /* invalid multibyte character */
            }
          else
            {
              /* incomplete multibyte character */
              *puc = 0xfffd;
              if (n == 1 || (s[1] ^ 0x80) >= 0x40)
                return 1;
              else if (n == 2 || (s[2] ^ 0x80) >= 0x40)
                return 2;
              else
                return 3;
            }
        }
    }
  /* invalid multibyte character */
  *puc = 0xfffd;
  return 1;
}

#endif

Line	Count	Source (jump to first uncovered line)
1		/* Conversion UTF-8 to UCS-4.
2		Copyright (C) 2001-2002, 2006-2007, 2009-2025 Free Software Foundation, Inc.
3		Written by Bruno Haible <bruno@clisp.org>, 2001.
4
5		This file is free software: you can redistribute it and/or modify
6		it under the terms of the GNU Lesser General Public License as
7		published by the Free Software Foundation; either version 2.1 of the
8		License, or (at your option) any later version.
9
10		This file is distributed in the hope that it will be useful,
11		but WITHOUT ANY WARRANTY; without even the implied warranty of
12		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13		GNU Lesser General Public License for more details.
14
15		You should have received a copy of the GNU Lesser General Public License
16		along with this program. If not, see <https://www.gnu.org/licenses/>. */
17
18		#include <config.h>
19
20		/* Specification. */
21		#include "unistr.h"
22
23		#if defined IN_LIBUNISTRING \|\| HAVE_INLINE
24
25		int
26		u8_mbtouc_unsafe_aux (ucs4_t puc, const uint8_t s, size_t n)
27	23.6M	{
28	23.6M	uint8_t c = *s;
29
30	23.6M	if (c >= 0xc2)
31	22.5M	{
32	22.5M	if (c < 0xe0)
33	19.2M	{
34	19.2M	if (n >= 2)
35	19.2M	{
36	19.2M	if ((s[1] ^ 0x80) < 0x40)
37	18.8M	{
38	18.8M	*puc = ((unsigned int) (c & 0x1f) << 6)
39	18.8M	\| (unsigned int) (s[1] ^ 0x80);
40	18.8M	return 2;
41	18.8M	}
42		/* invalid multibyte character */
43	19.2M	}
44	0	else
45	0	{
46		/* incomplete multibyte character */
47	0	*puc = 0xfffd;
48	0	return 1;
49	0	}
50	19.2M	}
51	3.27M	else if (c < 0xf0)
52	2.95M	{
53	2.95M	if (n >= 3)
54	2.95M	{
55	2.95M	if ((s[1] ^ 0x80) < 0x40)
56	2.85M	{
57	2.85M	if ((s[2] ^ 0x80) < 0x40)
58	2.83M	{
59	2.83M	if ((c >= 0xe1 \|\| s[1] >= 0xa0)
60	2.83M	&& (c != 0xed \|\| s[1] < 0xa0))
61	2.83M	{
62	2.83M	*puc = ((unsigned int) (c & 0x0f) << 12)
63	2.83M	\| ((unsigned int) (s[1] ^ 0x80) << 6)
64	2.83M	\| (unsigned int) (s[2] ^ 0x80);
65	2.83M	return 3;
66	2.83M	}
67		/* invalid multibyte character */
68	1.14k	*puc = 0xfffd;
69	1.14k	return 3;
70	2.83M	}
71		/* invalid multibyte character */
72	25.9k	*puc = 0xfffd;
73	25.9k	return 2;
74	2.85M	}
75		/* invalid multibyte character */
76	2.95M	}
77	4.89k	else
78	4.89k	{
79		/* incomplete multibyte character */
80	4.89k	*puc = 0xfffd;
81	4.89k	if (n == 1 \|\| (s[1] ^ 0x80) >= 0x40)
82	4.89k	return 1;
83	0	else
84	0	return 2;
85	4.89k	}
86	2.95M	}
87	318k	else if (c < 0xf8)
88	97.9k	{
89	97.9k	if (n >= 4)
90	93.2k	{
91	93.2k	if ((s[1] ^ 0x80) < 0x40)
92	39.5k	{
93	39.5k	if ((s[2] ^ 0x80) < 0x40)
94	28.2k	{
95	28.2k	if ((s[3] ^ 0x80) < 0x40)
96	25.0k	{
97	25.0k	if ((c >= 0xf1 \|\| s[1] >= 0x90)
98	25.0k	&& (c < 0xf4 \|\| (c == 0xf4 && s[1] < 0x90))
99	25.0k	)
100	23.2k	{
101	23.2k	*puc = ((unsigned int) (c & 0x07) << 18)
102	23.2k	\| ((unsigned int) (s[1] ^ 0x80) << 12)
103	23.2k	\| ((unsigned int) (s[2] ^ 0x80) << 6)
104	23.2k	\| (unsigned int) (s[3] ^ 0x80);
105	23.2k	return 4;
106	23.2k	}
107		/* invalid multibyte character */
108	1.81k	*puc = 0xfffd;
109	1.81k	return 4;
110	25.0k	}
111		/* invalid multibyte character */
112	3.14k	*puc = 0xfffd;
113	3.14k	return 3;
114	28.2k	}
115		/* invalid multibyte character */
116	11.3k	*puc = 0xfffd;
117	11.3k	return 2;
118	39.5k	}
119		/* invalid multibyte character */
120	93.2k	}
121	4.61k	else
122	4.61k	{
123		/* incomplete multibyte character */
124	4.61k	*puc = 0xfffd;
125	4.61k	if (n == 1 \|\| (s[1] ^ 0x80) >= 0x40)
126	3.86k	return 1;
127	743	else if (n == 2 \|\| (s[2] ^ 0x80) >= 0x40)
128	743	return 2;
129	0	else
130	0	return 3;
131	4.61k	}
132	97.9k	}
133	22.5M	}
134		/* invalid multibyte character */
135	1.94M	*puc = 0xfffd;
136	1.94M	return 1;
137	23.6M	}
138
139		#endif

Coverage Report

Created: 2025-08-28 06:41