| // © 2021 and later: Unicode, Inc. and others. |
| // License & terms of use: https://www.unicode.org/copyright.html |
| |
| // emojipropsbuilder.cpp |
| // created: 2021sep03 Markus W. Scherer |
| |
| #include <stdio.h> |
| #include <string.h> |
| #include <set> |
| #include <string> |
| #include "unicode/utypes.h" |
| #include "unicode/uchar.h" |
| #include "unicode/ucharstriebuilder.h" |
| #include "unicode/ucptrie.h" |
| #include "unicode/udata.h" |
| #include "unicode/umutablecptrie.h" |
| #include "unicode/uniset.h" |
| #include "unicode/unistr.h" |
| #include "charstr.h" |
| #include "cmemory.h" |
| #include "emojiprops.h" |
| #include "genprops.h" |
| #include "uassert.h" |
| #include "unewdata.h" |
| #include "uparse.h" |
| |
| /* Emoji properties file format ------------------------------------------------ |
| |
| The file format prepared and written here contains several data |
| structures that store indexes or data. |
| |
| Before the data contents described below, there are the headers required by |
| the udata API for loading ICU data. Especially, a UDataInfo structure |
| precedes the actual data. It contains platform properties values and the |
| file format version. |
| |
| The following is a description of format version 1.0 . |
| |
| The file contains the following structures: |
| |
| const int32_t indexes[] with values i0, i1, ...: |
| (see EmojiProps::IX_... constants for names of indexes) |
| |
| The length of the indexes[] array is indexes[IX_CPTRIE_OFFSET]/4; |
| |
| The first 14 indexes are byte offsets in ascending order. |
| Each byte offset marks the start of a part in the data file, |
| and the limit (exclusive end) of the previous one. |
| When two consecutive byte offsets are the same, then the corresponding part is empty. |
| Byte offsets are offsets from after the header, that is, from the beginning of the indexes[]. |
| Each part starts at an offset with proper alignment for its data. |
| If necessary, the previous part may include padding bytes to achieve this alignment. |
| |
| i0 offset of cpTrie (and the limit offset of the indexes[] array) |
| i1..i3 reserved, same as the limit offset of the previous part |
| i4 offset of Basic_Emoji string trie |
| i5 offset of Emoji_Keycap_Sequence string trie |
| i6 offset of RGI_Emoji_Modifier_Sequence string trie |
| i7 offset of RGI_Emoji_Flag_Sequence string trie |
| i8 offset of RGI_Emoji_Tag_Sequence string trie |
| i9 offset of RGI_Emoji_ZWJ_Sequence string trie |
| i10..i12 reserved, same as the limit offset of the previous part |
| i13 totalSize -- same as the limit offset of the previous part |
| i14..i15 reserved, 0 |
| |
| After the indexes array follows a UCPTrie=CodePointTrie (type=fast, valueWidth=8) |
| "cpTrie" with one bit each for multiple binary properties; |
| see EmojiProps::BIT_... constants. |
| |
| After that follow consecutive, serialized, |
| single-property UCharsTrie=CharsTrie string tries for multiple properties of strings; |
| see EmojiProps::IX_.._TRIE_OFFSET constants. |
| |
| The Basic_Emoji property contains both single code points and multi-character strings. |
| Its data is in both the code point trie and in one of the string tries. |
| |
| ----------------------------------------------------------------------------- */ |
| |
| U_NAMESPACE_USE |
| |
| // UDataInfo cf. udata.h |
| static UDataInfo dataInfo={ |
| sizeof(UDataInfo), |
| 0, |
| |
| U_IS_BIG_ENDIAN, |
| U_CHARSET_FAMILY, |
| U_SIZEOF_UCHAR, |
| 0, |
| |
| { u'E', u'm', u'o', u'j' }, // dataFormat="Emoj" |
| { 1, 0, 0, 0 }, // formatVersion |
| { 14, 0, 0, 0 } // dataVersion |
| }; |
| |
| class EmojiPropsBuilder : public PropsBuilder { |
| public: |
| EmojiPropsBuilder(UErrorCode &errorCode); |
| ~EmojiPropsBuilder() override; |
| |
| void setUnicodeVersion(const UVersionInfo version) override; |
| void setProps(const UniProps &, const UnicodeSet &newValues, UErrorCode &errorCode) override; |
| void parseUnidataFiles(const char *unidataPath, UErrorCode &errorCode) override; |
| void build(UErrorCode &errorCode) override; |
| void writeBinaryData(const char *path, UBool withCopyright, UErrorCode &errorCode) override; |
| |
| // visible for C adapter |
| void parsePropsOfStringsLine(char *fields[][2], UErrorCode &errorCode); |
| |
| private: |
| void setBit(UChar32 start, UChar32 end, int32_t shift, bool on, UErrorCode &errorCode); |
| void setBits(UChar32 start, UChar32 end, uint32_t value, uint32_t mask, UErrorCode &errorCode); |
| void parsePropsOfStringsFile(const char *path, UErrorCode &errorCode); |
| |
| static int32_t getTrieIndex(int32_t index) { |
| U_ASSERT(TRIE_IX_START <= index); |
| U_ASSERT(index < TRIE_IX_LIMIT); |
| return index - TRIE_IX_START; |
| } |
| UCharsTrieBuilder &getTrieBuilder(int32_t index) { |
| index = getTrieIndex(index); |
| U_ASSERT(trieBuilders[index] != nullptr); |
| return *trieBuilders[index]; |
| } |
| UnicodeString &getTrieString(int32_t index) { |
| index = getTrieIndex(index); |
| return trieStrings[index]; |
| } |
| int32_t &getNumStrings(int32_t index) { |
| index = getTrieIndex(index); |
| return numStrings[index]; |
| } |
| |
| static constexpr int32_t TRIE_IX_START = EmojiProps::IX_BASIC_EMOJI_TRIE_OFFSET; |
| static constexpr int32_t TRIE_IX_LIMIT = EmojiProps::IX_RESERVED10; |
| |
| UMutableCPTrie *mutableCPTrie = nullptr; |
| UCPTrie *cpTrie = nullptr; |
| std::set<std::string> unrecognized; |
| UCharsTrieBuilder *trieBuilders[TRIE_IX_LIMIT - TRIE_IX_START] = { |
| nullptr, nullptr, nullptr, nullptr, nullptr, nullptr |
| }; |
| UnicodeString trieStrings[TRIE_IX_LIMIT - TRIE_IX_START]; |
| int32_t numStrings[TRIE_IX_LIMIT - TRIE_IX_START]; |
| int32_t indexes[EmojiProps::IX_COUNT] = { |
| 0, 0, 0, 0, |
| 0, 0, 0, 0, |
| 0, 0, 0, 0, |
| 0, 0, 0, 0 |
| }; |
| uint8_t trieBlock[100000]; |
| int32_t trieSize = 0; |
| }; |
| |
| EmojiPropsBuilder::EmojiPropsBuilder(UErrorCode &errorCode) { |
| mutableCPTrie = umutablecptrie_open(0, 0, &errorCode); |
| if (U_FAILURE(errorCode)) { |
| fprintf(stderr, "genprops/emoji error: umutablecptrie_open() failed: %s\n", |
| u_errorName(errorCode)); |
| } |
| bool isNull = false; |
| for (auto &ptr : trieBuilders) { |
| ptr = new UCharsTrieBuilder(errorCode); |
| if (ptr == nullptr) { |
| isNull = true; |
| } |
| } |
| if (isNull && U_SUCCESS(errorCode)) { |
| errorCode = U_MEMORY_ALLOCATION_ERROR; |
| } |
| if (U_FAILURE(errorCode)) { |
| fprintf(stderr, "genprops/emoji error: new UCharsTrieBuilder() failed: %s\n", |
| u_errorName(errorCode)); |
| } |
| for (auto &num : numStrings) { |
| num = 0; |
| } |
| } |
| |
| EmojiPropsBuilder::~EmojiPropsBuilder() { |
| umutablecptrie_close(mutableCPTrie); |
| ucptrie_close(cpTrie); |
| for (auto ptr : trieBuilders) { |
| delete ptr; |
| } |
| } |
| |
| void |
| EmojiPropsBuilder::setUnicodeVersion(const UVersionInfo version) { |
| uprv_memcpy(dataInfo.dataVersion, version, 4); |
| } |
| |
| namespace { |
| |
| struct PropToBinary { |
| UProperty prop; |
| int32_t shift; |
| }; |
| |
| constexpr PropToBinary propToBinaries[] = { |
| { UCHAR_EMOJI, EmojiProps::BIT_EMOJI }, |
| { UCHAR_EMOJI_PRESENTATION, EmojiProps::BIT_EMOJI_PRESENTATION }, |
| { UCHAR_EMOJI_MODIFIER, EmojiProps::BIT_EMOJI_MODIFIER }, |
| { UCHAR_EMOJI_MODIFIER_BASE, EmojiProps::BIT_EMOJI_MODIFIER_BASE }, |
| { UCHAR_EMOJI_COMPONENT, EmojiProps::BIT_EMOJI_COMPONENT }, |
| { UCHAR_EXTENDED_PICTOGRAPHIC, EmojiProps::BIT_EXTENDED_PICTOGRAPHIC }, |
| }; |
| |
| struct PropNameToIndex { |
| const char *propName; |
| int32_t emojiPropsIndex; |
| }; |
| |
| constexpr PropNameToIndex propNameToIndex[] = { |
| { "Basic_Emoji", EmojiProps::IX_BASIC_EMOJI_TRIE_OFFSET }, |
| { "Emoji_Keycap_Sequence", EmojiProps::IX_EMOJI_KEYCAP_SEQUENCE_TRIE_OFFSET }, |
| { "RGI_Emoji_Modifier_Sequence", EmojiProps::IX_RGI_EMOJI_MODIFIER_SEQUENCE_TRIE_OFFSET }, |
| { "RGI_Emoji_Flag_Sequence", EmojiProps::IX_RGI_EMOJI_FLAG_SEQUENCE_TRIE_OFFSET }, |
| { "RGI_Emoji_Tag_Sequence", EmojiProps::IX_RGI_EMOJI_TAG_SEQUENCE_TRIE_OFFSET }, |
| { "RGI_Emoji_ZWJ_Sequence", EmojiProps::IX_RGI_EMOJI_ZWJ_SEQUENCE_TRIE_OFFSET }, |
| }; |
| |
| } // namespace |
| |
| void |
| EmojiPropsBuilder::setProps(const UniProps &props, const UnicodeSet &newValues, |
| UErrorCode &errorCode) { |
| if (U_FAILURE(errorCode)) { return; } |
| |
| if (newValues.containsSome(0, UCHAR_BINARY_LIMIT-1)) { |
| for (const auto &p2b : propToBinaries) { |
| U_ASSERT(p2b.shift < 8); |
| if (newValues.contains(p2b.prop)) { |
| setBit(props.start, props.end, p2b.shift, props.binProps[p2b.prop], errorCode); |
| } |
| } |
| } |
| } |
| |
| void |
| EmojiPropsBuilder::setBit(UChar32 start, UChar32 end, int32_t shift, bool on, |
| UErrorCode &errorCode) { |
| uint32_t mask = U_MASK(shift); |
| uint32_t value = on ? mask : 0; |
| setBits(start, end, value, mask, errorCode); |
| } |
| |
| void |
| EmojiPropsBuilder::setBits(UChar32 start, UChar32 end, uint32_t value, uint32_t mask, |
| UErrorCode &errorCode) { |
| if (U_FAILURE(errorCode)) { return; } |
| |
| if (start == end) { |
| uint32_t oldValue = umutablecptrie_get(mutableCPTrie, start); |
| uint32_t newValue = (oldValue & ~mask) | value; |
| if (newValue != oldValue) { |
| umutablecptrie_set(mutableCPTrie, start, newValue, &errorCode); |
| } |
| return; |
| } |
| while (start <= end && U_SUCCESS(errorCode)) { |
| uint32_t oldValue; |
| UChar32 rangeEnd = umutablecptrie_getRange( |
| mutableCPTrie, start, UCPMAP_RANGE_NORMAL, 0, nullptr, nullptr, &oldValue); |
| if (rangeEnd > end) { |
| rangeEnd = end; |
| } |
| uint32_t newValue = (oldValue & ~mask) | value; |
| if (newValue != oldValue) { |
| umutablecptrie_setRange(mutableCPTrie, start, rangeEnd, newValue, &errorCode); |
| } |
| start = rangeEnd + 1; |
| } |
| } |
| |
| namespace { |
| |
| void U_CALLCONV |
| parsePropsOfStringsLineFn( |
| void *context, |
| char *fields[][2], int32_t /* fieldCount */, |
| UErrorCode *pErrorCode) { |
| reinterpret_cast<EmojiPropsBuilder *>(context)->parsePropsOfStringsLine(fields, *pErrorCode); |
| } |
| |
| } // namespace |
| |
| void |
| EmojiPropsBuilder::parseUnidataFiles(const char *unidataPath, UErrorCode &errorCode) { |
| CharString path(unidataPath, errorCode); |
| path.ensureEndsWithFileSeparator(errorCode); |
| if (U_FAILURE(errorCode)) { return; } |
| int32_t pathLength = path.length(); |
| path.append("emoji-sequences.txt", errorCode); |
| parsePropsOfStringsFile(path.data(), errorCode); |
| if (U_FAILURE(errorCode)) { return; } |
| path.truncate(pathLength); |
| path.append("emoji-zwj-sequences.txt", errorCode); |
| parsePropsOfStringsFile(path.data(), errorCode); |
| |
| if (U_SUCCESS(errorCode) && !unrecognized.empty()) { |
| puts("\n*** genprops/emoji warning: sample of unrecognized property names:"); |
| int32_t i = 0; |
| for (const auto &s : unrecognized) { |
| printf(" \"%s\"\n", s.c_str()); |
| if (++i == 10) { break; } |
| } |
| } |
| } |
| |
| void |
| EmojiPropsBuilder::parsePropsOfStringsFile(const char *path, UErrorCode &errorCode) { |
| if (U_FAILURE(errorCode)) { return; } |
| char *fields[3][2]; |
| u_parseDelimitedFile(path, ';', fields, 3, parsePropsOfStringsLineFn, this, &errorCode); |
| } |
| |
| void EmojiPropsBuilder::parsePropsOfStringsLine(char *fields[][2], UErrorCode &errorCode) { |
| if (U_FAILURE(errorCode)) { return; } |
| // Format: |
| // code_point(s) ; type_field ; description # comments |
| *fields[1][1] = 0; // NUL-terminate the name field |
| char *propName = const_cast<char *>(u_skipWhitespace(fields[1][0])); |
| u_rtrim(propName); |
| int32_t index = -1; |
| for (const PropNameToIndex &pn2i : propNameToIndex) { |
| if (strcmp(pn2i.propName, propName) == 0) { |
| index = pn2i.emojiPropsIndex; |
| break; |
| } |
| } |
| if (index < 0) { |
| // not a supported property |
| unrecognized.insert(propName); |
| return; |
| } |
| |
| const char *rangeOrString = fields[0][0]; |
| if (strstr(rangeOrString, "..") != nullptr) { |
| // Code point range: |
| // 231A..231B ; Basic_Emoji ; watch |
| if (index != EmojiProps::IX_BASIC_EMOJI_TRIE_OFFSET) { |
| fprintf(stderr, |
| "genprops/emoji error: single code points %s for %s\n", rangeOrString, propName); |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| uint32_t start, end; |
| u_parseCodePointRange(rangeOrString, &start, &end, &errorCode); |
| setBit(start, end, EmojiProps::BIT_BASIC_EMOJI, true, errorCode); |
| } else { |
| // Code point or string: |
| // 23F0 ; Basic_Emoji ; alarm clock |
| // 23F1 FE0F ; Basic_Emoji ; stopwatch |
| uint32_t first; |
| UChar s[100]; |
| int32_t length = u_parseString(rangeOrString, s, UPRV_LENGTHOF(s), &first, &errorCode); |
| if (U_FAILURE(errorCode)) { return; } |
| if (length == 0) { |
| fprintf(stderr, |
| "genprops/emoji error: empty string on line\n %s ; %s ; %s\n", |
| rangeOrString, propName, fields[2][0]); |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| if (length == U16_LENGTH(first)) { |
| // single code point |
| if (index != EmojiProps::IX_BASIC_EMOJI_TRIE_OFFSET) { |
| fprintf(stderr, |
| "genprops/emoji error: single code point %s for %s\n", rangeOrString, propName); |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| setBit(first, first, EmojiProps::BIT_BASIC_EMOJI, true, errorCode); |
| } else { |
| // more than one code point |
| UnicodeString us(false, s, length); |
| getTrieBuilder(index).add(us, 0, errorCode); |
| ++getNumStrings(index); |
| } |
| } |
| } |
| |
| void |
| EmojiPropsBuilder::build(UErrorCode &errorCode) { |
| if (U_FAILURE(errorCode)) { return; } |
| cpTrie = umutablecptrie_buildImmutable( |
| mutableCPTrie, UCPTRIE_TYPE_FAST, UCPTRIE_VALUE_BITS_8, &errorCode); |
| if (U_FAILURE(errorCode)) { |
| fprintf(stderr, |
| "genprops/emoji error: umutablecptrie_buildImmutable() failed: %s\n", |
| u_errorName(errorCode)); |
| return; |
| } |
| trieSize = ucptrie_toBinary(cpTrie, trieBlock, sizeof(trieBlock), &errorCode); |
| if (U_FAILURE(errorCode)) { |
| fprintf(stderr, |
| "genprops/emoji error: ucptrie_toBinary() failed: %s (length %ld)\n", |
| u_errorName(errorCode), (long)trieSize); |
| return; |
| } |
| U_ASSERT((trieSize & 3) == 0); // multiple of 4 bytes |
| |
| for (int32_t index = TRIE_IX_START; index < TRIE_IX_LIMIT; ++index) { |
| if (getNumStrings(index) == 0) { |
| fprintf(stderr, "genprops/emoji error: no strings for property index %d\n", (int)index); |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| UCharsTrieBuilder &builder = getTrieBuilder(index); |
| UnicodeString &result = getTrieString(index); |
| builder.buildUnicodeString(USTRINGTRIE_BUILD_SMALL, result, errorCode); |
| if (U_FAILURE(errorCode)) { |
| fprintf(stderr, |
| "genprops/emoji error: UCharsTrieBuilder[%d].buildUnicodeString() failed: %s\n", |
| (int)index, u_errorName(errorCode)); |
| return; |
| } |
| } |
| |
| // Set indexes. |
| int32_t length = sizeof(indexes); |
| U_ASSERT(length == EmojiProps::IX_COUNT * 4); |
| int32_t offset = length; |
| indexes[EmojiProps::IX_CPTRIE_OFFSET] = offset; |
| if (!beQuiet) { |
| puts("* uemoji.icu stats *"); |
| printf("UCPTrie size in bytes: %5u\n", (int)trieSize); |
| } |
| offset += trieSize; |
| |
| indexes[EmojiProps::IX_RESERVED1] = offset; |
| indexes[EmojiProps::IX_RESERVED2] = offset; |
| indexes[EmojiProps::IX_RESERVED3] = offset; |
| |
| int32_t index = EmojiProps::IX_BASIC_EMOJI_TRIE_OFFSET; |
| indexes[index] = offset; |
| length = getTrieString(index).length() * 2; |
| if (!beQuiet) { |
| printf("UCharsTrie size in bytes: Basic_Emoji %5u num strings: %5u\n", |
| (int)length, (int)getNumStrings(index)); |
| } |
| offset += length; |
| |
| index = EmojiProps::IX_EMOJI_KEYCAP_SEQUENCE_TRIE_OFFSET; |
| indexes[index] = offset; |
| length = getTrieString(index).length() * 2; |
| if (!beQuiet) { |
| printf("UCharsTrie size in bytes: Emoji_Keycap_Sequence %5u num strings: %5u\n", |
| (int)length, (int)getNumStrings(index)); |
| } |
| offset += length; |
| |
| index = EmojiProps::IX_RGI_EMOJI_MODIFIER_SEQUENCE_TRIE_OFFSET; |
| indexes[index] = offset; |
| length = getTrieString(index).length() * 2; |
| if (!beQuiet) { |
| printf("UCharsTrie size in bytes: RGI_Emoji_Modifier_Sequence %5u num strings: %5u\n", |
| (int)length, (int)getNumStrings(index)); |
| } |
| offset += length; |
| |
| index = EmojiProps::IX_RGI_EMOJI_FLAG_SEQUENCE_TRIE_OFFSET; |
| indexes[index] = offset; |
| length = getTrieString(index).length() * 2; |
| if (!beQuiet) { |
| printf("UCharsTrie size in bytes: RGI_Emoji_Flag_Sequence %5u num strings: %5u\n", |
| (int)length, (int)getNumStrings(index)); |
| } |
| offset += length; |
| |
| index = EmojiProps::IX_RGI_EMOJI_TAG_SEQUENCE_TRIE_OFFSET; |
| indexes[index] = offset; |
| length = getTrieString(index).length() * 2; |
| if (!beQuiet) { |
| printf("UCharsTrie size in bytes: RGI_Emoji_Tag_Sequence %5u num strings: %5u\n", |
| (int)length, (int)getNumStrings(index)); |
| } |
| offset += length; |
| |
| index = EmojiProps::IX_RGI_EMOJI_ZWJ_SEQUENCE_TRIE_OFFSET; |
| indexes[index] = offset; |
| length = getTrieString(index).length() * 2; |
| if (!beQuiet) { |
| printf("UCharsTrie size in bytes: RGI_Emoji_ZWJ_Sequence %5u num strings: %5u\n", |
| (int)length, (int)getNumStrings(index)); |
| } |
| offset += length; |
| |
| indexes[EmojiProps::IX_RESERVED10] = offset; |
| indexes[EmojiProps::IX_RESERVED11] = offset; |
| indexes[EmojiProps::IX_RESERVED12] = offset; |
| indexes[EmojiProps::IX_TOTAL_SIZE] = offset; |
| |
| if (!beQuiet) { |
| printf("data size: %6ld\n", (long)offset); |
| } |
| } |
| |
| namespace { |
| |
| void writeTrieBlock(UNewDataMemory *pData, const UnicodeString &s) { |
| udata_writeBlock(pData, s.getBuffer(), s.length() * 2); |
| } |
| |
| } // namespace |
| |
| void |
| EmojiPropsBuilder::writeBinaryData(const char *path, UBool withCopyright, UErrorCode &errorCode) { |
| if (U_FAILURE(errorCode)) { return; } |
| |
| UNewDataMemory *pData = udata_create(path, "icu", "uemoji", &dataInfo, |
| withCopyright ? U_COPYRIGHT_STRING : nullptr, &errorCode); |
| if (U_FAILURE(errorCode)) { |
| fprintf(stderr, "genprops/emoji error: udata_create(%s, uemoji.icu) failed: %s\n", |
| path, u_errorName(errorCode)); |
| return; |
| } |
| |
| udata_writeBlock(pData, indexes, sizeof(indexes)); |
| udata_writeBlock(pData, trieBlock, trieSize); |
| writeTrieBlock(pData, getTrieString(EmojiProps::IX_BASIC_EMOJI_TRIE_OFFSET)); |
| writeTrieBlock(pData, getTrieString(EmojiProps::IX_EMOJI_KEYCAP_SEQUENCE_TRIE_OFFSET)); |
| writeTrieBlock(pData, getTrieString(EmojiProps::IX_RGI_EMOJI_MODIFIER_SEQUENCE_TRIE_OFFSET)); |
| writeTrieBlock(pData, getTrieString(EmojiProps::IX_RGI_EMOJI_FLAG_SEQUENCE_TRIE_OFFSET)); |
| writeTrieBlock(pData, getTrieString(EmojiProps::IX_RGI_EMOJI_TAG_SEQUENCE_TRIE_OFFSET)); |
| writeTrieBlock(pData, getTrieString(EmojiProps::IX_RGI_EMOJI_ZWJ_SEQUENCE_TRIE_OFFSET)); |
| |
| long dataLength = udata_finish(pData, &errorCode); |
| if (U_FAILURE(errorCode)) { |
| fprintf(stderr, |
| "genprops/emoji error: error %s writing the output file\n", |
| u_errorName(errorCode)); |
| return; |
| } |
| |
| int32_t totalSize = indexes[EmojiProps::IX_TOTAL_SIZE]; |
| if (dataLength != (long)totalSize) { |
| fprintf(stderr, |
| "udata_finish(uemoji.icu) reports %ld bytes written but should be %ld\n", |
| dataLength, (long)totalSize); |
| errorCode = U_INTERNAL_PROGRAM_ERROR; |
| } |
| } |
| |
| PropsBuilder * |
| createEmojiPropsBuilder(UErrorCode &errorCode) { |
| if (U_FAILURE(errorCode)) { return nullptr; } |
| PropsBuilder *pb = new EmojiPropsBuilder(errorCode); |
| if (pb == nullptr) { |
| errorCode = U_MEMORY_ALLOCATION_ERROR; |
| } |
| return pb; |
| } |
| |
| /* |
| * Hey, Emacs, please set the following: |
| * |
| * Local Variables: |
| * indent-tabs-mode: nil |
| * End: |
| * |
| */ |
