| /* |
| ******************************************************************************* |
| * |
| * Copyright (C) 2009-2014, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| * |
| ******************************************************************************* |
| * file name: n2builder.cpp |
| * encoding: US-ASCII |
| * tab size: 8 (not used) |
| * indentation:4 |
| * |
| * created on: 2009nov25 |
| * created by: Markus W. Scherer |
| * |
| * Builds Normalizer2 data and writes a binary .nrm file. |
| * For the file format see source/common/normalizer2impl.h. |
| */ |
| |
| #include "unicode/utypes.h" |
| #include "n2builder.h" |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #if U_HAVE_STD_STRING |
| #include <vector> |
| #endif |
| #include "unicode/errorcode.h" |
| #include "unicode/localpointer.h" |
| #include "unicode/putil.h" |
| #include "unicode/udata.h" |
| #include "unicode/uniset.h" |
| #include "unicode/unistr.h" |
| #include "unicode/ustring.h" |
| #include "charstr.h" |
| #include "hash.h" |
| #include "normalizer2impl.h" |
| #include "toolutil.h" |
| #include "unewdata.h" |
| #include "utrie2.h" |
| #include "uvectr32.h" |
| #include "writesrc.h" |
| |
| #if !UCONFIG_NO_NORMALIZATION |
| |
| /* UDataInfo cf. udata.h */ |
| static UDataInfo dataInfo={ |
| sizeof(UDataInfo), |
| 0, |
| |
| U_IS_BIG_ENDIAN, |
| U_CHARSET_FAMILY, |
| U_SIZEOF_UCHAR, |
| 0, |
| |
| { 0x4e, 0x72, 0x6d, 0x32 }, /* dataFormat="Nrm2" */ |
| { 2, 0, 0, 0 }, /* formatVersion */ |
| { 5, 2, 0, 0 } /* dataVersion (Unicode version) */ |
| }; |
| |
| U_NAMESPACE_BEGIN |
| |
| class HangulIterator { |
| public: |
| struct Range { |
| UChar32 start, limit; |
| uint16_t norm16; |
| }; |
| |
| HangulIterator() : rangeIndex(0) {} |
| const Range *nextRange() { |
| if(rangeIndex<UPRV_LENGTHOF(ranges)) { |
| return ranges+rangeIndex++; |
| } else { |
| return NULL; |
| } |
| } |
| void reset() { rangeIndex=0; } |
| private: |
| static const Range ranges[4]; |
| int32_t rangeIndex; |
| }; |
| |
| const HangulIterator::Range HangulIterator::ranges[4]={ |
| { Hangul::JAMO_L_BASE, Hangul::JAMO_L_BASE+Hangul::JAMO_L_COUNT, 1 }, |
| { Hangul::JAMO_V_BASE, Hangul::JAMO_V_BASE+Hangul::JAMO_V_COUNT, Normalizer2Impl::JAMO_VT }, |
| // JAMO_T_BASE+1: not U+11A7 |
| { Hangul::JAMO_T_BASE+1, Hangul::JAMO_T_BASE+Hangul::JAMO_T_COUNT, Normalizer2Impl::JAMO_VT }, |
| { Hangul::HANGUL_BASE, Hangul::HANGUL_BASE+Hangul::HANGUL_COUNT, 0 }, // will become minYesNo |
| }; |
| |
| struct CompositionPair { |
| CompositionPair(UChar32 t, UChar32 c) : trail(t), composite(c) {} |
| UChar32 trail, composite; |
| }; |
| |
| struct Norm { |
| enum MappingType { NONE, REMOVED, ROUND_TRIP, ONE_WAY }; |
| |
| UBool hasMapping() const { return mappingType>REMOVED; } |
| |
| // Requires hasMapping() and well-formed mapping. |
| void setMappingCP() { |
| UChar32 c; |
| if(!mapping->isEmpty() && mapping->length()==U16_LENGTH(c=mapping->char32At(0))) { |
| mappingCP=c; |
| } else { |
| mappingCP=U_SENTINEL; |
| } |
| } |
| |
| const CompositionPair *getCompositionPairs(int32_t &length) const { |
| if(compositions==NULL) { |
| length=0; |
| return NULL; |
| } else { |
| length=compositions->size()/2; |
| return reinterpret_cast<const CompositionPair *>(compositions->getBuffer()); |
| } |
| } |
| |
| UnicodeString *mapping; |
| UnicodeString *rawMapping; // non-NULL if the mapping is further decomposed |
| UChar32 mappingCP; // >=0 if mapping to 1 code point |
| int32_t mappingPhase; |
| MappingType mappingType; |
| |
| UVector32 *compositions; // (trail, composite) pairs |
| uint8_t cc; |
| UBool combinesBack; |
| UBool hasNoCompBoundaryAfter; |
| |
| enum OffsetType { |
| OFFSET_NONE, |
| // Composition for back-combining character. Allowed, but not normally used. |
| OFFSET_MAYBE_YES, |
| // Composition for a starter that does not have a decomposition mapping. |
| OFFSET_YES_YES, |
| // Round-trip mapping & composition for a starter. |
| OFFSET_YES_NO_MAPPING_AND_COMPOSITION, |
| // Round-trip mapping for a starter that itself does not combine-forward. |
| OFFSET_YES_NO_MAPPING_ONLY, |
| // One-way mapping. |
| OFFSET_NO_NO, |
| // Delta for an algorithmic one-way mapping. |
| OFFSET_DELTA |
| }; |
| enum { OFFSET_SHIFT=4, OFFSET_MASK=(1<<OFFSET_SHIFT)-1 }; |
| int32_t offset; |
| }; |
| |
| class Normalizer2DBEnumerator { |
| public: |
| Normalizer2DBEnumerator(Normalizer2DataBuilder &b) : builder(b) {} |
| virtual ~Normalizer2DBEnumerator() {} |
| virtual UBool rangeHandler(UChar32 start, UChar32 end, uint32_t value) = 0; |
| Normalizer2DBEnumerator *ptr() { return this; } |
| protected: |
| Normalizer2DataBuilder &builder; |
| }; |
| |
| U_CDECL_BEGIN |
| |
| static UBool U_CALLCONV |
| enumRangeHandler(const void *context, UChar32 start, UChar32 end, uint32_t value) { |
| return ((Normalizer2DBEnumerator *)context)->rangeHandler(start, end, value); |
| } |
| |
| U_CDECL_END |
| |
| Normalizer2DataBuilder::Normalizer2DataBuilder(UErrorCode &errorCode) : |
| phase(0), overrideHandling(OVERRIDE_PREVIOUS), optimization(OPTIMIZE_NORMAL), |
| norm16TrieLength(0) { |
| memset(unicodeVersion, 0, sizeof(unicodeVersion)); |
| normTrie=utrie2_open(0, 0, &errorCode); |
| normMem=utm_open("gennorm2 normalization structs", 10000, 0x110100, sizeof(Norm)); |
| norms=allocNorm(); // unused Norm struct at index 0 |
| memset(indexes, 0, sizeof(indexes)); |
| memset(smallFCD, 0, sizeof(smallFCD)); |
| } |
| |
| Normalizer2DataBuilder::~Normalizer2DataBuilder() { |
| utrie2_close(normTrie); |
| int32_t normsLength=utm_countItems(normMem); |
| for(int32_t i=1; i<normsLength; ++i) { |
| delete norms[i].mapping; |
| delete norms[i].rawMapping; |
| delete norms[i].compositions; |
| } |
| utm_close(normMem); |
| utrie2_close(norm16Trie); |
| } |
| |
| void |
| Normalizer2DataBuilder::setUnicodeVersion(const char *v) { |
| UVersionInfo nullVersion={ 0, 0, 0, 0 }; |
| UVersionInfo version; |
| u_versionFromString(version, v); |
| if( 0!=memcmp(version, unicodeVersion, U_MAX_VERSION_LENGTH) && |
| 0!=memcmp(nullVersion, unicodeVersion, U_MAX_VERSION_LENGTH) |
| ) { |
| char buffer[U_MAX_VERSION_STRING_LENGTH]; |
| u_versionToString(unicodeVersion, buffer); |
| fprintf(stderr, "gennorm2 error: multiple inconsistent Unicode version numbers %s vs. %s\n", |
| buffer, v); |
| exit(U_ILLEGAL_ARGUMENT_ERROR); |
| } |
| memcpy(unicodeVersion, version, U_MAX_VERSION_LENGTH); |
| } |
| |
| Norm *Normalizer2DataBuilder::allocNorm() { |
| Norm *p=(Norm *)utm_alloc(normMem); |
| norms=(Norm *)utm_getStart(normMem); // in case it got reallocated |
| return p; |
| } |
| |
| /* get an existing Norm unit */ |
| Norm *Normalizer2DataBuilder::getNorm(UChar32 c) { |
| uint32_t i=utrie2_get32(normTrie, c); |
| if(i==0) { |
| return NULL; |
| } |
| return norms+i; |
| } |
| |
| const Norm &Normalizer2DataBuilder::getNormRef(UChar32 c) const { |
| return norms[utrie2_get32(normTrie, c)]; |
| } |
| |
| /* |
| * get or create a Norm unit; |
| * get or create the intermediate trie entries for it as well |
| */ |
| Norm *Normalizer2DataBuilder::createNorm(UChar32 c) { |
| uint32_t i=utrie2_get32(normTrie, c); |
| if(i!=0) { |
| return norms+i; |
| } else { |
| /* allocate Norm */ |
| Norm *p=allocNorm(); |
| IcuToolErrorCode errorCode("gennorm2/createNorm()"); |
| utrie2_set32(normTrie, c, (uint32_t)(p-norms), errorCode); |
| return p; |
| } |
| } |
| |
| Norm *Normalizer2DataBuilder::checkNormForMapping(Norm *p, UChar32 c) { |
| if(p!=NULL) { |
| if(p->mappingType!=Norm::NONE) { |
| if( overrideHandling==OVERRIDE_NONE || |
| (overrideHandling==OVERRIDE_PREVIOUS && p->mappingPhase==phase) |
| ) { |
| fprintf(stderr, |
| "error in gennorm2 phase %d: " |
| "not permitted to override mapping for U+%04lX from phase %d\n", |
| (int)phase, (long)c, (int)p->mappingPhase); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| delete p->mapping; |
| p->mapping=NULL; |
| } |
| p->mappingPhase=phase; |
| } |
| return p; |
| } |
| |
| void Normalizer2DataBuilder::setOverrideHandling(OverrideHandling oh) { |
| overrideHandling=oh; |
| ++phase; |
| } |
| |
| void Normalizer2DataBuilder::setCC(UChar32 c, uint8_t cc) { |
| createNorm(c)->cc=cc; |
| } |
| |
| uint8_t Normalizer2DataBuilder::getCC(UChar32 c) const { |
| return getNormRef(c).cc; |
| } |
| |
| static UBool isWellFormed(const UnicodeString &s) { |
| UErrorCode errorCode=U_ZERO_ERROR; |
| u_strToUTF8(NULL, 0, NULL, s.getBuffer(), s.length(), &errorCode); |
| return U_SUCCESS(errorCode) || errorCode==U_BUFFER_OVERFLOW_ERROR; |
| } |
| |
| void Normalizer2DataBuilder::setOneWayMapping(UChar32 c, const UnicodeString &m) { |
| if(!isWellFormed(m)) { |
| fprintf(stderr, |
| "error in gennorm2 phase %d: " |
| "illegal one-way mapping from U+%04lX to malformed string\n", |
| (int)phase, (long)c); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| Norm *p=checkNormForMapping(createNorm(c), c); |
| p->mapping=new UnicodeString(m); |
| p->mappingType=Norm::ONE_WAY; |
| p->setMappingCP(); |
| } |
| |
| void Normalizer2DataBuilder::setRoundTripMapping(UChar32 c, const UnicodeString &m) { |
| if(U_IS_SURROGATE(c)) { |
| fprintf(stderr, |
| "error in gennorm2 phase %d: " |
| "illegal round-trip mapping from surrogate code point U+%04lX\n", |
| (int)phase, (long)c); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| if(!isWellFormed(m)) { |
| fprintf(stderr, |
| "error in gennorm2 phase %d: " |
| "illegal round-trip mapping from U+%04lX to malformed string\n", |
| (int)phase, (long)c); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| int32_t numCP=u_countChar32(m.getBuffer(), m.length()); |
| if(numCP!=2) { |
| fprintf(stderr, |
| "error in gennorm2 phase %d: " |
| "illegal round-trip mapping from U+%04lX to %d!=2 code points\n", |
| (int)phase, (long)c, (int)numCP); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| Norm *p=checkNormForMapping(createNorm(c), c); |
| p->mapping=new UnicodeString(m); |
| p->mappingType=Norm::ROUND_TRIP; |
| p->mappingCP=U_SENTINEL; |
| } |
| |
| void Normalizer2DataBuilder::removeMapping(UChar32 c) { |
| Norm *p=checkNormForMapping(getNorm(c), c); |
| if(p!=NULL) { |
| p->mappingType=Norm::REMOVED; |
| } |
| } |
| |
| class CompositionBuilder : public Normalizer2DBEnumerator { |
| public: |
| CompositionBuilder(Normalizer2DataBuilder &b) : Normalizer2DBEnumerator(b) {} |
| virtual UBool rangeHandler(UChar32 start, UChar32 end, uint32_t value) { |
| builder.addComposition(start, end, value); |
| return TRUE; |
| } |
| }; |
| |
| void |
| Normalizer2DataBuilder::addComposition(UChar32 start, UChar32 end, uint32_t value) { |
| if(norms[value].mappingType==Norm::ROUND_TRIP) { |
| if(start!=end) { |
| fprintf(stderr, |
| "gennorm2 error: same round-trip mapping for " |
| "more than 1 code point U+%04lX..U+%04lX\n", |
| (long)start, (long)end); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| if(norms[value].cc!=0) { |
| fprintf(stderr, |
| "gennorm2 error: " |
| "U+%04lX has a round-trip mapping and ccc!=0, " |
| "not possible in Unicode normalization\n", |
| (long)start); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| // setRoundTripMapping() ensured that there are exactly two code points. |
| const UnicodeString &m=*norms[value].mapping; |
| UChar32 lead=m.char32At(0); |
| UChar32 trail=m.char32At(m.length()-1); |
| if(getCC(lead)!=0) { |
| fprintf(stderr, |
| "gennorm2 error: " |
| "U+%04lX's round-trip mapping's starter U+%04lX has ccc!=0, " |
| "not possible in Unicode normalization\n", |
| (long)start, (long)lead); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| // Flag for trailing character. |
| createNorm(trail)->combinesBack=TRUE; |
| // Insert (trail, composite) pair into compositions list for the lead character. |
| IcuToolErrorCode errorCode("gennorm2/addComposition()"); |
| Norm *leadNorm=createNorm(lead); |
| UVector32 *compositions=leadNorm->compositions; |
| int32_t i; |
| if(compositions==NULL) { |
| compositions=leadNorm->compositions=new UVector32(errorCode); |
| i=0; // "insert" the first pair at index 0 |
| } else { |
| // Insertion sort, and check for duplicate trail characters. |
| int32_t length; |
| const CompositionPair *pairs=leadNorm->getCompositionPairs(length); |
| for(i=0; i<length; ++i) { |
| if(trail==pairs[i].trail) { |
| fprintf(stderr, |
| "gennorm2 error: same round-trip mapping for " |
| "more than 1 code point (e.g., U+%04lX) to U+%04lX + U+%04lX\n", |
| (long)start, (long)lead, (long)trail); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| if(trail<pairs[i].trail) { |
| break; |
| } |
| } |
| } |
| compositions->insertElementAt(trail, 2*i, errorCode); |
| compositions->insertElementAt(start, 2*i+1, errorCode); |
| } |
| } |
| |
| UBool Normalizer2DataBuilder::combinesWithCCBetween(const Norm &norm, |
| uint8_t lowCC, uint8_t highCC) const { |
| if((highCC-lowCC)>=2) { |
| int32_t length; |
| const CompositionPair *pairs=norm.getCompositionPairs(length); |
| for(int32_t i=0; i<length; ++i) { |
| uint8_t trailCC=getCC(pairs[i].trail); |
| if(lowCC<trailCC && trailCC<highCC) { |
| return TRUE; |
| } |
| } |
| } |
| return FALSE; |
| } |
| |
| UChar32 Normalizer2DataBuilder::combine(const Norm &norm, UChar32 trail) const { |
| int32_t length; |
| const CompositionPair *pairs=norm.getCompositionPairs(length); |
| for(int32_t i=0; i<length; ++i) { |
| if(trail==pairs[i].trail) { |
| return pairs[i].composite; |
| } |
| if(trail<pairs[i].trail) { |
| break; |
| } |
| } |
| return U_SENTINEL; |
| } |
| |
| class Decomposer : public Normalizer2DBEnumerator { |
| public: |
| Decomposer(Normalizer2DataBuilder &b) : Normalizer2DBEnumerator(b), didDecompose(FALSE) {} |
| virtual UBool rangeHandler(UChar32 start, UChar32 end, uint32_t value) { |
| didDecompose|=builder.decompose(start, end, value); |
| return TRUE; |
| } |
| UBool didDecompose; |
| }; |
| |
| UBool |
| Normalizer2DataBuilder::decompose(UChar32 start, UChar32 end, uint32_t value) { |
| if(norms[value].hasMapping()) { |
| Norm &norm=norms[value]; |
| const UnicodeString &m=*norm.mapping; |
| UnicodeString *decomposed=NULL; |
| const UChar *s=m.getBuffer(); |
| int32_t length=m.length(); |
| int32_t prev, i=0; |
| UChar32 c; |
| while(i<length) { |
| prev=i; |
| U16_NEXT(s, i, length, c); |
| if(start<=c && c<=end) { |
| fprintf(stderr, |
| "gennorm2 error: U+%04lX maps to itself directly or indirectly\n", |
| (long)c); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| const Norm &cNorm=getNormRef(c); |
| if(cNorm.hasMapping()) { |
| if(norm.mappingType==Norm::ROUND_TRIP) { |
| if(prev==0) { |
| if(cNorm.mappingType!=Norm::ROUND_TRIP) { |
| fprintf(stderr, |
| "gennorm2 error: " |
| "U+%04lX's round-trip mapping's starter " |
| "U+%04lX one-way-decomposes, " |
| "not possible in Unicode normalization\n", |
| (long)start, (long)c); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| uint8_t myTrailCC=getCC(m.char32At(i)); |
| UChar32 cTrailChar=cNorm.mapping->char32At(cNorm.mapping->length()-1); |
| uint8_t cTrailCC=getCC(cTrailChar); |
| if(cTrailCC>myTrailCC) { |
| fprintf(stderr, |
| "gennorm2 error: " |
| "U+%04lX's round-trip mapping's starter " |
| "U+%04lX decomposes and the " |
| "inner/earlier tccc=%hu > outer/following tccc=%hu, " |
| "not possible in Unicode normalization\n", |
| (long)start, (long)c, |
| (short)cTrailCC, (short)myTrailCC); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| } else { |
| fprintf(stderr, |
| "gennorm2 error: " |
| "U+%04lX's round-trip mapping's non-starter " |
| "U+%04lX decomposes, " |
| "not possible in Unicode normalization\n", |
| (long)start, (long)c); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| } |
| if(decomposed==NULL) { |
| decomposed=new UnicodeString(m, 0, prev); |
| } |
| decomposed->append(*cNorm.mapping); |
| } else if(Hangul::isHangul(c)) { |
| UChar buffer[3]; |
| int32_t hangulLength=Hangul::decompose(c, buffer); |
| if(norm.mappingType==Norm::ROUND_TRIP && prev!=0) { |
| fprintf(stderr, |
| "gennorm2 error: " |
| "U+%04lX's round-trip mapping's non-starter " |
| "U+%04lX decomposes, " |
| "not possible in Unicode normalization\n", |
| (long)start, (long)c); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| if(decomposed==NULL) { |
| decomposed=new UnicodeString(m, 0, prev); |
| } |
| decomposed->append(buffer, hangulLength); |
| } else if(decomposed!=NULL) { |
| decomposed->append(m, prev, i-prev); |
| } |
| } |
| if(decomposed!=NULL) { |
| if(norm.rawMapping==NULL) { |
| // Remember the original mapping when decomposing recursively. |
| norm.rawMapping=norm.mapping; |
| } else { |
| delete norm.mapping; |
| } |
| norm.mapping=decomposed; |
| // Not norm.setMappingCP(); because the original mapping |
| // is most likely to be encodable as a delta. |
| return TRUE; |
| } |
| } |
| return FALSE; |
| } |
| |
| class BuilderReorderingBuffer { |
| public: |
| BuilderReorderingBuffer() : fLength(0), fLastStarterIndex(-1), fDidReorder(FALSE) {} |
| void reset() { |
| fLength=0; |
| fLastStarterIndex=-1; |
| fDidReorder=FALSE; |
| } |
| int32_t length() const { return fLength; } |
| UBool isEmpty() const { return fLength==0; } |
| int32_t lastStarterIndex() const { return fLastStarterIndex; } |
| UChar32 charAt(int32_t i) const { return fArray[i]>>8; } |
| uint8_t ccAt(int32_t i) const { return (uint8_t)fArray[i]; } |
| UBool didReorder() const { return fDidReorder; } |
| void append(UChar32 c, uint8_t cc) { |
| if(cc==0 || fLength==0 || ccAt(fLength-1)<=cc) { |
| if(cc==0) { |
| fLastStarterIndex=fLength; |
| } |
| fArray[fLength++]=(c<<8)|cc; |
| return; |
| } |
| // Let this character bubble back to its canonical order. |
| int32_t i=fLength-1; |
| while(i>fLastStarterIndex && ccAt(i)>cc) { |
| --i; |
| } |
| ++i; // after the last starter or prevCC<=cc |
| // Move this and the following characters forward one to make space. |
| for(int32_t j=fLength; i<j; --j) { |
| fArray[j]=fArray[j-1]; |
| } |
| fArray[i]=(c<<8)|cc; |
| ++fLength; |
| fDidReorder=TRUE; |
| } |
| void toString(UnicodeString &dest) { |
| dest.remove(); |
| for(int32_t i=0; i<fLength; ++i) { |
| dest.append(charAt(i)); |
| } |
| } |
| void setComposite(UChar32 composite, int32_t combMarkIndex) { |
| fArray[fLastStarterIndex]=composite<<8; |
| // Remove the combining mark that contributed to the composite. |
| --fLength; |
| while(combMarkIndex<fLength) { |
| fArray[combMarkIndex]=fArray[combMarkIndex+1]; |
| ++combMarkIndex; |
| } |
| } |
| private: |
| int32_t fArray[Normalizer2Impl::MAPPING_LENGTH_MASK]; |
| int32_t fLength; |
| int32_t fLastStarterIndex; |
| UBool fDidReorder; |
| }; |
| |
| void |
| Normalizer2DataBuilder::reorder(Norm *p, BuilderReorderingBuffer &buffer) { |
| UnicodeString &m=*p->mapping; |
| int32_t length=m.length(); |
| if(length>Normalizer2Impl::MAPPING_LENGTH_MASK) { |
| return; // writeMapping() will complain about it and print the code point. |
| } |
| const UChar *s=m.getBuffer(); |
| int32_t i=0; |
| UChar32 c; |
| while(i<length) { |
| U16_NEXT(s, i, length, c); |
| buffer.append(c, getCC(c)); |
| } |
| if(buffer.didReorder()) { |
| buffer.toString(m); |
| } |
| } |
| |
| /* |
| * Computes the flag for the last code branch in Normalizer2Impl::hasCompBoundaryAfter(). |
| * A starter character with a mapping does not have a composition boundary after it |
| * if the character itself combines-forward (which is tested by the caller of this function), |
| * or it is deleted (mapped to the empty string), |
| * or its mapping contains no starter, |
| * or the last starter combines-forward. |
| */ |
| UBool Normalizer2DataBuilder::hasNoCompBoundaryAfter(BuilderReorderingBuffer &buffer) { |
| if(buffer.isEmpty()) { |
| return TRUE; // maps-to-empty-string is no boundary of any kind |
| } |
| int32_t lastStarterIndex=buffer.lastStarterIndex(); |
| if(lastStarterIndex<0) { |
| return TRUE; // no starter |
| } |
| UChar32 starter=buffer.charAt(lastStarterIndex); |
| if( Hangul::isJamoL(starter) || |
| (Hangul::isJamoV(starter) && |
| 0<lastStarterIndex && Hangul::isJamoL(buffer.charAt(lastStarterIndex-1))) |
| ) { |
| // A Jamo leading consonant or an LV pair combines-forward if it is at the end, |
| // otherwise it is blocked. |
| return lastStarterIndex==buffer.length()-1; |
| } |
| // Note: There can be no Hangul syllable in the fully decomposed mapping. |
| const Norm *starterNorm=&getNormRef(starter); |
| if(starterNorm->compositions==NULL) { |
| return FALSE; // the last starter does not combine forward |
| } |
| // Compose as far as possible, and see if further compositions are possible. |
| uint8_t prevCC=0; |
| for(int32_t combMarkIndex=lastStarterIndex+1; combMarkIndex<buffer.length();) { |
| uint8_t cc=buffer.ccAt(combMarkIndex); // !=0 because after last starter |
| if(combinesWithCCBetween(*starterNorm, prevCC, cc)) { |
| return TRUE; |
| } |
| if( prevCC<cc && |
| (starter=combine(*starterNorm, buffer.charAt(combMarkIndex)))>=0 |
| ) { |
| buffer.setComposite(starter, combMarkIndex); |
| starterNorm=&getNormRef(starter); |
| if(starterNorm->compositions==NULL) { |
| return FALSE; // the composite does not combine further |
| } |
| } else { |
| prevCC=cc; |
| ++combMarkIndex; |
| } |
| } |
| // TRUE if the final, forward-combining starter is at the end. |
| return prevCC==0; |
| } |
| |
| // Requires p->hasMapping(). |
| // Returns the offset of the "first unit" from the beginning of the extraData for c. |
| // That is the same as the length of the optional data for the raw mapping and the ccc/lccc word. |
| int32_t Normalizer2DataBuilder::writeMapping(UChar32 c, const Norm *p, UnicodeString &dataString) { |
| UnicodeString &m=*p->mapping; |
| int32_t length=m.length(); |
| if(length>Normalizer2Impl::MAPPING_LENGTH_MASK) { |
| fprintf(stderr, |
| "gennorm2 error: " |
| "mapping for U+%04lX longer than maximum of %d\n", |
| (long)c, Normalizer2Impl::MAPPING_LENGTH_MASK); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| int32_t leadCC, trailCC; |
| if(length==0) { |
| leadCC=trailCC=0; |
| } else { |
| leadCC=getCC(m.char32At(0)); |
| trailCC=getCC(m.char32At(length-1)); |
| } |
| if(c<Normalizer2Impl::MIN_CCC_LCCC_CP && (p->cc!=0 || leadCC!=0)) { |
| fprintf(stderr, |
| "gennorm2 error: " |
| "U+%04lX below U+0300 has ccc!=0 or lccc!=0, not supported by ICU\n", |
| (long)c); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| // Write small-FCD data. |
| if((leadCC|trailCC)!=0) { |
| UChar32 lead= c<=0xffff ? c : U16_LEAD(c); |
| smallFCD[lead>>8]|=(uint8_t)1<<((lead>>5)&7); |
| } |
| // Write the mapping & raw mapping extraData. |
| int32_t firstUnit=length|(trailCC<<8); |
| int32_t preMappingLength=0; |
| if(p->rawMapping!=NULL) { |
| UnicodeString &rm=*p->rawMapping; |
| int32_t rmLength=rm.length(); |
| if(rmLength>Normalizer2Impl::MAPPING_LENGTH_MASK) { |
| fprintf(stderr, |
| "gennorm2 error: " |
| "raw mapping for U+%04lX longer than maximum of %d\n", |
| (long)c, Normalizer2Impl::MAPPING_LENGTH_MASK); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| UChar rm0=rm.charAt(0); |
| if( rmLength==length-1 && |
| // 99: overlong substring lengths get pinned to remainder lengths anyway |
| 0==rm.compare(1, 99, m, 2, 99) && |
| rm0>Normalizer2Impl::MAPPING_LENGTH_MASK |
| ) { |
| // Compression: |
| // rawMapping=rm0+mapping.substring(2) -> store only rm0 |
| // |
| // The raw mapping is the same as the final mapping after replacing |
| // the final mapping's first two code units with the raw mapping's first one. |
| // In this case, we store only that first unit, rm0. |
| // This helps with a few hundred mappings. |
| dataString.append(rm0); |
| preMappingLength=1; |
| } else { |
| // Store the raw mapping with its length. |
| dataString.append(rm); |
| dataString.append((UChar)rmLength); |
| preMappingLength=rmLength+1; |
| } |
| firstUnit|=Normalizer2Impl::MAPPING_HAS_RAW_MAPPING; |
| } |
| int32_t cccLccc=p->cc|(leadCC<<8); |
| if(cccLccc!=0) { |
| dataString.append((UChar)cccLccc); |
| ++preMappingLength; |
| firstUnit|=Normalizer2Impl::MAPPING_HAS_CCC_LCCC_WORD; |
| } |
| if(p->hasNoCompBoundaryAfter) { |
| firstUnit|=Normalizer2Impl::MAPPING_NO_COMP_BOUNDARY_AFTER; |
| } |
| dataString.append((UChar)firstUnit); |
| dataString.append(m); |
| return preMappingLength; |
| } |
| |
| // Requires p->compositions!=NULL. |
| void Normalizer2DataBuilder::writeCompositions(UChar32 c, const Norm *p, UnicodeString &dataString) { |
| if(p->cc!=0) { |
| fprintf(stderr, |
| "gennorm2 error: " |
| "U+%04lX combines-forward and has ccc!=0, not possible in Unicode normalization\n", |
| (long)c); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| int32_t length; |
| const CompositionPair *pairs=p->getCompositionPairs(length); |
| for(int32_t i=0; i<length; ++i) { |
| const CompositionPair &pair=pairs[i]; |
| // 22 bits for the composite character and whether it combines forward. |
| UChar32 compositeAndFwd=pair.composite<<1; |
| if(getNormRef(pair.composite).compositions!=NULL) { |
| compositeAndFwd|=1; // The composite character also combines-forward. |
| } |
| // Encode most pairs in two units and some in three. |
| int32_t firstUnit, secondUnit, thirdUnit; |
| if(pair.trail<Normalizer2Impl::COMP_1_TRAIL_LIMIT) { |
| if(compositeAndFwd<=0xffff) { |
| firstUnit=pair.trail<<1; |
| secondUnit=compositeAndFwd; |
| thirdUnit=-1; |
| } else { |
| firstUnit=(pair.trail<<1)|Normalizer2Impl::COMP_1_TRIPLE; |
| secondUnit=compositeAndFwd>>16; |
| thirdUnit=compositeAndFwd; |
| } |
| } else { |
| firstUnit=(Normalizer2Impl::COMP_1_TRAIL_LIMIT+ |
| (pair.trail>>Normalizer2Impl::COMP_1_TRAIL_SHIFT))| |
| Normalizer2Impl::COMP_1_TRIPLE; |
| secondUnit=(pair.trail<<Normalizer2Impl::COMP_2_TRAIL_SHIFT)| |
| (compositeAndFwd>>16); |
| thirdUnit=compositeAndFwd; |
| } |
| // Set the high bit of the first unit if this is the last composition pair. |
| if(i==(length-1)) { |
| firstUnit|=Normalizer2Impl::COMP_1_LAST_TUPLE; |
| } |
| dataString.append((UChar)firstUnit).append((UChar)secondUnit); |
| if(thirdUnit>=0) { |
| dataString.append((UChar)thirdUnit); |
| } |
| } |
| } |
| |
| class ExtraDataWriter : public Normalizer2DBEnumerator { |
| public: |
| ExtraDataWriter(Normalizer2DataBuilder &b) : |
| Normalizer2DBEnumerator(b), |
| yesYesCompositions(1000, (UChar32)0xffff, 2), // 0=inert, 1=Jamo L, 2=start of compositions |
| yesNoMappingsAndCompositions(1000, (UChar32)0, 1) {} // 0=Hangul, 1=start of normal data |
| virtual UBool rangeHandler(UChar32 start, UChar32 end, uint32_t value) { |
| if(value!=0) { |
| if(start!=end) { |
| fprintf(stderr, |
| "gennorm2 error: unexpected shared data for " |
| "multiple code points U+%04lX..U+%04lX\n", |
| (long)start, (long)end); |
| exit(U_INTERNAL_PROGRAM_ERROR); |
| } |
| builder.writeExtraData(start, value, *this); |
| } |
| return TRUE; |
| } |
| UnicodeString maybeYesCompositions; |
| UnicodeString yesYesCompositions; |
| UnicodeString yesNoMappingsAndCompositions; |
| UnicodeString yesNoMappingsOnly; |
| UnicodeString noNoMappings; |
| Hashtable previousNoNoMappings; // If constructed in runtime code, pass in UErrorCode. |
| }; |
| |
| void Normalizer2DataBuilder::writeExtraData(UChar32 c, uint32_t value, ExtraDataWriter &writer) { |
| Norm *p=norms+value; |
| if(!p->hasMapping()) { |
| // Write small-FCD data. |
| // There is similar code in writeMapping() for characters that do have a mapping. |
| if(c<Normalizer2Impl::MIN_CCC_LCCC_CP && p->cc!=0) { |
| fprintf(stderr, |
| "gennorm2 error: " |
| "U+%04lX below U+0300 has ccc!=0, not supported by ICU\n", |
| (long)c); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| if(p->cc!=0) { |
| UChar32 lead= c<=0xffff ? c : U16_LEAD(c); |
| smallFCD[lead>>8]|=(uint8_t)1<<((lead>>5)&7); |
| } |
| } |
| if(p->combinesBack) { |
| if(p->hasMapping()) { |
| fprintf(stderr, |
| "gennorm2 error: " |
| "U+%04lX combines-back and decomposes, not possible in Unicode normalization\n", |
| (long)c); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| if(p->compositions!=NULL) { |
| p->offset= |
| (writer.maybeYesCompositions.length()<<Norm::OFFSET_SHIFT)| |
| Norm::OFFSET_MAYBE_YES; |
| writeCompositions(c, p, writer.maybeYesCompositions); |
| } |
| } else if(!p->hasMapping()) { |
| if(p->compositions!=NULL) { |
| p->offset= |
| (writer.yesYesCompositions.length()<<Norm::OFFSET_SHIFT)| |
| Norm::OFFSET_YES_YES; |
| writeCompositions(c, p, writer.yesYesCompositions); |
| } |
| } else if(p->mappingType==Norm::ROUND_TRIP) { |
| if(p->compositions!=NULL) { |
| int32_t offset=writer.yesNoMappingsAndCompositions.length()+ |
| writeMapping(c, p, writer.yesNoMappingsAndCompositions); |
| p->offset=(offset<<Norm::OFFSET_SHIFT)|Norm::OFFSET_YES_NO_MAPPING_AND_COMPOSITION; |
| writeCompositions(c, p, writer.yesNoMappingsAndCompositions); |
| } else { |
| int32_t offset=writer.yesNoMappingsOnly.length()+ |
| writeMapping(c, p, writer.yesNoMappingsOnly); |
| p->offset=(offset<<Norm::OFFSET_SHIFT)|Norm::OFFSET_YES_NO_MAPPING_ONLY; |
| } |
| } else /* one-way */ { |
| if(p->compositions!=NULL) { |
| fprintf(stderr, |
| "gennorm2 error: " |
| "U+%04lX combines-forward and has a one-way mapping, " |
| "not possible in Unicode normalization\n", |
| (long)c); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| if(p->cc==0 && optimization!=OPTIMIZE_FAST) { |
| // Try a compact, algorithmic encoding. |
| // Only for ccc=0, because we can't store additional information |
| // and we do not recursively follow an algorithmic encoding for access to the ccc. |
| // |
| // Also, if hasNoCompBoundaryAfter is set, we can only use the algorithmic encoding |
| // if the mappingCP decomposes further, to ensure that there is a place to store it. |
| // We want to see that the final mapping does not have exactly 1 code point, |
| // or else we would have to recursively ensure that the final mapping is stored |
| // in normal extraData. |
| if(p->mappingCP>=0 && (!p->hasNoCompBoundaryAfter || 1!=p->mapping->countChar32())) { |
| int32_t delta=p->mappingCP-c; |
| if(-Normalizer2Impl::MAX_DELTA<=delta && delta<=Normalizer2Impl::MAX_DELTA) { |
| p->offset=(delta<<Norm::OFFSET_SHIFT)|Norm::OFFSET_DELTA; |
| } |
| } |
| } |
| if(p->offset==0) { |
| int32_t oldNoNoLength=writer.noNoMappings.length(); |
| int32_t offset=oldNoNoLength+writeMapping(c, p, writer.noNoMappings); |
| UnicodeString newMapping=writer.noNoMappings.tempSubString(oldNoNoLength); |
| int32_t previousOffset=writer.previousNoNoMappings.geti(newMapping); |
| if(previousOffset!=0) { |
| // Duplicate, remove the new units and point to the old ones. |
| writer.noNoMappings.truncate(oldNoNoLength); |
| p->offset=((previousOffset-1)<<Norm::OFFSET_SHIFT)|Norm::OFFSET_NO_NO; |
| } else { |
| // Enter this new mapping into the hashtable, avoiding value 0 which is "not found". |
| IcuToolErrorCode errorCode("gennorm2/writeExtraData()/Hashtable.puti()"); |
| writer.previousNoNoMappings.puti(newMapping, offset+1, errorCode); |
| p->offset=(offset<<Norm::OFFSET_SHIFT)|Norm::OFFSET_NO_NO; |
| } |
| } |
| } |
| } |
| |
| class Norm16Writer : public Normalizer2DBEnumerator { |
| public: |
| Norm16Writer(Normalizer2DataBuilder &b) : Normalizer2DBEnumerator(b) {} |
| virtual UBool rangeHandler(UChar32 start, UChar32 end, uint32_t value) { |
| builder.writeNorm16(start, end, value); |
| return TRUE; |
| } |
| }; |
| |
| void Normalizer2DataBuilder::writeNorm16(UChar32 start, UChar32 end, uint32_t value) { |
| if(value!=0) { |
| const Norm *p=norms+value; |
| int32_t offset=p->offset>>Norm::OFFSET_SHIFT; |
| int32_t norm16=0; |
| UBool isDecompNo=FALSE; |
| UBool isCompNoMaybe=FALSE; |
| switch(p->offset&Norm::OFFSET_MASK) { |
| case Norm::OFFSET_NONE: |
| // No mapping, no compositions list. |
| if(p->combinesBack) { |
| norm16=Normalizer2Impl::MIN_NORMAL_MAYBE_YES+p->cc; |
| isDecompNo=(UBool)(p->cc!=0); |
| isCompNoMaybe=TRUE; |
| } else if(p->cc!=0) { |
| norm16=Normalizer2Impl::MIN_YES_YES_WITH_CC-1+p->cc; |
| isDecompNo=isCompNoMaybe=TRUE; |
| } |
| break; |
| case Norm::OFFSET_MAYBE_YES: |
| norm16=indexes[Normalizer2Impl::IX_MIN_MAYBE_YES]+offset; |
| isCompNoMaybe=TRUE; |
| break; |
| case Norm::OFFSET_YES_YES: |
| norm16=offset; |
| break; |
| case Norm::OFFSET_YES_NO_MAPPING_AND_COMPOSITION: |
| norm16=indexes[Normalizer2Impl::IX_MIN_YES_NO]+offset; |
| isDecompNo=TRUE; |
| break; |
| case Norm::OFFSET_YES_NO_MAPPING_ONLY: |
| norm16=indexes[Normalizer2Impl::IX_MIN_YES_NO_MAPPINGS_ONLY]+offset; |
| isDecompNo=TRUE; |
| break; |
| case Norm::OFFSET_NO_NO: |
| norm16=indexes[Normalizer2Impl::IX_MIN_NO_NO]+offset; |
| isDecompNo=isCompNoMaybe=TRUE; |
| break; |
| case Norm::OFFSET_DELTA: |
| norm16=getCenterNoNoDelta()+offset; |
| isDecompNo=isCompNoMaybe=TRUE; |
| break; |
| default: // Should not occur. |
| exit(U_INTERNAL_PROGRAM_ERROR); |
| } |
| IcuToolErrorCode errorCode("gennorm2/writeNorm16()"); |
| utrie2_setRange32(norm16Trie, start, end, (uint32_t)norm16, TRUE, errorCode); |
| if(isDecompNo && start<indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]) { |
| indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]=start; |
| } |
| if(isCompNoMaybe && start<indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]) { |
| indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]=start; |
| } |
| } |
| } |
| |
| void Normalizer2DataBuilder::setHangulData() { |
| HangulIterator hi; |
| const HangulIterator::Range *range; |
| // Check that none of the Hangul/Jamo code points have data. |
| while((range=hi.nextRange())!=NULL) { |
| for(UChar32 c=range->start; c<range->limit; ++c) { |
| if(utrie2_get32(norm16Trie, c)!=0) { |
| fprintf(stderr, |
| "gennorm2 error: " |
| "illegal mapping/composition/ccc data for Hangul or Jamo U+%04lX\n", |
| (long)c); |
| exit(U_INVALID_FORMAT_ERROR); |
| } |
| } |
| } |
| // Set data for algorithmic runtime handling. |
| IcuToolErrorCode errorCode("gennorm2/setHangulData()"); |
| hi.reset(); |
| while((range=hi.nextRange())!=NULL) { |
| uint16_t norm16=range->norm16; |
| if(norm16==0) { |
| norm16=(uint16_t)indexes[Normalizer2Impl::IX_MIN_YES_NO]; // Hangul LV/LVT encoded as minYesNo |
| if(range->start<indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]) { |
| indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]=range->start; |
| } |
| } else { |
| if(range->start<indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]) { // Jamo V/T are maybeYes |
| indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]=range->start; |
| } |
| } |
| utrie2_setRange32(norm16Trie, range->start, range->limit-1, norm16, TRUE, errorCode); |
| errorCode.assertSuccess(); |
| } |
| } |
| |
| U_CDECL_BEGIN |
| |
| static UBool U_CALLCONV |
| enumRangeMaxValue(const void *context, UChar32 /*start*/, UChar32 /*end*/, uint32_t value) { |
| uint32_t *pMaxValue=(uint32_t *)context; |
| if(value>*pMaxValue) { |
| *pMaxValue=value; |
| } |
| return TRUE; |
| } |
| |
| U_CDECL_END |
| |
| void Normalizer2DataBuilder::processData() { |
| IcuToolErrorCode errorCode("gennorm2/processData()"); |
| norm16Trie=utrie2_open(0, 0, errorCode); |
| errorCode.assertSuccess(); |
| |
| utrie2_enum(normTrie, NULL, enumRangeHandler, CompositionBuilder(*this).ptr()); |
| |
| Decomposer decomposer(*this); |
| do { |
| decomposer.didDecompose=FALSE; |
| utrie2_enum(normTrie, NULL, enumRangeHandler, &decomposer); |
| } while(decomposer.didDecompose); |
| |
| BuilderReorderingBuffer buffer; |
| int32_t normsLength=utm_countItems(normMem); |
| for(int32_t i=1; i<normsLength; ++i) { |
| // Set the hasNoCompBoundaryAfter flag for use by the last code branch |
| // in Normalizer2Impl::hasCompBoundaryAfter(). |
| // For details see the comments on hasNoCompBoundaryAfter(buffer). |
| const Norm &norm=norms[i]; |
| if(norm.hasMapping()) { |
| if(norm.compositions!=NULL) { |
| norms[i].hasNoCompBoundaryAfter=TRUE; |
| } else { |
| buffer.reset(); |
| reorder(norms+i, buffer); |
| norms[i].hasNoCompBoundaryAfter=hasNoCompBoundaryAfter(buffer); |
| } |
| } |
| } |
| |
| indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]=0x110000; |
| indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]=0x110000; |
| |
| ExtraDataWriter extraDataWriter(*this); |
| utrie2_enum(normTrie, NULL, enumRangeHandler, &extraDataWriter); |
| |
| extraData=extraDataWriter.maybeYesCompositions; |
| extraData.append(extraDataWriter.yesYesCompositions). |
| append(extraDataWriter.yesNoMappingsAndCompositions). |
| append(extraDataWriter.yesNoMappingsOnly). |
| append(extraDataWriter.noNoMappings); |
| // Pad to even length for 4-byte alignment of following data. |
| if(extraData.length()&1) { |
| extraData.append((UChar)0); |
| } |
| |
| indexes[Normalizer2Impl::IX_MIN_YES_NO]= |
| extraDataWriter.yesYesCompositions.length(); |
| indexes[Normalizer2Impl::IX_MIN_YES_NO_MAPPINGS_ONLY]= |
| indexes[Normalizer2Impl::IX_MIN_YES_NO]+ |
| extraDataWriter.yesNoMappingsAndCompositions.length(); |
| indexes[Normalizer2Impl::IX_MIN_NO_NO]= |
| indexes[Normalizer2Impl::IX_MIN_YES_NO_MAPPINGS_ONLY]+ |
| extraDataWriter.yesNoMappingsOnly.length(); |
| indexes[Normalizer2Impl::IX_LIMIT_NO_NO]= |
| indexes[Normalizer2Impl::IX_MIN_NO_NO]+ |
| extraDataWriter.noNoMappings.length(); |
| indexes[Normalizer2Impl::IX_MIN_MAYBE_YES]= |
| Normalizer2Impl::MIN_NORMAL_MAYBE_YES- |
| extraDataWriter.maybeYesCompositions.length(); |
| |
| int32_t minNoNoDelta=getCenterNoNoDelta()-Normalizer2Impl::MAX_DELTA; |
| if(indexes[Normalizer2Impl::IX_LIMIT_NO_NO]>minNoNoDelta) { |
| fprintf(stderr, |
| "gennorm2 error: " |
| "data structure overflow, too much mapping composition data\n"); |
| exit(U_BUFFER_OVERFLOW_ERROR); |
| } |
| |
| utrie2_enum(normTrie, NULL, enumRangeHandler, Norm16Writer(*this).ptr()); |
| |
| setHangulData(); |
| |
| // Look for the "worst" norm16 value of any supplementary code point |
| // corresponding to a lead surrogate, and set it as that surrogate's value. |
| // Enables quick check inner loops to look at only code units. |
| // |
| // We could be more sophisticated: |
| // We could collect a bit set for whether there are values in the different |
| // norm16 ranges (yesNo, maybeYes, yesYesWithCC etc.) |
| // and select the best value that only breaks the composition and/or decomposition |
| // inner loops if necessary. |
| // However, that seems like overkill for an optimization for supplementary characters. |
| for(UChar lead=0xd800; lead<0xdc00; ++lead) { |
| uint32_t maxValue=utrie2_get32(norm16Trie, lead); |
| utrie2_enumForLeadSurrogate(norm16Trie, lead, NULL, enumRangeMaxValue, &maxValue); |
| if( maxValue>=(uint32_t)indexes[Normalizer2Impl::IX_LIMIT_NO_NO] && |
| maxValue>(uint32_t)indexes[Normalizer2Impl::IX_MIN_NO_NO] |
| ) { |
| // Set noNo ("worst" value) if it got into "less-bad" maybeYes or ccc!=0. |
| // Otherwise it might end up at something like JAMO_VT which stays in |
| // the inner decomposition quick check loop. |
| maxValue=(uint32_t)indexes[Normalizer2Impl::IX_LIMIT_NO_NO]-1; |
| } |
| utrie2_set32ForLeadSurrogateCodeUnit(norm16Trie, lead, maxValue, errorCode); |
| } |
| |
| // Adjust supplementary minimum code points to break quick check loops at their lead surrogates. |
| // For an empty data file, minCP=0x110000 turns into 0xdc00 (first trail surrogate) |
| // which is harmless. |
| // As a result, the minimum code points are always BMP code points. |
| int32_t minCP=indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]; |
| if(minCP>=0x10000) { |
| indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]=U16_LEAD(minCP); |
| } |
| minCP=indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]; |
| if(minCP>=0x10000) { |
| indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]=U16_LEAD(minCP); |
| } |
| |
| utrie2_freeze(norm16Trie, UTRIE2_16_VALUE_BITS, errorCode); |
| norm16TrieLength=utrie2_serialize(norm16Trie, NULL, 0, errorCode); |
| if(errorCode.get()!=U_BUFFER_OVERFLOW_ERROR) { |
| fprintf(stderr, "gennorm2 error: unable to freeze/serialize the normalization trie - %s\n", |
| errorCode.errorName()); |
| exit(errorCode.reset()); |
| } |
| errorCode.reset(); |
| |
| int32_t offset=(int32_t)sizeof(indexes); |
| indexes[Normalizer2Impl::IX_NORM_TRIE_OFFSET]=offset; |
| offset+=norm16TrieLength; |
| indexes[Normalizer2Impl::IX_EXTRA_DATA_OFFSET]=offset; |
| offset+=extraData.length()*2; |
| indexes[Normalizer2Impl::IX_SMALL_FCD_OFFSET]=offset; |
| offset+=sizeof(smallFCD); |
| int32_t totalSize=offset; |
| for(int32_t i=Normalizer2Impl::IX_RESERVED3_OFFSET; i<=Normalizer2Impl::IX_TOTAL_SIZE; ++i) { |
| indexes[i]=totalSize; |
| } |
| |
| if(beVerbose) { |
| printf("size of normalization trie: %5ld bytes\n", (long)norm16TrieLength); |
| printf("size of 16-bit extra data: %5ld uint16_t\n", (long)extraData.length()); |
| printf("size of small-FCD data: %5ld bytes\n", (long)sizeof(smallFCD)); |
| printf("size of binary data file contents: %5ld bytes\n", (long)totalSize); |
| printf("minDecompNoCodePoint: U+%04lX\n", (long)indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]); |
| printf("minCompNoMaybeCodePoint: U+%04lX\n", (long)indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]); |
| printf("minYesNo: 0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_YES_NO]); |
| printf("minYesNoMappingsOnly: 0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_YES_NO_MAPPINGS_ONLY]); |
| printf("minNoNo: 0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_NO_NO]); |
| printf("limitNoNo: 0x%04x\n", (int)indexes[Normalizer2Impl::IX_LIMIT_NO_NO]); |
| printf("minMaybeYes: 0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_MAYBE_YES]); |
| } |
| |
| UVersionInfo nullVersion={ 0, 0, 0, 0 }; |
| if(0==memcmp(nullVersion, unicodeVersion, 4)) { |
| u_versionFromString(unicodeVersion, U_UNICODE_VERSION); |
| } |
| memcpy(dataInfo.dataVersion, unicodeVersion, 4); |
| } |
| |
| void Normalizer2DataBuilder::writeBinaryFile(const char *filename) { |
| processData(); |
| |
| IcuToolErrorCode errorCode("gennorm2/writeBinaryFile()"); |
| LocalArray<uint8_t> norm16TrieBytes(new uint8_t[norm16TrieLength]); |
| utrie2_serialize(norm16Trie, norm16TrieBytes.getAlias(), norm16TrieLength, errorCode); |
| errorCode.assertSuccess(); |
| |
| UNewDataMemory *pData= |
| udata_create(NULL, NULL, filename, &dataInfo, |
| haveCopyright ? U_COPYRIGHT_STRING : NULL, errorCode); |
| if(errorCode.isFailure()) { |
| fprintf(stderr, "gennorm2 error: unable to create the output file %s - %s\n", |
| filename, errorCode.errorName()); |
| exit(errorCode.reset()); |
| } |
| udata_writeBlock(pData, indexes, sizeof(indexes)); |
| udata_writeBlock(pData, norm16TrieBytes.getAlias(), norm16TrieLength); |
| udata_writeUString(pData, extraData.getBuffer(), extraData.length()); |
| udata_writeBlock(pData, smallFCD, sizeof(smallFCD)); |
| int32_t writtenSize=udata_finish(pData, errorCode); |
| if(errorCode.isFailure()) { |
| fprintf(stderr, "gennorm2: error %s writing the output file\n", errorCode.errorName()); |
| exit(errorCode.reset()); |
| } |
| int32_t totalSize=indexes[Normalizer2Impl::IX_TOTAL_SIZE]; |
| if(writtenSize!=totalSize) { |
| fprintf(stderr, "gennorm2 error: written size %ld != calculated size %ld\n", |
| (long)writtenSize, (long)totalSize); |
| exit(U_INTERNAL_PROGRAM_ERROR); |
| } |
| } |
| |
| void |
| Normalizer2DataBuilder::writeCSourceFile(const char *filename) { |
| processData(); |
| |
| IcuToolErrorCode errorCode("gennorm2/writeCSourceFile()"); |
| const char *basename=findBasename(filename); |
| CharString path(filename, (int32_t)(basename-filename), errorCode); |
| CharString dataName(basename, errorCode); |
| const char *extension=strrchr(basename, '.'); |
| if(extension!=NULL) { |
| dataName.truncate((int32_t)(extension-basename)); |
| } |
| errorCode.assertSuccess(); |
| |
| LocalArray<uint8_t> norm16TrieBytes(new uint8_t[norm16TrieLength]); |
| utrie2_serialize(norm16Trie, norm16TrieBytes.getAlias(), norm16TrieLength, errorCode); |
| errorCode.assertSuccess(); |
| |
| FILE *f=usrc_create(path.data(), basename, "icu/source/tools/gennorm2/n2builder.cpp"); |
| if(f==NULL) { |
| fprintf(stderr, "gennorm2/writeCSourceFile() error: unable to create the output file %s\n", |
| filename); |
| exit(U_FILE_ACCESS_ERROR); |
| return; |
| } |
| char line[100]; |
| sprintf(line, "static const UVersionInfo %s_formatVersion={", dataName.data()); |
| usrc_writeArray(f, line, dataInfo.formatVersion, 8, 4, "};\n"); |
| sprintf(line, "static const UVersionInfo %s_dataVersion={", dataName.data()); |
| usrc_writeArray(f, line, dataInfo.dataVersion, 8, 4, "};\n\n"); |
| sprintf(line, "static const int32_t %s_indexes[Normalizer2Impl::IX_COUNT]={\n", |
| dataName.data()); |
| usrc_writeArray(f, |
| line, |
| indexes, 32, Normalizer2Impl::IX_COUNT, |
| "\n};\n\n"); |
| sprintf(line, "static const uint16_t %s_trieIndex[%%ld]={\n", dataName.data()); |
| usrc_writeUTrie2Arrays(f, |
| line, NULL, |
| norm16Trie, |
| "\n};\n\n"); |
| sprintf(line, "static const uint16_t %s_extraData[%%ld]={\n", dataName.data()); |
| usrc_writeArray(f, |
| line, |
| extraData.getBuffer(), 16, extraData.length(), |
| "\n};\n\n"); |
| sprintf(line, "static const uint8_t %s_smallFCD[%%ld]={\n", dataName.data()); |
| usrc_writeArray(f, |
| line, |
| smallFCD, 8, sizeof(smallFCD), |
| "\n};\n\n"); |
| /*fputs( // TODO |
| "static const UCaseProps %s_singleton={\n" |
| " NULL,\n" |
| " %s_indexes,\n" |
| " %s_extraData,\n" |
| " %s_smallFCD,\n", |
| f);*/ |
| sprintf(line, "static const UTrie2 %s_trie={\n", dataName.data()); |
| char line2[100]; |
| sprintf(line2, "%s_trieIndex", dataName.data()); |
| usrc_writeUTrie2Struct(f, |
| line, |
| norm16Trie, line2, NULL, |
| "};\n"); |
| fclose(f); |
| } |
| |
| U_NAMESPACE_END |
| |
| #endif /* #if !UCONFIG_NO_NORMALIZATION */ |
| |
| /* |
| * Hey, Emacs, please set the following: |
| * |
| * Local Variables: |
| * indent-tabs-mode: nil |
| * End: |
| */ |
