Coverage Report

Created: 2025-12-31 06:37

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/libunistring/lib/unistr/u8-mbtoucr.c
Line
Count
Source
1
/* Look at first character in UTF-8 string, returning an error code.
2
   Copyright (C) 1999-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
int
24
u8_mbtoucr (ucs4_t *puc, const uint8_t *s, size_t n)
25
21.8M
{
26
21.8M
  uint8_t c = *s;
27
28
21.8M
  if (c < 0x80)
29
21.7M
    {
30
21.7M
      *puc = c;
31
21.7M
      return 1;
32
21.7M
    }
33
71.2k
  else if (c >= 0xc2)
34
71.2k
    {
35
71.2k
      if (c < 0xe0)
36
31.9k
        {
37
31.9k
          if (n >= 2)
38
31.9k
            {
39
31.9k
              if ((s[1] ^ 0x80) < 0x40)
40
31.8k
                {
41
31.8k
                  *puc = ((unsigned int) (c & 0x1f) << 6)
42
31.8k
                         | (unsigned int) (s[1] ^ 0x80);
43
31.8k
                  return 2;
44
31.8k
                }
45
              /* invalid multibyte character */
46
31.9k
            }
47
12
          else
48
12
            {
49
              /* incomplete multibyte character */
50
12
              *puc = 0xfffd;
51
12
              return -2;
52
12
            }
53
31.9k
        }
54
39.2k
      else if (c < 0xf0)
55
33.9k
        {
56
33.9k
          if (n >= 2)
57
33.9k
            {
58
33.9k
              if ((s[1] ^ 0x80) < 0x40
59
33.9k
                  && (c >= 0xe1 || s[1] >= 0xa0)
60
33.9k
                  && (c != 0xed || s[1] < 0xa0))
61
33.9k
                {
62
33.9k
                  if (n >= 3)
63
33.8k
                    {
64
33.8k
                      if ((s[2] ^ 0x80) < 0x40)
65
33.8k
                        {
66
33.8k
                          *puc = ((unsigned int) (c & 0x0f) << 12)
67
33.8k
                                 | ((unsigned int) (s[1] ^ 0x80) << 6)
68
33.8k
                                 | (unsigned int) (s[2] ^ 0x80);
69
33.8k
                          return 3;
70
33.8k
                        }
71
                      /* invalid multibyte character */
72
33.8k
                    }
73
34
                  else
74
34
                    {
75
                      /* incomplete multibyte character */
76
34
                      *puc = 0xfffd;
77
34
                      return -2;
78
34
                    }
79
33.9k
                }
80
              /* invalid multibyte character */
81
33.9k
            }
82
10
          else
83
10
            {
84
              /* incomplete multibyte character */
85
10
              *puc = 0xfffd;
86
10
              return -2;
87
10
            }
88
33.9k
        }
89
5.28k
      else if (c <= 0xf4)
90
5.26k
        {
91
5.26k
          if (n >= 2)
92
5.25k
            {
93
5.25k
              if ((s[1] ^ 0x80) < 0x40
94
5.23k
                  && (c >= 0xf1 || s[1] >= 0x90)
95
5.21k
                  && (c < 0xf4 || (/* c == 0xf4 && */ s[1] < 0x90)))
96
5.21k
                {
97
5.21k
                  if (n >= 3)
98
5.18k
                    {
99
5.18k
                      if ((s[2] ^ 0x80) < 0x40)
100
5.14k
                        {
101
5.14k
                          if (n >= 4)
102
5.13k
                            {
103
5.13k
                              if ((s[3] ^ 0x80) < 0x40)
104
5.10k
                                {
105
5.10k
                                  *puc = ((unsigned int) (c & 0x07) << 18)
106
5.10k
                                         | ((unsigned int) (s[1] ^ 0x80) << 12)
107
5.10k
                                         | ((unsigned int) (s[2] ^ 0x80) << 6)
108
5.10k
                                         | (unsigned int) (s[3] ^ 0x80);
109
5.10k
                                  return 4;
110
5.10k
                                }
111
                              /* invalid multibyte character */
112
5.13k
                            }
113
7
                          else
114
7
                            {
115
                              /* incomplete multibyte character */
116
7
                              *puc = 0xfffd;
117
7
                              return -2;
118
7
                            }
119
5.14k
                        }
120
                      /* invalid multibyte character */
121
5.18k
                    }
122
28
                  else
123
28
                    {
124
                      /* incomplete multibyte character */
125
28
                      *puc = 0xfffd;
126
28
                      return -2;
127
28
                    }
128
5.21k
                }
129
              /* invalid multibyte character */
130
5.25k
            }
131
4
          else
132
4
            {
133
              /* incomplete multibyte character */
134
4
              *puc = 0xfffd;
135
4
              return -2;
136
4
            }
137
5.26k
        }
138
71.2k
    }
139
  /* invalid multibyte character */
140
346
  *puc = 0xfffd;
141
346
  return -1;
142
21.8M
}