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
|
// © 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.
*
******************************************************************************/
/*----------------------------------------------------------------------------------
*
* UDataMemory A class-like struct that serves as a handle to a piece of memory
* that contains some ICU data (resource, converters, whatever.)
*
* When an application opens ICU data (with udata_open, for example,
* a UDataMemory * is returned.
*
*----------------------------------------------------------------------------------*/
#include "unicode/utypes.h"
#include "cmemory.h"
#include "unicode/udata.h"
#include "udatamem.h"
U_CFUNC void UDataMemory_init(UDataMemory *This) {
uprv_memset(This, 0, sizeof(UDataMemory));
This->length=-1;
}
U_CFUNC void UDatamemory_assign(UDataMemory *dest, UDataMemory *source) {
/* UDataMemory Assignment. Destination UDataMemory must be initialized first. */
UBool mallocedFlag = dest->heapAllocated;
uprv_memcpy(dest, source, sizeof(UDataMemory));
dest->heapAllocated = mallocedFlag;
}
U_CFUNC UDataMemory *UDataMemory_createNewInstance(UErrorCode *pErr) {
UDataMemory *This;
if (U_FAILURE(*pErr)) {
return nullptr;
}
This = (UDataMemory *)uprv_malloc(sizeof(UDataMemory));
if (This == nullptr) {
*pErr = U_MEMORY_ALLOCATION_ERROR; }
else {
UDataMemory_init(This);
This->heapAllocated = true;
}
return This;
}
U_CFUNC const DataHeader *
UDataMemory_normalizeDataPointer(const void *p) {
/* allow the data to be optionally prepended with an alignment-forcing double value */
const DataHeader *pdh = (const DataHeader *)p;
if(pdh==nullptr || (pdh->dataHeader.magic1==0xda && pdh->dataHeader.magic2==0x27)) {
return pdh;
} else {
#if U_PLATFORM == U_PF_OS400
/*
TODO: Fix this once the compiler implements this feature. Keep in sync with genccode.c
This is here because this platform can't currently put
const data into the read-only pages of an object or
shared library (service program). Only strings are allowed in read-only
pages, so we use char * strings to store the data.
In order to prevent the beginning of the data from ever matching the
magic numbers we must skip the initial double.
[grhoten 4/24/2003]
*/
return (const DataHeader *)*((const void **)p+1);
#else
return (const DataHeader *)((const double *)p+1);
#endif
}
}
U_CFUNC void UDataMemory_setData (UDataMemory *This, const void *dataAddr) {
This->pHeader = UDataMemory_normalizeDataPointer(dataAddr);
}
U_CAPI void U_EXPORT2
udata_close(UDataMemory *pData) {
if(pData!=nullptr) {
uprv_unmapFile(pData);
if(pData->heapAllocated ) {
uprv_free(pData);
} else {
UDataMemory_init(pData);
}
}
}
U_CAPI const void * U_EXPORT2
udata_getMemory(UDataMemory *pData) {
if(pData!=nullptr && pData->pHeader!=nullptr) {
return (char *)(pData->pHeader)+udata_getHeaderSize(pData->pHeader);
} else {
return nullptr;
}
}
/**
* Get the length of the data item if possible.
* The length may be up to 15 bytes larger than the actual data.
*
* TODO Consider making this function public.
* It would have to return the actual length in more cases.
* For example, the length of the last item in a .dat package could be
* computed from the size of the whole .dat package minus the offset of the
* last item.
* The size of a file that was directly memory-mapped could be determined
* using some system API.
*
* In order to get perfect values for all data items, we may have to add a
* length field to UDataInfo, but that complicates data generation
* and may be overkill.
*
* @param pData The data item.
* @return the length of the data item, or -1 if not known
* @internal Currently used only in cintltst/udatatst.c
*/
U_CAPI int32_t U_EXPORT2
udata_getLength(const UDataMemory *pData) {
if(pData!=nullptr && pData->pHeader!=nullptr && pData->length>=0) {
/*
* subtract the header size,
* return only the size of the actual data starting at udata_getMemory()
*/
return pData->length-udata_getHeaderSize(pData->pHeader);
} else {
return -1;
}
}
/**
* Get the memory including the data header.
* Used in cintltst/udatatst.c
* @internal
*/
U_CAPI const void * U_EXPORT2
udata_getRawMemory(const UDataMemory *pData) {
if(pData!=nullptr && pData->pHeader!=nullptr) {
return pData->pHeader;
} else {
return nullptr;
}
}
U_CFUNC UBool UDataMemory_isLoaded(const UDataMemory *This) {
return This->pHeader != nullptr;
}
|
