aboutsummaryrefslogtreecommitdiffstats
path: root/contrib/libs/icu/common/ucmndata.cpp
blob: cff4525f9a34d0f00cc0039bbaa67936229d3ad2 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
// © 2016 and later: Unicode, Inc. and others. 
// License & terms of use: http://www.unicode.org/copyright.html 
/* 
****************************************************************************** 
* 
*   Copyright (C) 1999-2011, International Business Machines 
*   Corporation and others.  All Rights Reserved. 
* 
******************************************************************************/ 
 
 
/*------------------------------------------------------------------------------ 
 * 
 *   UCommonData   An abstract interface for dealing with ICU Common Data Files. 
 *                 ICU Common Data Files are a grouping of a number of individual 
 *                 data items (resources, converters, tables, anything) into a 
 *                 single file or dll.  The combined format includes a table of 
 *                 contents for locating the individual items by name. 
 * 
 *                 Two formats for the table of contents are supported, which is 
 *                 why there is an abstract inteface involved. 
 * 
 */ 
 
#include "unicode/utypes.h" 
#include "unicode/udata.h" 
#include "cstring.h" 
#include "ucmndata.h" 
#include "udatamem.h" 
 
#if defined(UDATA_DEBUG) || defined(UDATA_DEBUG_DUMP) 
#   include <stdio.h> 
#endif 
 
U_CFUNC uint16_t 
udata_getHeaderSize(const DataHeader *udh) { 
    if(udh==NULL) { 
        return 0; 
    } else if(udh->info.isBigEndian==U_IS_BIG_ENDIAN) { 
        /* same endianness */ 
        return udh->dataHeader.headerSize; 
    } else { 
        /* opposite endianness */ 
        uint16_t x=udh->dataHeader.headerSize; 
        return (uint16_t)((x<<8)|(x>>8)); 
    } 
} 
 
U_CFUNC uint16_t 
udata_getInfoSize(const UDataInfo *info) { 
    if(info==NULL) { 
        return 0; 
    } else if(info->isBigEndian==U_IS_BIG_ENDIAN) { 
        /* same endianness */ 
        return info->size; 
    } else { 
        /* opposite endianness */ 
        uint16_t x=info->size; 
        return (uint16_t)((x<<8)|(x>>8)); 
    } 
} 
 
/*-----------------------------------------------------------------------------* 
 *                                                                             * 
 *  Pointer TOCs.   TODO: This form of table-of-contents should be removed     * 
 *                  because DLLs must be relocated on loading to correct the   * 
 *                  pointer values and this operation makes shared memory      * 
 *                  mapping of the data much less likely to work.              * 
 *                                                                             * 
 *-----------------------------------------------------------------------------*/ 
typedef struct { 
    const char       *entryName; 
    const DataHeader *pHeader; 
} PointerTOCEntry; 
 
 
typedef struct  { 
    uint32_t          count; 
    uint32_t          reserved; 
    /** 
     * Variable-length array declared with length 1 to disable bounds checkers. 
     * The actual array length is in the count field. 
     */ 
    PointerTOCEntry   entry[1]; 
}  PointerTOC; 
 
 
/* definition of OffsetTOC struct types moved to ucmndata.h */ 
 
/*-----------------------------------------------------------------------------* 
 *                                                                             * 
 *    entry point lookup implementations                                       * 
 *                                                                             * 
 *-----------------------------------------------------------------------------*/ 
 
#ifndef MIN 
#define MIN(a,b) (((a)<(b)) ? (a) : (b)) 
#endif 
 
/** 
 * Compare strings where we know the shared prefix length, 
 * and advance the prefix length as we find that the strings share even more characters. 
 */ 
static int32_t 
strcmpAfterPrefix(const char *s1, const char *s2, int32_t *pPrefixLength) { 
    int32_t pl=*pPrefixLength; 
    int32_t cmp=0; 
    s1+=pl; 
    s2+=pl; 
    for(;;) { 
        int32_t c1=(uint8_t)*s1++; 
        int32_t c2=(uint8_t)*s2++; 
        cmp=c1-c2; 
        if(cmp!=0 || c1==0) {  /* different or done */ 
            break; 
        } 
        ++pl;  /* increment shared same-prefix length */ 
    } 
    *pPrefixLength=pl; 
    return cmp; 
} 
 
static int32_t 
offsetTOCPrefixBinarySearch(const char *s, const char *names, 
                            const UDataOffsetTOCEntry *toc, int32_t count) { 
    int32_t start=0; 
    int32_t limit=count; 
    /* 
     * Remember the shared prefix between s, start and limit, 
     * and don't compare that shared prefix again. 
     * The shared prefix should get longer as we narrow the [start, limit[ range. 
     */ 
    int32_t startPrefixLength=0; 
    int32_t limitPrefixLength=0; 
    if(count==0) { 
        return -1; 
    } 
    /* 
     * Prime the prefix lengths so that we don't keep prefixLength at 0 until 
     * both the start and limit indexes have moved. 
     * At the same time, we find if s is one of the start and (limit-1) names, 
     * and if not, exclude them from the actual binary search. 
     */ 
    if(0==strcmpAfterPrefix(s, names+toc[0].nameOffset, &startPrefixLength)) { 
        return 0; 
    } 
    ++start; 
    --limit; 
    if(0==strcmpAfterPrefix(s, names+toc[limit].nameOffset, &limitPrefixLength)) { 
        return limit; 
    } 
    while(start<limit) { 
        int32_t i=(start+limit)/2; 
        int32_t prefixLength=MIN(startPrefixLength, limitPrefixLength); 
        int32_t cmp=strcmpAfterPrefix(s, names+toc[i].nameOffset, &prefixLength); 
        if(cmp<0) { 
            limit=i; 
            limitPrefixLength=prefixLength; 
        } else if(cmp==0) { 
            return i; 
        } else { 
            start=i+1; 
            startPrefixLength=prefixLength; 
        } 
    } 
    return -1; 
} 
 
static int32_t 
pointerTOCPrefixBinarySearch(const char *s, const PointerTOCEntry *toc, int32_t count) { 
    int32_t start=0; 
    int32_t limit=count; 
    /* 
     * Remember the shared prefix between s, start and limit, 
     * and don't compare that shared prefix again. 
     * The shared prefix should get longer as we narrow the [start, limit[ range. 
     */ 
    int32_t startPrefixLength=0; 
    int32_t limitPrefixLength=0; 
    if(count==0) { 
        return -1; 
    } 
    /* 
     * Prime the prefix lengths so that we don't keep prefixLength at 0 until 
     * both the start and limit indexes have moved. 
     * At the same time, we find if s is one of the start and (limit-1) names, 
     * and if not, exclude them from the actual binary search. 
     */ 
    if(0==strcmpAfterPrefix(s, toc[0].entryName, &startPrefixLength)) { 
        return 0; 
    } 
    ++start; 
    --limit; 
    if(0==strcmpAfterPrefix(s, toc[limit].entryName, &limitPrefixLength)) { 
        return limit; 
    } 
    while(start<limit) { 
        int32_t i=(start+limit)/2; 
        int32_t prefixLength=MIN(startPrefixLength, limitPrefixLength); 
        int32_t cmp=strcmpAfterPrefix(s, toc[i].entryName, &prefixLength); 
        if(cmp<0) { 
            limit=i; 
            limitPrefixLength=prefixLength; 
        } else if(cmp==0) { 
            return i; 
        } else { 
            start=i+1; 
            startPrefixLength=prefixLength; 
        } 
    } 
    return -1; 
} 
 
U_CDECL_BEGIN 
static uint32_t U_CALLCONV 
offsetTOCEntryCount(const UDataMemory *pData) { 
    int32_t          retVal=0; 
    const UDataOffsetTOC *toc = (UDataOffsetTOC *)pData->toc; 
    if (toc != NULL) { 
        retVal = toc->count; 
    } 
    return retVal; 
} 
 
static const DataHeader * U_CALLCONV 
offsetTOCLookupFn(const UDataMemory *pData, 
                  const char *tocEntryName, 
                  int32_t *pLength, 
                  UErrorCode *pErrorCode) { 
    (void)pErrorCode; 
    const UDataOffsetTOC  *toc = (UDataOffsetTOC *)pData->toc; 
    if(toc!=NULL) { 
        const char *base=(const char *)toc; 
        int32_t number, count=(int32_t)toc->count; 
 
        /* perform a binary search for the data in the common data's table of contents */ 
#if defined (UDATA_DEBUG_DUMP) 
        /* list the contents of the TOC each time .. not recommended */ 
        for(number=0; number<count; ++number) { 
            fprintf(stderr, "\tx%d: %s\n", number, &base[toc->entry[number].nameOffset]); 
        } 
#endif 
        number=offsetTOCPrefixBinarySearch(tocEntryName, base, toc->entry, count); 
        if(number>=0) { 
            /* found it */ 
            const UDataOffsetTOCEntry *entry=toc->entry+number; 
#ifdef UDATA_DEBUG 
            fprintf(stderr, "%s: Found.\n", tocEntryName); 
#endif 
            if((number+1) < count) { 
                *pLength = (int32_t)(entry[1].dataOffset - entry->dataOffset); 
            } else { 
                *pLength = -1; 
            } 
            return (const DataHeader *)(base+entry->dataOffset); 
        } else { 
#ifdef UDATA_DEBUG 
            fprintf(stderr, "%s: Not found.\n", tocEntryName); 
#endif 
            return NULL; 
        } 
    } else { 
#ifdef UDATA_DEBUG 
        fprintf(stderr, "returning header\n"); 
#endif 
 
        return pData->pHeader; 
    } 
} 
 
 
static uint32_t U_CALLCONV pointerTOCEntryCount(const UDataMemory *pData) { 
    const PointerTOC *toc = (PointerTOC *)pData->toc; 
    return (uint32_t)((toc != NULL) ? (toc->count) : 0); 
} 
 
static const DataHeader * U_CALLCONV pointerTOCLookupFn(const UDataMemory *pData, 
                   const char *name, 
                   int32_t *pLength, 
                   UErrorCode *pErrorCode) { 
    (void)pErrorCode; 
    if(pData->toc!=NULL) { 
        const PointerTOC *toc = (PointerTOC *)pData->toc; 
        int32_t number, count=(int32_t)toc->count; 
 
#if defined (UDATA_DEBUG_DUMP) 
        /* list the contents of the TOC each time .. not recommended */ 
        for(number=0; number<count; ++number) { 
            fprintf(stderr, "\tx%d: %s\n", number, toc->entry[number].entryName); 
        } 
#endif 
        number=pointerTOCPrefixBinarySearch(name, toc->entry, count); 
        if(number>=0) { 
            /* found it */ 
#ifdef UDATA_DEBUG 
            fprintf(stderr, "%s: Found.\n", toc->entry[number].entryName); 
#endif 
            *pLength=-1; 
            return UDataMemory_normalizeDataPointer(toc->entry[number].pHeader); 
        } else { 
#ifdef UDATA_DEBUG 
            fprintf(stderr, "%s: Not found.\n", name); 
#endif 
            return NULL; 
        } 
    } else { 
        return pData->pHeader; 
    } 
} 
U_CDECL_END 
 
 
static const commonDataFuncs CmnDFuncs = {offsetTOCLookupFn,  offsetTOCEntryCount}; 
static const commonDataFuncs ToCPFuncs = {pointerTOCLookupFn, pointerTOCEntryCount}; 
 
 
 
/*----------------------------------------------------------------------* 
 *                                                                      * 
 *  checkCommonData   Validate the format of a common data file.        * 
 *                    Fill in the virtual function ptr based on TOC type * 
 *                    If the data is invalid, close the UDataMemory     * 
 *                    and set the appropriate error code.               * 
 *                                                                      * 
 *----------------------------------------------------------------------*/ 
U_CFUNC void udata_checkCommonData(UDataMemory *udm, UErrorCode *err) { 
    if (U_FAILURE(*err)) { 
        return; 
    } 
 
    if(udm==NULL || udm->pHeader==NULL) { 
      *err=U_INVALID_FORMAT_ERROR; 
    } else if(!(udm->pHeader->dataHeader.magic1==0xda && 
        udm->pHeader->dataHeader.magic2==0x27 && 
        udm->pHeader->info.isBigEndian==U_IS_BIG_ENDIAN && 
        udm->pHeader->info.charsetFamily==U_CHARSET_FAMILY) 
        ) { 
        /* header not valid */ 
        *err=U_INVALID_FORMAT_ERROR; 
    } 
    else if (udm->pHeader->info.dataFormat[0]==0x43 && 
        udm->pHeader->info.dataFormat[1]==0x6d && 
        udm->pHeader->info.dataFormat[2]==0x6e && 
        udm->pHeader->info.dataFormat[3]==0x44 && 
        udm->pHeader->info.formatVersion[0]==1 
        ) { 
        /* dataFormat="CmnD" */ 
        udm->vFuncs = &CmnDFuncs; 
        udm->toc=(const char *)udm->pHeader+udata_getHeaderSize(udm->pHeader); 
    } 
    else if(udm->pHeader->info.dataFormat[0]==0x54 && 
        udm->pHeader->info.dataFormat[1]==0x6f && 
        udm->pHeader->info.dataFormat[2]==0x43 && 
        udm->pHeader->info.dataFormat[3]==0x50 && 
        udm->pHeader->info.formatVersion[0]==1 
        ) { 
        /* dataFormat="ToCP" */ 
        udm->vFuncs = &ToCPFuncs; 
        udm->toc=(const char *)udm->pHeader+udata_getHeaderSize(udm->pHeader); 
    } 
    else { 
        /* dataFormat not recognized */ 
        *err=U_INVALID_FORMAT_ERROR; 
    } 
 
    if (U_FAILURE(*err)) { 
        /* If the data is no good and we memory-mapped it ourselves, 
         *  close the memory mapping so it doesn't leak.  Note that this has 
         *  no effect on non-memory mapped data, other than clearing fields in udm. 
         */ 
        udata_close(udm); 
    } 
} 
 
/* 
 * TODO: Add a udata_swapPackageHeader() function that swaps an ICU .dat package 
 * header but not its sub-items. 
 * This function will be needed for automatic runtime swapping. 
 * Sub-items should not be swapped to limit the swapping to the parts of the 
 * package that are actually used. 
 * 
 * Since lengths of items are implicit in the order and offsets of their 
 * ToC entries, and since offsets are relative to the start of the ToC, 
 * a swapped version may need to generate a different data structure 
 * with pointers to the original data items and with their lengths 
 * (-1 for the last one if it is not known), and maybe even pointers to the 
 * swapped versions of the items. 
 * These pointers to swapped versions would establish a cache; 
 * instead, each open data item could simply own the storage for its swapped 
 * data. This fits better with the current design. 
 * 
 * markus 2003sep18 Jitterbug 2235 
 */