Coverage Report

Created: 2025-01-28 06:58

/src/gnutls/lib/unistring/uninorm/u-normalize-internal.h
Line
Count
Source (jump to first uncovered line)
1
/* Decomposition and composition of Unicode strings.
2
   Copyright (C) 2009-2025 Free Software Foundation, Inc.
3
   Written by Bruno Haible <bruno@clisp.org>, 2009.
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
UNIT *
19
FUNC (uninorm_t nf, const UNIT *s, size_t n,
20
      UNIT *resultbuf, size_t *lengthp)
21
191k
{
22
191k
  int (*decomposer) (ucs4_t uc, ucs4_t *decomposition) = nf->decomposer;
23
191k
  ucs4_t (*composer) (ucs4_t uc1, ucs4_t uc2) = nf->composer;
24
25
  /* The result being accumulated.  */
26
191k
  UNIT *result;
27
191k
  size_t length;
28
191k
  size_t allocated;
29
  /* The buffer for sorting.  */
30
191k
  #define SORTBUF_PREALLOCATED 64
31
191k
  struct ucs4_with_ccc sortbuf_preallocated[2 * SORTBUF_PREALLOCATED];
32
191k
  struct ucs4_with_ccc *sortbuf; /* array of size 2 * sortbuf_allocated */
33
191k
  size_t sortbuf_allocated;
34
191k
  size_t sortbuf_count;
35
36
  /* Initialize the accumulator.  */
37
191k
  if (resultbuf == NULL)
38
191k
    {
39
191k
      result = NULL;
40
191k
      allocated = 0;
41
191k
    }
42
0
  else
43
0
    {
44
0
      result = resultbuf;
45
0
      allocated = *lengthp;
46
0
    }
47
191k
  length = 0;
48
49
  /* Initialize the buffer for sorting.  */
50
191k
  sortbuf = sortbuf_preallocated;
51
191k
  sortbuf_allocated = SORTBUF_PREALLOCATED;
52
191k
  sortbuf_count = 0;
53
54
191k
  {
55
191k
    const UNIT *s_end = s + n;
56
57
191k
    for (;;)
58
2.14M
      {
59
2.14M
        int count;
60
2.14M
        ucs4_t decomposed[UC_DECOMPOSITION_MAX_LENGTH];
61
2.14M
        int decomposed_count;
62
2.14M
        int i;
63
64
2.14M
        if (s < s_end)
65
1.95M
          {
66
            /* Fetch the next character.  */
67
1.95M
            count = U_MBTOUC_UNSAFE (&decomposed[0], s, s_end - s);
68
1.95M
            decomposed_count = 1;
69
70
            /* Decompose it, recursively.
71
               It would be possible to precompute the recursive decomposition
72
               and store it in a table.  But this would significantly increase
73
               the size of the decomposition tables, because for example for
74
               U+1FC1 the recursive canonical decomposition and the recursive
75
               compatibility decomposition are different.  */
76
1.95M
            {
77
1.95M
              int curr;
78
79
4.17M
              for (curr = 0; curr < decomposed_count; )
80
2.22M
                {
81
                  /* Invariant: decomposed[0..curr-1] is fully decomposed, i.e.
82
                     all elements are atomic.  */
83
2.22M
                  ucs4_t curr_decomposed[UC_DECOMPOSITION_MAX_LENGTH];
84
2.22M
                  int curr_decomposed_count;
85
86
2.22M
                  curr_decomposed_count = decomposer (decomposed[curr], curr_decomposed);
87
2.22M
                  if (curr_decomposed_count >= 0)
88
134k
                    {
89
                      /* Move curr_decomposed[0..curr_decomposed_count-1] over
90
                         decomposed[curr], making room.  It's not worth using
91
                         memcpy() here, since the counts are so small.  */
92
134k
                      int shift = curr_decomposed_count - 1;
93
94
134k
                      if (shift < 0)
95
0
                        abort ();
96
134k
                      if (shift > 0)
97
132k
                        {
98
132k
                          int j;
99
100
132k
                          decomposed_count += shift;
101
132k
                          if (decomposed_count > UC_DECOMPOSITION_MAX_LENGTH)
102
0
                            abort ();
103
146k
                          for (j = decomposed_count - 1 - shift; j > curr; j--)
104
13.5k
                            decomposed[j + shift] = decomposed[j];
105
132k
                        }
106
400k
                      for (; shift >= 0; shift--)
107
266k
                        decomposed[curr + shift] = curr_decomposed[shift];
108
134k
                    }
109
2.08M
                  else
110
2.08M
                    {
111
                      /* decomposed[curr] is atomic.  */
112
2.08M
                      curr++;
113
2.08M
                    }
114
2.22M
                }
115
1.95M
            }
116
1.95M
          }
117
191k
        else
118
191k
          {
119
191k
            count = 0;
120
191k
            decomposed_count = 0;
121
191k
          }
122
123
2.14M
        i = 0;
124
2.14M
        for (;;)
125
4.23M
          {
126
4.23M
            ucs4_t uc;
127
4.23M
            int ccc;
128
129
4.23M
            if (s < s_end)
130
4.04M
              {
131
                /* Fetch the next character from the decomposition.  */
132
4.04M
                if (i == decomposed_count)
133
1.95M
                  break;
134
2.08M
                uc = decomposed[i];
135
2.08M
                ccc = uc_combining_class (uc);
136
2.08M
              }
137
191k
            else
138
191k
              {
139
                /* End of string reached.  */
140
191k
                uc = 0;
141
191k
                ccc = 0;
142
191k
              }
143
144
2.27M
            if (ccc == 0)
145
1.98M
              {
146
1.98M
                size_t j;
147
148
                /* Apply the canonical ordering algorithm to the accumulated
149
                   sequence of characters.  */
150
1.98M
                if (sortbuf_count > 1)
151
108k
                  gl_uninorm_decompose_merge_sort_inplace (sortbuf, sortbuf_count,
152
108k
                                                           sortbuf + sortbuf_count);
153
154
1.98M
                if (composer != NULL)
155
1.98M
                  {
156
                    /* Attempt to combine decomposed characters, as specified
157
                       in the Unicode Standard Annex #15 "Unicode Normalization
158
                       Forms".  We need to check
159
                         1. whether the first accumulated character is a
160
                            "starter" (i.e. has ccc = 0).  This is usually the
161
                            case.  But when the string starts with a
162
                            non-starter, the sortbuf also starts with a
163
                            non-starter.  Btw, this check could also be
164
                            omitted, because the composition table has only
165
                            entries (code1, code2) for which code1 is a
166
                            starter; if the first accumulated character is not
167
                            a starter, no lookup will succeed.
168
                         2. If the sortbuf has more than one character, check
169
                            for each of these characters that are not "blocked"
170
                            from the starter (i.e. have a ccc that is higher
171
                            than the ccc of the previous character) whether it
172
                            can be combined with the first character.
173
                         3. If only one character is left in sortbuf, check
174
                            whether it can be combined with the next character
175
                            (also a starter).  */
176
1.98M
                    if (sortbuf_count > 0 && sortbuf[0].ccc == 0)
177
1.79M
                      {
178
2.02M
                        for (j = 1; j < sortbuf_count; )
179
232k
                          {
180
232k
                            if (sortbuf[j].ccc > sortbuf[j - 1].ccc)
181
126k
                              {
182
126k
                                ucs4_t combined =
183
126k
                                  composer (sortbuf[0].code, sortbuf[j].code);
184
126k
                                if (combined)
185
101k
                                  {
186
101k
                                    size_t k;
187
188
101k
                                    sortbuf[0].code = combined;
189
                                    /* sortbuf[0].ccc = 0, still valid.  */
190
192k
                                    for (k = j + 1; k < sortbuf_count; k++)
191
91.6k
                                      sortbuf[k - 1] = sortbuf[k];
192
101k
                                    sortbuf_count--;
193
101k
                                    continue;
194
101k
                                  }
195
126k
                              }
196
131k
                            j++;
197
131k
                          }
198
1.79M
                        if (s < s_end && sortbuf_count == 1)
199
1.59M
                          {
200
1.59M
                            ucs4_t combined =
201
1.59M
                              composer (sortbuf[0].code, uc);
202
1.59M
                            if (combined)
203
6.94k
                              {
204
6.94k
                                uc = combined;
205
6.94k
                                ccc = 0;
206
                                /* uc could be further combined with subsequent
207
                                   characters.  So don't put it into sortbuf[0] in
208
                                   this round, only in the next round.  */
209
6.94k
                                sortbuf_count = 0;
210
6.94k
                              }
211
1.59M
                          }
212
1.79M
                      }
213
1.98M
                  }
214
215
3.96M
                for (j = 0; j < sortbuf_count; j++)
216
1.97M
                  {
217
1.97M
                    ucs4_t muc = sortbuf[j].code;
218
219
                    /* Append muc to the result accumulator.  */
220
1.97M
                    if (length < allocated)
221
1.78M
                      {
222
1.78M
                        int ret =
223
1.78M
                          U_UCTOMB (result + length, muc, allocated - length);
224
1.78M
                        if (ret == -1)
225
0
                          {
226
0
                            errno = EINVAL;
227
0
                            goto fail;
228
0
                          }
229
1.78M
                        if (ret >= 0)
230
1.78M
                          {
231
1.78M
                            length += ret;
232
1.78M
                            goto done_appending;
233
1.78M
                          }
234
1.78M
                      }
235
197k
                    {
236
197k
                      size_t old_allocated = allocated;
237
197k
                      size_t new_allocated = 2 * old_allocated;
238
197k
                      if (new_allocated < 64)
239
189k
                        new_allocated = 64;
240
197k
                      if (new_allocated < old_allocated) /* integer overflow? */
241
0
                        abort ();
242
197k
                      {
243
197k
                        UNIT *larger_result;
244
197k
                        if (result == NULL)
245
189k
                          {
246
189k
                            larger_result =
247
189k
                              (UNIT *) malloc (new_allocated * sizeof (UNIT));
248
189k
                            if (larger_result == NULL)
249
0
                              {
250
0
                                errno = ENOMEM;
251
0
                                goto fail;
252
0
                              }
253
189k
                          }
254
7.76k
                        else if (result == resultbuf)
255
0
                          {
256
0
                            larger_result =
257
0
                              (UNIT *) malloc (new_allocated * sizeof (UNIT));
258
0
                            if (larger_result == NULL)
259
0
                              {
260
0
                                errno = ENOMEM;
261
0
                                goto fail;
262
0
                              }
263
0
                            U_CPY (larger_result, resultbuf, length);
264
0
                          }
265
7.76k
                        else
266
7.76k
                          {
267
7.76k
                            larger_result =
268
7.76k
                              (UNIT *) realloc (result, new_allocated * sizeof (UNIT));
269
7.76k
                            if (larger_result == NULL)
270
0
                              {
271
0
                                errno = ENOMEM;
272
0
                                goto fail;
273
0
                              }
274
7.76k
                          }
275
197k
                        result = larger_result;
276
197k
                        allocated = new_allocated;
277
197k
                        {
278
197k
                          int ret =
279
197k
                            U_UCTOMB (result + length, muc, allocated - length);
280
197k
                          if (ret == -1)
281
0
                            {
282
0
                              errno = EINVAL;
283
0
                              goto fail;
284
0
                            }
285
197k
                          if (ret < 0)
286
0
                            abort ();
287
197k
                          length += ret;
288
197k
                          goto done_appending;
289
197k
                        }
290
197k
                      }
291
197k
                    }
292
1.97M
                   done_appending: ;
293
1.97M
                  }
294
295
                /* sortbuf is now empty.  */
296
1.98M
                sortbuf_count = 0;
297
1.98M
              }
298
299
2.27M
            if (!(s < s_end))
300
              /* End of string reached.  */
301
191k
              break;
302
303
            /* Append (uc, ccc) to sortbuf.  */
304
2.08M
            if (sortbuf_count == sortbuf_allocated)
305
1.46k
              {
306
1.46k
                struct ucs4_with_ccc *new_sortbuf;
307
308
1.46k
                sortbuf_allocated = 2 * sortbuf_allocated;
309
1.46k
                if (sortbuf_allocated < sortbuf_count) /* integer overflow? */
310
0
                  abort ();
311
1.46k
                new_sortbuf =
312
1.46k
                  (struct ucs4_with_ccc *) malloc (2 * sortbuf_allocated * sizeof (struct ucs4_with_ccc));
313
1.46k
                if (new_sortbuf == NULL)
314
0
                  {
315
0
                    errno = ENOMEM;
316
0
                    goto fail;
317
0
                  }
318
1.46k
                memcpy (new_sortbuf, sortbuf,
319
1.46k
                        sortbuf_count * sizeof (struct ucs4_with_ccc));
320
1.46k
                if (sortbuf != sortbuf_preallocated)
321
375
                  free (sortbuf);
322
1.46k
                sortbuf = new_sortbuf;
323
1.46k
              }
324
2.08M
            sortbuf[sortbuf_count].code = uc;
325
2.08M
            sortbuf[sortbuf_count].ccc = ccc;
326
2.08M
            sortbuf_count++;
327
328
2.08M
            i++;
329
2.08M
          }
330
331
2.14M
        if (!(s < s_end))
332
          /* End of string reached.  */
333
191k
          break;
334
335
1.95M
        s += count;
336
1.95M
      }
337
191k
  }
338
339
191k
  if (length == 0)
340
2.03k
    {
341
2.03k
      if (result == NULL)
342
2.03k
        {
343
          /* Return a non-NULL value.  NULL means error.  */
344
2.03k
          result = (UNIT *) malloc (1);
345
2.03k
          if (result == NULL)
346
0
            {
347
0
              errno = ENOMEM;
348
0
              goto fail;
349
0
            }
350
2.03k
        }
351
2.03k
    }
352
189k
  else if (result != resultbuf && length < allocated)
353
187k
    {
354
      /* Shrink the allocated memory if possible.  */
355
187k
      UNIT *memory;
356
357
187k
      memory = (UNIT *) realloc (result, length * sizeof (UNIT));
358
187k
      if (memory != NULL)
359
187k
        result = memory;
360
187k
    }
361
362
191k
  if (sortbuf_count > 0)
363
0
    abort ();
364
191k
  if (sortbuf != sortbuf_preallocated)
365
1.08k
    free (sortbuf);
366
367
191k
  *lengthp = length;
368
191k
  return result;
369
370
0
 fail:
371
0
  {
372
0
    int saved_errno = errno;
373
0
    if (sortbuf != sortbuf_preallocated)
374
0
      free (sortbuf);
375
0
    if (result != resultbuf)
376
0
      free (result);
377
0
    errno = saved_errno;
378
0
  }
379
0
  return NULL;
380
191k
}
Unexecuted instantiation: u16_normalize
u32_normalize
Line
Count
Source
21
191k
{
22
191k
  int (*decomposer) (ucs4_t uc, ucs4_t *decomposition) = nf->decomposer;
23
191k
  ucs4_t (*composer) (ucs4_t uc1, ucs4_t uc2) = nf->composer;
24
25
  /* The result being accumulated.  */
26
191k
  UNIT *result;
27
191k
  size_t length;
28
191k
  size_t allocated;
29
  /* The buffer for sorting.  */
30
191k
  #define SORTBUF_PREALLOCATED 64
31
191k
  struct ucs4_with_ccc sortbuf_preallocated[2 * SORTBUF_PREALLOCATED];
32
191k
  struct ucs4_with_ccc *sortbuf; /* array of size 2 * sortbuf_allocated */
33
191k
  size_t sortbuf_allocated;
34
191k
  size_t sortbuf_count;
35
36
  /* Initialize the accumulator.  */
37
191k
  if (resultbuf == NULL)
38
191k
    {
39
191k
      result = NULL;
40
191k
      allocated = 0;
41
191k
    }
42
0
  else
43
0
    {
44
0
      result = resultbuf;
45
0
      allocated = *lengthp;
46
0
    }
47
191k
  length = 0;
48
49
  /* Initialize the buffer for sorting.  */
50
191k
  sortbuf = sortbuf_preallocated;
51
191k
  sortbuf_allocated = SORTBUF_PREALLOCATED;
52
191k
  sortbuf_count = 0;
53
54
191k
  {
55
191k
    const UNIT *s_end = s + n;
56
57
191k
    for (;;)
58
2.14M
      {
59
2.14M
        int count;
60
2.14M
        ucs4_t decomposed[UC_DECOMPOSITION_MAX_LENGTH];
61
2.14M
        int decomposed_count;
62
2.14M
        int i;
63
64
2.14M
        if (s < s_end)
65
1.95M
          {
66
            /* Fetch the next character.  */
67
1.95M
            count = U_MBTOUC_UNSAFE (&decomposed[0], s, s_end - s);
68
1.95M
            decomposed_count = 1;
69
70
            /* Decompose it, recursively.
71
               It would be possible to precompute the recursive decomposition
72
               and store it in a table.  But this would significantly increase
73
               the size of the decomposition tables, because for example for
74
               U+1FC1 the recursive canonical decomposition and the recursive
75
               compatibility decomposition are different.  */
76
1.95M
            {
77
1.95M
              int curr;
78
79
4.17M
              for (curr = 0; curr < decomposed_count; )
80
2.22M
                {
81
                  /* Invariant: decomposed[0..curr-1] is fully decomposed, i.e.
82
                     all elements are atomic.  */
83
2.22M
                  ucs4_t curr_decomposed[UC_DECOMPOSITION_MAX_LENGTH];
84
2.22M
                  int curr_decomposed_count;
85
86
2.22M
                  curr_decomposed_count = decomposer (decomposed[curr], curr_decomposed);
87
2.22M
                  if (curr_decomposed_count >= 0)
88
134k
                    {
89
                      /* Move curr_decomposed[0..curr_decomposed_count-1] over
90
                         decomposed[curr], making room.  It's not worth using
91
                         memcpy() here, since the counts are so small.  */
92
134k
                      int shift = curr_decomposed_count - 1;
93
94
134k
                      if (shift < 0)
95
0
                        abort ();
96
134k
                      if (shift > 0)
97
132k
                        {
98
132k
                          int j;
99
100
132k
                          decomposed_count += shift;
101
132k
                          if (decomposed_count > UC_DECOMPOSITION_MAX_LENGTH)
102
0
                            abort ();
103
146k
                          for (j = decomposed_count - 1 - shift; j > curr; j--)
104
13.5k
                            decomposed[j + shift] = decomposed[j];
105
132k
                        }
106
400k
                      for (; shift >= 0; shift--)
107
266k
                        decomposed[curr + shift] = curr_decomposed[shift];
108
134k
                    }
109
2.08M
                  else
110
2.08M
                    {
111
                      /* decomposed[curr] is atomic.  */
112
2.08M
                      curr++;
113
2.08M
                    }
114
2.22M
                }
115
1.95M
            }
116
1.95M
          }
117
191k
        else
118
191k
          {
119
191k
            count = 0;
120
191k
            decomposed_count = 0;
121
191k
          }
122
123
2.14M
        i = 0;
124
2.14M
        for (;;)
125
4.23M
          {
126
4.23M
            ucs4_t uc;
127
4.23M
            int ccc;
128
129
4.23M
            if (s < s_end)
130
4.04M
              {
131
                /* Fetch the next character from the decomposition.  */
132
4.04M
                if (i == decomposed_count)
133
1.95M
                  break;
134
2.08M
                uc = decomposed[i];
135
2.08M
                ccc = uc_combining_class (uc);
136
2.08M
              }
137
191k
            else
138
191k
              {
139
                /* End of string reached.  */
140
191k
                uc = 0;
141
191k
                ccc = 0;
142
191k
              }
143
144
2.27M
            if (ccc == 0)
145
1.98M
              {
146
1.98M
                size_t j;
147
148
                /* Apply the canonical ordering algorithm to the accumulated
149
                   sequence of characters.  */
150
1.98M
                if (sortbuf_count > 1)
151
108k
                  gl_uninorm_decompose_merge_sort_inplace (sortbuf, sortbuf_count,
152
108k
                                                           sortbuf + sortbuf_count);
153
154
1.98M
                if (composer != NULL)
155
1.98M
                  {
156
                    /* Attempt to combine decomposed characters, as specified
157
                       in the Unicode Standard Annex #15 "Unicode Normalization
158
                       Forms".  We need to check
159
                         1. whether the first accumulated character is a
160
                            "starter" (i.e. has ccc = 0).  This is usually the
161
                            case.  But when the string starts with a
162
                            non-starter, the sortbuf also starts with a
163
                            non-starter.  Btw, this check could also be
164
                            omitted, because the composition table has only
165
                            entries (code1, code2) for which code1 is a
166
                            starter; if the first accumulated character is not
167
                            a starter, no lookup will succeed.
168
                         2. If the sortbuf has more than one character, check
169
                            for each of these characters that are not "blocked"
170
                            from the starter (i.e. have a ccc that is higher
171
                            than the ccc of the previous character) whether it
172
                            can be combined with the first character.
173
                         3. If only one character is left in sortbuf, check
174
                            whether it can be combined with the next character
175
                            (also a starter).  */
176
1.98M
                    if (sortbuf_count > 0 && sortbuf[0].ccc == 0)
177
1.79M
                      {
178
2.02M
                        for (j = 1; j < sortbuf_count; )
179
232k
                          {
180
232k
                            if (sortbuf[j].ccc > sortbuf[j - 1].ccc)
181
126k
                              {
182
126k
                                ucs4_t combined =
183
126k
                                  composer (sortbuf[0].code, sortbuf[j].code);
184
126k
                                if (combined)
185
101k
                                  {
186
101k
                                    size_t k;
187
188
101k
                                    sortbuf[0].code = combined;
189
                                    /* sortbuf[0].ccc = 0, still valid.  */
190
192k
                                    for (k = j + 1; k < sortbuf_count; k++)
191
91.6k
                                      sortbuf[k - 1] = sortbuf[k];
192
101k
                                    sortbuf_count--;
193
101k
                                    continue;
194
101k
                                  }
195
126k
                              }
196
131k
                            j++;
197
131k
                          }
198
1.79M
                        if (s < s_end && sortbuf_count == 1)
199
1.59M
                          {
200
1.59M
                            ucs4_t combined =
201
1.59M
                              composer (sortbuf[0].code, uc);
202
1.59M
                            if (combined)
203
6.94k
                              {
204
6.94k
                                uc = combined;
205
6.94k
                                ccc = 0;
206
                                /* uc could be further combined with subsequent
207
                                   characters.  So don't put it into sortbuf[0] in
208
                                   this round, only in the next round.  */
209
6.94k
                                sortbuf_count = 0;
210
6.94k
                              }
211
1.59M
                          }
212
1.79M
                      }
213
1.98M
                  }
214
215
3.96M
                for (j = 0; j < sortbuf_count; j++)
216
1.97M
                  {
217
1.97M
                    ucs4_t muc = sortbuf[j].code;
218
219
                    /* Append muc to the result accumulator.  */
220
1.97M
                    if (length < allocated)
221
1.78M
                      {
222
1.78M
                        int ret =
223
1.78M
                          U_UCTOMB (result + length, muc, allocated - length);
224
1.78M
                        if (ret == -1)
225
0
                          {
226
0
                            errno = EINVAL;
227
0
                            goto fail;
228
0
                          }
229
1.78M
                        if (ret >= 0)
230
1.78M
                          {
231
1.78M
                            length += ret;
232
1.78M
                            goto done_appending;
233
1.78M
                          }
234
1.78M
                      }
235
197k
                    {
236
197k
                      size_t old_allocated = allocated;
237
197k
                      size_t new_allocated = 2 * old_allocated;
238
197k
                      if (new_allocated < 64)
239
189k
                        new_allocated = 64;
240
197k
                      if (new_allocated < old_allocated) /* integer overflow? */
241
0
                        abort ();
242
197k
                      {
243
197k
                        UNIT *larger_result;
244
197k
                        if (result == NULL)
245
189k
                          {
246
189k
                            larger_result =
247
189k
                              (UNIT *) malloc (new_allocated * sizeof (UNIT));
248
189k
                            if (larger_result == NULL)
249
0
                              {
250
0
                                errno = ENOMEM;
251
0
                                goto fail;
252
0
                              }
253
189k
                          }
254
7.76k
                        else if (result == resultbuf)
255
0
                          {
256
0
                            larger_result =
257
0
                              (UNIT *) malloc (new_allocated * sizeof (UNIT));
258
0
                            if (larger_result == NULL)
259
0
                              {
260
0
                                errno = ENOMEM;
261
0
                                goto fail;
262
0
                              }
263
0
                            U_CPY (larger_result, resultbuf, length);
264
0
                          }
265
7.76k
                        else
266
7.76k
                          {
267
7.76k
                            larger_result =
268
7.76k
                              (UNIT *) realloc (result, new_allocated * sizeof (UNIT));
269
7.76k
                            if (larger_result == NULL)
270
0
                              {
271
0
                                errno = ENOMEM;
272
0
                                goto fail;
273
0
                              }
274
7.76k
                          }
275
197k
                        result = larger_result;
276
197k
                        allocated = new_allocated;
277
197k
                        {
278
197k
                          int ret =
279
197k
                            U_UCTOMB (result + length, muc, allocated - length);
280
197k
                          if (ret == -1)
281
0
                            {
282
0
                              errno = EINVAL;
283
0
                              goto fail;
284
0
                            }
285
197k
                          if (ret < 0)
286
0
                            abort ();
287
197k
                          length += ret;
288
197k
                          goto done_appending;
289
197k
                        }
290
197k
                      }
291
197k
                    }
292
1.97M
                   done_appending: ;
293
1.97M
                  }
294
295
                /* sortbuf is now empty.  */
296
1.98M
                sortbuf_count = 0;
297
1.98M
              }
298
299
2.27M
            if (!(s < s_end))
300
              /* End of string reached.  */
301
191k
              break;
302
303
            /* Append (uc, ccc) to sortbuf.  */
304
2.08M
            if (sortbuf_count == sortbuf_allocated)
305
1.46k
              {
306
1.46k
                struct ucs4_with_ccc *new_sortbuf;
307
308
1.46k
                sortbuf_allocated = 2 * sortbuf_allocated;
309
1.46k
                if (sortbuf_allocated < sortbuf_count) /* integer overflow? */
310
0
                  abort ();
311
1.46k
                new_sortbuf =
312
1.46k
                  (struct ucs4_with_ccc *) malloc (2 * sortbuf_allocated * sizeof (struct ucs4_with_ccc));
313
1.46k
                if (new_sortbuf == NULL)
314
0
                  {
315
0
                    errno = ENOMEM;
316
0
                    goto fail;
317
0
                  }
318
1.46k
                memcpy (new_sortbuf, sortbuf,
319
1.46k
                        sortbuf_count * sizeof (struct ucs4_with_ccc));
320
1.46k
                if (sortbuf != sortbuf_preallocated)
321
375
                  free (sortbuf);
322
1.46k
                sortbuf = new_sortbuf;
323
1.46k
              }
324
2.08M
            sortbuf[sortbuf_count].code = uc;
325
2.08M
            sortbuf[sortbuf_count].ccc = ccc;
326
2.08M
            sortbuf_count++;
327
328
2.08M
            i++;
329
2.08M
          }
330
331
2.14M
        if (!(s < s_end))
332
          /* End of string reached.  */
333
191k
          break;
334
335
1.95M
        s += count;
336
1.95M
      }
337
191k
  }
338
339
191k
  if (length == 0)
340
2.03k
    {
341
2.03k
      if (result == NULL)
342
2.03k
        {
343
          /* Return a non-NULL value.  NULL means error.  */
344
2.03k
          result = (UNIT *) malloc (1);
345
2.03k
          if (result == NULL)
346
0
            {
347
0
              errno = ENOMEM;
348
0
              goto fail;
349
0
            }
350
2.03k
        }
351
2.03k
    }
352
189k
  else if (result != resultbuf && length < allocated)
353
187k
    {
354
      /* Shrink the allocated memory if possible.  */
355
187k
      UNIT *memory;
356
357
187k
      memory = (UNIT *) realloc (result, length * sizeof (UNIT));
358
187k
      if (memory != NULL)
359
187k
        result = memory;
360
187k
    }
361
362
191k
  if (sortbuf_count > 0)
363
0
    abort ();
364
191k
  if (sortbuf != sortbuf_preallocated)
365
1.08k
    free (sortbuf);
366
367
191k
  *lengthp = length;
368
191k
  return result;
369
370
0
 fail:
371
0
  {
372
0
    int saved_errno = errno;
373
0
    if (sortbuf != sortbuf_preallocated)
374
0
      free (sortbuf);
375
0
    if (result != resultbuf)
376
0
      free (result);
377
0
    errno = saved_errno;
378
0
  }
379
0
  return NULL;
380
191k
}