1285 lines
55 KiB
Java
1285 lines
55 KiB
Java
package com.ibm.text.UCD;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.IOException;
|
|
import java.io.PrintWriter;
|
|
import java.io.UnsupportedEncodingException;
|
|
import java.lang.reflect.Field;
|
|
import java.text.ParseException;
|
|
import java.text.ParsePosition;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collection;
|
|
import java.util.Comparator;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.ResourceBundle;
|
|
import java.util.Set;
|
|
import java.util.TreeMap;
|
|
import java.util.TreeSet;
|
|
import java.util.regex.Matcher;
|
|
import java.util.regex.Pattern;
|
|
|
|
import com.ibm.icu.dev.test.util.BagFormatter;
|
|
import com.ibm.icu.dev.test.util.Tabber;
|
|
import com.ibm.icu.dev.test.util.UnicodeLabel;
|
|
import com.ibm.icu.dev.test.util.UnicodeProperty;
|
|
import com.ibm.icu.text.NumberFormat;
|
|
import com.ibm.icu.text.SymbolTable;
|
|
import com.ibm.icu.text.UTF16;
|
|
import com.ibm.icu.text.UnicodeMatcher;
|
|
import com.ibm.icu.text.UnicodeSet;
|
|
import com.ibm.text.UCD.GenerateBreakTest.GenerateGraphemeBreakTest;
|
|
import com.ibm.text.UCD.GenerateBreakTest.GenerateLineBreakTest;
|
|
import com.ibm.text.UCD.GenerateBreakTest.GenerateSentenceBreakTest;
|
|
import com.ibm.text.UCD.GenerateBreakTest.GenerateWordBreakTest;
|
|
import com.ibm.text.UCD.MakeUnicodeFiles.Format.PrintStyle;
|
|
import com.ibm.text.utility.UnicodeDataFile;
|
|
import com.ibm.text.utility.Utility;
|
|
import com.ibm.icu.text.Collator;
|
|
|
|
public class MakeUnicodeFiles {
|
|
public static int dVersion = -1; // change to fix the generated file D version. If less than zero, no "d"
|
|
|
|
/*static String[] hackNameList = {
|
|
"noBreak", "Arabic_Presentation_Forms-A", "Arabic_Presentation_Forms-B",
|
|
"CJK_Symbols_and_Punctuation", "Combining_Diacritical_Marks_for_Symbols",
|
|
"Enclosed_CJK_Letters_and_Months", "Greek_and_Coptic",
|
|
"Halfwidth_and_Fullwidth_Forms", "Latin-1_Supplement", "Latin_Extended-A",
|
|
"Latin_Extended-B", "Miscellaneous_Mathematical_Symbols-A",
|
|
"Miscellaneous_Mathematical_Symbols-B", "Miscellaneous_Symbols_and_Arrows",
|
|
"Superscripts_and_Subscripts", "Supplemental_Arrows-A", "Supplemental_Arrows-B",
|
|
"Supplementary_Private_Use_Area-A", "Supplementary_Private_Use_Area-B",
|
|
"Canadian-Aboriginal", "Old-Italic"
|
|
};
|
|
static {
|
|
for (int i = 0; i < hackNameList.length; ++i) {
|
|
System.out.println("HackName:\t" + hackNameList[i]);
|
|
}
|
|
}
|
|
*/
|
|
|
|
static boolean DEBUG = false;
|
|
|
|
public static void main(String[] args) throws IOException {
|
|
generateFile();
|
|
}
|
|
|
|
static class Format {
|
|
public static Format theFormat = new Format(); // singleton
|
|
|
|
|
|
Map printStyleMap = new TreeMap(UnicodeProperty.PROPERTY_COMPARATOR);
|
|
static PrintStyle DEFAULT_PRINT_STYLE = new PrintStyle();
|
|
Map fileToPropertySet = new TreeMap();
|
|
Map fileToComments = new TreeMap();
|
|
Map fileToDirectory = new TreeMap();
|
|
TreeMap propertyToValueToComments = new TreeMap();
|
|
Map hackMap = new HashMap();
|
|
UnicodeProperty.MapFilter hackMapFilter;
|
|
String[] filesToDo;
|
|
|
|
private Format(){
|
|
build();
|
|
}
|
|
/*
|
|
static String[] FILE_OPTIONS = {
|
|
"Script nameStyle=none makeUppercase skipUnassigned=Common hackValues",
|
|
"Age nameStyle=none noLabel skipValue=unassigned",
|
|
"Numeric_Type nameStyle=none makeFirstLetterLowercase skipValue=None",
|
|
"General_Category nameStyle=none valueStyle=short noLabel",
|
|
"Line_Break nameStyle=none valueStyle=short skipUnassigned=Unknown",
|
|
"Joining_Type nameStyle=none valueStyle=short skipValue=Non_Joining",
|
|
"Joining_Group nameStyle=none skipValue=No_Joining_Group makeUppercase",
|
|
"East_Asian_Width nameStyle=none valueStyle=short skipUnassigned=Neutral",
|
|
"Decomposition_Type nameStyle=none skipValue=None makeFirstLetterLowercase hackValues",
|
|
"Bidi_Class nameStyle=none valueStyle=short skipUnassigned=Left_To_Right",
|
|
"Block nameStyle=none noLabel valueList",
|
|
"Canonical_Combining_Class nameStyle=none valueStyle=short skipUnassigned=Not_Reordered longValueHeading=ccc",
|
|
"Hangul_Syllable_Type nameStyle=none valueStyle=short skipValue=Not_Applicable",
|
|
"NFD_Quick_Check nameStyle=short valueStyle=short skipValue=Yes",
|
|
"NFC_Quick_Check nameStyle=short valueStyle=short skipValue=Yes",
|
|
"NFKC_Quick_Check nameStyle=short valueStyle=short skipValue=Yes",
|
|
"NFKD_Quick_Check nameStyle=short valueStyle=short skipValue=Yes",
|
|
"FC_NFKC_Closure nameStyle=short"
|
|
};
|
|
*/
|
|
|
|
void printFileComments(PrintWriter pw, String filename) {
|
|
String fileComments = (String) fileToComments.get(filename);
|
|
if (fileComments != null)
|
|
pw.println(fileComments);
|
|
}
|
|
|
|
private void addPrintStyle(String options) {
|
|
PrintStyle result = new PrintStyle();
|
|
printStyleMap.put(result.parse(options), result);
|
|
}
|
|
|
|
public PrintStyle getPrintStyle(String propname) {
|
|
PrintStyle result = (PrintStyle) printStyleMap.get(propname);
|
|
if (result != null)
|
|
return result;
|
|
if (DEBUG)
|
|
System.out.println("Using default style!");
|
|
return DEFAULT_PRINT_STYLE;
|
|
}
|
|
|
|
public static class PrintStyle {
|
|
boolean noLabel = false;
|
|
boolean makeUppercase = false;
|
|
boolean makeFirstLetterLowercase = false;
|
|
boolean orderByRangeStart = false;
|
|
boolean interleaveValues = false;
|
|
boolean hackValues = false;
|
|
String nameStyle = "none";
|
|
String valueStyle = "long";
|
|
String skipValue = null;
|
|
String skipUnassigned = null;
|
|
String longValueHeading = null;
|
|
boolean sortNumeric = false;
|
|
|
|
String parse(String options) {
|
|
options = options.replace('\t', ' ');
|
|
String[] pieces = Utility.split(options, ' ');
|
|
for (int i = 1; i < pieces.length; ++i) {
|
|
String piece = pieces[i];
|
|
// binary
|
|
if (piece.equals("noLabel"))
|
|
noLabel = true;
|
|
else if (piece.equals("makeUppercase"))
|
|
makeUppercase = true;
|
|
else if (piece.equals("makeFirstLetterLowercase"))
|
|
makeFirstLetterLowercase = true;
|
|
else if (piece.equals("orderByRangeStart"))
|
|
orderByRangeStart = true;
|
|
else if (piece.equals("valueList"))
|
|
interleaveValues = true;
|
|
else if (piece.equals("hackValues"))
|
|
hackValues = true;
|
|
else if (piece.equals("sortNumeric"))
|
|
sortNumeric = true;
|
|
// with parameter
|
|
else if (piece.startsWith("valueStyle="))
|
|
valueStyle = afterEquals(piece);
|
|
else if (piece.startsWith("nameStyle="))
|
|
nameStyle = afterEquals(piece);
|
|
else if (piece.startsWith("longValueHeading="))
|
|
longValueHeading = afterEquals(piece);
|
|
else if (piece.startsWith("skipValue=")) {
|
|
if (skipUnassigned != null)
|
|
throw new IllegalArgumentException("Can't have both skipUnassigned and skipValue");
|
|
skipValue = afterEquals(piece);
|
|
} else if (piece.startsWith("skipUnassigned=")) {
|
|
if (skipValue != null)
|
|
throw new IllegalArgumentException("Can't have both skipUnassigned and skipValue");
|
|
skipUnassigned = afterEquals(piece);
|
|
} else if (piece.length() != 0) {
|
|
throw new IllegalArgumentException(
|
|
"Illegal PrintStyle Parameter: "
|
|
+ piece
|
|
+ " in "
|
|
+ pieces[0]);
|
|
}
|
|
}
|
|
return pieces[0];
|
|
}
|
|
public String toString() {
|
|
Class myClass = getClass();
|
|
String result = myClass.getName() + "\n";
|
|
Field[] myFields = myClass.getDeclaredFields();
|
|
for (int i = 0; i < myFields.length; ++i) {
|
|
String value = "<private>";
|
|
try {
|
|
Object obj = myFields[i].get(this);
|
|
if (obj == null) value = "<null>";
|
|
else value = obj.toString();
|
|
} catch (Exception e) {}
|
|
result += "\t" + myFields[i].getName() + "=<" + value + ">\n";
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
/*
|
|
static {
|
|
for (int i = 0; i < FILE_OPTIONS.length; ++i) {
|
|
PrintStyle.add(FILE_OPTIONS[i]);
|
|
}
|
|
}
|
|
*/
|
|
|
|
void addValueComments(String property, String value, String comments) {
|
|
if (DEBUG)
|
|
showPVC(property, value, comments);
|
|
TreeMap valueToComments =
|
|
(TreeMap) propertyToValueToComments.get(property);
|
|
if (valueToComments == null) {
|
|
valueToComments = new TreeMap();
|
|
propertyToValueToComments.put(property, valueToComments);
|
|
}
|
|
valueToComments.put(value, comments);
|
|
if (DEBUG && property.equals("BidiClass")) {
|
|
getValueComments(property, value);
|
|
}
|
|
}
|
|
|
|
private void showPVC(String property, String value, String comments) {
|
|
System.out.println(
|
|
"Putting Property: <"
|
|
+ property
|
|
+ ">, Value: <"
|
|
+ value
|
|
+ ">, Comments: <"
|
|
+ comments + ">");
|
|
}
|
|
|
|
String getValueComments(String property, String value) {
|
|
TreeMap valueToComments =
|
|
(TreeMap) propertyToValueToComments.get(property);
|
|
String result = null;
|
|
if (valueToComments != null)
|
|
result = (String) valueToComments.get(value);
|
|
if (DEBUG) System.out.println("Getting Property: <" + property + ">, Value: <"
|
|
+ value + ">, Comment: <" + result + ">");
|
|
return result;
|
|
}
|
|
|
|
Map getValue2CommentsMap(String property) {
|
|
return (Map) propertyToValueToComments.get(property);
|
|
}
|
|
|
|
static String afterEquals(String source) {
|
|
return source.substring(source.indexOf('=') + 1);
|
|
}
|
|
|
|
static String afterWhitespace(String source) {
|
|
// Note: don't need to be international
|
|
for (int i = 0; i < source.length(); ++i) {
|
|
char ch = source.charAt(i);
|
|
if (Character.isWhitespace(source.charAt(i))) {
|
|
return source.substring(i).trim();
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
/*private void add(String name, String[] properties) {
|
|
fileToPropertySet.put(name, properties);
|
|
}*/
|
|
|
|
private void build() {
|
|
/*
|
|
for (int i = 0; i < hackNameList.length; ++i) {
|
|
String item = hackNameList[i];
|
|
String regularItem = UnicodeProperty.regularize(item,true);
|
|
hackMap.put(regularItem, item);
|
|
}
|
|
*/
|
|
|
|
/*
|
|
for (int i = 0; i < UCD_Names.UNIFIED_PROPERTIES.length; ++i) {
|
|
String name = Utility.getUnskeleton(UCD_Names.UNIFIED_PROPERTIES[i], false);
|
|
valueComments.add(name, "*", "# " + UCD_Names.UNIFIED_PROPERTY_HEADERS[i]);
|
|
System.out.println();
|
|
System.out.println(name);
|
|
System.out.println("# " + UCD_Names.UNIFIED_PROPERTY_HEADERS[i]);
|
|
}
|
|
// HACK
|
|
valueComments.add("Bidi_Mirroring", "*", "# " + UCD_Names.UNIFIED_PROPERTY_HEADERS[9]);
|
|
*/
|
|
try {
|
|
BufferedReader br =
|
|
Utility.openReadFile("MakeUnicodeFiles.txt", Utility.UTF8);
|
|
String key = null;
|
|
String file = null, property = null, value = "", comments = "";
|
|
while (true) {
|
|
String line = br.readLine();
|
|
if (line == null)
|
|
break;
|
|
line = line.trim();
|
|
if (line.length() == 0)
|
|
continue;
|
|
if (DEBUG)
|
|
System.out.println("\t" + line);
|
|
String lineValue = afterWhitespace(line);
|
|
if (line.startsWith("Format:")) {
|
|
addPrintStyle(property + " " + lineValue); // fix later
|
|
} else if (line.startsWith("#")) {
|
|
if (comments.length() != 0) comments += "\n";
|
|
comments += line;
|
|
} else {
|
|
// end of comments, roll up
|
|
if (property != null)
|
|
addValueComments(property, value, comments);
|
|
comments = "";
|
|
if (line.startsWith("Generate:")) {
|
|
filesToDo = Utility.split(lineValue.trim(), ' ');
|
|
if (filesToDo.length == 0
|
|
|| (filesToDo.length == 1 && filesToDo[0].length() == 0)) {
|
|
filesToDo = new String[] {".*"};
|
|
}
|
|
} else if (line.startsWith("DeltaVersion:")) {
|
|
dVersion = Integer.parseInt(lineValue);
|
|
} else if (line.startsWith("CopyrightYear:")) {
|
|
Default.setYear(lineValue);
|
|
} else if (line.startsWith("File:")) {
|
|
int p2 = lineValue.lastIndexOf('/');
|
|
file = lineValue.substring(p2+1);
|
|
if (p2 >= 0) {
|
|
fileToDirectory.put(file, lineValue.substring(0,p2+1));
|
|
}
|
|
property = null;
|
|
} else if (line.startsWith("Property:")) {
|
|
property = lineValue;
|
|
addPropertyToFile(file, property);
|
|
value = "";
|
|
} else if (line.startsWith("Value:")) {
|
|
value = lineValue;
|
|
} else if (line.startsWith("HackName:")) {
|
|
String regularItem =
|
|
UnicodeProperty.regularize(lineValue, true);
|
|
hackMap.put(regularItem, lineValue);
|
|
} else if (line.startsWith("FinalComments")) {
|
|
break;
|
|
} else {
|
|
throw new IllegalArgumentException("Unknown command: " + line);
|
|
}
|
|
}
|
|
}
|
|
br.close();
|
|
} catch (IOException e) {
|
|
// TODO Auto-generated catch block
|
|
e.printStackTrace();
|
|
throw new IllegalArgumentException("File missing");
|
|
}
|
|
hackMapFilter = new UnicodeProperty.MapFilter(hackMap);
|
|
/*
|
|
add("PropertyValueAliases", null);
|
|
add("PropertyAliases", null);
|
|
add("SpecialCasing", null);
|
|
add("NormalizationTest", null);
|
|
add("StandardizedVariants", null);
|
|
add("CaseFolding", null);
|
|
add("DerivedAge", new String[] {"Age"});
|
|
add("Scripts", new String[] {"Script"});
|
|
add("HangulSyllableType", new String[] {"HangulSyllableType"});
|
|
add("DerivedBidiClass", new String[] {"BidiClass"});
|
|
add("DerivedBinaryProperties", new String[] {"BidiMirrored"});
|
|
add("DerivedCombiningClass", new String[] {"CanonicalCombiningClass"});
|
|
add("DerivedDecompositionType", new String[] {"DecompositionType"});
|
|
add("DerivedEastAsianWidth", new String[] {"EastAsianWidth"});
|
|
add("DerivedGeneralCategory", new String[] {"GeneralCategory"});
|
|
add("DerivedJoiningGroup", new String[] {"JoiningGroup"});
|
|
add("DerivedJoiningType", new String[] {"JoiningType"});
|
|
add("DerivedLineBreak", new String[] {"LineBreak"});
|
|
add("DerivedNumericType", new String[] {"NumericType"});
|
|
add("DerivedNumericValues", new String[] {"NumericValue"});
|
|
add("PropList", new String[] {
|
|
"White_Space", "Bidi_Control", "Join_Control",
|
|
"Dash", "Hyphen", "Quotation_Mark",
|
|
"Terminal_Punctuation", "Other_Math",
|
|
"Hex_Digit", "ASCII_Hex_Digit",
|
|
"Other_Alphabetic",
|
|
"Ideographic",
|
|
"Diacritic", "Extender",
|
|
"Other_Lowercase", "Other_Uppercase",
|
|
"Noncharacter_Code_Point",
|
|
"Other_Grapheme_Extend",
|
|
"Grapheme_Link",
|
|
"IDS_Binary_Operator", "IDS_Trinary_Operator",
|
|
"Radical", "Unified_Ideograph",
|
|
"Other_Default_Ignorable_Code_Point",
|
|
"Deprecated", "Soft_Dotted",
|
|
"Logical_Order_Exception",
|
|
"Other_ID_Start"
|
|
});
|
|
add("DerivedCoreProperties", new String[] {
|
|
"Math", "Alphabetic", "Lowercase", "Uppercase",
|
|
"ID_Start", "ID_Continue",
|
|
"XID_Start", "XID_Continue",
|
|
"Default_Ignorable_Code_Point",
|
|
"Grapheme_Extend", "Grapheme_Base"
|
|
});
|
|
add("DerivedNormalizationProps", new String[] {
|
|
"FC_NFKC_Closure",
|
|
"Full_Composition_Exclusion",
|
|
"NFD_QuickCheck", "NFC_QuickCheck", "NFKD_QuickCheck", "NFKC_QuickCheck",
|
|
"Expands_On_NFD", "Expands_On_NFC", "Expands_On_NFKD", "Expands_On_NFKC"
|
|
});
|
|
*/
|
|
write();
|
|
}
|
|
|
|
private void write() {
|
|
TreeMap fileoptions = new TreeMap();
|
|
/*for (int i = 0; i < FILE_OPTIONS.length; ++i) {
|
|
String s = FILE_OPTIONS[i];
|
|
int pos = s.indexOf(' ');
|
|
String name = s.substring(0,pos);
|
|
String options = s.substring(pos).trim();
|
|
fileoptions.put(name, options);
|
|
}
|
|
*/
|
|
for (Iterator it = fileToPropertySet.keySet().iterator(); it.hasNext();) {
|
|
String key = (String) it.next();
|
|
if (DEBUG) {
|
|
System.out.println();
|
|
System.out.println("File:\t" + key);
|
|
}
|
|
List propList2 = (List) fileToPropertySet.get(key);
|
|
if (propList2 == null) {
|
|
System.out.println("SPECIAL");
|
|
continue;
|
|
}
|
|
for (Iterator pIt = propList2.iterator(); pIt.hasNext();) {
|
|
String prop = (String) pIt.next();
|
|
String options = (String)fileoptions.get(prop);
|
|
if (DEBUG) {
|
|
System.out.println();
|
|
System.out.println("Property:\t" + prop);
|
|
if (options != null) {
|
|
System.out.println("Format:\t" + options);
|
|
}
|
|
}
|
|
Map vc = getValue2CommentsMap(prop);
|
|
if (vc == null) continue;
|
|
for (Iterator it2 = vc.keySet().iterator(); it2.hasNext();) {
|
|
String value = (String) it2.next();
|
|
String comment = (String) vc.get(value);
|
|
if (DEBUG) {
|
|
if (!value.equals("")) {
|
|
System.out.println("Value:\t" + value);
|
|
}
|
|
System.out.println(comment);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void addCommentToFile(String filename, String comment) {
|
|
fileToComments.put(filename, comment);
|
|
}
|
|
|
|
private void addPropertyToFile(String filename, String property) {
|
|
List properties = (List) fileToPropertySet.get(filename);
|
|
if (properties == null) {
|
|
properties = new ArrayList(1);
|
|
fileToPropertySet.put(filename, properties);
|
|
}
|
|
properties.add(property);
|
|
}
|
|
public List getPropertiesFromFile(String filename) {
|
|
return (List) fileToPropertySet.get(filename);
|
|
}
|
|
public Set getFiles() {
|
|
return fileToPropertySet.keySet();
|
|
}
|
|
}
|
|
|
|
public static void generateFile() throws IOException {
|
|
for (int i = 0; i < Format.theFormat.filesToDo.length; ++i) {
|
|
String fileNamePattern =
|
|
Format.theFormat.filesToDo[i].trim(); // .toLowerCase(Locale.ENGLISH);
|
|
Matcher matcher = Pattern.compile(fileNamePattern, Pattern.CASE_INSENSITIVE).matcher("");
|
|
Iterator it = Format.theFormat.getFiles().iterator();
|
|
boolean gotOne = false;
|
|
while (it.hasNext()) {
|
|
String propname = (String) it.next();
|
|
if (!matcher.reset(propname).matches()) continue;
|
|
//if (!propname.toLowerCase(Locale.ENGLISH).startsWith(fileName)) continue;
|
|
generateFile(propname);
|
|
gotOne = true;
|
|
}
|
|
if (!gotOne) {
|
|
throw new IllegalArgumentException(
|
|
"Non-matching file name: " + fileNamePattern);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void generateFile(String filename) throws IOException {
|
|
if (filename.endsWith("Aliases")) {
|
|
if (filename.endsWith("ValueAliases")) generateValueAliasFile(filename);
|
|
else generateAliasFile(filename);
|
|
} else if (filename.equals("NormalizationTest")) {
|
|
GenerateData.writeNormalizerTestSuite("DerivedData/", "NormalizationTest");
|
|
} else if (filename.equals("CaseFolding")) {
|
|
GenerateCaseFolding.makeCaseFold(false);
|
|
} else if (filename.equals("SpecialCasing")) {
|
|
GenerateCaseFolding.generateSpecialCasing(false);
|
|
} else if (filename.equals("StandardizedVariants")) {
|
|
GenerateStandardizedVariants.generate();
|
|
} else if (filename.equals("GraphemeBreakTest")) {
|
|
new GenerateGraphemeBreakTest(Default.ucd()).run();
|
|
} else if (filename.equals("WordBreakTest")) {
|
|
new GenerateWordBreakTest(Default.ucd()).run();
|
|
} else if (filename.equals("LineBreakTest")) {
|
|
new GenerateLineBreakTest(Default.ucd()).run();
|
|
} else if (filename.equals("SentenceBreakTest")) {
|
|
new GenerateSentenceBreakTest(Default.ucd()).run();
|
|
} else {
|
|
generatePropertyFile(filename);
|
|
}
|
|
}
|
|
|
|
static final String SEPARATOR = "# ================================================";
|
|
|
|
public static void generateAliasFile(String filename) throws IOException {
|
|
UnicodeDataFile udf = UnicodeDataFile.openAndWriteHeader("DerivedData/", filename);
|
|
PrintWriter pw = udf.out;
|
|
UnicodeProperty.Factory ups
|
|
= ToolUnicodePropertySource.make(Default.ucdVersion());
|
|
TreeSet sortedSet = new TreeSet(CASELESS_COMPARATOR);
|
|
BagFormatter bf = new BagFormatter();
|
|
Tabber.MonoTabber mt = new Tabber.MonoTabber()
|
|
.add(10,Tabber.LEFT)
|
|
.add(30,Tabber.LEFT);
|
|
int count = 0;
|
|
|
|
for (int i = UnicodeProperty.LIMIT_TYPE - 1; i >= UnicodeProperty.BINARY; --i) {
|
|
if ((i & UnicodeProperty.EXTENDED_MASK) != 0) continue;
|
|
List list = ups.getAvailableNames(1<<i);
|
|
//if (list.size() == 0) continue;
|
|
sortedSet.clear();
|
|
StringBuffer buffer = new StringBuffer();
|
|
for (Iterator it = list.iterator(); it.hasNext();) {
|
|
String propAlias = (String)it.next();
|
|
|
|
UnicodeProperty up = ups.getProperty(propAlias);
|
|
List aliases = up.getNameAliases();
|
|
if (aliases.size() == 1) {
|
|
sortedSet.add(mt.process(aliases.get(0) + "\t; " + aliases.get(0)));
|
|
} else {
|
|
buffer.setLength(0);
|
|
boolean isFirst = true;
|
|
for (Iterator it2 = aliases.iterator(); it2.hasNext();) {
|
|
if (isFirst) isFirst = false;
|
|
else buffer.append("\t; ");
|
|
buffer.append(it2.next());
|
|
}
|
|
if (aliases.size() == 1) {
|
|
// repeat
|
|
buffer.append("\t; ").append(aliases.get(0));
|
|
}
|
|
sortedSet.add(mt.process(buffer.toString()));
|
|
}
|
|
}
|
|
if (i == UnicodeProperty.STRING) {
|
|
for (int j = 0; j < specialString.length; ++j) {
|
|
sortedSet.add(mt.process(specialString[j]));
|
|
}
|
|
} else if (i == UnicodeProperty.MISC) {
|
|
for (int j = 0; j < specialMisc.length; ++j) {
|
|
sortedSet.add(mt.process(specialMisc[j]));
|
|
}
|
|
}
|
|
pw.println();
|
|
pw.println(SEPARATOR);
|
|
pw.println("# " + UnicodeProperty.getTypeName(i) + " Properties");
|
|
pw.println(SEPARATOR);
|
|
for (Iterator it = sortedSet.iterator(); it.hasNext();) {
|
|
pw.println(it.next());
|
|
count++;
|
|
}
|
|
}
|
|
pw.println();
|
|
pw.println(SEPARATOR);
|
|
pw.println("# Total: " + count);
|
|
pw.println();
|
|
udf.close();
|
|
}
|
|
|
|
static String[] specialMisc = {
|
|
"isc\t; ISO_Comment",
|
|
"na1\t; Unicode_1_Name",
|
|
"URS\t; Unicode_Radical_Stroke"};
|
|
|
|
static String[] specialString = {
|
|
"dm\t; Decomposition_Mapping",
|
|
"lc\t; Lowercase_Mapping",
|
|
"scc\t; Special_Case_Condition",
|
|
"sfc\t; Simple_Case_Folding",
|
|
"slc\t; Simple_Lowercase_Mapping",
|
|
"stc\t; Simple_Titlecase_Mapping",
|
|
"suc\t; Simple_Uppercase_Mapping",
|
|
"tc\t; Titlecase_Mapping",
|
|
"uc\t; Uppercase_Mapping"};
|
|
|
|
static String[] specialGC = {
|
|
"gc\t;\tC\t;\tOther\t# Cc | Cf | Cn | Co | Cs",
|
|
"gc\t;\tL\t;\tLetter\t# Ll | Lm | Lo | Lt | Lu",
|
|
"gc\t;\tLC\t;\tCased_Letter\t# Ll | Lt | Lu",
|
|
"gc\t;\tM\t;\tMark\t# Mc | Me | Mn",
|
|
"gc\t;\tN\t;\tNumber\t# Nd | Nl | No",
|
|
"gc\t;\tP\t;\tPunctuation\t;\tpunct\t# Pc | Pd | Pe | Pf | Pi | Po | Ps",
|
|
"gc\t;\tS\t;\tSymbol\t# Sc | Sk | Sm | So",
|
|
"gc\t;\tZ\t;\tSeparator\t# Zl | Zp | Zs"};
|
|
|
|
public static void generateValueAliasFile(String filename) throws IOException {
|
|
UnicodeDataFile udf = UnicodeDataFile.openAndWriteHeader("DerivedData/", filename);
|
|
PrintWriter pw = udf.out;
|
|
Format.theFormat.printFileComments(pw, filename);
|
|
UnicodeProperty.Factory toolFactory
|
|
= ToolUnicodePropertySource.make(Default.ucdVersion());
|
|
BagFormatter bf = new BagFormatter(toolFactory);
|
|
StringBuffer buffer = new StringBuffer();
|
|
Set sortedSet = new TreeSet(CASELESS_COMPARATOR);
|
|
|
|
//gc ; C ; Other # Cc | Cf | Cn | Co | Cs
|
|
// 123456789012345678901234567890123
|
|
|
|
// sc ; Arab ; Arabic
|
|
Tabber.MonoTabber mt2 = new Tabber.MonoTabber()
|
|
.add(3,Tabber.LEFT)
|
|
.add(2,Tabber.LEFT) // ;
|
|
.add(10,Tabber.LEFT)
|
|
.add(2,Tabber.LEFT) // ;
|
|
.add(33,Tabber.LEFT)
|
|
.add(2,Tabber.LEFT) // ;
|
|
.add(33,Tabber.LEFT);
|
|
|
|
// ccc; 216; ATAR ; Attached_Above_Right
|
|
Tabber.MonoTabber mt3 = new Tabber.MonoTabber()
|
|
.add(3,Tabber.LEFT)
|
|
.add(2,Tabber.LEFT) // ;
|
|
.add(3,Tabber.RIGHT)
|
|
.add(2,Tabber.LEFT) // ;
|
|
.add(5,Tabber.LEFT)
|
|
.add(2,Tabber.LEFT) // ;
|
|
.add(33,Tabber.LEFT)
|
|
.add(2,Tabber.LEFT) // ;
|
|
.add(33,Tabber.LEFT);
|
|
|
|
for (Iterator it = toolFactory.getAvailableNames(UnicodeProperty.ENUMERATED_OR_CATALOG_MASK).iterator(); it.hasNext();) {
|
|
String propName = (String) it.next();
|
|
UnicodeProperty up = toolFactory.getProperty(propName);
|
|
String shortProp = up.getFirstNameAlias();
|
|
sortedSet.clear();
|
|
|
|
for (Iterator it2 = up.getAvailableValues().iterator(); it2.hasNext();) {
|
|
String value = (String) it2.next();
|
|
List l = up.getValueAliases(value);
|
|
if (DEBUG) System.out.println(value + "\t" + bf.join(l));
|
|
|
|
// HACK
|
|
Tabber mt = mt2;
|
|
if (l.size() == 1) {
|
|
if (propName.equals("Canonical_Combining_Class")) continue;
|
|
if (propName.equals("Block")
|
|
|| propName.equals("Joining_Group")
|
|
//|| propName.equals("Numeric_Type")
|
|
|| propName.equals("Age")) {
|
|
l.add(0, "n/a");
|
|
} else {
|
|
l.add(0, l.get(0)); // double up
|
|
}
|
|
} else if (propName.equals("Canonical_Combining_Class")) {
|
|
mt = mt3;
|
|
}
|
|
if (UnicodeProperty.equalNames(value,"Cyrillic_Supplement")) {
|
|
l.add("Cyrillic_Supplementary");
|
|
}
|
|
|
|
buffer.setLength(0);
|
|
buffer.append(shortProp);
|
|
for (Iterator it3 = l.iterator(); it3.hasNext();) {
|
|
buffer.append("\t; \t" + it3.next());
|
|
}
|
|
|
|
sortedSet.add(mt.process(buffer.toString()));
|
|
}
|
|
// HACK
|
|
if (propName.equals("General_Category")) {
|
|
for (int i = 0; i < specialGC.length; ++i) {
|
|
sortedSet.add(mt2.process(specialGC[i]));
|
|
}
|
|
}
|
|
pw.println();
|
|
pw.println("# " + propName + " (" + shortProp + ")");
|
|
pw.println();
|
|
for (Iterator it4 = sortedSet.iterator(); it4.hasNext();) {
|
|
String line = (String) it4.next();
|
|
pw.println(line);
|
|
}
|
|
}
|
|
udf.close();
|
|
}
|
|
|
|
public static void generatePropertyFile(String filename) throws IOException {
|
|
String dir = (String) Format.theFormat.fileToDirectory.get(filename);
|
|
if (dir == null) dir = "";
|
|
UnicodeDataFile udf =
|
|
UnicodeDataFile.openAndWriteHeader("DerivedData/" + dir, filename);
|
|
PrintWriter pw = udf.out;
|
|
// bf2.openUTF8Writer(UCD_Types.GEN_DIR, "Test" + filename + ".txt");
|
|
Format.theFormat.printFileComments(pw, filename);
|
|
UnicodeProperty.Factory toolFactory =
|
|
ToolUnicodePropertySource.make(Default.ucdVersion());
|
|
UnicodeSet unassigned =
|
|
toolFactory.getSet("gc=cn").addAll(toolFactory.getSet("gc=cs"));
|
|
//System.out.println(unassigned.toPattern(true));
|
|
// .removeAll(toolFactory.getSet("noncharactercodepoint=true"));
|
|
|
|
List propList = Format.theFormat.getPropertiesFromFile(filename);
|
|
for (Iterator propIt = propList.iterator(); propIt.hasNext();) {
|
|
BagFormatter bf = new BagFormatter(toolFactory);
|
|
String nextPropName = (String) propIt.next();
|
|
UnicodeProperty prop = toolFactory.getProperty(nextPropName);
|
|
String name = prop.getName();
|
|
System.out.println("Property: " + name + "; " + prop.getTypeName(prop.getType()));
|
|
pw.println();
|
|
pw.println(SEPARATOR);
|
|
String propComment = Format.theFormat.getValueComments(name, "");
|
|
if (propComment != null && propComment.length() != 0) {
|
|
pw.println();
|
|
pw.println(propComment);
|
|
} else if (!prop.isType(UnicodeProperty.BINARY_MASK)) {
|
|
pw.println();
|
|
pw.println("# Property:\t" + name);
|
|
}
|
|
|
|
Format.PrintStyle ps = Format.theFormat.getPrintStyle(name);
|
|
if (DEBUG) System.out.println(ps.toString());
|
|
|
|
if (!prop.isType(UnicodeProperty.BINARY_MASK) &&
|
|
(ps.skipUnassigned != null || ps.skipValue != null)) {
|
|
String v = ps.skipValue;
|
|
if (v == null) {
|
|
v = ps.skipUnassigned;
|
|
}
|
|
String v2 = prop.getFirstValueAlias(v);
|
|
if (UnicodeProperty.compareNames(v,v2) != 0) v = v + " (" + v2 + ")";
|
|
pw.println();
|
|
pw.println("# All code points not explicitly listed for " + prop.getName());
|
|
pw.println("# have the value " + v + ".");
|
|
}
|
|
|
|
if (!ps.interleaveValues && prop.isType(UnicodeProperty.BINARY_MASK)) {
|
|
if (DEBUG) System.out.println("Resetting Binary Values");
|
|
ps.skipValue = "False";
|
|
if (ps.nameStyle.equals("none")) ps.nameStyle = "long";
|
|
ps.valueStyle = "none";
|
|
}
|
|
|
|
if (ps.noLabel) bf.setLabelSource(null);
|
|
if (ps.nameStyle.equals("none")) bf.setPropName(null);
|
|
else if (ps.nameStyle.equals("short")) bf.setPropName(prop.getFirstNameAlias());
|
|
else bf.setPropName(name);
|
|
|
|
if (ps.interleaveValues) {
|
|
writeInterleavedValues(pw, bf, prop, ps);
|
|
} else if (prop.isType(UnicodeProperty.STRING_OR_MISC_MASK)) {
|
|
writeStringValues(pw, bf, prop);
|
|
//} else if (prop.isType(UnicodeProperty.BINARY_MASK)) {
|
|
// writeBinaryValues(pw, bf, prop);
|
|
} else {
|
|
writeEnumeratedValues(pw, bf, unassigned, prop, ps);
|
|
}
|
|
}
|
|
udf.close();
|
|
}
|
|
|
|
private static void writeEnumeratedValues(
|
|
PrintWriter pw,
|
|
BagFormatter bf,
|
|
UnicodeSet unassigned,
|
|
UnicodeProperty prop,
|
|
Format.PrintStyle ps) {
|
|
if (DEBUG) System.out.println("Writing Enumerated Values: " + prop.getName());
|
|
|
|
bf.setValueSource(new UnicodeProperty.FilteredProperty(prop, Format.theFormat.hackMapFilter));
|
|
Collection aliases = prop.getAvailableValues();
|
|
if (ps.orderByRangeStart) {
|
|
if (DEBUG) System.out.println("Reordering");
|
|
TreeSet temp2 = new TreeSet(new RangeStartComparator(prop));
|
|
temp2.addAll(aliases);
|
|
aliases = temp2;
|
|
}
|
|
if (ps.sortNumeric) {
|
|
if (DEBUG) System.out.println("Reordering");
|
|
TreeSet temp2 = new TreeSet(NUMERIC_STRING_COMPARATOR);
|
|
temp2.addAll(aliases);
|
|
aliases = temp2;
|
|
}
|
|
for (Iterator it = aliases.iterator(); it.hasNext();) {
|
|
String value = (String)it.next();
|
|
if (DEBUG) System.out.println("Getting value " + value);
|
|
UnicodeSet s = prop.getSet(value);
|
|
String valueComment = Format.theFormat.getValueComments(prop.getName(), value);
|
|
|
|
if (DEBUG) {
|
|
System.out.println("Value:\t" + value + "\t" + prop.getFirstValueAlias(value) + "\tskip:" + ps.skipValue);
|
|
System.out.println("Value Comment\t" + valueComment);
|
|
System.out.println(s.toPattern(true));
|
|
}
|
|
|
|
int totalSize = s.size();
|
|
if (s.size() == 0) {
|
|
System.out.println("\tSkipping Empty: " + prop.getName() + "=" + value);
|
|
continue;
|
|
}
|
|
|
|
if (UnicodeProperty.compareNames(value, ps.skipValue) == 0) {
|
|
if (DEBUG) System.out.println("Skipping: " + value);
|
|
continue;
|
|
}
|
|
|
|
if (UnicodeProperty.compareNames(value, ps.skipUnassigned) == 0) {
|
|
bf.setFullTotal(s.size());
|
|
if (DEBUG) System.out.println("Removing Unassigneds: " + value);
|
|
s.removeAll(unassigned);
|
|
}
|
|
|
|
//if (s.size() == 0) continue;
|
|
//if (unassigned.containsAll(s)) continue; // skip if all unassigned
|
|
//if (s.contains(0xD0000)) continue; // skip unassigned
|
|
|
|
boolean nonLongValue = false;
|
|
String displayValue = value;
|
|
if (ps.valueStyle.equals("none")) {
|
|
displayValue = null;
|
|
nonLongValue = true;
|
|
} else if (ps.valueStyle.equals("short")) {
|
|
displayValue = prop.getFirstValueAlias(displayValue);
|
|
nonLongValue = true;
|
|
if (DEBUG) System.out.println("Changing value " + displayValue);
|
|
}
|
|
if (ps.makeUppercase && displayValue != null) {
|
|
displayValue = displayValue.toUpperCase(Locale.ENGLISH);
|
|
if (DEBUG) System.out.println("Changing value2 " + displayValue);
|
|
}
|
|
if (ps.makeFirstLetterLowercase && displayValue != null) {
|
|
// NOTE: this is ok since we are only working in ASCII
|
|
displayValue = displayValue.substring(0,1).toLowerCase(Locale.ENGLISH)
|
|
+ displayValue.substring(1);
|
|
if (DEBUG) System.out.println("Changing value2 " + displayValue);
|
|
}
|
|
if (DEBUG) System.out.println("Setting value " + displayValue);
|
|
bf.setValueSource(displayValue);
|
|
|
|
if (!prop.isType(UnicodeProperty.BINARY_MASK)) {
|
|
pw.println();
|
|
pw.println(SEPARATOR);
|
|
if (nonLongValue) {
|
|
pw.println();
|
|
pw.println("# " + prop.getName() + "=" + value);
|
|
}
|
|
}
|
|
|
|
if (valueComment != null) {
|
|
pw.println();
|
|
pw.println(valueComment);
|
|
}
|
|
if (false && ps.longValueHeading != null) {
|
|
String headingValue = value;
|
|
if (ps.longValueHeading == "ccc") {
|
|
headingValue = Utility.replace(value, "_", "");
|
|
char c = headingValue.charAt(0);
|
|
if ('0' <= c && c <= '9') headingValue = "Other Combining Class";
|
|
}
|
|
pw.println();
|
|
pw.println("# " + headingValue);
|
|
}
|
|
pw.println();
|
|
//if (s.size() != 0)
|
|
bf.showSetNames(pw, s);
|
|
}
|
|
|
|
}
|
|
//static NumberFormat nf = NumberFormat.getInstance();
|
|
static Comparator NUMERIC_STRING_COMPARATOR = new Comparator() {
|
|
public int compare(Object o1, Object o2) {
|
|
if (o1 == o2) return 0;
|
|
if (o1 == null) return -1;
|
|
if (o2 == null) return 1;
|
|
return Double.compare(
|
|
Double.parseDouble((String) o1),
|
|
Double.parseDouble((String) o2));
|
|
}
|
|
|
|
};
|
|
/*
|
|
private static void writeBinaryValues(
|
|
PrintWriter pw,
|
|
BagFormatter bf,
|
|
UnicodeProperty prop) {
|
|
if (DEBUG) System.out.println("Writing Binary Values: " + prop.getName());
|
|
UnicodeSet s = prop.getSet("True");
|
|
bf.setValueSource(prop.getName());
|
|
bf.showSetNames(pw, s);
|
|
}
|
|
*/
|
|
|
|
private static void writeInterleavedValues(
|
|
PrintWriter pw,
|
|
BagFormatter bf,
|
|
UnicodeProperty prop, PrintStyle ps) {
|
|
if (DEBUG) System.out.println("Writing Interleaved Values: " + prop.getName());
|
|
pw.println();
|
|
bf.setValueSource(new UnicodeProperty.FilteredProperty(prop, new RestoreSpacesFilter(ps)))
|
|
.setNameSource(null)
|
|
.setLabelSource(null)
|
|
.setRangeBreakSource(null)
|
|
.setShowCount(false)
|
|
.showSetNames(pw,new UnicodeSet(0,0x10FFFF));
|
|
}
|
|
|
|
private static void writeStringValues(
|
|
PrintWriter pw,
|
|
BagFormatter bf,
|
|
UnicodeProperty prop) {
|
|
if (DEBUG) System.out.println("Writing String Values: " + prop.getName());
|
|
pw.println();
|
|
bf.setValueSource(prop)
|
|
.setHexValue(true)
|
|
.setMergeRanges(false)
|
|
.showSetNames(pw,new UnicodeSet(0,0x10FFFF));
|
|
}
|
|
|
|
static class RangeStartComparator implements Comparator {
|
|
UnicodeProperty prop;
|
|
CompareProperties.UnicodeSetComparator comp = new CompareProperties.UnicodeSetComparator();
|
|
RangeStartComparator(UnicodeProperty prop) {
|
|
this.prop = prop;
|
|
}
|
|
public int compare(Object o1, Object o2) {
|
|
UnicodeSet s1 = prop.getSet((String)o1);
|
|
UnicodeSet s2 = prop.getSet((String)o2);
|
|
if (true) System.out.println("comparing " + o1 + ", " + o2
|
|
+ s1.toPattern(true) + "?" + s2.toPattern(true)
|
|
+ ", " + comp.compare(s1, s2));
|
|
return comp.compare(s1, s2);
|
|
}
|
|
|
|
}
|
|
|
|
static class RestoreSpacesFilter extends UnicodeProperty.StringFilter {
|
|
String skipValue;
|
|
/**
|
|
* @param ps
|
|
*/
|
|
public RestoreSpacesFilter(PrintStyle ps) {
|
|
skipValue = ps.skipValue;
|
|
if (skipValue == null) skipValue = ps.skipUnassigned;
|
|
}
|
|
|
|
public String remap(String original) {
|
|
// ok, because doesn't change length
|
|
String mod = (String) Format.theFormat.hackMap.get(original);
|
|
if (mod != null) original = mod;
|
|
if (original.equals(skipValue)) return null;
|
|
return original.replace('_',' ');
|
|
}
|
|
}
|
|
|
|
static Comparator CASELESS_COMPARATOR = new Comparator() {
|
|
public int compare(Object o1, Object o2) {
|
|
String s = o1.toString();
|
|
String t = o2.toString();
|
|
return s.compareToIgnoreCase(t);
|
|
}
|
|
};
|
|
|
|
public static void showDiff() throws IOException {
|
|
PrintWriter out = BagFormatter.openUTF8Writer(UCD_Types.GEN_DIR, "propertyDifference.txt");
|
|
try {
|
|
showDifferences(out, "4.0.1", "LB", "GC");
|
|
showDifferences(out, "4.0.1", "East Asian Width", "LB");
|
|
showDifferences(out, "4.0.1", "East Asian Width", "GC");
|
|
} finally {
|
|
out.close();
|
|
}
|
|
}
|
|
|
|
public static void showAllDiff() throws IOException {
|
|
PrintWriter out = BagFormatter.openUTF8Writer(UCD_Types.GEN_DIR, "propertyDifference.txt");
|
|
try {
|
|
UnicodeProperty.Factory fac = ToolUnicodePropertySource.make("4.0.1");
|
|
List props = fac.getAvailableNames(
|
|
(1<<UnicodeProperty.BINARY)
|
|
| (1<<UnicodeProperty.ENUMERATED)
|
|
//| (1<<UnicodeProperty.CATALOG)
|
|
);
|
|
Set skipList = new HashSet();
|
|
skipList.add("Age");
|
|
skipList.add("Joining_Group");
|
|
skipList.add("Canonical_Combining_Class");
|
|
|
|
for (Iterator it = props.iterator(); it.hasNext();) {
|
|
String prop1 = (String) it.next();
|
|
for (Iterator it2 = props.iterator(); it2.hasNext();) {
|
|
String prop2 = (String) it2.next();
|
|
if (prop1.equals(prop2)) continue;
|
|
if (skipList.contains(prop2)) continue;
|
|
System.out.println(prop1 + " vs. " + prop2);
|
|
showDifferences(out, fac.getProperty(prop1), fac.getProperty(prop2), false);
|
|
out.flush();
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
out.close();
|
|
}
|
|
}
|
|
|
|
static NumberFormat nf = NumberFormat.getIntegerInstance(Locale.ENGLISH);
|
|
|
|
|
|
static void showDifferences(PrintWriter out, String version, String prop1, String prop2) throws IOException {
|
|
UnicodeProperty p1 = ToolUnicodePropertySource.make(version).getProperty(prop1);
|
|
UnicodeProperty p2 = ToolUnicodePropertySource.make(version).getProperty(prop2);
|
|
showDifferences(out, p1, p2, true);
|
|
}
|
|
|
|
static void showDifferences(PrintWriter out, UnicodeProperty p1, UnicodeProperty p2, boolean doOverlaps) throws IOException {
|
|
BagFormatter bf = new BagFormatter();
|
|
//out.println("Comparing " + p1.getName() + " and " + p2.getName());
|
|
System.out.println("Comparing " + p1.getName() + " and " + p2.getName());
|
|
String pn1 = '$' + p1.getName();
|
|
String pn2 = '$' + p2.getName();
|
|
UnicodeSet intersection = new UnicodeSet();
|
|
UnicodeSet disjoint = new UnicodeSet();
|
|
String skip1 = p1.getValue(0xEFFFD);
|
|
String skip2 = p2.getValue(0xEFFFD);
|
|
main:
|
|
for (Iterator it1 = p1.getAvailableValues().iterator(); it1.hasNext();) {
|
|
String v1 = (String)it1.next();
|
|
if (v1.equals(skip1)) continue;
|
|
UnicodeSet s1 = p1.getSet(v1);
|
|
if (s1.size() == 0) continue;
|
|
String pv1 = pn1 + (v1.equals("True") ? "" : ":" + v1);
|
|
//v1 += " (" + p1.getFirstValueAlias(v1) + ")";
|
|
System.out.println(v1);
|
|
//out.println();
|
|
//out.println(v1 + " [" + nf.format(s1.size()) + "]");
|
|
|
|
// create some containers so that the output is organized reasonably
|
|
String contains = "";
|
|
String overlaps = "";
|
|
UnicodeSet containsSet = new UnicodeSet();
|
|
Set overlapsSet = new TreeSet();
|
|
for (Iterator it2 = p2.getAvailableValues().iterator(); it2.hasNext();) {
|
|
String v2 = (String)it2.next();
|
|
if (v2.equals(skip2)) continue;
|
|
UnicodeSet s2 = p2.getSet(v2);
|
|
if (s2.size() == 0) continue;
|
|
// v2 += "(" + p2.getFirstValueAlias(v2) + ")";
|
|
//v2 = p2.getFirstValueAlias(v2);
|
|
String pv2 = pn2 + (v2.equals("True") ? "" : ":" + v2);
|
|
if (s1.containsNone(s2)) continue;
|
|
if (s1.equals(s2)) {
|
|
out.println(pv1 + "\t= " + pv2);
|
|
continue main; // since they are partitions, we can stop here
|
|
} else if (s2.containsAll(s1)) {
|
|
// out.println(pv1 + "\t\u2282 " + pv2);
|
|
continue main; // partition, stop
|
|
} else if (s1.containsAll(s2)) {
|
|
if (contains.length() != 0) contains += " ";
|
|
contains += pv2;
|
|
containsSet.addAll(s2);
|
|
if (containsSet.size() == s1.size()) break;
|
|
} else if (doOverlaps) { // doesn't contain, isn't contained
|
|
if (overlaps.length() != 0) overlaps += "\r\n\t";
|
|
intersection.clear().addAll(s2).retainAll(s1);
|
|
disjoint.clear().addAll(s1).removeAll(s2);
|
|
overlaps += "\u2283 " + v2 + " [" + nf.format(intersection.size()) + "]"
|
|
+ " \u2285 " + v2 + " [" + nf.format(disjoint.size()) + "]";
|
|
overlapsSet.add(v2);
|
|
}
|
|
}
|
|
if (contains.length() != 0) {
|
|
out.println(pv1 + (containsSet.size() == s1.size() ? "\t= "
|
|
: "\t\u2283 ") + "[" + contains + "]");
|
|
}
|
|
if (overlaps.length() != 0) out.println("\t" + overlaps);
|
|
if (false && overlapsSet.size() != 0) {
|
|
out.println("\t\u2260\u2284\u2285");
|
|
for (Iterator it3 = overlapsSet.iterator(); it3.hasNext();) {
|
|
String v3 = (String) it3.next();
|
|
UnicodeSet s3 = p2.getSet(v3);
|
|
out.println("\t" + v3);
|
|
bf.showSetDifferences(out,v1,s1,v3,s3);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static class UnicodeDataHack extends UnicodeLabel {
|
|
private UnicodeProperty.Factory factory;
|
|
private UnicodeProperty name;
|
|
private UnicodeProperty bidiMirrored;
|
|
private UnicodeProperty numericValue;
|
|
private UnicodeProperty numericType;
|
|
private UnicodeProperty decompositionValue;
|
|
private UnicodeProperty decompositionType;
|
|
private UnicodeProperty bidiClass;
|
|
private UnicodeProperty combiningClass;
|
|
private UnicodeProperty category;
|
|
UnicodeDataHack(UnicodeProperty.Factory factory) {
|
|
this.factory = factory;
|
|
name = factory.getProperty("Name");
|
|
category = factory.getProperty("General_Category");
|
|
combiningClass = factory.getProperty("Canonical_Combining_Class");
|
|
bidiClass = factory.getProperty("Bidi_Class");
|
|
decompositionType = factory.getProperty("Decomposition_Type");
|
|
decompositionValue = factory.getProperty("Decomposition_Value");
|
|
numericType = factory.getProperty("Numeric_Type");
|
|
numericValue = factory.getProperty("Numeric_Value");
|
|
bidiMirrored = factory.getProperty("Bidi_Mirrored");
|
|
//name10
|
|
//isoComment
|
|
}
|
|
public String getValue(int codepoint, boolean isShort) {
|
|
String nameStr = name.getName();
|
|
if (nameStr.startsWith("<reserved")) return null;
|
|
String code = Utility.hex(codepoint);
|
|
int pos = nameStr.indexOf(code);
|
|
if (pos > 0) {
|
|
nameStr = nameStr.substring(0,pos) + "%" + nameStr.substring(pos + code.length());
|
|
}
|
|
nameStr += ";"
|
|
+ category.getValue(codepoint, true) + ";"
|
|
+ combiningClass.getValue(codepoint, true) + ";"
|
|
+ bidiClass.getValue(codepoint, true) + ";"
|
|
;
|
|
String temp = decompositionType.getValue(codepoint, true);
|
|
if (!temp.equals("None")) {
|
|
nameStr += "<" + temp + "> " + Utility.hex(decompositionValue.getValue(codepoint));
|
|
}
|
|
nameStr += ";";
|
|
temp = numericType.getValue(codepoint, true);
|
|
if (temp.equals("Decimal")) {
|
|
nameStr += temp + ";" + temp + ";" + temp + ";";
|
|
} else if (temp.equals("Digit")) {
|
|
nameStr += ";" + temp + ";" + temp + ";";
|
|
} else if (temp.equals("Numeric")) {
|
|
nameStr += ";;" + temp + ";";
|
|
} else if (temp.equals("Digit")) {
|
|
nameStr += ";;;";
|
|
}
|
|
if (bidiMirrored.getValue(codepoint, true).equals("True")) {
|
|
nameStr += "Y" + ";";
|
|
}
|
|
nameStr += ";";
|
|
return nameStr;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
static class PropertySymbolTable implements SymbolTable {
|
|
static boolean DEBUG = false;
|
|
UnicodeProperty.Factory factory;
|
|
//static Matcher identifier = Pattern.compile("([:letter:] [\\_\\-[:letter:][:number:]]*)").matcher("");
|
|
|
|
PropertySymbolTable (UnicodeProperty.Factory factory) {
|
|
this.factory = factory;
|
|
}
|
|
|
|
public char[] lookup(String s) {
|
|
if (DEBUG) System.out.println("\tLooking up " + s);
|
|
int pos = s.indexOf('=');
|
|
if (pos < 0) return null; // should never happen
|
|
UnicodeProperty prop = factory.getProperty(s.substring(0,pos));
|
|
if (prop == null) {
|
|
throw new IllegalArgumentException("Invalid Property: " + s + "\r\nUse "
|
|
+ showSet(factory.getAvailableNames()));
|
|
}
|
|
String value = s.substring(pos+1);
|
|
UnicodeSet set = prop.getSet(value);
|
|
if (set.size() == 0) {
|
|
throw new IllegalArgumentException("Empty Property-Value: " + s + "\r\nUse "
|
|
+ showSet(prop.getAvailableValues()));
|
|
}
|
|
if (DEBUG) System.out.println("\tReturning " + set.toPattern(true));
|
|
return set.toPattern(true).toCharArray(); // really ugly
|
|
}
|
|
|
|
private String showSet(List list) {
|
|
StringBuffer result = new StringBuffer("[");
|
|
boolean first = true;
|
|
for (Iterator it = list.iterator(); it.hasNext();) {
|
|
if (!first) result.append(", ");
|
|
else first = false;
|
|
result.append(it.next().toString());
|
|
}
|
|
result.append("]");
|
|
return result.toString();
|
|
}
|
|
|
|
public UnicodeMatcher lookupMatcher(int ch) {
|
|
return null;
|
|
}
|
|
|
|
public String parseReference(String text, ParsePosition pos, int limit) {
|
|
if (DEBUG) System.out.println("\tParsing <" + text.substring(pos.getIndex(),limit) + ">");
|
|
int start = pos.getIndex();
|
|
int i = getIdentifier(text, start, limit);
|
|
if (i == start) return null;
|
|
String prop = text.substring(start, i);
|
|
String value = "true";
|
|
if (i < limit) {
|
|
int cp = text.charAt(i);
|
|
if (cp == ':' || cp == '=') {
|
|
int j = getIdentifier(text, i+1, limit);
|
|
value = text.substring(i+1, j);
|
|
i = j;
|
|
}
|
|
}
|
|
pos.setIndex(i);
|
|
if (DEBUG) System.out.println("\tParsed <" + prop + ">=<" + value + ">");
|
|
return prop + '=' + value;
|
|
}
|
|
|
|
private int getIdentifier(String text, int start, int limit) {
|
|
if (DEBUG) System.out.println("\tGetID <" + text.substring(start,limit) + ">");
|
|
int cp = 0;
|
|
int i;
|
|
for (i = start; i < limit; i += UTF16.getCharCount(cp)) {
|
|
cp = UTF16.charAt(text, i);
|
|
if (!com.ibm.icu.lang.UCharacter.isUnicodeIdentifierPart(cp)) {
|
|
break;
|
|
}
|
|
}
|
|
if (DEBUG) System.out.println("\tGotID <" + text.substring(start,i) + ">");
|
|
return i;
|
|
}
|
|
|
|
};
|
|
|
|
/* getCombo(UnicodeProperty.Factory factory, String line) {
|
|
UnicodeSet result = new UnicodeSet();
|
|
String[] pieces = Utility.split(line, '+');
|
|
for (int i = 0; i < pieces.length; ++i) {
|
|
String[] parts = Utility.split(pieces[i],':');
|
|
String prop = parts[0].trim();
|
|
String value = "true";
|
|
if (parts.length > 1) value = parts[1].trim();
|
|
UnicodeProperty p = factory.getProperty(prop);
|
|
result.addAll(p.getSet(value));
|
|
}
|
|
return result;
|
|
}
|
|
*/
|
|
}
|
|
|
|
/*
|
|
static class OrderedMap {
|
|
HashMap map = new HashMap();
|
|
ArrayList keys = new ArrayList();
|
|
void put(Object o, Object t) {
|
|
map.put(o,t);
|
|
keys.add(o);
|
|
}
|
|
List keyset() {
|
|
return keys;
|
|
}
|
|
}
|
|
*/ |