Get rid of many symbol tables (#1085)

* Get rid of many symbol tables

* Static initialization order fiasco

* These throw instead of being empty now.

* oldestLoaded

* More queries that now fail

* And another one

* ASCII to Block=ASCII (short for Basic Latin) passim

* Variables. Looks like there is a bug in U-1.

* :

* Ignore leading spaces too

* Enumerated pseudoproperty Do_Not_Emit_Type cannot be @none@

* That’s not how Age works

* what

* Too much skeletonizing

* Get rid of the last one and factor out NO_PROPS

Author: eggrobin

UnicodeJsps/src/main/java/org/unicode/jsp/BidiCharMap.java

@@ -48,7 +48,7 @@ class BidiCharMap {
 
         for (UnicodeSetIterator it =
                         new UnicodeSetIterator(
-                                new UnicodeSet("[[:ascii:]-[[:cc:]-[:whitespace:]]]"));
+                                new UnicodeSet("[[:Block=ASCII:]-[[:cc:]-[:whitespace:]]]"));
                 it.next(); ) {
             asciiHackMap.put(
                     it.codepoint,

UnicodeJsps/src/main/java/org/unicode/jsp/UnicodeSetUtilities.java

@@ -7,19 +7,11 @@
 import com.ibm.icu.text.UTF16.StringComparator;
 import com.ibm.icu.text.UnicodeSet;
 import com.ibm.icu.util.ULocale;
-import com.ibm.icu.util.VersionInfo;
 import java.text.ParsePosition;
 import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
 import java.util.regex.Pattern;
 import org.unicode.cldr.util.MultiComparator;
-import org.unicode.props.IndexUnicodeProperties;
-import org.unicode.props.UcdProperty;
-import org.unicode.props.UcdPropertyValues;
-import org.unicode.props.UnicodeProperty;
-import org.unicode.props.UnicodeProperty.PatternMatcher;
-import org.unicode.props.UnicodePropertySymbolTable;
+import org.unicode.text.UCD.VersionedSymbolTable;
 
 public class UnicodeSetUtilities {
 
@@ -114,7 +106,12 @@ public static UnicodeSet parseUnicodeSet(String input) {
         input = input.trim() + "]]]]]";
         String parseInput = "[" + input + "]]]]]";
         ParsePosition parsePosition = new ParsePosition(0);
-        UnicodeSet result = new UnicodeSet(parseInput, parsePosition, fullSymbolTable);
+        UnicodeSet result =
+                new UnicodeSet(
+                        parseInput,
+                        parsePosition,
+                        VersionedSymbolTable.forReview(UcdLoader::getOldestLoadedUcd)
+                                .setUnversionedExtensions(XPropertyFactory.make()));
         int parseEnd = parsePosition.getIndex();
         if (parseEnd != parseInput.length()
                 && !UnicodeSetUtilities.OK_AT_END.containsAll(parseInput.substring(parseEnd))) {
@@ -129,262 +126,4 @@ public static UnicodeSet parseUnicodeSet(String input) {
         }
         return result;
     }
-
-    static UnicodeSet.XSymbolTable fullSymbolTable = new MySymbolTable();
-
-    private static class MySymbolTable extends UnicodeSet.XSymbolTable {
-        UnicodeRegex unicodeRegex;
-        XPropertyFactory factory;
-
-        public MySymbolTable() {
-            unicodeRegex = new UnicodeRegex().setSymbolTable(this);
-        }
-
-        //    public boolean applyPropertyAlias0(String propertyName,
-        //            String propertyValue, UnicodeSet result) {
-        //      if (!propertyName.contains("*")) {
-        //        return applyPropertyAlias(propertyName, propertyValue, result);
-        //      }
-        //      String[] propertyNames = propertyName.split("[*]");
-        //      for (int i = propertyNames.length - 1; i >= 0; ++i) {
-        //        String pname = propertyNames[i];
-        //
-        //      }
-        //      return null;
-        //    }
-
-        @Override
-        public boolean applyPropertyAlias(
-                String propertyName, String propertyValue, UnicodeSet result) {
-            boolean status = false;
-            boolean invert = false;
-            int posNotEqual = propertyName.indexOf('\u2260');
-            if (posNotEqual >= 0) {
-                propertyValue =
-                        propertyValue.length() == 0
-                                ? propertyName.substring(posNotEqual + 1)
-                                : propertyName.substring(posNotEqual + 1) + "=" + propertyValue;
-                propertyName = propertyName.substring(0, posNotEqual);
-                invert = true;
-            }
-            if (propertyName.endsWith("!")) {
-                propertyName = propertyName.substring(0, propertyName.length() - 1);
-                invert = !invert;
-            }
-            int posColon = propertyName.indexOf(':');
-            String versionPrefix = "";
-            String versionlessPropertyName = propertyName;
-            if (posColon >= 0) {
-                versionPrefix = propertyName.substring(0, posColon + 1);
-                versionlessPropertyName = propertyName.substring(posColon + 1);
-            }
-
-            if (factory == null) {
-                factory = XPropertyFactory.make();
-            }
-
-            var gcProp = factory.getProperty(versionPrefix + "gc");
-            var scProp = factory.getProperty(versionPrefix + "sc");
-
-            UnicodeProperty prop = factory.getProperty(propertyName);
-            if (propertyValue.length() != 0) {
-                if (prop == null) {
-                    propertyValue = propertyValue.trim();
-                } else if (prop.isTrimmable()) {
-                    propertyValue = propertyValue.trim();
-                } else {
-                    int debug = 0;
-                }
-                status = applyPropertyAlias0(prop, propertyValue, result, invert);
-            } else {
-                try {
-                    status = applyPropertyAlias0(gcProp, versionlessPropertyName, result, invert);
-                } catch (Exception e) {
-                }
-                ;
-                if (!status) {
-                    try {
-                        status =
-                                applyPropertyAlias0(
-                                        scProp, versionlessPropertyName, result, invert);
-                    } catch (Exception e) {
-                    }
-                    if (!status) {
-                        if (prop.isType(UnicodeProperty.BINARY_OR_ENUMERATED_OR_CATALOG_MASK)) {
-                            try {
-                                status = applyPropertyAlias0(prop, "No", result, !invert);
-                            } catch (Exception e) {
-                            }
-                        }
-                        if (!status) {
-                            status = applyPropertyAlias0(prop, "", result, invert);
-                        }
-                    }
-                }
-            }
-            return status;
-        }
-
-        private static Map<UcdPropertyValues.General_Category_Values, String[]>
-                COARSE_GENERAL_CATEGORIES =
-                        Map.of(
-                                UcdPropertyValues.General_Category_Values.Other,
-                                new String[] {"Cc", "Cf", "Cn", "Co", "Cs"},
-                                UcdPropertyValues.General_Category_Values.Letter,
-                                new String[] {"Ll", "Lm", "Lo", "Lt", "Lu"},
-                                UcdPropertyValues.General_Category_Values.Cased_Letter,
-                                new String[] {"Ll", "Lt", "Lu"},
-                                UcdPropertyValues.General_Category_Values.Mark,
-                                new String[] {"Mc", "Me", "Mn"},
-                                UcdPropertyValues.General_Category_Values.Number,
-                                new String[] {"Nd", "Nl", "No"},
-                                UcdPropertyValues.General_Category_Values.Punctuation,
-                                new String[] {"Pc", "Pd", "Pe", "Pf", "Pi", "Po", "Ps"},
-                                UcdPropertyValues.General_Category_Values.Symbol,
-                                new String[] {"Sc", "Sk", "Sm", "So"},
-                                UcdPropertyValues.General_Category_Values.Separator,
-                                new String[] {"Zl", "Zp", "Zs"});
-
-        // TODO(eggrobin): I think this function only ever returns true; might as well make it void.
-        private boolean applyPropertyAlias0(
-                UnicodeProperty prop, String propertyValue, UnicodeSet result, boolean invert) {
-            result.clear();
-            String propertyName = prop.getName();
-            String trimmedPropertyValue = propertyValue.trim();
-            PatternMatcher patternMatcher = null;
-            if (trimmedPropertyValue.length() > 1
-                    && trimmedPropertyValue.startsWith("/")
-                    && trimmedPropertyValue.endsWith("/")) {
-                String fixedRegex =
-                        unicodeRegex.transform(
-                                trimmedPropertyValue.substring(
-                                        1, trimmedPropertyValue.length() - 1));
-                patternMatcher = new UnicodeProperty.RegexMatcher().set(fixedRegex);
-            }
-            UnicodeProperty otherProperty = null;
-            boolean testCp = false;
-            boolean testNone = false;
-            if (trimmedPropertyValue.length() > 1
-                    && trimmedPropertyValue.startsWith("@")
-                    && trimmedPropertyValue.endsWith("@")) {
-                String otherPropName =
-                        trimmedPropertyValue.substring(1, trimmedPropertyValue.length() - 1).trim();
-                if (UnicodeProperty.equalNames("code point", otherPropName)) {
-                    testCp = true;
-                } else if (UnicodeProperty.equalNames("none", otherPropName)) {
-                    testNone = true;
-                } else {
-                    otherProperty = factory.getProperty(otherPropName);
-                }
-            }
-            // TODO(egg): Name and Name_Alias require special handling (UAX44-LM2), and
-            // treating Name_Alias as aliases for Name.
-            boolean isAge = UnicodeProperty.equalNames("age", propertyName);
-            if (prop != null) {
-                UnicodeSet set;
-                if (testCp) {
-                    set = new UnicodeSet();
-                    for (int i = 0; i <= 0x10FFFF; ++i) {
-                        if (invert != UnicodeProperty.equals(i, prop.getValue(i))) {
-                            set.add(i);
-                        }
-                    }
-                    invert = false;
-                } else if (testNone) {
-                    set = prop.getSet(UnicodeProperty.NULL_MATCHER);
-                } else if (otherProperty != null) {
-                    System.err.println(otherProperty + ", " + invert);
-                    set = new UnicodeSet();
-                    for (int i = 0; i <= 0x10FFFF; ++i) {
-                        String v1 = prop.getValue(i);
-                        String v2 = otherProperty.getValue(i);
-                        if (invert != UnicodeProperty.equals(v1, v2)) {
-                            set.add(i);
-                        }
-                    }
-                    invert = false;
-                } else if (patternMatcher == null) {
-                    if (!isValid(prop, propertyValue)) {
-                        throw new IllegalArgumentException(
-                                "The value '"
-                                        + propertyValue
-                                        + "' is illegal. Values for "
-                                        + propertyName
-                                        + " must be in "
-                                        + prop.getAvailableValues()
-                                        + " or in "
-                                        + prop.getValueAliases());
-                    }
-                    if (isAge) {
-                        set =
-                                prop.getSet(
-                                        new UnicodePropertySymbolTable.ComparisonMatcher<
-                                                VersionInfo>(
-                                                UnicodePropertySymbolTable.parseVersionInfoOrMax(
-                                                        propertyValue),
-                                                UnicodePropertySymbolTable.Relation.geq,
-                                                Comparator.nullsFirst(Comparator.naturalOrder()),
-                                                UnicodePropertySymbolTable::parseVersionInfoOrMax));
-                    } else {
-                        if (prop.getName().equals("General_Category")) {
-                            for (var entry : COARSE_GENERAL_CATEGORIES.entrySet()) {
-                                final var aliases = entry.getKey().getNames().getAllNames();
-                                if (aliases.stream()
-                                        .anyMatch(
-                                                a ->
-                                                        UnicodeProperty.equalNames(
-                                                                propertyValue, a))) {
-                                    for (var value : entry.getValue()) {
-                                        prop.getSet(value, result);
-                                    }
-                                    return true;
-                                }
-                            }
-                        }
-                        set = prop.getSet(propertyValue);
-                        if (set.isEmpty()
-                                && prop instanceof IndexUnicodeProperties.IndexUnicodeProperty
-                                && prop.getName().equals("Name")) {
-                            set =
-                                    ((IndexUnicodeProperties.IndexUnicodeProperty) prop)
-                                            .getFactory()
-                                            .getProperty(UcdProperty.Name_Alias)
-                                            .getSet(propertyValue);
-                        }
-                    }
-                } else if (isAge) {
-                    set = new UnicodeSet();
-                    List<String> values = prop.getAvailableValues();
-                    for (String value : values) {
-                        if (patternMatcher.test(value)) {
-                            for (String other : values) {
-                                if (other.compareTo(value) <= 0) {
-                                    set.addAll(prop.getSet(other));
-                                }
-                            }
-                        }
-                    }
-                } else {
-                    set = prop.getSet(patternMatcher);
-                }
-                if (invert) {
-                    if (isAge) {
-                        set.complement();
-                    } else {
-                        set = prop.getUnicodeMap().keySet().removeAll(set);
-                    }
-                }
-                result.addAll(set);
-                return true;
-            }
-            throw new IllegalArgumentException("Illegal property: " + propertyName);
-        }
-
-        private boolean isValid(UnicodeProperty prop, String propertyValue) {
-            //      if (prop.getName().equals("General_Category")) {
-            //        if (propertyValue)
-            //      }
-            return prop.isValidValue(propertyValue);
-        }
-    }
 }

UnicodeJsps/src/test/java/org/unicode/jsptest/TestJsp.java

@@ -743,9 +743,9 @@ public void TestMapping() {
         assertContains(sample, "abcd");
         sample = UnicodeJsp.showTransform("bc > CB; X > xx;", "Abcd");
         assertContains(sample, "ACBd");
-        sample = UnicodeJsp.showTransform("lower", "[[:ascii:]{Abcd}]");
+        sample = UnicodeJsp.showTransform("lower", "[[:Block=ASCII:]{Abcd}]");
         assertContains(sample, "\u00A0A\u00A0");
-        sample = UnicodeJsp.showTransform("bc > CB; X > xx;", "[[:ascii:]{Abcd}]");
+        sample = UnicodeJsp.showTransform("bc > CB; X > xx;", "[[:Block=ASCII:]{Abcd}]");
         assertContains(sample, "\u00A0ACBd\u00A0");
         sample = UnicodeJsp.showTransform("casefold", "[\\u0000-\\u00FF]");
         assertContains(sample, "\u00A0\u00E1\u00A0");
@@ -791,7 +791,7 @@ public void TestStuff() throws IOException {
             UnicodeJsp.showSet(
                     "sc gc",
                     "",
-                    new UnicodeSet("[[:ascii:]{123}{ab}{456}]"),
+                    new UnicodeSet("[[:Block=ASCII:]{123}{ab}{456}]"),
                     false,
                     true,
                     true,
@@ -912,7 +912,7 @@ public void TestParameters() {
 
     @Test
     public void TestRegex() {
-        final String fix = UnicodeRegex.fix("ab[[:ascii:]&[:Ll:]]*c");
+        final String fix = UnicodeRegex.fix("ab[[:Block=ASCII:]&[:Ll:]]*c");
         assertEquals("", "ab[a-z]*c", fix);
         assertEquals(
                 "",
@@ -1028,7 +1028,7 @@ public void TestBnf() {
                         + "host = \\/\\/ reserved+;\n"
                         + "query = [\\=reserved]+;\n"
                         + "fragment = reserved+;\n"
-                        + "reserved = [[:ascii:][:sc=grek:]&[:alphabetic:]];\n",
+                        + "reserved = [[:Block=ASCII:][:sc=grek:]&[:alphabetic:]];\n",
                 "http://αβγ?huh=hi#there"
             },
             //                {