organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-05 21:45:37 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 12

ICU-0 misc fixes for 4.0.1

Browse source 
X-SVN-Rev: 12644
This commit is contained in:
Mark Davis 2003-07-21 15:50:07 +00:00
parent a7562f974b
commit 48a93f33de
15 changed files with 159 additions and 124 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
tools/unicodetools/com/ibm/text/UCD/CompareProperties.java
View file

@ -5,8 +5,8 @@
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/UCD/CompareProperties.java,v $
* $Date: 2003/05/14 22:31:38 $
* $Revision: 1.1 $
* $Date: 2003/07/21 15:50:07 $
* $Revision: 1.2 $
*
*******************************************************************************
*/
@ -179,7 +179,7 @@ public class CompareProperties implements UCD_Types {
}
UnicodeProperty up = UnifiedBinaryProperty.make(i, Default.ucd);
if (up == null) continue;
if (up.getValueType() < BINARY) {
if (up.getValueType() < BINARY_PROP) {
System.out.println("\tSkipping " + up.getName() + "; value varies");
continue;
}
@ -401,7 +401,7 @@ public class CompareProperties implements UCD_Types {
System.out.println("Skipping " + upi.getName() + "; not standard");
continue;
}
if (upi.getValueType() < UCD_Types.BINARY) {
if (upi.getValueType() < UCD_Types.BINARY_PROP) {
System.out.println("Skipping " + upi.getName() + "; value varies");
continue;
}
@ -422,7 +422,7 @@ public class CompareProperties implements UCD_Types {
UnicodeProperty upj = UnifiedBinaryProperty.make(j, Default.ucd);
if (upj == null) continue;
if (!upj.isStandard()) continue;
if (upj.getValueType() < UCD_Types.BINARY) continue;
if (upj.getValueType() < UCD_Types.BINARY_PROP) continue;
if ((j >> 8) != last) {

10
tools/unicodetools/com/ibm/text/UCD/ConvertUCD.java
View file

@ -5,8 +5,8 @@
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/UCD/ConvertUCD.java,v $
* $Date: 2003/03/12 16:01:26 $
* $Revision: 1.11 $
* $Date: 2003/07/21 15:50:06 $
* $Revision: 1.12 $
*
*******************************************************************************
*/
@ -701,7 +701,7 @@ public final class ConvertUCD implements UCD_Types {
static void setBinaryProperty(int cp, int binProp) {
UData charEntry = getEntry(cp);
charEntry.binaryProperties |= (1 << binProp);
charEntry.binaryProperties |= (1L << binProp);
}
static void appendCharProperties(int cp, String key) {
@ -824,7 +824,7 @@ public final class ConvertUCD implements UCD_Types {
uData.specialCasing += fieldValue;
} else if (fieldName.equals("xp")) {
uData.binaryProperties |= 1 << Utility.lookup(fieldValue, UCD_Names.BP, true);
uData.binaryProperties |= 1L << Utility.lookup(fieldValue, UCD_Names.BP, true);
//UCD_Names.BP_OLD
} else if (fieldName.equals("gc")) {
@ -866,7 +866,7 @@ public final class ConvertUCD implements UCD_Types {
} else if (fieldName.equals("cc")) {
uData.combiningClass = (byte)Utility.intFrom(fieldValue);
} else if (fieldName.equals("bp")) {
uData.binaryProperties = (byte)Utility.intFrom(fieldValue);
uData.binaryProperties = (byte)Utility.longFrom(fieldValue);
} else {
throw new IllegalArgumentException("Unknown fieldName");
}

19
tools/unicodetools/com/ibm/text/UCD/DerivedProperty.java
View file

@ -5,8 +5,8 @@
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/UCD/DerivedProperty.java,v $
* $Date: 2003/05/02 21:46:33 $
* $Revision: 1.21 $
* $Date: 2003/07/21 15:50:06 $
* $Revision: 1.22 $
*
*******************************************************************************
*/
@ -230,7 +230,7 @@ public final class DerivedProperty implements UCD_Types {
GenDProp (int i) {
isStandard = false;
setValueType(NON_ENUMERATED);
setValueType(STRING_PROP);
type = DERIVED_NORMALIZATION;
nfx = nf[i];
name = nfx.getName();
@ -307,7 +307,7 @@ public final class DerivedProperty implements UCD_Types {
Normalizer nfx;
QuickDProp (int i) {
// setValueType((i == NFC || i == NFKC) ? ENUMERATED : BINARY);
setValueType(ENUMERATED);
setValueType(ENUMERATED_PROP);
type = DERIVED_NORMALIZATION;
nfx = nf[i];
NO = nfx.getName() + "_NO";
@ -601,7 +601,7 @@ of characters, the first of which has a non-zero combining class.
dprops[FC_NFKC_Closure] = new UnicodeProperty() {
{
type = DERIVED_NORMALIZATION;
setValueType(NON_ENUMERATED);
setValueType(STRING_PROP);
name = "FC_NFKC_Closure";
shortName = "FC_NFKC";
header = "# Derived Property: " + name
@ -626,7 +626,7 @@ of characters, the first of which has a non-zero combining class.
type = DERIVED_NORMALIZATION;
isStandard = false;
name = "FC_NFC_Closure";
setValueType(NON_ENUMERATED);
setValueType(STRING_PROP);
shortName = "FC_NFC";
header = "# Derived Property: " + name
+ "\r\n# Generated from computing: b = NFC(Fold(a)); c = NFC(Fold(b));"
@ -656,7 +656,8 @@ of characters, the first of which has a non-zero combining class.
hasUnassigned = true;
shortName = "DI";
header = header = "# Derived Property: " + name
+ "\r\n# Generated from Other_Default_Ignorable_Code_Point + Cf + Cc + Cs - White_Space"
+ "\r\n# Generated from (Other_Default_Ignorable_Code_Point + Variation_Selector"
+ "\r\n# + Noncharacter_Code_Point + Cf + Cc + Cs) - White_Space"
//+ "\r\n# - U+0600..U+0603 - U+06DD - U+070F"
;
}
@ -666,6 +667,8 @@ of characters, the first of which has a non-zero combining class.
//if (0x0600 <= cp && cp <= 0x0603 || 0x06DD == cp || 0x070F == cp) return false;
if (ucdData.getBinaryProperty(cp, Other_Default_Ignorable_Code_Point)) return true;
if (ucdData.getBinaryProperty(cp, Variation_Selector)) return true;
if (ucdData.getBinaryProperty(cp, Noncharacter_Code_Point)) return true;
byte cat = ucdData.getCategory(cp);
if (cat == Cf || cat == Cs || cat == Cc) return true;
return false;
@ -887,7 +890,7 @@ of characters, the first of which has a non-zero combining class.
for (int i = 0; i < dprops.length; ++i) {
UnicodeProperty up = dprops[i];
if (up == null) continue;
if (up.getValueType() != BINARY) continue;
if (up.getValueType() != BINARY_PROP) continue;
up.setValue(NUMBER, "1");
up.setValue(SHORT, "T");
up.setValue(LONG, "True");

6
tools/unicodetools/com/ibm/text/UCD/DerivedPropertyLister.java
View file

@ -5,8 +5,8 @@
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/UCD/DerivedPropertyLister.java,v $
* $Date: 2002/03/20 00:21:43 $
* $Revision: 1.10 $
* $Date: 2003/07/21 15:50:06 $
* $Revision: 1.11 $
*
*******************************************************************************
*/
@ -34,7 +34,7 @@ final class DerivedPropertyLister extends PropertyLister {
this.ucdData = ucd;
// this.dprop = new DerivedProperty(ucd);
uprop = DerivedProperty.make(propMask, ucd);
varies = uprop.getValueType() < BINARY;
varies = uprop.getValueType() < BINARY_PROP;
width = super.minPropertyWidth();
switch (propMask) {

80
tools/unicodetools/com/ibm/text/UCD/GenerateData.java
View file

@ -5,8 +5,8 @@
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/UCD/GenerateData.java,v $
* $Date: 2003/05/02 21:46:33 $
* $Revision: 1.28 $
* $Date: 2003/07/21 15:50:06 $
* $Revision: 1.29 $
*
*******************************************************************************
*/
@ -350,33 +350,30 @@ public class GenerateData implements UCD_Types {
Set sorted = new TreeSet(java.text.Collator.getInstance());
Set accumulation = new TreeSet(java.text.Collator.getInstance());
/*
BufferedReader blocks = Utility.openUnicodeFile("Blocks", Default.ucd.getVersion());
String[] parts = new String[10];
while (true) {
String line = blocks.readLine();
if (line == null) break;
int commentPos = line.indexOf('#');
if (commentPos >= 0) line = line.substring(0,commentPos);
line = line.trim();
if (line.length() == 0) continue;
int count = Utility.split(line,';',parts);
if (count != 2) System.out.println("Whow!");
value = Utility.getUnskeleton(parts[1].trim(), true);
valueAbb = "n/a";
addLine(sorted, "blk; " + valueAbb + spacing + "; " + value);
checkDuplicate(duplicates, accumulation, value, "Block=" + value);
}
blocks.close();
*/
for (int k = 0; k < UCD_Names.NON_ENUMERATED.length; ++k) {
propAbb = Utility.getUnskeleton(UCD_Names.NON_ENUMERATED[k][0], false);
prop = Utility.getUnskeleton(UCD_Names.NON_ENUMERATED[k][1], true);
addLine(sorted, "AA", propAbb, prop);
for (int k = 0; k < UCD_Names.NON_ENUMERATED_NAMES.length; ++k) {
propAbb = Utility.getUnskeleton(UCD_Names.NON_ENUMERATED_NAMES[k][0], false);
prop = Utility.getUnskeleton(UCD_Names.NON_ENUMERATED_NAMES[k][1], true);
byte type = STRING_PROP;
if (propAbb.equals("nv")) {
type = NUMERIC_PROP;
} else if (propAbb.equals("age")) {
type = CATALOG_PROP;
} else if (propAbb.equals("blk")) {
type = CATALOG_PROP;
} else if (propAbb.equals("na")) {
type = DESCRIPTIVE_PROP;
} else if (propAbb.equals("na1")) {
type = DESCRIPTIVE_PROP;
} else if (propAbb.equals("isc")) {
type = DESCRIPTIVE_PROP;
}
addLine(sorted, UCD_Names.PROP_TYPE_NAMES[type][1], propAbb, prop);
checkDuplicate(duplicates, accumulation, propAbb, prop);
if (!prop.equals(propAbb)) checkDuplicate(duplicates, accumulation, prop, prop);
}
addLine(sorted, UCD_Names.PROP_TYPE_NAMES[CATALOG_PROP][1], "URS", "Unicode_Radical_Stroke");
// TODO: merge above
for (int k = 0; k < UCD_Names.SUPER_CATEGORIES.length; ++k) {
valueAbb = Utility.getUnskeleton(UCD_Names.SUPER_CATEGORIES[k][0], false);
@ -386,8 +383,6 @@ public class GenerateData implements UCD_Types {
if (!value.equals(valueAbb)) checkDuplicate(duplicates, accumulation, valueAbb, "General_Category=" + value);
}
addLine(sorted, "AA", "URS", "Unicode_Radical_Stroke");
/*
addLine(sorted, "xx; T ; True");
checkDuplicate(duplicates, accumulation, "T", "xx=True");
@ -428,16 +423,18 @@ public class GenerateData implements UCD_Types {
}
propAbb = Utility.getUnskeleton(up.getProperty(SHORT), false);
prop = Utility.getUnskeleton(up.getProperty(LONG), true);
addLine(sorted, type != DERIVED && type != BINARY_PROPERTIES ? "BB"
: up.getValueType() == NON_ENUMERATED ? "AA"
: up.getValueType() == ENUMERATED ? "BB"
: "ZZ",
addLine(sorted,
type == SCRIPT
? UCD_Names.PROP_TYPE_NAMES[CATALOG_PROP][1]
: type != DERIVED && type != BINARY_PROPERTIES
? UCD_Names.PROP_TYPE_NAMES[ENUMERATED_PROP][1]
: UCD_Names.PROP_TYPE_NAMES[up.getValueType()][1],
propAbb, prop);
checkDuplicate(duplicates, accumulation, propAbb, prop);
if (!prop.equals(propAbb)) checkDuplicate(duplicates, accumulation, prop, prop);
}
if (up.getValueType() < BINARY) continue;
if (up.getValueType() < BINARY_PROP) continue;
value = up.getValue(LONG);
if (value.length() == 0) value = "none";
else if (value.equals("<unused>")) continue;
@ -493,7 +490,7 @@ public class GenerateData implements UCD_Types {
/*
if (type == BINARY_PROPERTIES || type == DERIVED) {
//if (value.equals(YN_TABLE_LONG[1])) continue;
addLine(sorted, "ZZ", valueAbb, value);
addLine(sorted, PROP_TYPE_NAMES[BINARY][1], valueAbb, value);
checkDuplicate(duplicates, accumulation, value, value);
if (!value.equalsIgnoreCase(valueAbb)) checkDuplicate(duplicates, accumulation, valueAbb, value);
continue;
@ -596,9 +593,17 @@ public class GenerateData implements UCD_Types {
this.status = status;
}
public byte getType (String c) {
for (byte i = 0; i <= BINARY_PROP; ++i) {
if (c.startsWith(UCD_Names.PROP_TYPE_NAMES[i][1])) return i;
}
return UNKNOWN_PROP;
}
public boolean filter(Object current) {
String c = current.toString();
if (c.startsWith("AA") || c.startsWith("BB") || c.startsWith("ZZ")) return status;
byte type = getType(c);
if (type != UNKNOWN_PROP) return status;
return !status;
}
@ -612,9 +617,8 @@ public class GenerateData implements UCD_Types {
if (!c.substring(0,2).equals(o.substring(0,2))) {
sep = "\r\n";
if (status) {
if (c.startsWith("AA")) sep = sep + HORIZONTAL_LINE + sep + "# Non-enumerated Properties" + sep + HORIZONTAL_LINE + sep;
if (c.startsWith("BB")) sep = sep + HORIZONTAL_LINE + sep + "# Enumerated Non-Binary Properties" + sep + HORIZONTAL_LINE + sep;
if (c.startsWith("ZZ")) sep = sep + HORIZONTAL_LINE + sep + "# Binary Properties" + sep + HORIZONTAL_LINE + sep;
byte type = getType(c);
sep = sep + HORIZONTAL_LINE + sep + "# " + UCD_Names.PROP_TYPE_NAMES[type][0] + " Properties" + sep + HORIZONTAL_LINE + sep;
}
}
if (status) {

6
tools/unicodetools/com/ibm/text/UCD/MyPropertyLister.java
View file

@ -5,8 +5,8 @@
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/UCD/MyPropertyLister.java,v $
* $Date: 2003/03/19 17:30:56 $
* $Revision: 1.9 $
* $Date: 2003/07/21 15:50:06 $
* $Revision: 1.10 $
*
*******************************************************************************
*/
@ -56,7 +56,7 @@ final class MyPropertyLister extends PropertyLister {
}
public String valueName(int cp) {
if (up.getValueType() == BINARY) return up.getName();
if (up.getValueType() == BINARY_PROP) return up.getName();
return up.getValue(cp);
}

10
tools/unicodetools/com/ibm/text/UCD/UCD.java
View file

@ -5,8 +5,8 @@
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/UCD/UCD.java,v $
* $Date: 2003/07/07 15:58:56 $
* $Revision: 1.27 $
* $Date: 2003/07/21 15:50:06 $
* $Revision: 1.28 $
*
*******************************************************************************
*/
@ -767,12 +767,12 @@ public final class UCD implements UCD_Types {
return get(codePoint, false).joiningGroup;
}
public int getBinaryProperties(int codePoint) {
public long getBinaryProperties(int codePoint) {
return get(codePoint, false).binaryProperties;
}
public boolean getBinaryProperty(int codePoint, int bit) {
return (get(codePoint, false).binaryProperties & (1<<bit)) != 0;
return (get(codePoint, false).binaryProperties & (1L<<bit)) != 0;
}
// ENUM Mask Utilties
@ -991,7 +991,7 @@ public final class UCD implements UCD_Types {
}
public String getBinaryPropertiesID(int codePoint, byte bit) {
return (getBinaryProperties(codePoint) & (1<<bit)) != 0 ? UCD_Names.YN_TABLE[1] : UCD_Names.YN_TABLE[0];
return getBinaryProperty(codePoint, bit) ? UCD_Names.YN_TABLE[1] : UCD_Names.YN_TABLE[0];
}
public static String getBinaryPropertiesID_fromIndex(byte bit) {

55
tools/unicodetools/com/ibm/text/UCD/UCD_Names.java
View file

@ -5,8 +5,8 @@
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/UCD/UCD_Names.java,v $
* $Date: 2003/05/02 21:46:33 $
* $Revision: 1.21 $
* $Date: 2003/07/21 15:50:05 $
* $Revision: 1.22 $
*
*******************************************************************************
*/
@ -18,7 +18,7 @@ import com.ibm.text.utility.*;
final class UCD_Names implements UCD_Types {
public static String[][] NON_ENUMERATED = {
public static String[][] NON_ENUMERATED_NAMES = {
{"na", "Name"},
{"dm", "Decomposition_Mapping"},
{"nv", "Numeric_Value"},
@ -148,6 +148,8 @@ final class UCD_Names implements UCD_Types {
"Soft_Dotted",
"Logical_Order_Exception",
"Other_ID_Start",
"Sentence_Terminal",
"Variation_Selector"
};
static final String[] SHORT_BP = {
@ -183,6 +185,8 @@ final class UCD_Names implements UCD_Types {
"SD",
"LOE",
"OIDS",
"STerm",
"VS"
};
/*
@ -591,9 +595,11 @@ final class UCD_Names implements UCD_Types {
"numeric",
"digit",
"decimal",
/*
"Han_Primary",
"Han_Accounting",
"Han_Other"
*/
};
static String[] SHORT_NT = {
@ -601,47 +607,46 @@ final class UCD_Names implements UCD_Types {
"nu",
"di",
"de",
/*
"hp",
"ha",
"ho"
*/
};
static {
if (LIMIT_CATEGORY != GC.length || LIMIT_CATEGORY != LONG_GC.length) {
System.err.println("!! ERROR !! UnicodeTypes and UInfo out of sync: category");
System.err.println("!! ERROR !! Enums and Names out of sync: category");
}
if (LIMIT_BIDI_CLASS != BC.length) {
System.err.println("!! ERROR !! UnicodeTypes and UInfo out of sync: bidi");
System.err.println("!! ERROR !! Enums and Names out of sync: bidi");
}
if (LIMIT_LINE_BREAK != LB.length || LIMIT_LINE_BREAK != LONG_LB.length) {
System.err.println("!! ERROR !! UnicodeTypes and UInfo out of sync: linebreak");
System.err.println("!! ERROR !! Enums and Names out of sync: linebreak");
}
if (LIMIT_DECOMPOSITION_TYPE != DT.length || LIMIT_DECOMPOSITION_TYPE != SHORT_DT.length) {
System.err.println("!! ERROR !! UnicodeTypes and UInfo out of sync: compat type");
System.err.println("!! ERROR !! Enums and Names out of sync: decomp type");
}
if (MIRRORED_LIMIT != MIRRORED_TABLE.length) {
System.err.println("!! ERROR !! UnicodeTypes and UInfo out of sync: compat type");
if (LIMIT_MIRRORED != MIRRORED_TABLE.length) {
System.err.println("!! ERROR !! Enums and Names out of sync: compat type");
}
if (MIRRORED_LIMIT != MIRRORED_TABLE.length) {
System.err.println("!! ERROR !! UnicodeTypes and UInfo out of sync: compat type");
}
if (CASE_LIMIT != CASE_TABLE.length) {
System.err.println("!! ERROR !! UnicodeTypes and UInfo out of sync: case");
if (LIMIT_CASE != CASE_TABLE.length) {
System.err.println("!! ERROR !! Enums and Names out of sync: case");
}
if (LIMIT_NUMERIC_TYPE != NT.length) {
System.err.println("!! ERROR !! UnicodeTypes and UInfo out of sync: case");
System.err.println("!! ERROR !! Enums and Names out of sync: numeric type");
}
if (LIMIT_EAST_ASIAN_WIDTH != EA.length) {
System.err.println("!! ERROR !! UnicodeTypes and UInfo out of sync: east Asian Width");
System.err.println("!! ERROR !! Enums and Names out of sync: east Asian Width");
}
if (LIMIT_BINARY_PROPERTIES != BP.length) {
System.err.println("!! ERROR !! UnicodeTypes and UInfo out of sync: binary properties");
System.err.println("!! ERROR !! Enums and Names out of sync: binary properties");
}
if (LIMIT_SCRIPT != SCRIPT.length) {
System.err.println("!! ERROR !! UnicodeTypes and UInfo out of sync: script");
System.err.println("!! ERROR !! Enums and Names out of sync: script");
}
if (LIMIT_AGE != AGE.length) {
System.err.println("!! ERROR !! UnicodeTypes and UInfo out of sync: age");
System.err.println("!! ERROR !! Enums and Names out of sync: age");
}
}
@ -928,6 +933,18 @@ final class UCD_Names implements UCD_Types {
{"HANGUL", "H."},
};
static final String[][] PROP_TYPE_NAMES = {
{"Numeric", "AA"},
{"String", "AB"},
{"Descriptive", "AC"},
{"Catalog", "AD"},
{"Enumerated", "AE"},
{"Binary", "ZX"},
{"Flattened Binary", "ZY"},
{"Unknown", "ZZ"}
};
/*
LETTER: 23598
MATHEMATICAL: 11976

30
tools/unicodetools/com/ibm/text/UCD/UCD_Types.java
View file

@ -5,8 +5,8 @@
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/UCD/UCD_Types.java,v $
* $Date: 2003/04/03 02:29:30 $
* $Revision: 1.23 $
* $Date: 2003/07/21 15:50:05 $
* $Revision: 1.24 $
*
*******************************************************************************
*/
@ -15,7 +15,7 @@ package com.ibm.text.UCD;
public interface UCD_Types {
public static final int dVersion = 21; // change to fix the generated file D version. If less than zero, no "d"
public static final int dVersion = 2; // change to fix the generated file D version. If less than zero, no "d"
public static final String BASE_DIR = "C:\\DATA\\";
public static final String UCD_DIR = BASE_DIR + "UCD\\";
@ -34,7 +34,7 @@ public interface UCD_Types {
CJK_B_BASE = 0x20000,
CJK_B_LIMIT = 0x2A6DF+1;
static final byte BINARY_FORMAT = 8; // bumped if binary format of UCD changes
static final byte BINARY_FORMAT = 10; // bumped if binary format of UCD changes
// Unicode Property Types
static final byte
@ -45,11 +45,15 @@ public interface UCD_Types {
ALL = (byte)-1;
static final byte
NON_ENUMERATED = -1,
ENUMERATED = 0,
BINARY = 1,
FLATTENED_BINARY = 2;
NUMERIC_PROP = 0,
STRING_PROP = 1,
DESCRIPTIVE_PROP = 2,
CATALOG_PROP = 3,
ENUMERATED_PROP = 4,
BINARY_PROP = 5,
FLATTENED_BINARY_PROP = 6,
UNKNOWN_PROP = 7;
/*
0 Code value in 4-digit hexadecimal format.
1 Unicode 2.1 Character Name. These names match exactly the
@ -209,7 +213,9 @@ public interface UCD_Types {
Soft_Dotted = 29,
Logical_Order_Exception = 30,
Other_ID_Start = 31,
LIMIT_BINARY_PROPERTIES = 32;
Sentence_Terminal = 32,
Variation_Selector = 33,
LIMIT_BINARY_PROPERTIES = 34;
/*
static final int
@ -301,13 +307,13 @@ public interface UCD_Types {
LIMIT_DECOMPOSITION_TYPE = 18;
// mirrored type
static final byte NO = 0, YES = 1, MIRRORED_LIMIT = 2;
static final byte NO = 0, YES = 1, LIMIT_MIRRORED = 2;
// for QuickCheck
static final byte QNO = 0, QMAYBE = 1, QYES = 2;
// case type
static final byte LOWER = 0, TITLE = 1, UPPER = 2, UNCASED = 3, FOLD = 3, CASE_LIMIT = 4;
static final byte LOWER = 0, TITLE = 1, UPPER = 2, UNCASED = 3, FOLD = 3, LIMIT_CASE = 4;
static final byte SIMPLE = 0, FULL = 8;
// normalization type

14
tools/unicodetools/com/ibm/text/UCD/UData.java
View file

@ -5,8 +5,8 @@
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/UCD/UData.java,v $
* $Date: 2003/03/15 02:36:48 $
* $Revision: 1.8 $
* $Date: 2003/07/21 15:50:05 $
* $Revision: 1.9 $
*
*******************************************************************************
*/
@ -33,7 +33,7 @@ class UData implements UCD_Types {
int codePoint = -1;
double numericValue = Double.NaN;
int binaryProperties; // bidiMirroring, compositionExclusions, PropList
long binaryProperties; // bidiMirroring, compositionExclusions, PropList
byte generalCategory = Cn;
byte combiningClass = 0;
@ -224,9 +224,9 @@ class UData implements UCD_Types {
}
//String bp = "";
int bprops = binaryProperties;
long bprops = binaryProperties;
for (int i = 0; i < LIMIT_BINARY_PROPERTIES; ++i) {
if ((bprops & (1<<i)) != 0) result.append(UCD_Names.BP[i]).append("='T' ");
if ((bprops & (1L<<i)) != 0) result.append(UCD_Names.BP[i]).append("='T' ");
}
if (lastPos != result.length()) {
result.append("\r\n");
@ -266,7 +266,7 @@ class UData implements UCD_Types {
writeString(os, bidiMirror);
os.writeDouble(numericValue);
os.writeInt(binaryProperties);
os.writeLong(binaryProperties);
os.writeByte(generalCategory);
os.writeByte(combiningClass);
@ -298,7 +298,7 @@ class UData implements UCD_Types {
bidiMirror = readString(is);
numericValue = is.readDouble();
binaryProperties = is.readInt();
binaryProperties = is.readLong();
generalCategory = is.readByte();
combiningClass = is.readByte();

8
tools/unicodetools/com/ibm/text/UCD/UnicodeProperty.java
View file

@ -9,7 +9,7 @@ public abstract class UnicodeProperty implements UCD_Types {
protected UCD ucd;
protected boolean isStandard = true;
protected byte type = NOT_DERIVED;
private byte valueType = BINARY;
private byte valueType = BINARY_PROP;
protected boolean hasUnassigned = false;
protected boolean isBinary = true;
protected byte defaultValueStyle = SHORT;
@ -114,7 +114,7 @@ public abstract class UnicodeProperty implements UCD_Types {
public String getValue(int cp) { return getValue(cp, NORMAL); }
public void setValue(byte style, String in) {
if (getValueType() < BINARY) throw new IllegalArgumentException("Can't set varying value: " + style);
if (getValueType() < BINARY_PROP) throw new IllegalArgumentException("Can't set varying value: " + style);
if (style == NORMAL) style = defaultValueStyle;
switch (style) {
case LONG: valueName = Utility.getUnskeleton(in, false); break;
@ -125,7 +125,7 @@ public abstract class UnicodeProperty implements UCD_Types {
}
public String getValue(byte style) {
if (getValueType() < BINARY) throw new IllegalArgumentException(
if (getValueType() < BINARY_PROP) throw new IllegalArgumentException(
"Value varies in " + getName(LONG) + "; call getValue(cp)");
try {
if (style == NORMAL) style = defaultValueStyle;
@ -144,7 +144,7 @@ public abstract class UnicodeProperty implements UCD_Types {
* special hack for NFD/NFKD
*/
public String getListingValue(int cp) {
if (getValueType() != BINARY) return getValue(cp, LONG);
if (getValueType() != BINARY_PROP) return getValue(cp, LONG);
return getProperty(LONG);
}

8
tools/unicodetools/com/ibm/text/UCD/UnifiedBinaryProperty.java
View file

@ -5,8 +5,8 @@
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/UCD/UnifiedBinaryProperty.java,v $
* $Date: 2003/05/02 21:46:33 $
* $Revision: 1.13 $
* $Date: 2003/07/21 15:50:05 $
* $Revision: 1.14 $
*
*******************************************************************************
*/
@ -61,7 +61,7 @@ public final class UnifiedBinaryProperty extends UnicodeProperty {
UnicodeProperty up = UnifiedBinaryProperty.make(i, ucd);
if (up == null) continue;
if (!up.isStandard()) continue;
if (up.getValueType() < BINARY) continue;
if (up.getValueType() < BINARY_PROP) continue;
String shortValue = Utility.getSkeleton(up.getValue(SHORT));
String shortName = Utility.getSkeleton(up.getProperty(SHORT));
String longValue = Utility.getSkeleton(up.getValue(LONG));
@ -125,7 +125,7 @@ public final class UnifiedBinaryProperty extends UnicodeProperty {
if (majorProp <= (JOINING_GROUP>>8)
|| majorProp == (SCRIPT>>8)
|| majorProp==(HANGUL_SYLLABLE_TYPE>>8)) {
setValueType(FLATTENED_BINARY);
setValueType(FLATTENED_BINARY_PROP);
}
//System.out.println("B: " + getValueType());

8
tools/unicodetools/com/ibm/text/UCD/UnifiedProperty.java
View file

@ -5,8 +5,8 @@
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/UCD/UnifiedProperty.java,v $
* $Date: 2003/02/25 23:38:22 $
* $Revision: 1.3 $
* $Date: 2003/07/21 15:50:05 $
* $Revision: 1.4 $
*
*******************************************************************************
*/
@ -63,7 +63,7 @@ public final class UnifiedProperty extends UnicodeProperty {
UnicodeProperty up = UnifiedProperty.make(i, ucd);
if (up == null) continue;
if (!up.isStandard()) continue;
if (up.getValueType() < BINARY) continue;
if (up.getValueType() < BINARY_PROP) continue;
String shortName = Utility.getSkeleton(up.getProperty(SHORT));
String longName = Utility.getSkeleton(up.getProperty(LONG));
Integer result = new Integer(i);
@ -120,7 +120,7 @@ public final class UnifiedProperty extends UnicodeProperty {
majorProp = propMask >> 8;
//System.out.println("A: " + getValueType());
if (majorProp <= (JOINING_GROUP>>8) || majorProp == SCRIPT>>8) setValueType(FLATTENED_BINARY);
if (majorProp <= (JOINING_GROUP>>8) || majorProp == SCRIPT>>8) setValueType(FLATTENED_BINARY_PROP);
//System.out.println("B: " + getValueType());
header = UCD_Names.UNIFIED_PROPERTY_HEADERS[majorProp];

8
tools/unicodetools/com/ibm/text/UCD/VerifyUCD.java
View file

@ -5,8 +5,8 @@
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/UCD/VerifyUCD.java,v $
* $Date: 2003/03/12 16:01:26 $
* $Revision: 1.21 $
* $Date: 2003/07/21 15:50:05 $
* $Revision: 1.22 $
*
*******************************************************************************
*/
@ -920,7 +920,7 @@ can help you narrow these down.
int ccc = Default.ucd.getCombiningClass(cp);
for (byte style = FOLD; style < CASE_LIMIT; ++style) {
for (byte style = FOLD; style < LIMIT_CASE; ++style) {
String fold_NFD = Default.nfd.normalize(Default.ucd.getCase(realTest, FULL, style));
String NFD_fold = Default.ucd.getCase(Default.nfd.normalize(realTest), FULL, style);
@ -2246,7 +2246,7 @@ E0020-E007F; [TAGGING CHARACTERS]
check(i, Default.ucd.getNumericType(i), Default.ucd.getNumericType(j), UCD_Names.NT, "NumericType");
if (false) {
for (byte k = LOWER; k <= FOLD; ++k) {
for (byte k = LOWER; k < LIMIT_CASE; ++k) {
check(i, Default.ucd.getCase(i, SIMPLE, k), Default.ucd.getCase(j, SIMPLE, k), "Simple("+k+")");
check(i, Default.ucd.getCase(i, FULL, k), Default.ucd.getCase(j, FULL, k), "Full("+k+")");
}

11
tools/unicodetools/com/ibm/text/utility/Utility.java
View file

@ -5,8 +5,8 @@
*******************************************************************************
*
* $Source: /xsrl/Nsvn/icu/unicodetools/com/ibm/text/utility/Utility.java,v $
* $Date: 2003/07/07 15:58:56 $
* $Revision: 1.34 $
* $Date: 2003/07/21 15:50:07 $
* $Revision: 1.35 $
*
*******************************************************************************
*/
@ -283,10 +283,15 @@ public final class Utility implements UCD_Types { // COMMON UTILITIES
}
public static int intFrom(String p) {
if (p.length() == 0) return Short.MIN_VALUE;
if (p.length() == 0) return Integer.MIN_VALUE;
return Integer.parseInt(p);
}
public static long longFrom(String p) {
if (p.length() == 0) return Long.MIN_VALUE;
return Long.parseInt(p);
}
public static float floatFrom(String p) {
if (p.length() == 0) return Float.NaN;
int fract = p.indexOf('/');