1 /* 2 * Copyright (c) 2003, 2019, 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 ch == 0x2E2F; 118 } 119 120 boolean isUnicodeIdentifierPart(int ch) { 121 return (getPropertiesEx(ch) & $$maskIDContinue) != 0 || 122 isIdentifierIgnorable(ch) || 123 ch == 0x2E2F; 124 } 125 126 boolean isIdentifierIgnorable(int ch) { 127 int props = getProperties(ch); 128 return ((props & $$maskIdentifierInfo) == $$valueIgnorable); 129 } 130 131 int toLowerCase(int ch) { 132 int mapChar = ch; 133 int val = getProperties(ch); 134 135 if ((val & $$maskLowerCase) != 0) { 136 int offset = val << $$shiftCaseOffsetSign >> ($$shiftCaseOffsetSign+$$shiftCaseOffset); 137 mapChar = ch + offset; 138 } 139 return mapChar; 140 } 141 142 int toUpperCase(int ch) { 143 int mapChar = ch; 144 int val = getProperties(ch); 145 146 if ((val & $$maskUpperCase) != 0) { 147 int offset = val << $$shiftCaseOffsetSign >> ($$shiftCaseOffsetSign+$$shiftCaseOffset); 148 mapChar = ch - offset; 149 } 150 return mapChar; 151 } 152 153 int toTitleCase(int ch) { 154 int mapChar = ch; 155 int val = getProperties(ch); 156 157 if ((val & $$maskTitleCase) != 0) { 158 // There is a titlecase equivalent. Perform further checks: 159 if ((val & $$maskUpperCase) == 0) { 160 // The character does not have an uppercase equivalent, so it must 161 // already be uppercase; so add 1 to get the titlecase form. 162 mapChar = ch + 1; 163 } 164 else if ((val & $$maskLowerCase) == 0) { 165 // The character does not have a lowercase equivalent, so it must 166 // already be lowercase; so subtract 1 to get the titlecase form. 167 mapChar = ch - 1; 168 } 169 // else { 170 // The character has both an uppercase equivalent and a lowercase 171 // equivalent, so it must itself be a titlecase form; return it. 172 // return ch; 173 //} 174 } 175 else if ((val & $$maskUpperCase) != 0) { 176 // This character has no titlecase equivalent but it does have an 177 // uppercase equivalent, so use that (subtract the signed case offset). 178 mapChar = toUpperCase(ch); 179 } 180 return mapChar; 181 } 182 183 int digit(int ch, int radix) { 184 int value = -1; 185 if (radix >= Character.MIN_RADIX && radix <= Character.MAX_RADIX) { 186 int val = getProperties(ch); 187 int kind = val & $$maskType; 188 if (kind == Character.DECIMAL_DIGIT_NUMBER) { 189 value = ch + ((val & $$maskDigitOffset) >> $$shiftDigitOffset) & $$maskDigit; 190 } 191 else if ((val & $$maskNumericType) == $$valueJavaSupradecimal) { 192 // Java supradecimal digit 193 value = (ch + ((val & $$maskDigitOffset) >> $$shiftDigitOffset) & $$maskDigit) + 10; 194 } 195 } 196 return (value < radix) ? value : -1; 197 } 198 199 int getNumericValue(int ch) { 200 int val = getProperties(ch); 201 int retval = -1; 202 203 switch (val & $$maskNumericType) { 204 default: // cannot occur 205 case ($$valueNotNumeric): // not numeric 206 retval = -1; 207 break; 208 case ($$valueDigit): // simple numeric 209 retval = ch + ((val & $$maskDigitOffset) >> $$shiftDigitOffset) & $$maskDigit; 210 break; 211 case ($$valueStrangeNumeric) : // "strange" numeric 212 retval = -2; 213 break; 214 case ($$valueJavaSupradecimal): // Java supradecimal 215 retval = (ch + ((val & $$maskDigitOffset) >> $$shiftDigitOffset) & $$maskDigit) + 10; 216 break; 217 } 218 return retval; 219 } 220 221 boolean isDigit(int ch) { 222 int props = getProperties(ch); 223 return (props & $$maskType) == Character.DECIMAL_DIGIT_NUMBER; 224 } 225 226 boolean isLowerCase(int ch) { 227 int props = getProperties(ch); 228 return (props & $$maskType) == Character.LOWERCASE_LETTER; 229 } 230 231 boolean isUpperCase(int ch) { 232 int props = getProperties(ch); 233 return (props & $$maskType) == Character.UPPERCASE_LETTER; 234 } 235 236 boolean isWhitespace(int ch) { 237 int props = getProperties(ch); 238 return ((props & $$maskIdentifierInfo) == $$valueJavaWhitespace); 239 } 240 241 byte getDirectionality(int ch) { 242 int val = getProperties(ch); 243 byte directionality = (byte)((val & $$maskBidi) >> $$shiftBidi); 244 if (directionality == 0xF ) { 245 directionality = Character.DIRECTIONALITY_UNDEFINED; 246 } 247 return directionality; 248 } 249 250 boolean isMirrored(int ch) { 251 int props = getProperties(ch); 252 return ((props & $$maskMirrored) != 0); 253 } 254 255 static final CharacterData instance = new CharacterData0E(); 256 private CharacterData0E() {}; 257 258 $$Tables 259 260 static { 261 $$Initializers 262 } 263 }