Coverage Report

Created: 2025-01-28 06:58

/src/libidn2/lib/tr46map.c
Line
Count
Source (jump to first uncovered line)
1
/* tr46map.c - implementation of IDNA2008 TR46 functions
2
   Copyright (C) 2016-2017 Tim Rühsen
3
4
   Libidn2 is free software: you can redistribute it and/or modify it
5
   under the terms of either:
6
7
     * the GNU Lesser General Public License as published by the Free
8
       Software Foundation; either version 3 of the License, or (at
9
       your option) any later version.
10
11
   or
12
13
     * the GNU General Public License as published by the Free
14
       Software Foundation; either version 2 of the License, or (at
15
       your option) any later version.
16
17
   or both in parallel, as here.
18
19
   This program is distributed in the hope that it will be useful,
20
   but WITHOUT ANY WARRANTY; without even the implied warranty of
21
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22
   GNU General Public License for more details.
23
24
   You should have received copies of the GNU General Public License and
25
   the GNU Lesser General Public License along with this program.  If
26
   not, see <http://www.gnu.org/licenses/>.
27
*/
28
29
#include <config.h>
30
31
#include <stdint.h>
32
#include <stdlib.h>   /* bsearch */
33
#include <string.h>   /* memset */
34
35
#include "tr46map.h"
36
#include "tr46map_data.c"
37
38
0
#define countof(a) (sizeof(a)/sizeof(*(a)))
39
40
static void
41
_fill_map (uint32_t c, const uint8_t *p, IDNAMap *map)
42
5.84M
{
43
5.84M
  uint32_t value;
44
45
5.84M
  if (c <= 0xFF)
46
3.93M
    {
47
3.93M
      map->cp1 = *p++;
48
3.93M
      map->range = *p++;
49
3.93M
    }
50
1.90M
  else if (c <= 0xFFFF)
51
1.85M
    {
52
1.85M
      map->cp1 = (p[0] << 8) | p[1];
53
1.85M
      map->range = (p[2] << 8) | p[3];
54
1.85M
      p += 4;
55
1.85M
    }
56
48.7k
  else
57
48.7k
    {
58
48.7k
      map->cp1 = (p[0] << 16) | (p[1] << 8) | p[2];
59
48.7k
      map->range = (p[3] << 8) | p[4];
60
48.7k
      p += 5;
61
48.7k
    }
62
63
5.84M
  value = (p[0] << 16) | (p[1] << 8) | p[2];
64
65
  /* deconstruct value, construction was
66
   *   value = (((map->nmappings << 14) | map->offset) << 3) | map->flag_index; */
67
5.84M
  map->flag_index = value & 0x7;
68
5.84M
  map->offset = (value >> 3) & 0x3FFF;
69
5.84M
  map->nmappings = (value >> 17) & 0x1F;
70
5.84M
}
71
72
static int
73
_compare_idna_map (const uint32_t *c, const uint8_t *p)
74
5.13M
{
75
5.13M
  IDNAMap map;
76
77
5.13M
  _fill_map (*c, p, &map);
78
79
5.13M
  if (*c < map.cp1)
80
2.40M
    return -1;
81
2.73M
  if (*c > map.cp1 + map.range)
82
2.02M
    return 1;
83
704k
  return 0;
84
2.73M
}
85
86
/*
87
static int
88
_compare_idna_map(uint32_t *c, IDNAMap *m2)
89
{
90
  if (*c < m2->cp1)
91
    return -1;
92
  if (*c > m2->cp1 + m2->range)
93
    return 1;
94
  return 0;
95
}
96
97
IDNAMap
98
*get_idna_map(uint32_t c)
99
{
100
  return bsearch(&c, idna_map, countof(idna_map), sizeof(IDNAMap), (int(*)(const void *, const void *))_compare_idna_map);
101
}
102
*/
103
104
int
105
get_idna_map (uint32_t c, IDNAMap *map)
106
704k
{
107
704k
  uint8_t *p;
108
109
704k
  if (c <= 0xFF)
110
551k
    p =
111
551k
      (uint8_t *) bsearch (&c, idna_map_8, sizeof (idna_map_8) / 5, 5,
112
551k
         (int (*)(const void *, const void *))
113
551k
         _compare_idna_map);
114
152k
  else if (c <= 0xFFFF)
115
148k
    p =
116
148k
      (uint8_t *) bsearch (&c, idna_map_16, sizeof (idna_map_16) / 7, 7,
117
148k
         (int (*)(const void *, const void *))
118
148k
         _compare_idna_map);
119
4.04k
  else if (c <= 0xFFFFFF)
120
4.04k
    p =
121
4.04k
      (uint8_t *) bsearch (&c, idna_map_24, sizeof (idna_map_24) / 8, 8,
122
4.04k
         (int (*)(const void *, const void *))
123
4.04k
         _compare_idna_map);
124
0
  else
125
0
    p = NULL;
126
127
704k
  if (!p)
128
0
    {
129
0
      memset (map, 0, sizeof (IDNAMap));
130
0
      return -1;
131
0
    }
132
133
704k
  _fill_map (c, p, map);
134
704k
  return 0;
135
704k
}
136
137
int
138
map_is (const IDNAMap *map, unsigned flags)
139
1.71M
{
140
1.71M
  return (idna_flags[map->flag_index] & flags) == flags;
141
1.71M
}
142
143
static int G_GNUC_IDN2_ATTRIBUTE_PURE
144
_compare_nfcqc_map (uint32_t *c, NFCQCMap *m2)
145
0
{
146
0
  if (*c < m2->cp1)
147
0
    return -1;
148
0
  if (*c > m2->cp2)
149
0
    return 1;
150
0
  return 0;
151
0
}
152
153
NFCQCMap *
154
get_nfcqc_map (uint32_t c)
155
0
{
156
0
  return (NFCQCMap *) bsearch (&c, nfcqc_map, countof (nfcqc_map),
157
0
             sizeof (NFCQCMap),
158
0
             (int (*)(const void *, const void *))
159
0
             _compare_nfcqc_map);
160
0
}
161
162
/* copy 'n' codepoints from mapdata stream */
163
int
164
get_map_data (uint32_t *dst, const IDNAMap *map)
165
39.6k
{
166
39.6k
  int n = map->nmappings;
167
39.6k
  const uint8_t *src = mapdata + map->offset;
168
169
131k
  for (; n > 0; n--)
170
91.6k
    {
171
91.6k
      uint32_t cp = 0;
172
91.6k
      do
173
152k
  cp = (cp << 7) | (*src & 0x7F);
174
152k
      while (*src++ & 0x80);
175
91.6k
      *dst++ = cp;
176
91.6k
    }
177
178
39.6k
  return map->nmappings;
179
39.6k
}