unicode-muncher.pl: Removed this file.

2006-03-28  Anthony Balkissoon  <abalkiss@redhat.com>

	* scripts/unicode-muncher.pl: Removed this file.
	* scripts/MakeCharTables.java: Likewise.
	* scripts/unicode-to-chartables.pl: New file.
	* java/lang/natCharacter.cc: 
	(UNASSIGNED_TYPE): New field.
	(UNASSIGNED_DIGIT): Likewise.
	(UNASSIGNED_DIRECTION): Likewise.
	(UNASSIGNED_NUMERIC_VALUE): Likewise.
	(PRIVATE_TYPE): Likewise.
	(PRIVATE_DIRECTION): Likewise.
	(readCodePoint): New method.
	(getType(jint)): Likewise.
	(toLowerCase(jint)): Likewise.
	(toUpperCase(jint)): Likewise.
	(toTitleCase(jint)): Likewise.
	(digit(jint, jint)): Likewise.
	(getNumericValue(jint)): Likewise.
	(getDirectionality(jint)): Likewise.
	(readChar),
	(getType(jchar)),
	(toLowerCase(jchar)),
	(toUpperCase(jchar)),
	(toTitleCase(jchar)),
	(digit(jchar, jint)),
	(getNumericValue(jchar)),
	(getDirectionality(jchar)): Changed references from data to data[0], 
	blocks to blocks[0], direction to direction[0], numValue to 
	numValue[0], upper to upper[0], lower to lower[0], and shift to 
	shift[0] to reflect the new structures in java-chartables.h.	
	* java/lang/Character.java:
	(readCodePoint): Declared new native method.
	(getType(int)): Likewise.
	(toLowerCase(int)): Likewise.
	(toUpperCase(int)): Likewise.
	(toTitleCase(int)): Likewise.
	(digit(int, int)): Likewise.
	(getNumericValue(int)): Likewise.
	(getDirectionality(int)): Likewise.
	(isLowerCase(int)): New method.
	(isUpperCase(int)): Likewise.
	(itTitleCase(int)): Likewise.
	(isDigit(int)): Likewise.
	(isDefined(int)): Likewise.
	(isLetter(int)): Likewise.
	(isLetterOrDigit(int)): Likewise.
	(isJavaIdentifierStart(int)): Likewise.
	(isJavaIdentifierPart(int)): Likewise.
	(isUnicodeIdentifierStart(int)): Likewise.
	(isUnicodeIdentifierPart(int)): Likewise.
	(isIdentifierIgnorable(int)): Likewise.
	(isSpaceChar(int)): Likewise.
	(isWhitespace(int)): Likewise.
	(isISOControl(int)): Likewise.
	(isMirrored(int)): Likewise.
	* include/java-chartables.h: Generated from 
	scripts/unicode-to-chartables.h.

From-SVN: r112454

1 files changed, 131 insertions, 7 deletions

diff --git a/libjava/java/lang/natCharacter.cc b/libjava/java/lang/natCharacter.cc
index e9362fe..8d246dd 100644
--- a/libjava/java/lang/natCharacter.cc
+++ b/libjava/java/lang/natCharacter.cc
@@ -45,30 +45,91 @@ exception statement from your version. */
 
 
 
+// These constants define the return values for characters that are unassigned
+// or reserved for private use.
+#define UNASSIGNED_TYPE 0
+#define UNASSIGNED_DIGIT -1
+#define UNASSIGNED_DIRECTION -1
+#define UNASSIGNED_NUMERIC_VALUE -1
+
+#define PRIVATE_TYPE 18
+#define PRIVATE_DIRECTION 0
+
+// The methods that take a char as an argument all have counterparts that 
+// take ints.  The ones that take chars only work for the BMP or plane 0 of the
+// Unicode standard but the ones that take ints work for all Unicode code
+// points.  However, the ones that take chars don't simply redirect the calls
+// because the BMP is by far the most used plane so saving a little time on
+// each call makes sense.
+
 jchar
 java::lang::Character::readChar(jchar ch)
 {
   // Perform 16-bit addition to find the correct entry in data.
-  return data[(jchar) (blocks[ch >> SHIFT] + ch)];
+  return data[0][(jchar) (blocks[0][ch >> shift[0]] + ch)];
+}
+
+jchar
+java::lang::Character::readCodePoint(jint codePoint)
+{
+  jint plane = codePoint >> 16;
+  jchar offset = (jchar)(codePoint & 0xffff);
+  // Be careful not to call this method with an unassigned character.  The only
+  // characters assigned as of Unicode 4.0.0 belong to planes 0, 1, 2, and 14.
+  return data[plane][(jchar) (blocks[plane][offset >> shift[plane]] + offset)];
 }
 
 jint
 java::lang::Character::getType(jchar ch)
 {
   // Perform 16-bit addition to find the correct entry in data.
-  return (jint) (data[(jchar) (blocks[ch >> SHIFT] + ch)] & TYPE_MASK);
+  return (jint) (data[0][(jchar) (blocks[0][ch >> shift[0]] + ch)] & TYPE_MASK);
+}
+
+jint
+java::lang::Character::getType(jint codePoint)
+{
+  jint plane = codePoint >> 16;
+  if (plane > 2 && plane != 14)
+    {
+      if (plane > 14 && ((codePoint & 0xffff) < 0xfffe))
+        return (jint) PRIVATE_TYPE;
+      return (jint) UNASSIGNED_TYPE;
+    }
+  jint offset = codePoint & 0xffff;
+  return (jint) 
+    (data[plane]
+     [(jchar) (blocks[plane][offset >> shift[plane]] + offset)] & TYPE_MASK);
 }
 
 jchar
 java::lang::Character::toLowerCase(jchar ch)
 {
-  return (jchar) (ch + lower[readChar(ch) >> 7]);
+  return (jchar) (ch + lower[0][readChar(ch) >> 7]);
+}
+
+jint
+java::lang::Character::toLowerCase(jint codePoint)
+{
+  jint plane = codePoint >> 16;
+  if (plane > 2 && plane != 14)
+    return codePoint;
+  return (lower[plane][readCodePoint(codePoint) >> 7]) + codePoint;
 }
 
 jchar
 java::lang::Character::toUpperCase(jchar ch)
 {
-  return (jchar) (ch + upper[readChar(ch) >> 7]);
+  return (jchar) (ch + upper[0][readChar(ch) >> 7]);
+}
+
+jint
+java::lang::Character::toUpperCase(jint codePoint)
+{
+  jint plane = codePoint >> 16;
+  if (plane > 2 && plane != 14)
+    return codePoint;
+  return (upper[plane][readCodePoint(codePoint) >> 7]) + codePoint;
 }
 
 jchar
@@ -82,6 +143,16 @@ java::lang::Character::toTitleCase(jchar ch)
 }
 
 jint
+java::lang::Character::toTitleCase(jint codePoint)
+{
+  // As of Unicode 4.0.0 no characters outside of plane 0 have titlecase
+  // mappings that are different from their uppercase mapping.
+  if (codePoint < 0x10000)
+    return toTitleCase((jchar)codePoint);
+  return toUpperCase(codePoint);
+}
+
+jint
 java::lang::Character::digit(jchar ch, jint radix)
 {
   if (radix < MIN_RADIX || radix > MAX_RADIX)
@@ -93,21 +164,74 @@ java::lang::Character::digit(jchar ch, jint radix)
           | (1 << DECIMAL_DIGIT_NUMBER))))
     {
       // Signedness doesn't matter; 0xffff vs. -1 are both rejected.
-      jint digit = (jint) numValue[attr >> 7];
+      jint digit = (jint) numValue[0][attr >> 7];
       return (digit >= 0 && digit < radix) ? digit : (jint) -1;
     }
   return (jint) -1;
 }
 
 jint
+java::lang::Character::digit(jint codePoint, jint radix)
+{
+  if (radix < MIN_RADIX || radix > MAX_RADIX)
+    return (jint) -1;
+
+  jint plane = codePoint >> 16;
+  if (plane > 2 && plane != 14)
+    return UNASSIGNED_DIGIT;
+
+  jchar attr = readCodePoint(codePoint);
+  if (((1 << (attr & TYPE_MASK))
+       & ((1 << UPPERCASE_LETTER)
+          | (1 << LOWERCASE_LETTER)
+          | (1 << DECIMAL_DIGIT_NUMBER))))
+    {
+      // Signedness doesn't matter; 0xffff vs. -1 are both rejected.
+      jint digit = (jint) numValue[plane][attr >> 7];
+      if (digit <= -3)
+        digit = largenums[-digit -3];
+      return (digit >= 0 && digit < radix) ? digit : (jint) -1;
+    }
+  return (jint) -1;
+
+}
+
+jint
 java::lang::Character::getNumericValue(jchar ch)
 {
   // numValue is stored as an array of jshort, since 10000 is the maximum.
-  return (jint) numValue[readChar(ch) >> 7];
+  return (jint) numValue[0][readChar(ch) >> 7];
+}
+
+jint
+java::lang::Character::getNumericValue(jint codePoint)
+{
+  jint plane = codePoint >> 16;
+  if (plane > 2 && plane != 14)
+    return UNASSIGNED_NUMERIC_VALUE;
+  jshort num = numValue[plane][readCodePoint(codePoint) >> 7];
+  if (num <= -3)
+    return largenums[-num - 3];
+  return num;
 }
 
 jbyte
 java::lang::Character::getDirectionality(jchar ch)
 {
-  return direction[readChar(ch) >> 7];
+  return direction[0][readChar(ch) >> 7];
 }
+
+jbyte
+java::lang::Character::getDirectionality(jint codePoint)
+{
+  jint plane = codePoint >> 16;
+  if (plane > 2 && plane != 14)
+    {
+      if (plane > 14 && ((codePoint & 0xffff) < 0xfffe))
+        return (jint) PRIVATE_DIRECTION;
+      return (jint) UNASSIGNED_DIRECTION;
+    }
+  return direction[plane][readCodePoint(codePoint) >> 7];
+}
+
+