king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd5f7aa4152'
${ noResults }
v811_spc009/external/icu/icu4c/source/tools/gennorm2/n2builder.cpp

1052 lines
40 KiB
Raw Blame History

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
*
* Copyright (C) 2009-2016, International Business Machines
* Corporation and others. All Rights Reserved.
*
*******************************************************************************
* file name: n2builder.cpp
* encoding: UTF-8
* 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>
#include <vector>
#include "unicode/errorcode.h"
#include "unicode/localpointer.h"
#include "unicode/putil.h"
#include "unicode/ucptrie.h"
#include "unicode/udata.h"
#include "unicode/umutablecptrie.h"
#include "unicode/uniset.h"
#include "unicode/unistr.h"
#include "unicode/usetiter.h"
#include "unicode/ustring.h"
#include "charstr.h"
#include "extradata.h"
#include "hash.h"
#include "normalizer2impl.h"
#include "norms.h"
#include "toolutil.h"
#include "unewdata.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" */
{ 4, 0, 0, 0 }, /* formatVersion */
{ 11, 0, 0, 0 } /* dataVersion (Unicode version) */
};
U_NAMESPACE_BEGIN
class HangulIterator {
public:
struct Range {
UChar32 start, end;
};
HangulIterator() : rangeIndex(0) {}
const Range *nextRange() {
if(rangeIndex<UPRV_LENGTHOF(ranges)) {
return ranges+rangeIndex++;
} else {
return NULL;
}
}
private:
static const Range ranges[4];
int32_t rangeIndex;
};
const HangulIterator::Range HangulIterator::ranges[4]={
{ Hangul::JAMO_L_BASE, Hangul::JAMO_L_END },
{ Hangul::JAMO_V_BASE, Hangul::JAMO_V_END },
// JAMO_T_BASE+1: not U+11A7
{ Hangul::JAMO_T_BASE+1, Hangul::JAMO_T_END },
{ Hangul::HANGUL_BASE, Hangul::HANGUL_END },
};
Normalizer2DataBuilder::Normalizer2DataBuilder(UErrorCode &errorCode) :
norms(errorCode),
phase(0), overrideHandling(OVERRIDE_PREVIOUS), optimization(OPTIMIZE_NORMAL),
norm16TrieBytes(nullptr), norm16TrieLength(0) {
memset(unicodeVersion, 0, sizeof(unicodeVersion));
memset(indexes, 0, sizeof(indexes));
memset(smallFCD, 0, sizeof(smallFCD));
}
Normalizer2DataBuilder::~Normalizer2DataBuilder() {
delete[] norm16TrieBytes;
}
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::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) {
norms.createNorm(c)->cc=cc;
norms.ccSet.add(c);
}
static UBool isWellFormed(const UnicodeString &s) {
UErrorCode errorCode=U_ZERO_ERROR;
u_strToUTF8(NULL, 0, NULL, toUCharPtr(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(norms.createNorm(c), c);
p->mapping=new UnicodeString(m);
p->mappingType=Norm::ONE_WAY;
p->setMappingCP();
norms.mappingSet.add(c);
}
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(toUCharPtr(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(norms.createNorm(c), c);
p->mapping=new UnicodeString(m);
p->mappingType=Norm::ROUND_TRIP;
p->mappingCP=U_SENTINEL;
norms.mappingSet.add(c);
}
void Normalizer2DataBuilder::removeMapping(UChar32 c) {
// createNorm(c), not getNorm(c), to record a non-mapping and detect conflicting data.
Norm *p=checkNormForMapping(norms.createNorm(c), c);
p->mappingType=Norm::REMOVED;
norms.mappingSet.add(c);
}
UBool Normalizer2DataBuilder::mappingHasCompBoundaryAfter(const BuilderReorderingBuffer &buffer,
Norm::MappingType mappingType) const {
if(buffer.isEmpty()) {
return FALSE; // Maps-to-empty-string is no boundary of any kind.
}
int32_t lastStarterIndex=buffer.lastStarterIndex();
if(lastStarterIndex<0) {
return FALSE; // no starter
}
const int32_t lastIndex=buffer.length()-1;
if(mappingType==Norm::ONE_WAY && lastStarterIndex<lastIndex && buffer.ccAt(lastIndex)>1) {
// One-way mapping where after the last starter is at least one combining mark
// with a combining class greater than 1,
// which means that another combining mark can reorder before it.
// By contrast, in a round-trip mapping this does not prevent a boundary as long as
// the starter or composite does not combine-forward with a following combining mark.
return FALSE;
}
UChar32 starter=buffer.charAt(lastStarterIndex);
if(lastStarterIndex==0 && norms.combinesBack(starter)) {
// The last starter is at the beginning of the mapping and combines backward.
return FALSE;
}
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!=lastIndex;
}
// Note: There can be no Hangul syllable in the fully decomposed mapping.
// Multiple starters can combine into one.
// Look for the first of the last sequence of starters, excluding Jamos.
int32_t i=lastStarterIndex;
UChar32 c;
while(0<i && buffer.ccAt(i-1)==0 && !Hangul::isJamo(c=buffer.charAt(i-1))) {
starter=c;
--i;
}
// Compose as far as possible, and see if further compositions with
// characters following this mapping are possible.
const Norm *starterNorm=norms.getNorm(starter);
if(i==lastStarterIndex &&
(starterNorm==nullptr || starterNorm->compositions==nullptr)) {
return TRUE; // The last starter does not combine forward.
}
uint8_t prevCC=0;
while(++i<buffer.length()) {
uint8_t cc=buffer.ccAt(i); // !=0 if after last starter
if(i>lastStarterIndex && norms.combinesWithCCBetween(*starterNorm, prevCC, cc)) {
// The starter combines with a mark that reorders before the current one.
return FALSE;
}
UChar32 c=buffer.charAt(i);
if(starterNorm!=nullptr && (prevCC<cc || prevCC==0) &&
norms.getNormRef(c).combinesBack && (starter=starterNorm->combine(c))>=0) {
// The starter combines with c into a composite replacement starter.
starterNorm=norms.getNorm(starter);
if(i>=lastStarterIndex &&
(starterNorm==nullptr || starterNorm->compositions==nullptr)) {
return TRUE; // The composite does not combine further.
}
// Keep prevCC because we "removed" the combining mark.
} else if(cc==0) {
starterNorm=norms.getNorm(c);
if(i==lastStarterIndex &&
(starterNorm==nullptr || starterNorm->compositions==nullptr)) {
return TRUE; // The new starter does not combine forward.
}
prevCC=0;
} else {
prevCC=cc;
}
}
if(prevCC==0) {
return FALSE; // forward-combining starter at the very end
}
if(norms.combinesWithCCBetween(*starterNorm, prevCC, 256)) {
// The starter combines with another mark.
return FALSE;
}
return TRUE;
}
UBool Normalizer2DataBuilder::mappingRecomposes(const BuilderReorderingBuffer &buffer) const {
if(buffer.lastStarterIndex()<0) {
return FALSE; // no starter
}
const Norm *starterNorm=nullptr;
uint8_t prevCC=0;
for(int32_t i=0; i<buffer.length(); ++i) {
UChar32 c=buffer.charAt(i);
uint8_t cc=buffer.ccAt(i);
if(starterNorm!=nullptr && (prevCC<cc || prevCC==0) &&
norms.getNormRef(c).combinesBack && starterNorm->combine(c)>=0) {
return TRUE; // normal composite
} else if(cc==0) {
if(Hangul::isJamoL(c)) {
if((i+1)<buffer.length() && Hangul::isJamoV(buffer.charAt(i+1))) {
return TRUE; // Hangul syllable
}
starterNorm=nullptr;
} else {
starterNorm=norms.getNorm(c);
}
}
prevCC=cc;
}
return FALSE;
}
void Normalizer2DataBuilder::postProcess(Norm &norm) {
// Prerequisites: Compositions are built, mappings are recursively decomposed.
// Mappings are not yet in canonical order.
//
// This function works on a Norm struct. We do not know which code point(s) map(s) to it.
// Therefore, we cannot compute algorithmic mapping deltas here.
// Error conditions are checked, but printed later when we do know the offending code point.
if(norm.hasMapping()) {
if(norm.mapping->length()>Normalizer2Impl::MAPPING_LENGTH_MASK) {
norm.error="mapping longer than maximum of 31";
return;
}
// Ensure canonical order.
BuilderReorderingBuffer buffer;
if(norm.rawMapping!=nullptr) {
norms.reorder(*norm.rawMapping, buffer);
buffer.reset();
}
norms.reorder(*norm.mapping, buffer);
if(buffer.isEmpty()) {
// A character that is deleted (maps to an empty string) must
// get the worst-case lccc and tccc values because arbitrary
// characters on both sides will become adjacent.
norm.leadCC=1;
norm.trailCC=0xff;
} else {
norm.leadCC=buffer.ccAt(0);
norm.trailCC=buffer.ccAt(buffer.length()-1);
}
norm.hasCompBoundaryBefore=
!buffer.isEmpty() && norm.leadCC==0 && !norms.combinesBack(buffer.charAt(0));
norm.hasCompBoundaryAfter=
norm.compositions==nullptr && mappingHasCompBoundaryAfter(buffer, norm.mappingType);
if(norm.combinesBack) {
norm.error="combines-back and decomposes, not possible in Unicode normalization";
} else if(norm.mappingType==Norm::ROUND_TRIP) {
if(norm.compositions!=NULL) {
norm.type=Norm::YES_NO_COMBINES_FWD;
} else {
norm.type=Norm::YES_NO_MAPPING_ONLY;
}
} else { // one-way mapping
if(norm.compositions!=NULL) {
norm.error="combines-forward and has a one-way mapping, "
"not possible in Unicode normalization";
} else if(buffer.isEmpty()) {
norm.type=Norm::NO_NO_EMPTY;
} else if(!norm.hasCompBoundaryBefore) {
norm.type=Norm::NO_NO_COMP_NO_MAYBE_CC;
} else if(mappingRecomposes(buffer)) {
norm.type=Norm::NO_NO_COMP_BOUNDARY_BEFORE;
} else {
// The mapping is comp-normalized.
norm.type=Norm::NO_NO_COMP_YES;
}
}
} else { // no mapping
norm.leadCC=norm.trailCC=norm.cc;
norm.hasCompBoundaryBefore=
norm.cc==0 && !norm.combinesBack;
norm.hasCompBoundaryAfter=
norm.cc==0 && !norm.combinesBack && norm.compositions==nullptr;
if(norm.combinesBack) {
if(norm.compositions!=nullptr) {
// Earlier code checked ccc=0.
norm.type=Norm::MAYBE_YES_COMBINES_FWD;
} else {
norm.type=Norm::MAYBE_YES_SIMPLE; // any ccc
}
} else if(norm.compositions!=nullptr) {
// Earlier code checked ccc=0.
norm.type=Norm::YES_YES_COMBINES_FWD;
} else if(norm.cc!=0) {
norm.type=Norm::YES_YES_WITH_CC;
} else {
norm.type=Norm::INERT;
}
}
}
class Norm16Writer : public Norms::Enumerator {
public:
Norm16Writer(UMutableCPTrie *trie, Norms &n, Normalizer2DataBuilder &b) :
Norms::Enumerator(n), builder(b), norm16Trie(trie) {}
void rangeHandler(UChar32 start, UChar32 end, Norm &norm) U_OVERRIDE {
builder.writeNorm16(norm16Trie, start, end, norm);
}
Normalizer2DataBuilder &builder;
UMutableCPTrie *norm16Trie;
};
void Normalizer2DataBuilder::setSmallFCD(UChar32 c) {
UChar32 lead= c<=0xffff ? c : U16_LEAD(c);
smallFCD[lead>>8]|=(uint8_t)1<<((lead>>5)&7);
}
void Normalizer2DataBuilder::writeNorm16(UMutableCPTrie *norm16Trie, UChar32 start, UChar32 end, Norm &norm) {
if((norm.leadCC|norm.trailCC)!=0) {
for(UChar32 c=start; c<=end; ++c) {
setSmallFCD(c);
}
}
int32_t norm16;
switch(norm.type) {
case Norm::INERT:
norm16=Normalizer2Impl::INERT;
break;
case Norm::YES_YES_COMBINES_FWD:
norm16=norm.offset*2;
break;
case Norm::YES_NO_COMBINES_FWD:
norm16=indexes[Normalizer2Impl::IX_MIN_YES_NO]+norm.offset*2;
break;
case Norm::YES_NO_MAPPING_ONLY:
norm16=indexes[Normalizer2Impl::IX_MIN_YES_NO_MAPPINGS_ONLY]+norm.offset*2;
break;
case Norm::NO_NO_COMP_YES:
norm16=indexes[Normalizer2Impl::IX_MIN_NO_NO]+norm.offset*2;
break;
case Norm::NO_NO_COMP_BOUNDARY_BEFORE:
norm16=indexes[Normalizer2Impl::IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE]+norm.offset*2;
break;
case Norm::NO_NO_COMP_NO_MAYBE_CC:
norm16=indexes[Normalizer2Impl::IX_MIN_NO_NO_COMP_NO_MAYBE_CC]+norm.offset*2;
break;
case Norm::NO_NO_EMPTY:
norm16=indexes[Normalizer2Impl::IX_MIN_NO_NO_EMPTY]+norm.offset*2;
break;
case Norm::NO_NO_DELTA:
{
// Positive offset from minNoNoDelta, shifted left for additional bits.
int32_t offset=(norm.offset+Normalizer2Impl::MAX_DELTA)<<Normalizer2Impl::DELTA_SHIFT;
if(norm.trailCC==0) {
// DELTA_TCCC_0==0
} else if(norm.trailCC==1) {
offset|=Normalizer2Impl::DELTA_TCCC_1;
} else {
offset|=Normalizer2Impl::DELTA_TCCC_GT_1;
}
norm16=getMinNoNoDelta()+offset;
break;
}
case Norm::MAYBE_YES_COMBINES_FWD:
norm16=indexes[Normalizer2Impl::IX_MIN_MAYBE_YES]+norm.offset*2;
break;
case Norm::MAYBE_YES_SIMPLE:
norm16=Normalizer2Impl::MIN_NORMAL_MAYBE_YES+norm.cc*2; // ccc=0..255
break;
case Norm::YES_YES_WITH_CC:
U_ASSERT(norm.cc!=0);
norm16=Normalizer2Impl::MIN_YES_YES_WITH_CC-2+norm.cc*2; // ccc=1..255
break;
default: // Should not occur.
exit(U_INTERNAL_PROGRAM_ERROR);
}
U_ASSERT((norm16&1)==0);
if(norm.hasCompBoundaryAfter) {
norm16|=Normalizer2Impl::HAS_COMP_BOUNDARY_AFTER;
}
IcuToolErrorCode errorCode("gennorm2/writeNorm16()");
umutablecptrie_setRange(norm16Trie, start, end, (uint32_t)norm16, errorCode);
// Set the minimum code points for real data lookups in the quick check loops.
UBool isDecompNo=
(Norm::YES_NO_COMBINES_FWD<=norm.type && norm.type<=Norm::NO_NO_DELTA) ||
norm.cc!=0;
if(isDecompNo && start<indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]) {
indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]=start;
}
UBool isCompNoMaybe= norm.type>=Norm::NO_NO_COMP_YES;
if(isCompNoMaybe && start<indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]) {
indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]=start;
}
if(norm.leadCC!=0 && start<indexes[Normalizer2Impl::IX_MIN_LCCC_CP]) {
indexes[Normalizer2Impl::IX_MIN_LCCC_CP]=start;
}
}
void Normalizer2DataBuilder::setHangulData(UMutableCPTrie *norm16Trie) {
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->end; ++c) {
if(umutablecptrie_get(norm16Trie, c)>Normalizer2Impl::INERT) {
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()");
// Jamo V/T are maybeYes
if(Hangul::JAMO_V_BASE<indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]) {
indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]=Hangul::JAMO_V_BASE;
}
umutablecptrie_setRange(norm16Trie, Hangul::JAMO_L_BASE, Hangul::JAMO_L_END,
Normalizer2Impl::JAMO_L, errorCode);
umutablecptrie_setRange(norm16Trie, Hangul::JAMO_V_BASE, Hangul::JAMO_V_END,
Normalizer2Impl::JAMO_VT, errorCode);
// JAMO_T_BASE+1: not U+11A7
umutablecptrie_setRange(norm16Trie, Hangul::JAMO_T_BASE+1, Hangul::JAMO_T_END,
Normalizer2Impl::JAMO_VT, errorCode);
// Hangul LV encoded as minYesNo
uint32_t lv=indexes[Normalizer2Impl::IX_MIN_YES_NO];
// Hangul LVT encoded as minYesNoMappingsOnly|HAS_COMP_BOUNDARY_AFTER
uint32_t lvt=indexes[Normalizer2Impl::IX_MIN_YES_NO_MAPPINGS_ONLY]|
Normalizer2Impl::HAS_COMP_BOUNDARY_AFTER;
if(Hangul::HANGUL_BASE<indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]) {
indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]=Hangul::HANGUL_BASE;
}
// Set the first LV, then write all other Hangul syllables as LVT,
// then overwrite the remaining LV.
umutablecptrie_set(norm16Trie, Hangul::HANGUL_BASE, lv, errorCode);
umutablecptrie_setRange(norm16Trie, Hangul::HANGUL_BASE+1, Hangul::HANGUL_END, lvt, errorCode);
UChar32 c=Hangul::HANGUL_BASE;
while((c+=Hangul::JAMO_T_COUNT)<=Hangul::HANGUL_END) {
umutablecptrie_set(norm16Trie, c, lv, errorCode);
}
errorCode.assertSuccess();
}
LocalUCPTriePointer Normalizer2DataBuilder::processData() {
// Build composition lists before recursive decomposition,
// so that we still have the raw, pair-wise mappings.
CompositionBuilder compBuilder(norms);
norms.enumRanges(compBuilder);
// Recursively decompose all mappings.
Decomposer decomposer(norms);
do {
decomposer.didDecompose=FALSE;
norms.enumRanges(decomposer);
} while(decomposer.didDecompose);
// Set the Norm::Type and other properties.
int32_t normsLength=norms.length();
for(int32_t i=1; i<normsLength; ++i) {
postProcess(norms.getNormRefByIndex(i));
}
// Write the properties, mappings and composition lists to
// appropriate parts of the "extra data" array.
ExtraData extra(norms, optimization==OPTIMIZE_FAST);
norms.enumRanges(extra);
extraData=extra.yesYesCompositions;
indexes[Normalizer2Impl::IX_MIN_YES_NO]=extraData.length()*2;
extraData.append(extra.yesNoMappingsAndCompositions);
indexes[Normalizer2Impl::IX_MIN_YES_NO_MAPPINGS_ONLY]=extraData.length()*2;
extraData.append(extra.yesNoMappingsOnly);
indexes[Normalizer2Impl::IX_MIN_NO_NO]=extraData.length()*2;
extraData.append(extra.noNoMappingsCompYes);
indexes[Normalizer2Impl::IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE]=extraData.length()*2;
extraData.append(extra.noNoMappingsCompBoundaryBefore);
indexes[Normalizer2Impl::IX_MIN_NO_NO_COMP_NO_MAYBE_CC]=extraData.length()*2;
extraData.append(extra.noNoMappingsCompNoMaybeCC);
indexes[Normalizer2Impl::IX_MIN_NO_NO_EMPTY]=extraData.length()*2;
extraData.append(extra.noNoMappingsEmpty);
indexes[Normalizer2Impl::IX_LIMIT_NO_NO]=extraData.length()*2;
// Pad the maybeYesCompositions length to a multiple of 4,
// so that NO_NO_DELTA bits 2..1 can be used without subtracting the center.
while(extra.maybeYesCompositions.length()&3) {
extra.maybeYesCompositions.append((UChar)0);
}
extraData.insert(0, extra.maybeYesCompositions);
indexes[Normalizer2Impl::IX_MIN_MAYBE_YES]=
Normalizer2Impl::MIN_NORMAL_MAYBE_YES-
extra.maybeYesCompositions.length()*2;
// Pad to even length for 4-byte alignment of following data.
if(extraData.length()&1) {
extraData.append((UChar)0);
}
int32_t minNoNoDelta=getMinNoNoDelta();
U_ASSERT((minNoNoDelta&7)==0);
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);
}
// writeNorm16() and setHangulData() reduce these as needed.
indexes[Normalizer2Impl::IX_MIN_DECOMP_NO_CP]=0x110000;
indexes[Normalizer2Impl::IX_MIN_COMP_NO_MAYBE_CP]=0x110000;
indexes[Normalizer2Impl::IX_MIN_LCCC_CP]=0x110000;
IcuToolErrorCode errorCode("gennorm2/processData()");
UMutableCPTrie *norm16Trie = umutablecptrie_open(
Normalizer2Impl::INERT, Normalizer2Impl::INERT, errorCode);
errorCode.assertSuccess();
// Map each code point to its norm16 value,
// including the properties that fit directly,
// and the offset to the "extra data" if necessary.
Norm16Writer norm16Writer(norm16Trie, norms, *this);
norms.enumRanges(norm16Writer);
// TODO: iterate via getRange() instead of callback?
setHangulData(norm16Trie);
// 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 UTF-16 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.
//
// First check that surrogate code *points* are inert.
// The parser should have rejected values/mappings for them.
uint32_t value;
UChar32 end = umutablecptrie_getRange(norm16Trie, 0xd800, UCPMAP_RANGE_NORMAL, 0,
nullptr, nullptr, &value);
if (value != Normalizer2Impl::INERT || end < 0xdfff) {
fprintf(stderr,
"gennorm2 error: not all surrogate code points are inert: U+d800..U+%04x=%lx\n",
(int)end, (long)value);
exit(U_INTERNAL_PROGRAM_ERROR);
}
uint32_t maxNorm16 = 0;
// ANDing values yields 0 bits where any value has a 0.
// Used for worst-case HAS_COMP_BOUNDARY_AFTER.
uint32_t andedNorm16 = 0;
end = 0;
for (UChar32 start = 0x10000;;) {
if (start > end) {
end = umutablecptrie_getRange(norm16Trie, start, UCPMAP_RANGE_NORMAL, 0,
nullptr, nullptr, &value);
if (end < 0) { break; }
}
if ((start & 0x3ff) == 0) {
// Data for a new lead surrogate.
maxNorm16 = andedNorm16 = value;
} else {
if (value > maxNorm16) {
maxNorm16 = value;
}
andedNorm16 &= value;
}
// Intersect each range with the code points for one lead surrogate.
UChar32 leadEnd = start | 0x3ff;
if (leadEnd <= end) {
// End of the supplementary block for a lead surrogate.
if (maxNorm16 >= (uint32_t)indexes[Normalizer2Impl::IX_LIMIT_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.
maxNorm16 = (uint32_t)indexes[Normalizer2Impl::IX_LIMIT_NO_NO];
}
maxNorm16 =
(maxNorm16 & ~Normalizer2Impl::HAS_COMP_BOUNDARY_AFTER)|
(andedNorm16 & Normalizer2Impl::HAS_COMP_BOUNDARY_AFTER);
if (maxNorm16 != Normalizer2Impl::INERT) {
umutablecptrie_set(norm16Trie, U16_LEAD(start), maxNorm16, errorCode);
}
if (value == Normalizer2Impl::INERT) {
// Potentially skip inert supplementary blocks for several lead surrogates.
start = (end + 1) & ~0x3ff;
} else {
start = leadEnd + 1;
}
} else {
start = end + 1;
}
}
// 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);
}
minCP=indexes[Normalizer2Impl::IX_MIN_LCCC_CP];
if(minCP>=0x10000) {
indexes[Normalizer2Impl::IX_MIN_LCCC_CP]=U16_LEAD(minCP);
}
LocalUCPTriePointer builtTrie(
umutablecptrie_buildImmutable(norm16Trie, UCPTRIE_TYPE_FAST, UCPTRIE_VALUE_BITS_16, errorCode));
norm16TrieLength=ucptrie_toBinary(builtTrie.getAlias(), nullptr, 0, errorCode);
if(errorCode.get()!=U_BUFFER_OVERFLOW_ERROR) {
fprintf(stderr, "gennorm2 error: unable to build/serialize the normalization trie - %s\n",
errorCode.errorName());
exit(errorCode.reset());
}
umutablecptrie_close(norm16Trie);
errorCode.reset();
norm16TrieBytes=new uint8_t[norm16TrieLength];
ucptrie_toBinary(builtTrie.getAlias(), norm16TrieBytes, norm16TrieLength, errorCode);
errorCode.assertSuccess();
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("minLcccCodePoint: U+%04lX\n", (long)indexes[Normalizer2Impl::IX_MIN_LCCC_CP]);
printf("minYesNo: (with compositions) 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: (comp-normalized) 0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_NO_NO]);
printf("minNoNoCompBoundaryBefore: 0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_NO_NO_COMP_BOUNDARY_BEFORE]);
printf("minNoNoCompNoMaybeCC: 0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_NO_NO_COMP_NO_MAYBE_CC]);
printf("minNoNoEmpty: 0x%04x\n", (int)indexes[Normalizer2Impl::IX_MIN_NO_NO_EMPTY]);
printf("limitNoNo: 0x%04x\n", (int)indexes[Normalizer2Impl::IX_LIMIT_NO_NO]);
printf("minNoNoDelta: 0x%04x\n", (int)minNoNoDelta);
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);
return builtTrie;
}
void Normalizer2DataBuilder::writeBinaryFile(const char *filename) {
processData();
IcuToolErrorCode errorCode("gennorm2/writeBinaryFile()");
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, norm16TrieLength);
udata_writeUString(pData, toUCharPtr(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) {
LocalUCPTriePointer norm16Trie = 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));
}
const char *name=dataName.data();
errorCode.assertSuccess();
FILE *f=usrc_create(path.data(), basename, 2016, "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);
}
fputs("#ifdef INCLUDED_FROM_NORMALIZER2_CPP\n\n", f);
char line[100];
sprintf(line, "static const UVersionInfo %s_formatVersion={", name);
usrc_writeArray(f, line, dataInfo.formatVersion, 8, 4, "};\n");
sprintf(line, "static const UVersionInfo %s_dataVersion={", name);
usrc_writeArray(f, line, dataInfo.dataVersion, 8, 4, "};\n\n");
sprintf(line, "static const int32_t %s_indexes[Normalizer2Impl::IX_COUNT]={\n", name);
usrc_writeArray(f, line, indexes, 32, Normalizer2Impl::IX_COUNT, "\n};\n\n");
usrc_writeUCPTrie(f, name, norm16Trie.getAlias());
sprintf(line, "static const uint16_t %s_extraData[%%ld]={\n", name);
usrc_writeArray(f, line, extraData.getBuffer(), 16, extraData.length(), "\n};\n\n");
sprintf(line, "static const uint8_t %s_smallFCD[%%ld]={\n", name);
usrc_writeArray(f, line, smallFCD, 8, sizeof(smallFCD), "\n};\n\n");
fputs("#endif // INCLUDED_FROM_NORMALIZER2_CPP\n", f);
fclose(f);
}
namespace {
bool equalStrings(const UnicodeString *s1, const UnicodeString *s2) {
if(s1 == nullptr) {
return s2 == nullptr;
} else if(s2 == nullptr) {
return false;
} else {
return *s1 == *s2;
}
}
const char *typeChars = "?-=>";
void writeMapping(FILE *f, const UnicodeString *m) {
if(m != nullptr && !m->isEmpty()) {
int32_t i = 0;
UChar32 c = m->char32At(i);
fprintf(f, "%04lX", (long)c);
while((i += U16_LENGTH(c)) < m->length()) {
c = m->char32At(i);
fprintf(f, " %04lX", (long)c);
}
}
fputs("\n", f);
}
} // namespace
void
Normalizer2DataBuilder::writeDataFile(const char *filename, bool writeRemoved) const {
// Do not processData() before writing the input-syntax data file.
FILE *f = fopen(filename, "w");
if(f == nullptr) {
fprintf(stderr, "gennorm2/writeDataFile() error: unable to create the output file %s\n",
filename);
exit(U_FILE_ACCESS_ERROR);
return;
}
if(unicodeVersion[0] != 0 || unicodeVersion[1] != 0 ||
unicodeVersion[2] != 0 || unicodeVersion[3] != 0) {
char uv[U_MAX_VERSION_STRING_LENGTH];
u_versionToString(unicodeVersion, uv);
fprintf(f, "* Unicode %s\n\n", uv);
}
UnicodeSetIterator ccIter(norms.ccSet);
UChar32 start = U_SENTINEL;
UChar32 end = U_SENTINEL;
uint8_t prevCC = 0;
bool done = false;
bool didWrite = false;
do {
UChar32 c;
uint8_t cc;
if(ccIter.next() && !ccIter.isString()) {
c = ccIter.getCodepoint();
cc = norms.getCC(c);
} else {
c = 0x110000;
cc = 0;
done = true;
}
if(cc == prevCC && c == (end + 1)) {
end = c;
} else {
if(prevCC != 0) {
if(start == end) {
fprintf(f, "%04lX:%d\n", (long)start, (int)prevCC);
} else {
fprintf(f, "%04lX..%04lX:%d\n", (long)start, (long)end, (int)prevCC);
}
didWrite = true;
}
start = end = c;
prevCC = cc;
}
} while(!done);
if(didWrite) {
fputs("\n", f);
}
UnicodeSetIterator mIter(norms.mappingSet);
start = U_SENTINEL;
end = U_SENTINEL;
const UnicodeString *prevMapping = nullptr;
Norm::MappingType prevType = Norm::NONE;
done = false;
do {
UChar32 c;
const Norm *norm;
if(mIter.next() && !mIter.isString()) {
c = mIter.getCodepoint();
norm = norms.getNorm(c);
} else {
c = 0x110000;
norm = nullptr;
done = true;
}
const UnicodeString *mapping;
Norm::MappingType type;
if(norm == nullptr) {
mapping = nullptr;
type = Norm::NONE;
} else {
type = norm->mappingType;
if(type == Norm::NONE) {
mapping = nullptr;
} else {
mapping = norm->mapping;
}
}
if(type == prevType && equalStrings(mapping, prevMapping) && c == (end + 1)) {
end = c;
} else {
if(writeRemoved ? prevType != Norm::NONE : prevType > Norm::REMOVED) {
if(start == end) {
fprintf(f, "%04lX%c", (long)start, typeChars[prevType]);
} else {
fprintf(f, "%04lX..%04lX%c", (long)start, (long)end, typeChars[prevType]);
}
writeMapping(f, prevMapping);
}
start = end = c;
prevMapping = mapping;
prevType = type;
}
} while(!done);
fclose(f);
}
void
Normalizer2DataBuilder::computeDiff(const Normalizer2DataBuilder &b1,
const Normalizer2DataBuilder &b2,
Normalizer2DataBuilder &diff) {
// Compute diff = b1 - b2
// so that we should be able to get b1 = b2 + diff.
if(0 != memcmp(b1.unicodeVersion, b2.unicodeVersion, U_MAX_VERSION_LENGTH)) {
memcpy(diff.unicodeVersion, b1.unicodeVersion, U_MAX_VERSION_LENGTH);
}
UnicodeSet ccSet(b1.norms.ccSet);
ccSet.addAll(b2.norms.ccSet);
UnicodeSetIterator ccIter(ccSet);
while(ccIter.next() && !ccIter.isString()) {
UChar32 c = ccIter.getCodepoint();
uint8_t cc1 = b1.norms.getCC(c);
uint8_t cc2 = b2.norms.getCC(c);
if(cc1 != cc2) {
diff.setCC(c, cc1);
}
}
UnicodeSet mSet(b1.norms.mappingSet);
mSet.addAll(b2.norms.mappingSet);
UnicodeSetIterator mIter(mSet);
while(mIter.next() && !mIter.isString()) {
UChar32 c = mIter.getCodepoint();
const Norm *norm1 = b1.norms.getNorm(c);
const Norm *norm2 = b2.norms.getNorm(c);
const UnicodeString *mapping1;
Norm::MappingType type1;
if(norm1 == nullptr || !norm1->hasMapping()) {
mapping1 = nullptr;
type1 = Norm::NONE;
} else {
mapping1 = norm1->mapping;
type1 = norm1->mappingType;
}
const UnicodeString *mapping2;
Norm::MappingType type2;
if(norm2 == nullptr || !norm2->hasMapping()) {
mapping2 = nullptr;
type2 = Norm::NONE;
} else {
mapping2 = norm2->mapping;
type2 = norm2->mappingType;
}
if(type1 == type2 && equalStrings(mapping1, mapping2)) {
// Nothing to do.
} else if(type1 == Norm::NONE) {
diff.removeMapping(c);
} else if(type1 == Norm::ROUND_TRIP) {
diff.setRoundTripMapping(c, *mapping1);
} else if(type1 == Norm::ONE_WAY) {
diff.setOneWayMapping(c, *mapping1);
}
}
}
U_NAMESPACE_END
#endif /* #if !UCONFIG_NO_NORMALIZATION */
/*
* Hey, Emacs, please set the following:
*
* Local Variables:
* indent-tabs-mode: nil
* End:
*/
Reference in new issue View Git Blame Copy Permalink