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); }