bool contRangeProcSet::cgDisconnect(ConstrGraph* tgtCG) const
{
bool modified=false;
if(emptySet() || !validSet()) return modified;
if(tgtCG!=NULL)
{
// Disconnect this process set's bounds from its constraint craph
modified = tgtCG->removeVar(getLB()) || modified;
modified = tgtCG->removeVar(getUB()) || modified;
}
return modified;
}
// Removes the upper and lower bounds of this set from its associated constraint graph
// or the provided constraint graph (if it is not ==NULL) and sets cg to NULL if tgtCG==NULL.
// Returns true if this causes the constraint graph to change, false otherwise.
bool contRangeProcSet::cgDisconnect()
{
bool modified=false;
if(emptySet() || !validSet()) return modified;
if(cg!=NULL)
{
// Disconnect this process set's bounds from its constraint craph
modified = cg->removeVar(getLB()) || modified;
modified = cg->removeVar(getUB()) || modified;
cg = NULL;
}
return modified;
}
extern int
main(int argc, const char *argv[]) {
ExitingErrorCode errorCode("genuts46");
// predefined base sets
icu::UnicodeSet unassignedSet(UNICODE_STRING_SIMPLE("[:Cn:]"), errorCode);
icu::UnicodeSet labelSeparators(
UNICODE_STRING_SIMPLE("[\\u002E\\u3002\\uFF0E\\uFF61]"), errorCode);
icu::UnicodeSet mappedSet(
UNICODE_STRING_SIMPLE("[:Changes_When_NFKC_Casefolded:]"), errorCode);
mappedSet.removeAll(labelSeparators); // simplifies checking of mapped characters
icu::UnicodeSet baseValidSet(icu::UnicodeString(
"[[[[:^Changes_When_NFKC_Casefolded:]"
"-[:C:]-[:Z:]"
"-[:Block=Ideographic_Description_Characters:]]"
"[:ascii:]]-[.]]", -1, US_INV), errorCode);
// Characters that are disallowed when STD3 rules are applied,
// but valid when STD3 rules are not applied.
icu::UnicodeSet disallowedSTD3Set(icu::UnicodeString(
"[[:ascii:]-[\\u002D.a-zA-Z0-9]]", -1, US_INV), errorCode);
icu::UnicodeSet deviationSet(
UNICODE_STRING_SIMPLE("[\\u00DF\\u03C2\\u200C\\u200D]"), errorCode);
errorCode.assertSuccess();
// derived sets
icu::LocalUStringPrepProfilePointer namePrep(usprep_openByType(USPREP_RFC3491_NAMEPREP, errorCode));
const icu::Normalizer2 *nfkc_cf=
icu::Normalizer2::getInstance(NULL, "nfkc_cf", UNORM2_COMPOSE, errorCode);
errorCode.assertSuccess();
// HACK: The StringPrep API performs a BiDi check according to the data.
// We need to override that for this data generation, by resetting an internal flag.
namePrep->checkBiDi=FALSE;
icu::UnicodeSet baseExclusionSet;
icu::UnicodeString cString, mapping, namePrepResult;
for(UChar32 c=0; c<=0x10ffff; ++c) {
if(c==0xd800) {
c=0xe000;
}
int namePrepStatus=toIDNA2003(namePrep.getAlias(), c, namePrepResult);
if(namePrepStatus!=0) {
// get the UTS #46 base mapping value
switch(c) {
case 0xff0e:
case 0x3002:
case 0xff61:
mapping.setTo(0x2e);
break;
default:
cString.setTo(c);
nfkc_cf->normalize(cString, mapping, errorCode);
break;
}
if(
namePrepStatus>0 ?
// c is valid or mapped in IDNA2003
!labelSeparators.contains(c) && namePrepResult!=mapping :
// namePrepStatus<0: c is prohibited in IDNA2003
baseValidSet.contains(c) || (cString!=mapping && baseValidSet.containsAll(mapping))
) {
baseExclusionSet.add(c);
}
}
}
icu::UnicodeSet disallowedSet(0, 0x10ffff);
disallowedSet.
removeAll(labelSeparators).
removeAll(deviationSet).
removeAll(mappedSet).
removeAll(baseValidSet).
addAll(baseExclusionSet).
addAll(unassignedSet);
const icu::Normalizer2 *nfd=
icu::Normalizer2::getInstance(NULL, "nfc", UNORM2_DECOMPOSE, errorCode);
errorCode.assertSuccess();
icu::UnicodeSet ignoredSet; // will be a subset of mappedSet
icu::UnicodeSet removeSet;
icu::UnicodeString nfdString;
{
icu::UnicodeSetIterator iter(mappedSet);
while(iter.next()) {
UChar32 c=iter.getCodepoint();
cString.setTo(c);
nfkc_cf->normalize(cString, mapping, errorCode);
if(!baseValidSet.containsAll(mapping)) {
fprintf(stderr, "U+%04lX mapped -> disallowed: mapping not wholly in base valid set\n", (long)c);
disallowedSet.add(c);
removeSet.add(c);
} else if(mapping.isEmpty()) {
ignoredSet.add(c);
}
}
mappedSet.removeAll(removeSet);
}
errorCode.assertSuccess();
icu::UnicodeSet validSet(baseValidSet);
validSet.
removeAll(labelSeparators). // non-ASCII label separators will be mapped in the end
removeAll(deviationSet).
removeAll(disallowedSet).
removeAll(mappedSet).
add(0x2e); // not mapped, simply valid
UBool madeChange;
do {
madeChange=FALSE;
{
removeSet.clear();
icu::UnicodeSetIterator iter(validSet);
while(iter.next()) {
UChar32 c=iter.getCodepoint();
if(nfd->getDecomposition(c, nfdString) && !validSet.containsAll(nfdString)) {
fprintf(stderr, "U+%04lX valid -> disallowed: NFD not wholly valid\n", (long)c);
disallowedSet.add(c);
removeSet.add(c);
madeChange=TRUE;
}
}
validSet.removeAll(removeSet);
}
{
removeSet.clear();
icu::UnicodeSetIterator iter(mappedSet);
while(iter.next()) {
UChar32 c=iter.getCodepoint();
cString.setTo(c);
nfkc_cf->normalize(cString, mapping, errorCode);
nfd->normalize(mapping, nfdString, errorCode);
if(!validSet.containsAll(nfdString)) {
fprintf(stderr, "U+%04lX mapped -> disallowed: NFD of mapping not wholly valid\n", (long)c);
disallowedSet.add(c);
removeSet.add(c);
madeChange=TRUE;
}
}
mappedSet.removeAll(removeSet);
}
} while(madeChange);
errorCode.assertSuccess();
// finish up
labelSeparators.remove(0x2e).freeze(); // U+002E is simply valid
deviationSet.freeze();
ignoredSet.freeze();
validSet.freeze();
mappedSet.freeze();
disallowedSTD3Set.freeze();
// output
UChar32 prevStart=0, c=0;
Status prevStatus=DISALLOWED_STD3_VALID, status;
icu::UnicodeString prevMapping;
UVersionInfo prevAge={ 1, 1, 0, 0 }, age;
icu::UnicodeSetIterator iter(disallowedSet);
while(iter.nextRange()) {
UChar32 start=iter.getCodepoint();
while(c<start) {
mapping.remove();
if(labelSeparators.contains(c)) {
status=MAPPED;
mapping.setTo(0x2e);
} else if(deviationSet.contains(c)) {
status=DEVIATION;
cString.setTo(c);
nfkc_cf->normalize(cString, mapping, errorCode);
} else if(ignoredSet.contains(c)) {
status=IGNORED;
} else if(validSet.contains(c)) {
if(disallowedSTD3Set.contains(c)) {
fprintf(stderr, "U+%04lX valid -> disallowed_STD3_valid: itself not STD3\n", (long)c);
status=DISALLOWED_STD3_VALID;
} else if( nfd->getDecomposition(c, nfdString) &&
disallowedSTD3Set.containsSome(nfdString)
) {
fprintf(stderr, "U+%04lX valid -> disallowed_STD3_valid: NFD not wholly STD3\n", (long)c);
status=DISALLOWED_STD3_VALID;
} else {
status=VALID;
}
} else if(mappedSet.contains(c)) {
cString.setTo(c);
nfkc_cf->normalize(cString, mapping, errorCode);
if(disallowedSTD3Set.containsSome(mapping)) {
fprintf(stderr, "U+%04lX mapped -> disallowed_STD3_mapped\n", (long)c);
status=DISALLOWED_STD3_MAPPED;
} else {
status=MAPPED;
}
} else {
fprintf(stderr, "*** undetermined status of U+%04lX\n", (long)c);
}
// Print a new line where the status, the mapping or
// the character age change.
getAgeIfAssigned(c, age);
if( prevStart<c &&
(status!=prevStatus || mapping!=prevMapping || 0!=memcmp(prevAge, age, 4))
) {
printLine(prevStart, c-1, prevStatus, prevMapping);
prevStart=c;
prevStatus=status;
prevMapping=mapping;
memcpy(prevAge, age, 4);
}
++c;
}
// c==start is disallowed
if(prevStart<c) {
printLine(prevStart, c-1, prevStatus, prevMapping);
}
prevStart=c;
prevStatus=DISALLOWED;
prevMapping.remove();
getAgeIfAssigned(c, prevAge);
UChar32 end=iter.getCodepointEnd();
while(++c<=end) {
getAgeIfAssigned(c, age);
if(prevStart<c && 0!=memcmp(prevAge, age, 4)) {
printLine(prevStart, c-1, prevStatus, prevMapping);
prevStart=c;
memcpy(prevAge, age, 4);
}
}
}
if(prevStart<c) {
printLine(prevStart, c-1, prevStatus, prevMapping);
}
return 0;
}
