1 /* 2 * Copyright (c) 2003, 2020, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package java.lang; 27 28 /** The CharacterData class encapsulates the large tables found in 29 Java.lang.Character. */ 30 31 class CharacterData0E extends CharacterData { 32 /* The character properties are currently encoded into 32 bits in the following manner: 33 1 bit mirrored property 34 4 bits directionality property 35 9 bits signed offset used for converting case 36 1 bit if 1, adding the signed offset converts the character to lowercase 37 1 bit if 1, subtracting the signed offset converts the character to uppercase 38 1 bit if 1, this character has a titlecase equivalent (possibly itself) 39 3 bits 0 may not be part of an identifier 40 1 ignorable control; may continue a Unicode identifier or Java identifier 41 2 may continue a Java identifier but not a Unicode identifier (unused) 42 3 may continue a Unicode identifier or Java identifier 43 4 is a Java whitespace character 44 5 may start or continue a Java identifier; 45 may continue but not start a Unicode identifier (underscores) 46 6 may start or continue a Java identifier but not a Unicode identifier ($) 47 7 may start or continue a Unicode identifier or Java identifier 48 Thus: 49 5, 6, 7 may start a Java identifier 50 1, 2, 3, 5, 6, 7 may continue a Java identifier 51 7 may start a Unicode identifier 52 1, 3, 5, 7 may continue a Unicode identifier 53 1 is ignorable within an identifier 54 4 is Java whitespace 55 2 bits 0 this character has no numeric property 56 1 adding the digit offset to the character code and then 57 masking with 0x1F will produce the desired numeric value 58 2 this character has a "strange" numeric value 59 3 a Java supradecimal digit: adding the digit offset to the 60 character code, then masking with 0x1F, then adding 10 61 will produce the desired numeric value 62 5 bits digit offset 63 5 bits character type 64 65 The encoding of character properties is subject to change at any time. 66 */ 67 68 int getProperties(int ch) { 69 char offset = (char)ch; 70 int props = $$Lookup(offset); 71 return props; 72 } 73 74 int getPropertiesEx(int ch) { 75 char offset = (char)ch; 76 int props = $$LookupEx(offset); 77 return props; 78 } 79 80 boolean isOtherLowercase(int ch) { 81 int props = getPropertiesEx(ch); 82 return (props & $$maskOtherLowercase) != 0; 83 } 84 85 boolean isOtherUppercase(int ch) { 86 int props = getPropertiesEx(ch); 87 return (props & $$maskOtherUppercase) != 0; 88 } 89 90 boolean isOtherAlphabetic(int ch) { 91 int props = getPropertiesEx(ch); 92 return (props & $$maskOtherAlphabetic) != 0; 93 } 94 95 boolean isIdeographic(int ch) { 96 int props = getPropertiesEx(ch); 97 return (props & $$maskIdeographic) != 0; 98 } 99 100 int getType(int ch) { 101 int props = getProperties(ch); 102 return (props & $$maskType); 103 } 104 105 boolean isJavaIdentifierStart(int ch) { 106 int props = getProperties(ch); 107 return ((props & $$maskIdentifierInfo) >= $$lowJavaStart); 108 } 109 110 boolean isJavaIdentifierPart(int ch) { 111 int props = getProperties(ch); 112 return ((props & $$nonzeroJavaPart) != 0); 113 } 114 115 boolean isUnicodeIdentifierStart(int ch) { 116 return (getPropertiesEx(ch) & $$maskIDStart) != 0; 117 } 118 119 boolean isUnicodeIdentifierPart(int ch) { 120 return (getPropertiesEx(ch) & $$maskIDContinue) != 0 || 121 isIdentifierIgnorable(ch); 122 } 123 124 boolean isIdentifierIgnorable(int ch) { 125 int props = getProperties(ch); 126 return ((props & $$maskIdentifierInfo) == $$valueIgnorable); 127 } 128 129 int toLowerCase(int ch) { 130 int mapChar = ch; 131 int val = getProperties(ch); 132 133 if ((val & $$maskLowerCase) != 0) { 134 int offset = val << $$shiftCaseOffsetSign >> ($$shiftCaseOffsetSign+$$shiftCaseOffset); 135 mapChar = ch + offset; 136 } 137 return mapChar; 138 } 139 140 int toUpperCase(int ch) { 141 int mapChar = ch; 142 int val = getProperties(ch); 143 144 if ((val & $$maskUpperCase) != 0) { 145 int offset = val << $$shiftCaseOffsetSign >> ($$shiftCaseOffsetSign+$$shiftCaseOffset); 146 mapChar = ch - offset; 147 } 148 return mapChar; 149 } 150 151 int toTitleCase(int ch) { 152 int mapChar = ch; 153 int val = getProperties(ch); 154 155 if ((val & $$maskTitleCase) != 0) { 156 // There is a titlecase equivalent. Perform further checks: 157 if ((val & $$maskUpperCase) == 0) { 158 // The character does not have an uppercase equivalent, so it must 159 // already be uppercase; so add 1 to get the titlecase form. 160 mapChar = ch + 1; 161 } 162 else if ((val & $$maskLowerCase) == 0) { 163 // The character does not have a lowercase equivalent, so it must 164 // already be lowercase; so subtract 1 to get the titlecase form. 165 mapChar = ch - 1; 166 } 167 // else { 168 // The character has both an uppercase equivalent and a lowercase 169 // equivalent, so it must itself be a titlecase form; return it. 170 // return ch; 171 //} 172 } 173 else if ((val & $$maskUpperCase) != 0) { 174 // This character has no titlecase equivalent but it does have an 175 // uppercase equivalent, so use that (subtract the signed case offset). 176 mapChar = toUpperCase(ch); 177 } 178 return mapChar; 179 } 180 181 int digit(int ch, int radix) { 182 int value = -1; 183 if (radix >= Character.MIN_RADIX && radix <= Character.MAX_RADIX) { 184 int val = getProperties(ch); 185 int kind = val & $$maskType; 186 if (kind == Character.DECIMAL_DIGIT_NUMBER) { 187 value = ch + ((val & $$maskDigitOffset) >> $$shiftDigitOffset) & $$maskDigit; 188 } 189 else if ((val & $$maskNumericType) == $$valueJavaSupradecimal) { 190 // Java supradecimal digit 191 value = (ch + ((val & $$maskDigitOffset) >> $$shiftDigitOffset) & $$maskDigit) + 10; 192 } 193 } 194 return (value < radix) ? value : -1; 195 } 196 197 int getNumericValue(int ch) { 198 int val = getProperties(ch); 199 int retval = -1; 200 201 switch (val & $$maskNumericType) { 202 default: // cannot occur 203 case ($$valueNotNumeric): // not numeric 204 retval = -1; 205 break; 206 case ($$valueDigit): // simple numeric 207 retval = ch + ((val & $$maskDigitOffset) >> $$shiftDigitOffset) & $$maskDigit; 208 break; 209 case ($$valueStrangeNumeric) : // "strange" numeric 210 retval = -2; 211 break; 212 case ($$valueJavaSupradecimal): // Java supradecimal 213 retval = (ch + ((val & $$maskDigitOffset) >> $$shiftDigitOffset) & $$maskDigit) + 10; 214 break; 215 } 216 return retval; 217 } 218 219 boolean isDigit(int ch) { 220 int props = getProperties(ch); 221 return (props & $$maskType) == Character.DECIMAL_DIGIT_NUMBER; 222 } 223 224 boolean isLowerCase(int ch) { 225 int props = getProperties(ch); 226 return (props & $$maskType) == Character.LOWERCASE_LETTER; 227 } 228 229 boolean isUpperCase(int ch) { 230 int props = getProperties(ch); 231 return (props & $$maskType) == Character.UPPERCASE_LETTER; 232 } 233 234 boolean isWhitespace(int ch) { 235 int props = getProperties(ch); 236 return ((props & $$maskIdentifierInfo) == $$valueJavaWhitespace); 237 } 238 239 byte getDirectionality(int ch) { 240 int val = getProperties(ch); 241 byte directionality = (byte)((val & $$maskBidi) >> $$shiftBidi); 242 if (directionality == 0xF ) { 243 directionality = Character.DIRECTIONALITY_UNDEFINED; 244 } 245 return directionality; 246 } 247 248 boolean isMirrored(int ch) { 249 int props = getProperties(ch); 250 return ((props & $$maskMirrored) != 0); 251 } 252 253 static final CharacterData instance = new CharacterData0E(); 254 private CharacterData0E() {}; 255 256 $$Tables 257 258 static { 259 $$Initializers 260 } 261 }