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