extern int
main(int argc, const char *argv[]) {
UNewDataMemory *pData;
UErrorCode errorCode=U_ZERO_ERROR;
char stringValue[]={'E', 'X', 'A', 'M', 'P', 'L', 'E', '\0'};
uint16_t intValue=2000;
long dataLength;
uint32_t size;
#ifdef WIN32
char *currdir = _getcwd(NULL, 0);
#else
char *currdir = getcwd(NULL, 0);
#endif
pData=udata_create(currdir, DATA_TYPE, DATA_NAME, &dataInfo,
U_COPYRIGHT_STRING, &errorCode);
if(currdir != NULL) {
free(currdir);
}
if(U_FAILURE(errorCode)) {
fprintf(stderr, "Error: unable to create data memory, error %d\n", errorCode);
exit(errorCode);
}
/* write the data to the file */
/* a 16 bit value and a String*/
printf("Writing uint16_t value of %d\n", intValue);
udata_write16(pData, intValue);
printf("Writing string value of %s\n", stringValue);
udata_writeString(pData, stringValue, sizeof(stringValue));
/* finish up */
dataLength=udata_finish(pData, &errorCode);
if(U_FAILURE(errorCode)) {
fprintf(stderr, "Error: error %d writing the output file\n", errorCode);
exit(errorCode);
}
size=sizeof(stringValue) + sizeof(intValue);
if(dataLength!=(long)size) {
fprintf(stderr, "Error: data length %ld != calculated size %lu\n", dataLength, size);
exit(U_INTERNAL_PROGRAM_ERROR);
}
return 0;
}
static void
writeAliasTable(UNewDataMemory *out) {
uint32_t i, j;
uint32_t uniqueAliasesSize;
uint16_t aliasOffset = (uint16_t)(tagBlock.top/sizeof(uint16_t));
uint16_t *aliasArrLists = (uint16_t *)uprv_malloc(tagCount * converterCount * sizeof(uint16_t));
uint16_t *uniqueAliases = (uint16_t *)uprv_malloc(knownAliasesCount * sizeof(uint16_t));
uint16_t *uniqueAliasesToConverter = (uint16_t *)uprv_malloc(knownAliasesCount * sizeof(uint16_t));
qsort(knownAliases, knownAliasesCount, sizeof(knownAliases[0]), compareAliases);
uniqueAliasesSize = resolveAliases(uniqueAliases, uniqueAliasesToConverter, aliasOffset);
/* Array index starts at 1. aliasLists[0] is the size of the lists section. */
aliasListsSize = 0;
/* write the offsets of all the aliases lists in a 2D array, and create the lists. */
for (i = 0; i < tagCount; ++i) {
for (j = 0; j < converterCount; ++j) {
createOneAliasList(aliasArrLists, i, j, aliasOffset);
}
}
/* Write the size of the TOC */
if (tableOptions.stringNormalizationType == UCNV_IO_UNNORMALIZED) {
udata_write32(out, 8);
}
else {
udata_write32(out, 9);
}
/* Write the sizes of each section */
/* All sizes are the number of uint16_t units, not bytes */
udata_write32(out, converterCount);
udata_write32(out, tagCount);
udata_write32(out, uniqueAliasesSize); /* list of aliases */
udata_write32(out, uniqueAliasesSize); /* The preresolved form of mapping an untagged the alias to a converter */
udata_write32(out, tagCount * converterCount);
udata_write32(out, aliasListsSize + 1);
udata_write32(out, sizeof(tableOptions) / sizeof(uint16_t));
udata_write32(out, (tagBlock.top + stringBlock.top) / sizeof(uint16_t));
if (tableOptions.stringNormalizationType != UCNV_IO_UNNORMALIZED) {
udata_write32(out, (tagBlock.top + stringBlock.top) / sizeof(uint16_t));
}
/* write the table of converters */
/* Think of this as the column headers */
for(i=0; i<converterCount; ++i) {
udata_write16(out, (uint16_t)(converters[i].converter + aliasOffset));
}
/* write the table of tags */
/* Think of this as the row headers */
for(i=UCNV_NUM_RESERVED_TAGS; i<tagCount; ++i) {
udata_write16(out, tags[i].tag);
}
/* The empty tag is considered the leftover list, and put that at the end of the priority list. */
udata_write16(out, tags[EMPTY_TAG_NUM].tag);
udata_write16(out, tags[ALL_TAG_NUM].tag);
/* Write the unique list of aliases */
udata_writeBlock(out, uniqueAliases, uniqueAliasesSize * sizeof(uint16_t));
/* Write the unique list of aliases */
udata_writeBlock(out, uniqueAliasesToConverter, uniqueAliasesSize * sizeof(uint16_t));
/* Write the array to the lists */
udata_writeBlock(out, (const void *)(aliasArrLists + (2*converterCount)), (((tagCount - 2) * converterCount) * sizeof(uint16_t)));
/* Now write the leftover part of the array for the EMPTY and ALL lists */
udata_writeBlock(out, (const void *)aliasArrLists, (2 * converterCount * sizeof(uint16_t)));
/* Offset the next array to make the index start at 1. */
udata_write16(out, 0xDEAD);
/* Write the lists */
udata_writeBlock(out, (const void *)aliasLists, aliasListsSize * sizeof(uint16_t));
/* Write any options for the alias table. */
udata_writeBlock(out, (const void *)&tableOptions, sizeof(tableOptions));
/* write the tags strings */
udata_writeString(out, tagBlock.store, tagBlock.top);
/* write the aliases strings */
udata_writeString(out, stringBlock.store, stringBlock.top);
/* write the normalized aliases strings */
if (tableOptions.stringNormalizationType != UCNV_IO_UNNORMALIZED) {
char *normalizedStrings = (char *)uprv_malloc(tagBlock.top + stringBlock.top);
createNormalizedAliasStrings(normalizedStrings, tagBlock.store, tagBlock.top);
createNormalizedAliasStrings(normalizedStrings + tagBlock.top, stringBlock.store, stringBlock.top);
/* Write out the complete normalized array. */
udata_writeString(out, normalizedStrings, tagBlock.top + stringBlock.top);
uprv_free(normalizedStrings);
}
uprv_free(uniqueAliasesToConverter);
uprv_free(uniqueAliases);
uprv_free(aliasArrLists);
}
