organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-07 22:44:49 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 2

ICU-157 UDATA updates for Machines with Alignment Problems, and to align cnv/ucmp data.

Browse source 
X-SVN-Rev: 416
This commit is contained in:
Steven R. Loomis 1999-12-15 05:14:03 +00:00
parent 2812d5d3df
commit 343d4b3e58
8 changed files with 123 additions and 152 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
icu4c/source/common/ucmp16.c
View file

@ -465,6 +465,10 @@ U_CAPI CompactShortArray * U_EXPORT2 ucmp16_cloneFromData(const uint8_t **sourc
array->fAlias = TRUE;
/* eat up padding */
while((*source-((uint8_t*)oldArray))%4)
(*source)++;
return array;
}

22
icu4c/source/common/ucmp8.c
View file

@ -416,17 +416,19 @@ U_CAPI CompactByteArray * U_EXPORT2 ucmp8_cloneFromData(const uint8_t **source,
array->fArray = (const int8_t*)*source;
*source += (sizeof(int8_t)*array->fCount);
if(((*source)-((const uint8_t*)oldArray)) & 1 )
{
(*source)++;
}
array->fIndex = (const uint16_t*)*source;
*source += (sizeof(uint16_t)*UCMP8_kIndexCount);
/* eat up padding */
while((*source-((uint8_t*)oldArray))%4)
(*source)++;
return array;
}

20
icu4c/source/common/ucnv_bld.c
View file

@ -280,7 +280,7 @@ isCnvAcceptable(void *context,
pInfo->dataFormat[1]==0x6e &&
pInfo->dataFormat[2]==0x76 &&
pInfo->dataFormat[3]==0x74 &&
pInfo->formatVersion[0]==1;
pInfo->formatVersion[0]==2;
}
#define DATA_TYPE "cnv"
@ -960,7 +960,7 @@ UConverter *
UConverterSharedData* ucnv_data_unFlattenClone(const UConverterSharedData *source, UErrorCode *status)
{
const uint8_t *raw;
const uint8_t *raw, *oldraw;
UConverterSharedData *data = NULL;
if(U_FAILURE(*status))
@ -994,8 +994,14 @@ UConverterSharedData* ucnv_data_unFlattenClone(const UConverterSharedData *sourc
case UCNV_EBCDIC_STATEFUL:
case UCNV_DBCS:
data->table = icu_malloc(sizeof(UConverterDBCSTable));
data->table->dbcs.
toUnicode=ucmp16_cloneFromData(&raw, status);
oldraw = raw;
data->table->dbcs.toUnicode=ucmp16_cloneFromData(&raw, status);
while((raw-oldraw)%4) /* pad to 4 */
raw++;
data->table->dbcs.fromUnicode =ucmp16_cloneFromData(&raw, status);
break;
@ -1006,7 +1012,13 @@ toUnicode=ucmp16_cloneFromData(&raw, status);
data->table->mbcs.starters = (bool_t*)raw;
raw += sizeof(bool_t)*256;
oldraw = raw;
data->table->mbcs.toUnicode = ucmp16_cloneFromData(&raw, status);
while((raw-oldraw)%4) /* pad to 4 */
raw++;
data->table->mbcs.fromUnicode = ucmp16_cloneFromData(&raw, status);
break;

5
icu4c/source/common/udata.c
View file

@ -111,7 +111,8 @@ getChoice(Library lib, const char *entry,
#define LIB_SUFFIX ".dll"
#define GET_ENTRY(lib, entryName) (MappedData *)GetProcAddress(lib, entryName)
/* skip the bogus double */
#define GET_ENTRY(lib, entryName) (MappedData *)(((double*)GetProcAddress(lib, entryName))+1)
#define NO_LIBRARY NULL
#define IS_LIBRARY(lib) ((lib)!=NULL)
@ -259,7 +260,7 @@ getChoice(Library lib, const char *entry,
UDataMemoryIsAcceptable *isAcceptable, void *context,
UErrorCode *pErrorCode);
#define GET_ENTRY(lib, entryName) (MappedData *)dlsym(lib, entryName)
#define GET_ENTRY(lib, entryName) (MappedData *)(((double*)dlsym(lib, entryName))+1)
#define NO_LIBRARY NULL
#define IS_LIBRARY(lib) ((lib)!=NULL)

12
icu4c/source/tools/genccode/genccode.c
View file

@ -80,8 +80,12 @@ writeCCode(const char *filename) {
exit(U_FILE_ACCESS_ERROR);
}
T_FileStream_writeLine(out, "#include \"utypes.h\"\nU_CAPI const uint8_t U_EXPORT2 ");
T_FileStream_writeLine(out, "#include \"utypes.h\"\nU_CAPI const struct U_EXPORT2 {\n double bogus;\n uint8_t bytes ");
T_FileStream_writeLine(out, "[");
sprintf(buffer, "%d", T_FileStream_size(in) );
T_FileStream_writeLine(out, buffer);
T_FileStream_writeLine(out, "]; \n} ");
for(i=0;i<strlen(entry);i++)
{
if(entry[i]=='-')
@ -90,8 +94,8 @@ writeCCode(const char *filename) {
}
}
T_FileStream_writeLine(out, entry);
T_FileStream_writeLine(out, "[]={\n");
T_FileStream_writeLine(out, entry);
T_FileStream_writeLine(out,"={ 0, {\n");
for(;;) {
length=T_FileStream_read(in, buffer, sizeof(buffer));
@ -103,7 +107,7 @@ writeCCode(const char *filename) {
}
}
T_FileStream_writeLine(out, "\n};\n");
T_FileStream_writeLine(out, "\n}\n};\n");
if(T_FileStream_error(in)) {
fprintf(stderr, "genccode: file read error while generating from file %s\n", filename);

154
icu4c/source/tools/makeconv/makeconv.c
View file

@ -153,7 +153,7 @@ static const UDataInfo dataInfo={
0,
0x63, 0x6e, 0x76, 0x74, /* dataFormat="cnvt" */
1, 0, 0, 0, /* formatVersion */
2, 0, 0, 0, /* formatVersion */
1, 3, 1, 0 /* dataVersion */
};
@ -241,121 +241,6 @@ int main(int argc, char** argv)
}
/*Streams out to a file a compact short array*/
void writeCompactShortArrayToFile(FileStream* outfile, const CompactShortArray* myArray)
{
int32_t i = 0;
const int16_t* myShortArray = NULL;
const uint16_t* myIndexArray = NULL;
int32_t myValuesCount = 0;
int32_t myIndexCount = ucmp16_getkUnicodeCount() / ucmp16_getkBlockCount();
int32_t myBlockShift = myArray->kBlockShift;
/*streams out the length of the arrays to come*/
myValuesCount = myArray->fCount;
T_FileStream_write(outfile, &myValuesCount, sizeof(int32_t));
T_FileStream_write(outfile, &myIndexCount, sizeof(int32_t));
T_FileStream_write(outfile, &myBlockShift, sizeof(int32_t));
/*Gets pointers to the internal arrays*/
myShortArray = myArray->fArray;
myIndexArray = myArray->fIndex;
/*streams out the 2 arrays*/
T_FileStream_write(outfile, myShortArray, myValuesCount*sizeof(int16_t));
T_FileStream_write(outfile, myIndexArray, myIndexCount*sizeof(uint16_t));
return ;
}
void writeCompactByteArrayToFile(FileStream* outfile, const CompactByteArray* myArray)
{
int32_t i = 0;
const int8_t* myByteArray = NULL;
const uint16_t* myIndexArray = NULL;
int32_t myValuesCount = 0;
int32_t myIndexCount = ucmp8_getkUnicodeCount() / ucmp8_getkBlockCount();
/*streams out the length of the arrays to come*/
myValuesCount = ucmp8_getCount(myArray);
T_FileStream_write(outfile, &myValuesCount, sizeof(int32_t));
T_FileStream_write(outfile, &myIndexCount, sizeof(int32_t));
/*Gets pointers to the internal arrays*/
myByteArray = myArray->fArray;
myIndexArray = myArray->fIndex;
/*streams out the 2 arrays*/
T_FileStream_write(outfile, myByteArray, myValuesCount*sizeof(int8_t));
T_FileStream_write(outfile, myIndexArray, myIndexCount*sizeof(uint16_t));
return ;
}
void writeUConverterSharedDataToFile(const char* filename,
UConverterSharedData* mySharedData,
UErrorCode* err)
{
int32_t i = 0;
const int8_t* myByteArray = NULL;
const uint16_t* myIndexArray = NULL;
int32_t myValuesCount = 0;
int32_t myIndexCount = 0;
int32_t myCheck = UCNV_FILE_CHECK_MARKER;
FileStream* outfile = NULL;
UConverterTable* myTableAlias = NULL;
if (U_FAILURE(*err)) return;
outfile = T_FileStream_open(filename, "wb");
if (outfile == NULL)
{
*err = U_FILE_ACCESS_ERROR;
return;
}
/*Writes a Sentinel value*/
T_FileStream_write(outfile, &myCheck, sizeof(int32_t));
T_FileStream_write(outfile, U_COPYRIGHT_STRING, U_COPYRIGHT_STRING_LENGTH);
/*Writes NULL in places where there is a pointer in order
*to enable bitwise equivalence of binary files
*/
myTableAlias = mySharedData->table;
mySharedData->table = NULL;
T_FileStream_write(outfile, mySharedData, sizeof(UConverterSharedData));
mySharedData->table = myTableAlias;
switch (mySharedData->conversionType)
{
case UCNV_SBCS :
{
T_FileStream_write(outfile, mySharedData->table->sbcs.toUnicode, 256*sizeof(UChar));
writeCompactByteArrayToFile(outfile, mySharedData->table->sbcs.fromUnicode);
}break;
case UCNV_DBCS : case UCNV_EBCDIC_STATEFUL:
{
writeCompactShortArrayToFile(outfile, mySharedData->table->dbcs.toUnicode);
writeCompactShortArrayToFile(outfile, mySharedData->table->dbcs.fromUnicode);
}break;
case UCNV_MBCS :
{
T_FileStream_write(outfile, mySharedData->table->mbcs.starters, 256*sizeof(bool_t));
writeCompactShortArrayToFile(outfile, mySharedData->table->mbcs.toUnicode);
writeCompactShortArrayToFile(outfile, mySharedData->table->mbcs.fromUnicode);
}break;
};
if (T_FileStream_error(outfile))
{
*err = U_FILE_ACCESS_ERROR;
}
T_FileStream_close(outfile);
}
void copyPlatformString(char* platformString, UConverterPlatform pltfrm)
{
switch (pltfrm)
@ -892,30 +777,47 @@ UConverterSharedData* createConverterFromTableFile(const char* converterName, UE
static void WriteConverterSharedData(UNewDataMemory *pData, const UConverterSharedData* data)
{
udata_writeBlock(pData, data, sizeof(UConverterSharedData));
uint32_t size = 0;
udata_writeBlock(pData, data, sizeof(UConverterSharedData));
switch (data->conversionType)
size += sizeof(UConverterSharedData); /* Is 4-aligned- it ends with a pointer */
switch (data->conversionType)
{
case UCNV_SBCS:
{
{
udata_writeBlock(pData, (void*)data->table->sbcs.toUnicode, sizeof(UChar)*256);
udata_write_ucmp8(pData, data->table->sbcs.fromUnicode);
size += udata_write_ucmp8(pData, data->table->sbcs.fromUnicode);
size += sizeof(UChar)*256;
/* don't care aboutalignment */
}
break;
break;
case UCNV_DBCS:
case UCNV_EBCDIC_STATEFUL:
{
udata_write_ucmp16(pData,data->table->dbcs.toUnicode);
udata_write_ucmp16(pData,data->table->dbcs.fromUnicode);
size += udata_write_ucmp16(pData,data->table->dbcs.toUnicode);
if(size%4)
{
udata_writePadding(pData, 4-(size%4) );
size+= 4-(size%4);
}
size += udata_write_ucmp16(pData,data->table->dbcs.fromUnicode);
}
break;
case UCNV_MBCS:
{
udata_writeBlock(pData, data->table->mbcs.starters, 256*sizeof(bool_t));
udata_write_ucmp16(pData,data->table->mbcs.toUnicode);
udata_write_ucmp16(pData,data->table->mbcs.fromUnicode);
size += 256*sizeof(bool_t);
size += udata_write_ucmp16(pData,data->table->mbcs.toUnicode);
if(size%4)
{
udata_writePadding(pData, 4-(size%4) );
size+= 4-(size%4);
}
size += udata_write_ucmp16(pData,data->table->mbcs.fromUnicode);
}
break;

43
icu4c/source/tools/toolutil/ucmpwrit.c
View file

@ -1,11 +1,31 @@
#include "ucmpwrit.h"
#include <stdio.h>
U_CAPI void U_EXPORT2 udata_write_ucmp8 (UNewDataMemory *pData, const CompactByteArray* array)
U_CAPI uint32_t U_EXPORT2 udata_write_ucmp8 (UNewDataMemory *pData, const CompactByteArray* array)
{
uint32_t size = sizeof(*array);
udata_writeBlock(pData, array, sizeof(*array));
udata_writeBlock(pData, array->fArray, sizeof(array->fArray[0])*array->fCount);
size += sizeof(array->fArray[0])*array->fCount;
if((sizeof(*array)+(sizeof(array->fArray[0])*array->fCount))&1)
{
udata_writePadding(pData, 1); /* Pad total so far to even size */
size += 1;
}
udata_writeBlock(pData, array->fIndex, sizeof(array->fIndex[0])*UCMP8_kIndexCount);
size += sizeof(array->fIndex[0])*UCMP8_kIndexCount;
while(size%4) /* end padding */
{
udata_writePadding(pData, 1); /* Pad total so far to even size */
size += 1;
}
return size;
}
/* internal constants*/
@ -29,11 +49,30 @@ const int32_t UCMP16_kIndexCount = UCMP16_kIndexCount_int;
const uint32_t UCMP16_kBlockMask = UCMP16_kBlockMask_int;
U_CAPI void U_EXPORT2 udata_write_ucmp16 (UNewDataMemory *pData, const CompactShortArray* array)
U_CAPI uint32_t U_EXPORT2 udata_write_ucmp16 (UNewDataMemory *pData, const CompactShortArray* array)
{
uint32_t size = sizeof(*array);
udata_writeBlock(pData, array, sizeof(*array));
if(sizeof(*array)&1)
{
udata_writePadding(pData, 1); /* Pad to even size */
size++;
}
udata_writeBlock(pData, array->fArray, sizeof(array->fArray[0])*array->fCount);
size += sizeof(array->fArray[0])*array->fCount;
udata_writeBlock(pData, array->fIndex, sizeof(array->fIndex[0])*UCMP16_kIndexCount);
size += sizeof(array->fIndex[0])*UCMP16_kIndexCount;
while(size%4) /* end padding */
{
udata_writePadding(pData, 1); /* Pad total so far to even size */
size += 1;
}
return size;
}

15
icu4c/source/tools/toolutil/ucmpwrit.h
View file

@ -6,7 +6,8 @@
*********************************************************************/
/**
API's for writing UCMPs
API's for writing UCMPs.
Return nbytes written.
*/
#ifndef _UCMPWRIT
@ -19,12 +20,18 @@
#include "ucmp16.h"
#include "ucmp32.h"
U_CAPI void U_EXPORT2 udata_write_ucmp8 (UNewDataMemory *pData, const CompactByteArray* array);
U_CAPI uint32_t U_EXPORT2 udata_write_ucmp8 (UNewDataMemory *pData, const CompactByteArray* array);
U_CAPI void U_EXPORT2 udata_write_ucmp16(UNewDataMemory *pData, const CompactShortArray* array);
U_CAPI uint32_t U_EXPORT2 udata_write_ucmp16(UNewDataMemory *pData, const CompactShortArray* array);
/*Not implemented. [yet] */
/*U_CAPI void U_EXPORT2 udata_write_ucmp32(UNewDataMemory *pData, const CompactIntArray* array);*/
/*U_CAPI uint32_t U_EXPORT2 udata_write_ucmp32(UNewDataMemory *pData, const CompactIntArray* array);*/
#endif