1 /*
   2  * Copyright (c) 2003, 2006, 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 CharacterData02 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 getType(int ch) {
  75         int props = getProperties(ch);
  76         return (props & $$maskType);
  77     }
  78 
  79     boolean isJavaIdentifierStart(int ch) {
  80         int props = getProperties(ch);
  81         return ((props & $$maskIdentifierInfo) >= $$lowJavaStart);
  82     }
  83 
  84     boolean isJavaIdentifierPart(int ch) {
  85         int props = getProperties(ch);
  86         return ((props & $$nonzeroJavaPart) != 0);
  87     }
  88 
  89     boolean isUnicodeIdentifierStart(int ch) {
  90         int props = getProperties(ch);
  91         return ((props & $$maskIdentifierInfo) == $$valueUnicodeStart);
  92     }
  93 
  94     boolean isUnicodeIdentifierPart(int ch) {
  95         int props = getProperties(ch);
  96         return ((props & $$maskUnicodePart) != 0);
  97     }
  98 
  99     boolean isIdentifierIgnorable(int ch) {
 100         int props = getProperties(ch);
 101         return ((props & $$maskIdentifierInfo) == $$valueIgnorable);
 102     }
 103 
 104     int toLowerCase(int ch) {
 105         int mapChar = ch;
 106         int val = getProperties(ch);
 107 
 108         if ((val & $$maskLowerCase) != 0) {
 109             int offset = val << $$shiftCaseOffsetSign >> ($$shiftCaseOffsetSign+$$shiftCaseOffset);
 110             mapChar = ch + offset;
 111         }
 112         return mapChar;
 113     }
 114 
 115     int toUpperCase(int ch) {
 116         int mapChar = ch;
 117         int val = getProperties(ch);
 118 
 119         if ((val & $$maskUpperCase) != 0) {
 120             int offset = val  << $$shiftCaseOffsetSign >> ($$shiftCaseOffsetSign+$$shiftCaseOffset);
 121             mapChar =  ch - offset;
 122         }
 123         return mapChar;
 124     }
 125 
 126     int toTitleCase(int ch) {
 127         int mapChar = ch;
 128         int val = getProperties(ch);
 129 
 130         if ((val & $$maskTitleCase) != 0) {
 131             // There is a titlecase equivalent.  Perform further checks:
 132             if ((val & $$maskUpperCase) == 0) {
 133                 // The character does not have an uppercase equivalent, so it must
 134                 // already be uppercase; so add 1 to get the titlecase form.
 135                 mapChar = ch + 1;
 136             }
 137             else if ((val & $$maskLowerCase) == 0) {
 138                 // The character does not have a lowercase equivalent, so it must
 139                 // already be lowercase; so subtract 1 to get the titlecase form.
 140                 mapChar = ch - 1;
 141             }
 142             // else {
 143             // The character has both an uppercase equivalent and a lowercase
 144             // equivalent, so it must itself be a titlecase form; return it.
 145             // return ch;
 146             //}
 147         }
 148         else if ((val & $$maskUpperCase) != 0) {
 149             // This character has no titlecase equivalent but it does have an
 150             // uppercase equivalent, so use that (subtract the signed case offset).
 151             mapChar = toUpperCase(ch);
 152         }
 153         return mapChar;
 154     }
 155 
 156     int digit(int ch, int radix) {
 157         int value = -1;
 158         if (radix >= Character.MIN_RADIX && radix <= Character.MAX_RADIX) {
 159             int val = getProperties(ch);
 160             int kind = val & $$maskType;
 161             if (kind == Character.DECIMAL_DIGIT_NUMBER) {
 162                 value = ch + ((val & $$maskDigitOffset) >> $$shiftDigitOffset) & $$maskDigit;
 163             }
 164             else if ((val & $$maskNumericType) == $$valueJavaSupradecimal) {
 165                 // Java supradecimal digit
 166                 value = (ch + ((val & $$maskDigitOffset) >> $$shiftDigitOffset) & $$maskDigit) + 10;
 167             }
 168         }
 169         return (value < radix) ? value : -1;
 170     }
 171 
 172     int getNumericValue(int ch) {
 173         int val = getProperties(ch);
 174         int retval = -1;
 175 
 176         switch (val & $$maskNumericType) {
 177         default: // cannot occur
 178         case ($$valueNotNumeric):         // not numeric
 179             retval = -1;
 180             break;
 181         case ($$valueDigit):              // simple numeric
 182             retval = ch + ((val & $$maskDigitOffset) >> $$shiftDigitOffset) & $$maskDigit;
 183             break;
 184         case ($$valueStrangeNumeric)      :       // "strange" numeric
 185             retval = -2;
 186             break;
 187         case ($$valueJavaSupradecimal):           // Java supradecimal
 188             retval = (ch + ((val & $$maskDigitOffset) >> $$shiftDigitOffset) & $$maskDigit) + 10;
 189             break;
 190         }
 191         return retval;
 192     }
 193 
 194     boolean isWhitespace(int ch) {
 195         return (getProperties(ch) & $$maskIdentifierInfo) == $$valueJavaWhitespace;
 196     }
 197 
 198     byte getDirectionality(int ch) {
 199         int val = getProperties(ch);
 200         byte directionality = (byte)((val & $$maskBidi) >> $$shiftBidi);
 201         if (directionality == 0xF ) {
 202                 directionality = Character.DIRECTIONALITY_UNDEFINED;
 203         }
 204         return directionality;
 205     }
 206 
 207     boolean isMirrored(int ch) {
 208         return (getProperties(ch) & $$maskMirrored) != 0;
 209     }
 210 
 211     static final CharacterData instance = new CharacterData02();
 212     private CharacterData02() {};
 213 
 214     $$Tables
 215 
 216     static {
 217         $$Initializers
 218     }        
 219 }