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
22.8M
{
43
22.8M
  uint32_t value;
44
45
22.8M
  if (c <= 0xFF)
46
14.9M
    {
47
14.9M
      map->cp1 = *p++;
48
14.9M
      map->range = *p++;
49
14.9M
    }
50
7.96M
  else if (c <= 0xFFFF)
51
7.72M
    {
52
7.72M
      map->cp1 = (p[0] << 8) | p[1];
53
7.72M
      map->range = (p[2] << 8) | p[3];
54
7.72M
      p += 4;
55
7.72M
    }
56
241k
  else
57
241k
    {
58
241k
      map->cp1 = (p[0] << 16) | (p[1] << 8) | p[2];
59
241k
      map->range = (p[3] << 8) | p[4];
60
241k
      p += 5;
61
241k
    }
62
63
22.8M
  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
22.8M
  map->flag_index = value & 0x7;
68
22.8M
  map->offset = (value >> 3) & 0x3FFF;
69
22.8M
  map->nmappings = (value >> 17) & 0x1F;
70
22.8M
}
71
72
static int
73
_compare_idna_map (const uint32_t *c, const uint8_t *p)
74
20.2M
{
75
20.2M
  IDNAMap map;
76
77
20.2M
  _fill_map (*c, p, &map);
78
79
20.2M
  if (*c < map.cp1)
80
10.1M
    return -1;
81
10.0M
  if (*c > map.cp1 + map.range)
82
7.39M
    return 1;
83
2.66M
  return 0;
84
10.0M
}
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
2.66M
{
107
2.66M
  uint8_t *p;
108
109
2.66M
  if (c <= 0xFF)
110
2.03M
    p =
111
2.03M
      (uint8_t *) bsearch (&c, idna_map_8, sizeof (idna_map_8) / 5, 5,
112
2.03M
         (int (*)(const void *, const void *))
113
2.03M
         _compare_idna_map);
114
627k
  else if (c <= 0xFFFF)
115
606k
    p =
116
606k
      (uint8_t *) bsearch (&c, idna_map_16, sizeof (idna_map_16) / 7, 7,
117
606k
         (int (*)(const void *, const void *))
118
606k
         _compare_idna_map);
119
20.2k
  else if (c <= 0xFFFFFF)
120
20.2k
    p =
121
20.2k
      (uint8_t *) bsearch (&c, idna_map_24, sizeof (idna_map_24) / 8, 8,
122
20.2k
         (int (*)(const void *, const void *))
123
20.2k
         _compare_idna_map);
124
0
  else
125
0
    p = NULL;
126
127
2.66M
  if (!p)
128
0
    {
129
0
      memset (map, 0, sizeof (IDNAMap));
130
0
      return -1;
131
0
    }
132
133
2.66M
  _fill_map (c, p, map);
134
2.66M
  return 0;
135
2.66M
}
136
137
int
138
map_is (const IDNAMap *map, unsigned flags)
139
6.37M
{
140
6.37M
  return (idna_flags[map->flag_index] & flags) == flags;
141
6.37M
}
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
237k
{
166
237k
  int n = map->nmappings;
167
237k
  const uint8_t *src = mapdata + map->offset;
168
169
711k
  for (; n > 0; n--)
170
473k
    {
171
473k
      uint32_t cp = 0;
172
473k
      do
173
722k
  cp = (cp << 7) | (*src & 0x7F);
174
722k
      while (*src++ & 0x80);
175
473k
      *dst++ = cp;
176
473k
    }
177
178
237k
  return map->nmappings;
179
237k
}