Remove more of our C-style casts, fix more of our native method names.

Change-Id: I08d7915e22faf091489171240d2f9bf8b3acecca

11 files changed, 385 insertions, 638 deletions

diff --git a/luni/src/main/java/com/ibm/icu4jni/text/NativeDecimalFormat.java b/luni/src/main/java/com/ibm/icu4jni/text/NativeDecimalFormat.java
index 111275a..e5b0656 100644
--- a/luni/src/main/java/com/ibm/icu4jni/text/NativeDecimalFormat.java
+++ b/luni/src/main/java/com/ibm/icu4jni/text/NativeDecimalFormat.java
@@ -120,7 +120,7 @@ public final class NativeDecimalFormat {
 
     public NativeDecimalFormat(String pattern, DecimalFormatSymbols dfs) {
         try {
-            this.addr = openDecimalFormatImpl(pattern, dfs.getCurrencySymbol(),
+            this.addr = open(pattern, dfs.getCurrencySymbol(),
                     dfs.getDecimalSeparator(), dfs.getDigit(), dfs.getGroupingSeparator(),
                     dfs.getInfinity(), dfs.getInternationalCurrencySymbol(), dfs.getMinusSign(),
                     dfs.getMonetaryDecimalSeparator(), dfs.getNaN(), dfs.getPatternSeparator(),
@@ -135,7 +135,7 @@ public final class NativeDecimalFormat {
 
     // Used to implement clone.
     private NativeDecimalFormat(NativeDecimalFormat other) {
-        this.addr = cloneDecimalFormatImpl(other.addr);
+        this.addr = cloneImpl(other.addr);
         this.lastPattern = other.lastPattern;
         this.negPrefNull = other.negPrefNull;
         this.negSuffNull = other.negSuffNull;
@@ -156,7 +156,7 @@ public final class NativeDecimalFormat {
 
     @Override
     protected void finalize() {
-        closeDecimalFormatImpl(this.addr);
+        close(this.addr);
     }
 
     /**
@@ -606,14 +606,14 @@ public final class NativeDecimalFormat {
     }
 
     private static native void applyPatternImpl(int addr, boolean localized, String pattern);
-    private static native int cloneDecimalFormatImpl(int addr);
-    private static native void closeDecimalFormatImpl(int addr);
+    private static native int cloneImpl(int addr);
+    private static native void close(int addr);
     private static native String format(int addr, long value, FieldPositionIterator iter);
     private static native String format(int addr, double value, FieldPositionIterator iter);
     private static native String format(int addr, String value, FieldPositionIterator iter);
     private static native int getAttribute(int addr, int symbol);
     private static native String getTextAttribute(int addr, int symbol);
-    private static native int openDecimalFormatImpl(String pattern, String currencySymbol,
+    private static native int open(String pattern, String currencySymbol,
             char decimalSeparator, char digit, char groupingSeparator, String infinity,
             String internationalCurrencySymbol, char minusSign, char monetaryDecimalSeparator,
             String nan, char patternSeparator, char percent, char perMill, char zeroDigit);
diff --git a/luni/src/main/native/NativeBreakIterator.cpp b/luni/src/main/native/NativeBreakIterator.cpp
index 89ccbc6..cd4407f 100644
--- a/luni/src/main/native/NativeBreakIterator.cpp
+++ b/luni/src/main/native/NativeBreakIterator.cpp
@@ -35,19 +35,19 @@ static jint getIterator(JNIEnv* env, jstring locale, UBreakIteratorType type) {
     return reinterpret_cast<uintptr_t>(it);
 }
 
-static jint getCharacterInstanceImpl(JNIEnv* env, jclass, jstring locale) {
+static jint NativeBreakIterator_getCharacterInstanceImpl(JNIEnv* env, jclass, jstring locale) {
     return getIterator(env, locale, UBRK_CHARACTER);
 }
 
-static jint getLineInstanceImpl(JNIEnv* env, jclass, jstring locale) {
+static jint NativeBreakIterator_getLineInstanceImpl(JNIEnv* env, jclass, jstring locale) {
     return getIterator(env, locale, UBRK_LINE);
 }
 
-static jint getSentenceInstanceImpl(JNIEnv* env, jclass, jstring locale) {
+static jint NativeBreakIterator_getSentenceInstanceImpl(JNIEnv* env, jclass, jstring locale) {
     return getIterator(env, locale, UBRK_SENTENCE);
 }
 
-static jint getWordInstanceImpl(JNIEnv* env, jclass, jstring locale) {
+static jint NativeBreakIterator_getWordInstanceImpl(JNIEnv* env, jclass, jstring locale) {
     return getIterator(env, locale, UBRK_WORD);
 }
 
@@ -55,11 +55,11 @@ static UBreakIterator* breakIterator(jint address) {
     return reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(address));
 }
 
-static void closeBreakIteratorImpl(JNIEnv*, jclass, jint address) {
+static void NativeBreakIterator_closeBreakIteratorImpl(JNIEnv*, jclass, jint address) {
     ubrk_close(breakIterator(address));
 }
 
-static jint cloneImpl(JNIEnv* env, jclass, jint address) {
+static jint NativeBreakIterator_cloneImpl(JNIEnv* env, jclass, jint address) {
     UErrorCode status = U_ZERO_ERROR;
     jint bufferSize = U_BRK_SAFECLONE_BUFFERSIZE;
     UBreakIterator* it = ubrk_safeClone(breakIterator(address), NULL, &bufferSize, &status);
@@ -67,7 +67,7 @@ static jint cloneImpl(JNIEnv* env, jclass, jint address) {
     return reinterpret_cast<uintptr_t>(it);
 }
 
-static void setTextImpl(JNIEnv* env, jclass, jint address, jstring javaText) {
+static void NativeBreakIterator_setTextImpl(JNIEnv* env, jclass, jint address, jstring javaText) {
     ScopedJavaUnicodeString text(env, javaText);
     UnicodeString& s(text.unicodeString());
     UErrorCode status = U_ZERO_ERROR;
@@ -75,11 +75,11 @@ static void setTextImpl(JNIEnv* env, jclass, jint address, jstring javaText) {
     icu4jni_error(env, status);
 }
 
-static jboolean isBoundaryImpl(JNIEnv*, jclass, jint address, jint offset) {
+static jboolean NativeBreakIterator_isBoundaryImpl(JNIEnv*, jclass, jint address, jint offset) {
     return ubrk_isBoundary(breakIterator(address), offset);
 }
 
-static jint nextImpl(JNIEnv*, jclass, jint address, jint n) {
+static jint NativeBreakIterator_nextImpl(JNIEnv*, jclass, jint address, jint n) {
     UBreakIterator* bi = breakIterator(address);
     if (n < 0) {
         while (n++ < -1) {
@@ -97,46 +97,46 @@ static jint nextImpl(JNIEnv*, jclass, jint address, jint n) {
     return -1;
 }
 
-static jint precedingImpl(JNIEnv*, jclass, jint address, jint offset) {
+static jint NativeBreakIterator_precedingImpl(JNIEnv*, jclass, jint address, jint offset) {
     return ubrk_preceding(breakIterator(address), offset);
 }
 
-static jint firstImpl(JNIEnv*, jclass, jint address) {
+static jint NativeBreakIterator_firstImpl(JNIEnv*, jclass, jint address) {
     return ubrk_first(breakIterator(address));
 }
 
-static jint followingImpl(JNIEnv*, jclass, jint address, jint offset) {
+static jint NativeBreakIterator_followingImpl(JNIEnv*, jclass, jint address, jint offset) {
     return ubrk_following(breakIterator(address), offset);
 }
 
-static jint currentImpl(JNIEnv*, jclass, jint address) {
+static jint NativeBreakIterator_currentImpl(JNIEnv*, jclass, jint address) {
     return ubrk_current(breakIterator(address));
 }
 
-static jint previousImpl(JNIEnv*, jclass, jint address) {
+static jint NativeBreakIterator_previousImpl(JNIEnv*, jclass, jint address) {
     return ubrk_previous(breakIterator(address));
 }
 
-static jint lastImpl(JNIEnv*, jclass, jint address) {
+static jint NativeBreakIterator_lastImpl(JNIEnv*, jclass, jint address) {
     return ubrk_last(breakIterator(address));
 }
 
 static JNINativeMethod gMethods[] = {
-    { "cloneImpl", "(I)I", (void*) cloneImpl },
-    { "closeBreakIteratorImpl", "(I)V", (void*) closeBreakIteratorImpl },
-    { "currentImpl", "(I)I", (void*) currentImpl },
-    { "firstImpl", "(I)I", (void*) firstImpl },
-    { "followingImpl", "(II)I", (void*) followingImpl },
-    { "getCharacterInstanceImpl", "(Ljava/lang/String;)I", (void*) getCharacterInstanceImpl },
-    { "getLineInstanceImpl", "(Ljava/lang/String;)I", (void*) getLineInstanceImpl },
-    { "getSentenceInstanceImpl", "(Ljava/lang/String;)I", (void*) getSentenceInstanceImpl },
-    { "getWordInstanceImpl", "(Ljava/lang/String;)I", (void*) getWordInstanceImpl },
-    { "isBoundaryImpl", "(II)Z", (void*) isBoundaryImpl },
-    { "lastImpl", "(I)I", (void*) lastImpl },
-    { "nextImpl", "(II)I", (void*) nextImpl },
-    { "precedingImpl", "(II)I", (void*) precedingImpl },
-    { "previousImpl", "(I)I", (void*) previousImpl },
-    { "setTextImpl", "(ILjava/lang/String;)V", (void*) setTextImpl },
+    { "cloneImpl", "(I)I", (void*) NativeBreakIterator_cloneImpl },
+    { "closeBreakIteratorImpl", "(I)V", (void*) NativeBreakIterator_closeBreakIteratorImpl },
+    { "currentImpl", "(I)I", (void*) NativeBreakIterator_currentImpl },
+    { "firstImpl", "(I)I", (void*) NativeBreakIterator_firstImpl },
+    { "followingImpl", "(II)I", (void*) NativeBreakIterator_followingImpl },
+    { "getCharacterInstanceImpl", "(Ljava/lang/String;)I", (void*) NativeBreakIterator_getCharacterInstanceImpl },
+    { "getLineInstanceImpl", "(Ljava/lang/String;)I", (void*) NativeBreakIterator_getLineInstanceImpl },
+    { "getSentenceInstanceImpl", "(Ljava/lang/String;)I", (void*) NativeBreakIterator_getSentenceInstanceImpl },
+    { "getWordInstanceImpl", "(Ljava/lang/String;)I", (void*) NativeBreakIterator_getWordInstanceImpl },
+    { "isBoundaryImpl", "(II)Z", (void*) NativeBreakIterator_isBoundaryImpl },
+    { "lastImpl", "(I)I", (void*) NativeBreakIterator_lastImpl },
+    { "nextImpl", "(II)I", (void*) NativeBreakIterator_nextImpl },
+    { "precedingImpl", "(II)I", (void*) NativeBreakIterator_precedingImpl },
+    { "previousImpl", "(I)I", (void*) NativeBreakIterator_previousImpl },
+    { "setTextImpl", "(ILjava/lang/String;)V", (void*) NativeBreakIterator_setTextImpl },
 };
 int register_com_ibm_icu4jni_text_NativeBreakIterator(JNIEnv* env) {
     return jniRegisterNativeMethods(env, "com/ibm/icu4jni/text/NativeBreakIterator",
diff --git a/luni/src/main/native/NativeCollation.cpp b/luni/src/main/native/NativeCollation.cpp
index ed2a0e5..868a88f 100644
--- a/luni/src/main/native/NativeCollation.cpp
+++ b/luni/src/main/native/NativeCollation.cpp
@@ -26,15 +26,15 @@ static UCollationElements* toCollationElements(jint address) {
     return reinterpret_cast<UCollationElements*>(static_cast<uintptr_t>(address));
 }
 
-static void closeCollator(JNIEnv*, jclass, jint address) {
+static void NativeCollation_closeCollator(JNIEnv*, jclass, jint address) {
     ucol_close(toCollator(address));
 }
 
-static void closeElements(JNIEnv*, jclass, jint address) {
+static void NativeCollation_closeElements(JNIEnv*, jclass, jint address) {
     ucol_closeElements(toCollationElements(address));
 }
 
-static jint compare(JNIEnv* env, jclass, jint address, jstring lhs0, jstring rhs0) {
+static jint NativeCollation_compare(JNIEnv* env, jclass, jint address, jstring lhs0, jstring rhs0) {
     ScopedJavaUnicodeString lhs(env, lhs0);
     ScopedJavaUnicodeString rhs(env, rhs0);
     return ucol_strcoll(toCollator(address),
@@ -42,14 +42,14 @@ static jint compare(JNIEnv* env, jclass, jint address, jstring lhs0, jstring rhs
             rhs.unicodeString().getBuffer(), rhs.unicodeString().length());
 }
 
-static jint getAttribute(JNIEnv* env, jclass, jint address, jint type) {
+static jint NativeCollation_getAttribute(JNIEnv* env, jclass, jint address, jint type) {
     UErrorCode status = U_ZERO_ERROR;
     jint result = ucol_getAttribute(toCollator(address), (UColAttribute) type, &status);
     icu4jni_error(env, status);
     return result;
 }
 
-static jint getCollationElementIterator(JNIEnv* env, jclass, jint address, jstring source0) {
+static jint NativeCollation_getCollationElementIterator(JNIEnv* env, jclass, jint address, jstring source0) {
     ScopedJavaUnicodeString source(env, source0);
     UErrorCode status = U_ZERO_ERROR;
     UCollationElements* result = ucol_openElements(toCollator(address),
@@ -58,34 +58,34 @@ static jint getCollationElementIterator(JNIEnv* env, jclass, jint address, jstri
     return static_cast<jint>(reinterpret_cast<uintptr_t>(result));
 }
 
-static jint getMaxExpansion(JNIEnv*, jclass, jint address, jint order) {
+static jint NativeCollation_getMaxExpansion(JNIEnv*, jclass, jint address, jint order) {
     return ucol_getMaxExpansion(toCollationElements(address), order);
 }
 
-static jint getNormalization(JNIEnv* env, jclass, jint address) {
+static jint NativeCollation_getNormalization(JNIEnv* env, jclass, jint address) {
     UErrorCode status = U_ZERO_ERROR;
     jint result = ucol_getAttribute(toCollator(address), UCOL_NORMALIZATION_MODE, &status);
     icu4jni_error(env, status);
     return result;
 }
 
-static void setNormalization(JNIEnv* env, jclass, jint address, jint mode) {
+static void NativeCollation_setNormalization(JNIEnv* env, jclass, jint address, jint mode) {
     UErrorCode status = U_ZERO_ERROR;
     ucol_setAttribute(toCollator(address), UCOL_NORMALIZATION_MODE, UColAttributeValue(mode), &status);
     icu4jni_error(env, status);
 }
 
-static jint getOffset(JNIEnv*, jclass, jint address) {
+static jint NativeCollation_getOffset(JNIEnv*, jclass, jint address) {
     return ucol_getOffset(toCollationElements(address));
 }
 
-static jstring getRules(JNIEnv* env, jclass, jint address) {
+static jstring NativeCollation_getRules(JNIEnv* env, jclass, jint address) {
     int32_t length = 0;
     const UChar* rules = ucol_getRules(toCollator(address), &length);
     return env->NewString(rules, length);
 }
 
-static jbyteArray getSortKey(JNIEnv* env, jclass, jint address, jstring source0) {
+static jbyteArray NativeCollation_getSortKey(JNIEnv* env, jclass, jint address, jstring source0) {
     ScopedJavaUnicodeString source(env, source0);
     const UCollator* collator  = toCollator(address);
     uint8_t byteArray[UCOL_MAX_BUFFER * 2];
@@ -108,14 +108,14 @@ static jbyteArray getSortKey(JNIEnv* env, jclass, jint address, jstring source0)
     return result;
 }
 
-static jint next(JNIEnv* env, jclass, jint address) {
+static jint NativeCollation_next(JNIEnv* env, jclass, jint address) {
     UErrorCode status = U_ZERO_ERROR;
     jint result = ucol_next(toCollationElements(address), &status);
     icu4jni_error(env, status);
     return result;
 }
 
-static jint openCollator(JNIEnv* env, jclass, jstring localeName) {
+static jint NativeCollation_openCollator(JNIEnv* env, jclass, jstring localeName) {
     ScopedUtfChars localeChars(env, localeName);
     if (localeChars.c_str() == NULL) {
         return 0;
@@ -126,7 +126,7 @@ static jint openCollator(JNIEnv* env, jclass, jstring localeName) {
     return static_cast<jint>(reinterpret_cast<uintptr_t>(c));
 }
 
-static jint openCollatorFromRules(JNIEnv* env, jclass, jstring rules0, jint mode, jint strength) {
+static jint NativeCollation_openCollatorFromRules(JNIEnv* env, jclass, jstring rules0, jint mode, jint strength) {
     ScopedJavaUnicodeString rules(env, rules0);
     UErrorCode status = U_ZERO_ERROR;
     UCollator* c = ucol_openRules(rules.unicodeString().getBuffer(), rules.unicodeString().length(),
@@ -135,18 +135,18 @@ static jint openCollatorFromRules(JNIEnv* env, jclass, jstring rules0, jint mode
     return static_cast<jint>(reinterpret_cast<uintptr_t>(c));
 }
 
-static jint previous(JNIEnv* env, jclass, jint address) {
+static jint NativeCollation_previous(JNIEnv* env, jclass, jint address) {
     UErrorCode status = U_ZERO_ERROR;
     jint result = ucol_previous(toCollationElements(address), &status);
     icu4jni_error(env, status);
     return result;
 }
 
-static void reset(JNIEnv*, jclass, jint address) {
+static void NativeCollation_reset(JNIEnv*, jclass, jint address) {
     ucol_reset(toCollationElements(address));
 }
 
-static jint safeClone(JNIEnv* env, jclass, jint address) {
+static jint NativeCollation_safeClone(JNIEnv* env, jclass, jint address) {
     UErrorCode status = U_ZERO_ERROR;
     jint bufferSize = U_COL_SAFECLONE_BUFFERSIZE;
     UCollator* c = ucol_safeClone(toCollator(address), NULL, &bufferSize, &status);
@@ -154,19 +154,19 @@ static jint safeClone(JNIEnv* env, jclass, jint address) {
     return static_cast<jint>(reinterpret_cast<uintptr_t>(c));
 }
 
-static void setAttribute(JNIEnv* env, jclass, jint address, jint type, jint value) {
+static void NativeCollation_setAttribute(JNIEnv* env, jclass, jint address, jint type, jint value) {
     UErrorCode status = U_ZERO_ERROR;
     ucol_setAttribute(toCollator(address), (UColAttribute)type, (UColAttributeValue)value, &status);
     icu4jni_error(env, status);
 }
 
-static void setOffset(JNIEnv* env, jclass, jint address, jint offset) {
+static void NativeCollation_setOffset(JNIEnv* env, jclass, jint address, jint offset) {
     UErrorCode status = U_ZERO_ERROR;
     ucol_setOffset(toCollationElements(address), offset, &status);
     icu4jni_error(env, status);
 }
 
-static void setText(JNIEnv* env, jclass, jint address, jstring source0) {
+static void NativeCollation_setText(JNIEnv* env, jclass, jint address, jstring source0) {
     ScopedJavaUnicodeString source(env, source0);
     UErrorCode status = U_ZERO_ERROR;
     ucol_setText(toCollationElements(address),
@@ -175,26 +175,26 @@ static void setText(JNIEnv* env, jclass, jint address, jstring source0) {
 }
 
 static JNINativeMethod gMethods[] = {
-    { "openCollator", "(Ljava/lang/String;)I", (void*) openCollator },
-    { "openCollatorFromRules", "(Ljava/lang/String;II)I", (void*) openCollatorFromRules },
-    { "closeCollator", "(I)V", (void*) closeCollator },
-    { "compare", "(ILjava/lang/String;Ljava/lang/String;)I", (void*) compare },
-    { "getNormalization", "(I)I", (void*) getNormalization },
-    { "setNormalization", "(II)V", (void*) setNormalization },
-    { "getRules", "(I)Ljava/lang/String;", (void*) getRules },
-    { "getSortKey", "(ILjava/lang/String;)[B", (void*) getSortKey },
-    { "setAttribute", "(III)V", (void*) setAttribute },
-    { "getAttribute", "(II)I", (void*) getAttribute },
-    { "safeClone", "(I)I", (void*) safeClone },
-    { "getCollationElementIterator", "(ILjava/lang/String;)I", (void*) getCollationElementIterator },
-    { "closeElements", "(I)V", (void*) closeElements },
-    { "reset", "(I)V", (void*) reset },
-    { "next", "(I)I", (void*) next },
-    { "previous", "(I)I", (void*) previous },
-    { "getMaxExpansion", "(II)I", (void*) getMaxExpansion },
-    { "setText", "(ILjava/lang/String;)V", (void*) setText },
-    { "getOffset", "(I)I", (void*) getOffset },
-    { "setOffset", "(II)V", (void*) setOffset }
+    { "closeCollator", "(I)V", (void*) NativeCollation_closeCollator },
+    { "closeElements", "(I)V", (void*) NativeCollation_closeElements },
+    { "compare", "(ILjava/lang/String;Ljava/lang/String;)I", (void*) NativeCollation_compare },
+    { "getAttribute", "(II)I", (void*) NativeCollation_getAttribute },
+    { "getCollationElementIterator", "(ILjava/lang/String;)I", (void*) NativeCollation_getCollationElementIterator },
+    { "getMaxExpansion", "(II)I", (void*) NativeCollation_getMaxExpansion },
+    { "getNormalization", "(I)I", (void*) NativeCollation_getNormalization },
+    { "getOffset", "(I)I", (void*) NativeCollation_getOffset },
+    { "getRules", "(I)Ljava/lang/String;", (void*) NativeCollation_getRules },
+    { "getSortKey", "(ILjava/lang/String;)[B", (void*) NativeCollation_getSortKey },
+    { "next", "(I)I", (void*) NativeCollation_next },
+    { "openCollator", "(Ljava/lang/String;)I", (void*) NativeCollation_openCollator },
+    { "openCollatorFromRules", "(Ljava/lang/String;II)I", (void*) NativeCollation_openCollatorFromRules },
+    { "previous", "(I)I", (void*) NativeCollation_previous },
+    { "reset", "(I)V", (void*) NativeCollation_reset },
+    { "safeClone", "(I)I", (void*) NativeCollation_safeClone },
+    { "setAttribute", "(III)V", (void*) NativeCollation_setAttribute },
+    { "setNormalization", "(II)V", (void*) NativeCollation_setNormalization },
+    { "setOffset", "(II)V", (void*) NativeCollation_setOffset },
+    { "setText", "(ILjava/lang/String;)V", (void*) NativeCollation_setText },
 };
 int register_com_ibm_icu4jni_text_NativeCollator(JNIEnv* env) {
     return jniRegisterNativeMethods(env, "com/ibm/icu4jni/text/NativeCollation",
diff --git a/luni/src/main/native/NativeDecimalFormat.cpp b/luni/src/main/native/NativeDecimalFormat.cpp
index b068a45..4a7b821 100644
--- a/luni/src/main/native/NativeDecimalFormat.cpp
+++ b/luni/src/main/native/NativeDecimalFormat.cpp
@@ -72,7 +72,7 @@ static DecimalFormatSymbols* makeDecimalFormatSymbols(JNIEnv* env,
     return result;
 }
 
-static void setDecimalFormatSymbols(JNIEnv* env, jclass, jint addr,
+static void NativeDecimalFormat_setDecimalFormatSymbols(JNIEnv* env, jclass, jint addr,
         jstring currencySymbol, jchar decimalSeparator, jchar digit,
         jchar groupingSeparator, jstring infinity,
         jstring internationalCurrencySymbol, jchar minusSign,
@@ -86,7 +86,7 @@ static void setDecimalFormatSymbols(JNIEnv* env, jclass, jint addr,
     toDecimalFormat(addr)->adoptDecimalFormatSymbols(symbols);
 }
 
-static jint openDecimalFormatImpl(JNIEnv* env, jclass, jstring pattern0,
+static jint NativeDecimalFormat_open(JNIEnv* env, jclass, jstring pattern0,
         jstring currencySymbol, jchar decimalSeparator, jchar digit,
         jchar groupingSeparator, jstring infinity,
         jstring internationalCurrencySymbol, jchar minusSign,
@@ -112,17 +112,17 @@ static jint openDecimalFormatImpl(JNIEnv* env, jclass, jstring pattern0,
     return static_cast<jint>(reinterpret_cast<uintptr_t>(fmt));
 }
 
-static void closeDecimalFormatImpl(JNIEnv*, jclass, jint addr) {
+static void NativeDecimalFormat_close(JNIEnv*, jclass, jint addr) {
     delete toDecimalFormat(addr);
 }
 
-static void setRoundingMode(JNIEnv*, jclass, jint addr, jint mode, jdouble increment) {
+static void NativeDecimalFormat_setRoundingMode(JNIEnv*, jclass, jint addr, jint mode, jdouble increment) {
     DecimalFormat* fmt = toDecimalFormat(addr);
     fmt->setRoundingMode(static_cast<DecimalFormat::ERoundingMode>(mode));
     fmt->setRoundingIncrement(increment);
 }
 
-static void setSymbol(JNIEnv* env, jclass, jint addr, jint javaSymbol, jstring javaValue) {
+static void NativeDecimalFormat_setSymbol(JNIEnv* env, jclass, jint addr, jint javaSymbol, jstring javaValue) {
     ScopedJavaUnicodeString value(env, javaValue);
     UnicodeString& s(value.unicodeString());
     UErrorCode status = U_ZERO_ERROR;
@@ -131,17 +131,17 @@ static void setSymbol(JNIEnv* env, jclass, jint addr, jint javaSymbol, jstring j
     icu4jni_error(env, status);
 }
 
-static void setAttribute(JNIEnv*, jclass, jint addr, jint javaAttr, jint value) {
+static void NativeDecimalFormat_setAttribute(JNIEnv*, jclass, jint addr, jint javaAttr, jint value) {
     UNumberFormatAttribute attr = static_cast<UNumberFormatAttribute>(javaAttr);
     unum_setAttribute(toUNumberFormat(addr), attr, value);
 }
 
-static jint getAttribute(JNIEnv*, jclass, jint addr, jint javaAttr) {
+static jint NativeDecimalFormat_getAttribute(JNIEnv*, jclass, jint addr, jint javaAttr) {
     UNumberFormatAttribute attr = static_cast<UNumberFormatAttribute>(javaAttr);
     return unum_getAttribute(toUNumberFormat(addr), attr);
 }
 
-static void setTextAttribute(JNIEnv* env, jclass, jint addr, jint javaAttr, jstring javaValue) {
+static void NativeDecimalFormat_setTextAttribute(JNIEnv* env, jclass, jint addr, jint javaAttr, jstring javaValue) {
     ScopedJavaUnicodeString value(env, javaValue);
     UnicodeString& s(value.unicodeString());
     UErrorCode status = U_ZERO_ERROR;
@@ -150,7 +150,7 @@ static void setTextAttribute(JNIEnv* env, jclass, jint addr, jint javaAttr, jstr
     icu4jni_error(env, status);
 }
 
-static jstring getTextAttribute(JNIEnv* env, jclass, jint addr, jint javaAttr) {
+static jstring NativeDecimalFormat_getTextAttribute(JNIEnv* env, jclass, jint addr, jint javaAttr) {
     UErrorCode status = U_ZERO_ERROR;
     UNumberFormat* fmt = toUNumberFormat(addr);
     UNumberFormatTextAttribute attr = static_cast<UNumberFormatTextAttribute>(javaAttr);
@@ -169,7 +169,7 @@ static jstring getTextAttribute(JNIEnv* env, jclass, jint addr, jint javaAttr) {
     return icu4jni_error(env, status) ? NULL : env->NewString(chars.get(), charCount);
 }
 
-static void applyPatternImpl(JNIEnv* env, jclass, jint addr, jboolean localized, jstring pattern0) {
+static void NativeDecimalFormat_applyPatternImpl(JNIEnv* env, jclass, jint addr, jboolean localized, jstring pattern0) {
     if (pattern0 == NULL) {
         jniThrowNullPointerException(env, NULL);
         return;
@@ -185,7 +185,7 @@ static void applyPatternImpl(JNIEnv* env, jclass, jint addr, jboolean localized,
     icu4jni_error(env, status);
 }
 
-static jstring toPatternImpl(JNIEnv* env, jclass, jint addr, jboolean localized) {
+static jstring NativeDecimalFormat_toPatternImpl(JNIEnv* env, jclass, jint addr, jboolean localized) {
     DecimalFormat* fmt = toDecimalFormat(addr);
     UnicodeString pattern;
     if (localized) {
@@ -227,17 +227,17 @@ static jstring format(JNIEnv* env, jint addr, jobject fpIter, T val) {
     return formatResult(env, str, pfpi, fpIter);
 }
 
-static jstring formatLong(JNIEnv* env, jclass, jint addr, jlong value, jobject fpIter) {
+static jstring NativeDecimalFormat_formatLong(JNIEnv* env, jclass, jint addr, jlong value, jobject fpIter) {
     int64_t longValue = value;
     return format(env, addr, fpIter, (jlong) longValue);
 }
 
-static jstring formatDouble(JNIEnv* env, jclass, jint addr, jdouble value, jobject fpIter) {
+static jstring NativeDecimalFormat_formatDouble(JNIEnv* env, jclass, jint addr, jdouble value, jobject fpIter) {
     double doubleValue = value;
     return format(env, addr, fpIter, (jdouble) doubleValue);
 }
 
-static jstring formatDigitList(JNIEnv* env, jclass, jint addr, jstring value, jobject fpIter) {
+static jstring NativeDecimalFormat_formatDigitList(JNIEnv* env, jclass, jint addr, jstring value, jobject fpIter) {
     ScopedUtfChars chars(env, value);
     if (chars.c_str() == NULL) {
         return NULL;
@@ -258,8 +258,8 @@ static jobject newBigDecimal(JNIEnv* env, const char* value, jsize len) {
     return env->NewObject(JniConstants::bigDecimalClass, gBigDecimal_init, str);
 }
 
-static jobject parse(JNIEnv* env, jclass, jint addr, jstring text,
-                     jobject position, jboolean parseBigDecimal) {
+static jobject NativeDecimalFormat_parse(JNIEnv* env, jclass, jint addr, jstring text,
+        jobject position, jboolean parseBigDecimal) {
 
     static jmethodID gPP_getIndex = env->GetMethodID(JniConstants::parsePositionClass, "getIndex", "()I");
     static jmethodID gPP_setIndex = env->GetMethodID(JniConstants::parsePositionClass, "setIndex", "(I)V");
@@ -323,32 +323,30 @@ static jobject parse(JNIEnv* env, jclass, jint addr, jstring text,
     }
 }
 
-static jint cloneDecimalFormatImpl(JNIEnv*, jclass, jint addr) {
+static jint NativeDecimalFormat_cloneImpl(JNIEnv*, jclass, jint addr) {
     DecimalFormat* fmt = toDecimalFormat(addr);
     return static_cast<jint>(reinterpret_cast<uintptr_t>(fmt->clone()));
 }
 
 static JNINativeMethod gMethods[] = {
-      {"applyPatternImpl", "(IZLjava/lang/String;)V", (void*) applyPatternImpl},
-      {"cloneDecimalFormatImpl", "(I)I", (void*) cloneDecimalFormatImpl},
-      {"closeDecimalFormatImpl", "(I)V", (void*) closeDecimalFormatImpl},
-      {"format", "(IDLcom/ibm/icu4jni/text/NativeDecimalFormat$FieldPositionIterator;)Ljava/lang/String;", (void*) formatDouble},
-      {"format", "(IJLcom/ibm/icu4jni/text/NativeDecimalFormat$FieldPositionIterator;)Ljava/lang/String;", (void*) formatLong},
-      {"format", "(ILjava/lang/String;Lcom/ibm/icu4jni/text/NativeDecimalFormat$FieldPositionIterator;)Ljava/lang/String;", (void*) formatDigitList},
-      {"getAttribute", "(II)I", (void*) getAttribute},
-      {"getTextAttribute", "(II)Ljava/lang/String;", (void*) getTextAttribute},
-      {"openDecimalFormatImpl", "(Ljava/lang/String;Ljava/lang/String;CCCLjava/lang/String;Ljava/lang/String;CCLjava/lang/String;CCCC)I", (void*) openDecimalFormatImpl},
-      {"parse", "(ILjava/lang/String;Ljava/text/ParsePosition;Z)Ljava/lang/Number;", (void*) parse},
-      {"setAttribute", "(III)V", (void*) setAttribute},
-      {"setDecimalFormatSymbols", "(ILjava/lang/String;CCCLjava/lang/String;Ljava/lang/String;CCLjava/lang/String;CCCC)V", (void*) setDecimalFormatSymbols},
-      {"setSymbol", "(IILjava/lang/String;)V", (void*) setSymbol},
-      {"setRoundingMode", "(IID)V", (void*) setRoundingMode},
-      {"setTextAttribute", "(IILjava/lang/String;)V", (void*) setTextAttribute},
-      {"toPatternImpl", "(IZ)Ljava/lang/String;", (void*) toPatternImpl},
+    {"applyPatternImpl", "(IZLjava/lang/String;)V", (void*) NativeDecimalFormat_applyPatternImpl},
+    {"cloneImpl", "(I)I", (void*) NativeDecimalFormat_cloneImpl},
+    {"close", "(I)V", (void*) NativeDecimalFormat_close},
+    {"format", "(IDLcom/ibm/icu4jni/text/NativeDecimalFormat$FieldPositionIterator;)Ljava/lang/String;", (void*) NativeDecimalFormat_formatDouble},
+    {"format", "(IJLcom/ibm/icu4jni/text/NativeDecimalFormat$FieldPositionIterator;)Ljava/lang/String;", (void*) NativeDecimalFormat_formatLong},
+    {"format", "(ILjava/lang/String;Lcom/ibm/icu4jni/text/NativeDecimalFormat$FieldPositionIterator;)Ljava/lang/String;", (void*) NativeDecimalFormat_formatDigitList},
+    {"getAttribute", "(II)I", (void*) NativeDecimalFormat_getAttribute},
+    {"getTextAttribute", "(II)Ljava/lang/String;", (void*) NativeDecimalFormat_getTextAttribute},
+    {"open", "(Ljava/lang/String;Ljava/lang/String;CCCLjava/lang/String;Ljava/lang/String;CCLjava/lang/String;CCCC)I", (void*) NativeDecimalFormat_open},
+    {"parse", "(ILjava/lang/String;Ljava/text/ParsePosition;Z)Ljava/lang/Number;", (void*) NativeDecimalFormat_parse},
+    {"setAttribute", "(III)V", (void*) NativeDecimalFormat_setAttribute},
+    {"setDecimalFormatSymbols", "(ILjava/lang/String;CCCLjava/lang/String;Ljava/lang/String;CCLjava/lang/String;CCCC)V", (void*) NativeDecimalFormat_setDecimalFormatSymbols},
+    {"setRoundingMode", "(IID)V", (void*) NativeDecimalFormat_setRoundingMode},
+    {"setSymbol", "(IILjava/lang/String;)V", (void*) NativeDecimalFormat_setSymbol},
+    {"setTextAttribute", "(IILjava/lang/String;)V", (void*) NativeDecimalFormat_setTextAttribute},
+    {"toPatternImpl", "(IZ)Ljava/lang/String;", (void*) NativeDecimalFormat_toPatternImpl},
 };
-
 int register_com_ibm_icu4jni_text_NativeDecimalFormat(JNIEnv* env) {
-    return jniRegisterNativeMethods(env,
-            "com/ibm/icu4jni/text/NativeDecimalFormat", gMethods,
+    return jniRegisterNativeMethods(env, "com/ibm/icu4jni/text/NativeDecimalFormat", gMethods,
             NELEM(gMethods));
 }
diff --git a/luni/src/main/native/java_io_Console.cpp b/luni/src/main/native/java_io_Console.cpp
index 3c80c3d..4d8a5ea 100644
--- a/luni/src/main/native/java_io_Console.cpp
+++ b/luni/src/main/native/java_io_Console.cpp
@@ -23,11 +23,11 @@
 #include <termios.h>
 #include <unistd.h>
 
-static jboolean java_io_Console_isatty(JNIEnv*, jclass, jint fd) {
+static jboolean Console_isatty(JNIEnv*, jclass, jint fd) {
     return TEMP_FAILURE_RETRY(isatty(fd));
 }
 
-static jint java_io_Console_setEcho(JNIEnv* env, jclass, jboolean on, jint previousState) {
+static jint Console_setEcho(JNIEnv* env, jclass, jboolean on, jint previousState) {
     termios state;
     if (TEMP_FAILURE_RETRY(tcgetattr(STDIN_FILENO, &state)) == -1) {
         jniThrowIOException(env, errno);
@@ -47,8 +47,8 @@ static jint java_io_Console_setEcho(JNIEnv* env, jclass, jboolean on, jint previ
 }
 
 static JNINativeMethod gMethods[] = {
-    { "isatty", "(I)Z", (void*) java_io_Console_isatty },
-    { "setEchoImpl", "(ZI)I", (void*) java_io_Console_setEcho },
+    { "isatty", "(I)Z", (void*) Console_isatty },
+    { "setEchoImpl", "(ZI)I", (void*) Console_setEcho },
 };
 int register_java_io_Console(JNIEnv* env) {
     return jniRegisterNativeMethods(env, "java/io/Console", gMethods, NELEM(gMethods));
diff --git a/luni/src/main/native/java_lang_Math.cpp b/luni/src/main/native/java_lang_Math.cpp
index c549f31..42be565 100644
--- a/luni/src/main/native/java_lang_Math.cpp
+++ b/luni/src/main/native/java_lang_Math.cpp
@@ -22,194 +22,144 @@
 #include <stdlib.h>
 #include <math.h>
 
-/* native public static double sin(double a); */
-static jdouble jsin(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_sin(JNIEnv*, jclass, jdouble a) {
     return sin(a);
 }
 
-/* native public static double cos(double a); */
-static jdouble jcos(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_cos(JNIEnv*, jclass, jdouble a) {
     return cos(a);
 }
 
-/* native public static double tan(double a); */
-static jdouble jtan(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_tan(JNIEnv*, jclass, jdouble a) {
     return tan(a);
 }
 
-/* native public static double asin(double a); */
-static jdouble jasin(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_asin(JNIEnv*, jclass, jdouble a) {
     return asin(a);
 }
 
-/* native public static double acos(double a); */
-static jdouble jacos(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_acos(JNIEnv*, jclass, jdouble a) {
     return acos(a);
 }
 
-/* native public static double atan(double a); */
-static jdouble jatan(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_atan(JNIEnv*, jclass, jdouble a) {
     return atan(a);
 }
 
-/* native public static double exp(double a); */
-static jdouble jexp(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_exp(JNIEnv*, jclass, jdouble a) {
     return exp(a);
 }
 
-/* native public static double log(double a); */
-static jdouble jlog(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_log(JNIEnv*, jclass, jdouble a) {
     return log(a);
 }
 
-/* native public static double sqrt(double a); */
-static jdouble jsqrt(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_sqrt(JNIEnv*, jclass, jdouble a) {
     return sqrt(a);
 }
 
-/* native public static double IEEEremainder(double a, double b); */
-static jdouble jieee_remainder(JNIEnv*, jclass, jdouble a, jdouble b)
-{
+static jdouble Math_IEEEremainder(JNIEnv*, jclass, jdouble a, jdouble b) {
     return remainder(a, b);
 }
 
-/* native public static double floor(double a); */
-static jdouble jfloor(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_floor(JNIEnv*, jclass, jdouble a) {
     return floor(a);
 }
 
-/* native public static double ceil(double a); */
-static jdouble jceil(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_ceil(JNIEnv*, jclass, jdouble a) {
     return ceil(a);
 }
 
-/* native public static double rint(double a); */
-static jdouble jrint(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_rint(JNIEnv*, jclass, jdouble a) {
     return rint(a);
 }
 
-/* native public static double atan2(double a, double b); */
-static jdouble jatan2(JNIEnv*, jclass, jdouble a, jdouble b)
-{
+static jdouble Math_atan2(JNIEnv*, jclass, jdouble a, jdouble b) {
     return atan2(a, b);
 }
 
-/* native public static double pow(double a, double b); */
-static jdouble jpow(JNIEnv*, jclass, jdouble a, jdouble b)
-{
+static jdouble Math_pow(JNIEnv*, jclass, jdouble a, jdouble b) {
     return pow(a, b);
 }
 
-/* native public static double sinh(double a); */
-static jdouble jsinh(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_sinh(JNIEnv*, jclass, jdouble a) {
     return sinh(a);
 }
 
-/* native public static double tanh(double a); */
-static jdouble jtanh(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_tanh(JNIEnv*, jclass, jdouble a) {
     return tanh(a);
 }
 
-/* native public static double cosh(double a); */
-static jdouble jcosh(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_cosh(JNIEnv*, jclass, jdouble a) {
     return cosh(a);
 }
 
-/* native public static double log10(double a); */
-static jdouble jlog10(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_log10(JNIEnv*, jclass, jdouble a) {
     return log10(a);
 }
 
-/* native public static double cbrt(double a); */
-static jdouble jcbrt(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_cbrt(JNIEnv*, jclass, jdouble a) {
     return cbrt(a);
 }
 
-/* native public static double expm1(double a); */
-static jdouble jexpm1(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_expm1(JNIEnv*, jclass, jdouble a) {
     return expm1(a);
 }
 
-/* native public static double hypot(double a, double b); */
-static jdouble jhypot(JNIEnv*, jclass, jdouble a, jdouble b)
-{
+static jdouble Math_hypot(JNIEnv*, jclass, jdouble a, jdouble b) {
     return hypot(a, b);
 }
 
-/* native public static double log1p(double a); */
-static jdouble jlog1p(JNIEnv*, jclass, jdouble a)
-{
+static jdouble Math_log1p(JNIEnv*, jclass, jdouble a) {
     return log1p(a);
 }
 
-/* native public static double nextafter(double a, double b); */
-static jdouble jnextafter(JNIEnv*, jclass, jdouble a, jdouble b)
-{
+static jdouble Math_nextafter(JNIEnv*, jclass, jdouble a, jdouble b) {
     return nextafter(a, b);
 }
 
-/* native public static float nextafterf(float a, float b); */
-static jfloat jnextafterf(JNIEnv*, jclass, jfloat a, jfloat b)
-{
+static jfloat Math_nextafterf(JNIEnv*, jclass, jfloat a, jfloat b) {
     return nextafterf(a, b);
 }
 
-static jdouble copySign(JNIEnv*, jclass, jdouble a, jdouble b) {
+static jdouble Math_copySign(JNIEnv*, jclass, jdouble a, jdouble b) {
     // Our StrictMath.copySign delegates to Math.copySign, so we need to treat NaN as positive.
     return copysign(a, isnan(b) ? 1.0 : b);
 }
 
-static jfloat copySign_f(JNIEnv*, jclass, jfloat a, jfloat b) {
+static jfloat Math_copySign_f(JNIEnv*, jclass, jfloat a, jfloat b) {
     // Our StrictMath.copySign delegates to Math.copySign, so we need to treat NaN as positive.
     return copysignf(a, isnan(b) ? 1.0 : b);
 }
 
 static JNINativeMethod gMethods[] = {
-    { "IEEEremainder", "(DD)D", (void*)jieee_remainder },
-    { "acos",          "(D)D",  (void*)jacos },
-    { "asin",          "(D)D",  (void*)jasin },
-    { "atan",          "(D)D",  (void*)jatan },
-    { "atan2",         "(DD)D", (void*)jatan2 },
-    { "cbrt",          "(D)D",  (void*)jcbrt },
-    { "ceil",          "(D)D",  (void*)jceil },
-    { "copySign",      "(DD)D", (void*)copySign },
-    { "copySign",      "(FF)F", (void*)copySign_f },
-    { "cos",           "(D)D",  (void*)jcos },
-    { "cosh",          "(D)D",  (void*)jcosh },
-    { "exp",           "(D)D",  (void*)jexp },
-    { "expm1",         "(D)D",  (void*)jexpm1 },
-    { "floor",         "(D)D",  (void*)jfloor },
-    { "hypot",         "(DD)D", (void*)jhypot },
-    { "log",           "(D)D",  (void*)jlog },
-    { "log10",         "(D)D",  (void*)jlog10 },
-    { "log1p",         "(D)D",  (void*)jlog1p },
-    { "nextafter",     "(DD)D", (void*)jnextafter },
-    { "nextafterf",    "(FF)F", (void*)jnextafterf },
-    { "pow",           "(DD)D", (void*)jpow },
-    { "rint",          "(D)D",  (void*)jrint },
-    { "sin",           "(D)D",  (void*)jsin },
-    { "sinh",          "(D)D",  (void*)jsinh },
-    { "sqrt",          "(D)D",  (void*)jsqrt },
-    { "tan",           "(D)D",  (void*)jtan },
-    { "tanh",          "(D)D",  (void*)jtanh },
+    { "IEEEremainder", "(DD)D", (void*) Math_IEEEremainder },
+    { "acos",          "(D)D",  (void*) Math_acos },
+    { "asin",          "(D)D",  (void*) Math_asin },
+    { "atan",          "(D)D",  (void*) Math_atan },
+    { "atan2",         "(DD)D", (void*) Math_atan2 },
+    { "cbrt",          "(D)D",  (void*) Math_cbrt },
+    { "ceil",          "(D)D",  (void*) Math_ceil },
+    { "copySign",      "(DD)D", (void*) Math_copySign },
+    { "copySign",      "(FF)F", (void*) Math_copySign_f },
+    { "cos",           "(D)D",  (void*) Math_cos },
+    { "cosh",          "(D)D",  (void*) Math_cosh },
+    { "exp",           "(D)D",  (void*) Math_exp },
+    { "expm1",         "(D)D",  (void*) Math_expm1 },
+    { "floor",         "(D)D",  (void*) Math_floor },
+    { "hypot",         "(DD)D", (void*) Math_hypot },
+    { "log",           "(D)D",  (void*) Math_log },
+    { "log10",         "(D)D",  (void*) Math_log10 },
+    { "log1p",         "(D)D",  (void*) Math_log1p },
+    { "nextafter",     "(DD)D", (void*) Math_nextafter },
+    { "nextafterf",    "(FF)F", (void*) Math_nextafterf },
+    { "pow",           "(DD)D", (void*) Math_pow },
+    { "rint",          "(D)D",  (void*) Math_rint },
+    { "sin",           "(D)D",  (void*) Math_sin },
+    { "sinh",          "(D)D",  (void*) Math_sinh },
+    { "sqrt",          "(D)D",  (void*) Math_sqrt },
+    { "tan",           "(D)D",  (void*) Math_tan },
+    { "tanh",          "(D)D",  (void*) Math_tanh },
 };
 
 int register_java_lang_Math(JNIEnv* env) {
diff --git a/luni/src/main/native/java_lang_ProcessManager.cpp b/luni/src/main/native/java_lang_ProcessManager.cpp
index fd0f4cf..669dd62 100644
--- a/luni/src/main/native/java_lang_ProcessManager.cpp
+++ b/luni/src/main/native/java_lang_ProcessManager.cpp
@@ -50,7 +50,7 @@ static int androidSystemPropertiesFd = -1;
 #define WAIT_STATUS_STRANGE_ERRNO (-3) // observed an undocumented errno
 
 /** Closes a file descriptor. */
-static void java_lang_ProcessManager_close(JNIEnv* env, jclass, jobject javaDescriptor) {
+static void ProcessManager_close(JNIEnv* env, jclass, jobject javaDescriptor) {
     int fd = jniGetFDFromFileDescriptor(env, javaDescriptor);
     if (TEMP_FAILURE_RETRY(close(fd)) == -1) {
         jniThrowIOException(env, errno);
@@ -60,7 +60,7 @@ static void java_lang_ProcessManager_close(JNIEnv* env, jclass, jobject javaDesc
 /**
  * Kills process with the given ID.
  */
-static void java_lang_ProcessManager_kill(JNIEnv* env, jclass, jint pid) {
+static void ProcessManager_kill(JNIEnv* env, jclass, jint pid) {
     int result = kill((pid_t) pid, SIGKILL);
     if (result == -1) {
         jniThrowIOException(env, errno);
@@ -70,7 +70,7 @@ static void java_lang_ProcessManager_kill(JNIEnv* env, jclass, jint pid) {
 /**
  * Loops indefinitely and calls ProcessManager.onExit() when children exit.
  */
-static void java_lang_ProcessManager_watchChildren(JNIEnv* env, jobject o) {
+static void ProcessManager_watchChildren(JNIEnv* env, jobject o) {
     if (onExitMethod == NULL) {
         jniThrowException(env, "java/lang/IllegalStateException",
                 "staticInitialize() must run first.");
@@ -329,7 +329,7 @@ static void freeStrings(JNIEnv* env, jobjectArray javaArray, char** array) {
 /**
  * Converts Java String[] to char** and delegates to executeProcess().
  */
-static pid_t java_lang_ProcessManager_exec(
+static pid_t ProcessManager_exec(
         JNIEnv* env, jclass, jobjectArray javaCommands,
         jobjectArray javaEnvironment, jstring javaWorkingDirectory,
         jobject inDescriptor, jobject outDescriptor, jobject errDescriptor,
@@ -377,7 +377,7 @@ static pid_t java_lang_ProcessManager_exec(
 /**
  * Looks up Java members.
  */
-static void java_lang_ProcessManager_staticInitialize(JNIEnv* env,
+static void ProcessManager_staticInitialize(JNIEnv* env,
         jclass clazz) {
 #ifdef ANDROID
     char* fdString = getenv("ANDROID_PROPERTY_WORKSPACE");
@@ -393,12 +393,12 @@ static void java_lang_ProcessManager_staticInitialize(JNIEnv* env,
 }
 
 static JNINativeMethod methods[] = {
-    { "close",            "(Ljava/io/FileDescriptor;)V", (void*) java_lang_ProcessManager_close },
-    { "kill",             "(I)V",                        (void*) java_lang_ProcessManager_kill },
-    { "staticInitialize", "()V",                         (void*) java_lang_ProcessManager_staticInitialize },
-    { "watchChildren",    "()V",                         (void*) java_lang_ProcessManager_watchChildren },
+    { "close",            "(Ljava/io/FileDescriptor;)V", (void*) ProcessManager_close },
+    { "kill",             "(I)V",                        (void*) ProcessManager_kill },
+    { "staticInitialize", "()V",                         (void*) ProcessManager_staticInitialize },
+    { "watchChildren",    "()V",                         (void*) ProcessManager_watchChildren },
     { "exec",             "([Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;Ljava/io/FileDescriptor;Ljava/io/FileDescriptor;Ljava/io/FileDescriptor;Z)I",
-                                                         (void*) java_lang_ProcessManager_exec },
+                                                         (void*) ProcessManager_exec },
 };
 int register_java_lang_ProcessManager(JNIEnv* env) {
     return jniRegisterNativeMethods(env, "java/lang/ProcessManager", methods, NELEM(methods));
diff --git a/luni/src/main/native/java_net_NetworkInterface.cpp b/luni/src/main/native/java_net_NetworkInterface.cpp
index 3a224e1..c4bb92d 100644
--- a/luni/src/main/native/java_net_NetworkInterface.cpp
+++ b/luni/src/main/native/java_net_NetworkInterface.cpp
@@ -88,7 +88,7 @@ static jobject makeInterfaceAddress(JNIEnv* env, jint interfaceIndex, ifaddrs* i
             interfaceIndex, javaName, javaAddress, javaMask);
 }
 
-static jobjectArray getAllInterfaceAddressesImpl(JNIEnv* env, jclass) {
+static jobjectArray NetworkInterface_getAllInterfaceAddressesImpl(JNIEnv* env, jclass) {
     // Get the list of interface addresses.
     ScopedInterfaceAddresses addresses;
     if (!addresses.init()) {
@@ -173,7 +173,7 @@ static jboolean hasFlag(JNIEnv* env, jstring name, int flag) {
     return (ifr.ifr_flags & flag) != 0;
 }
 
-static jbyteArray getHardwareAddressImpl(JNIEnv* env, jclass, jstring name) {
+static jbyteArray NetworkInterface_getHardwareAddressImpl(JNIEnv* env, jclass, jstring name) {
     ifreq ifr;
     if (!doIoctl(env, name, SIOCGIFHWADDR, ifr)) {
         return NULL;
@@ -194,36 +194,36 @@ static jbyteArray getHardwareAddressImpl(JNIEnv* env, jclass, jstring name) {
     return result;
 }
 
-static jint getMTUImpl(JNIEnv* env, jclass, jstring name) {
+static jint NetworkInterface_getMTUImpl(JNIEnv* env, jclass, jstring name) {
     ifreq ifr;
     doIoctl(env, name, SIOCGIFMTU, ifr); // May throw.
     return ifr.ifr_mtu;
 }
 
-static jboolean isLoopbackImpl(JNIEnv* env, jclass, jstring name) {
+static jboolean NetworkInterface_isLoopbackImpl(JNIEnv* env, jclass, jstring name) {
     return hasFlag(env, name, IFF_LOOPBACK);
 }
 
-static jboolean isPointToPointImpl(JNIEnv* env, jclass, jstring name) {
+static jboolean NetworkInterface_isPointToPointImpl(JNIEnv* env, jclass, jstring name) {
     return hasFlag(env, name, IFF_POINTOPOINT); // Unix API typo!
 }
 
-static jboolean isUpImpl(JNIEnv* env, jclass, jstring name) {
+static jboolean NetworkInterface_isUpImpl(JNIEnv* env, jclass, jstring name) {
     return hasFlag(env, name, IFF_UP);
 }
 
-static jboolean supportsMulticastImpl(JNIEnv* env, jclass, jstring name) {
+static jboolean NetworkInterface_supportsMulticastImpl(JNIEnv* env, jclass, jstring name) {
     return hasFlag(env, name, IFF_MULTICAST);
 }
 
 static JNINativeMethod gMethods[] = {
-    { "getAllInterfaceAddressesImpl", "()[Ljava/net/InterfaceAddress;", (void*) getAllInterfaceAddressesImpl },
-    { "getHardwareAddressImpl", "(Ljava/lang/String;)[B", (void*) getHardwareAddressImpl },
-    { "getMTUImpl", "(Ljava/lang/String;)I", (void*) getMTUImpl },
-    { "isLoopbackImpl", "(Ljava/lang/String;)Z", (void*) isLoopbackImpl },
-    { "isPointToPointImpl", "(Ljava/lang/String;)Z", (void*) isPointToPointImpl },
-    { "isUpImpl", "(Ljava/lang/String;)Z", (void*) isUpImpl },
-    { "supportsMulticastImpl", "(Ljava/lang/String;)Z", (void*) supportsMulticastImpl },
+    { "getAllInterfaceAddressesImpl", "()[Ljava/net/InterfaceAddress;", (void*) NetworkInterface_getAllInterfaceAddressesImpl },
+    { "getHardwareAddressImpl", "(Ljava/lang/String;)[B", (void*) NetworkInterface_getHardwareAddressImpl },
+    { "getMTUImpl", "(Ljava/lang/String;)I", (void*) NetworkInterface_getMTUImpl },
+    { "isLoopbackImpl", "(Ljava/lang/String;)Z", (void*) NetworkInterface_isLoopbackImpl },
+    { "isPointToPointImpl", "(Ljava/lang/String;)Z", (void*) NetworkInterface_isPointToPointImpl },
+    { "isUpImpl", "(Ljava/lang/String;)Z", (void*) NetworkInterface_isUpImpl },
+    { "supportsMulticastImpl", "(Ljava/lang/String;)Z", (void*) NetworkInterface_supportsMulticastImpl },
 };
 int register_java_net_NetworkInterface(JNIEnv* env) {
     return jniRegisterNativeMethods(env, "java/net/NetworkInterface", gMethods, NELEM(gMethods));
diff --git a/luni/src/main/native/java_util_regex_Matcher.cpp b/luni/src/main/native/java_util_regex_Matcher.cpp
index c47a211..b0e5e44 100644
--- a/luni/src/main/native/java_util_regex_Matcher.cpp
+++ b/luni/src/main/native/java_util_regex_Matcher.cpp
@@ -117,11 +117,11 @@ private:
     void operator=(const MatcherAccessor&);
 };
 
-static void RegexMatcher_closeImpl(JNIEnv*, jclass, jint addr) {
+static void Matcher_closeImpl(JNIEnv*, jclass, jint addr) {
     delete toRegexMatcher(addr);
 }
 
-static jint RegexMatcher_findImpl(JNIEnv* env, jclass, jint addr, jstring javaText, jint startIndex, jintArray offsets) {
+static jint Matcher_findImpl(JNIEnv* env, jclass, jint addr, jstring javaText, jint startIndex, jintArray offsets) {
     MatcherAccessor matcher(env, addr, javaText, false);
     UBool result = matcher->find(startIndex, matcher.status());
     if (result) {
@@ -130,7 +130,7 @@ static jint RegexMatcher_findImpl(JNIEnv* env, jclass, jint addr, jstring javaTe
     return result;
 }
 
-static jint RegexMatcher_findNextImpl(JNIEnv* env, jclass, jint addr, jstring javaText, jintArray offsets) {
+static jint Matcher_findNextImpl(JNIEnv* env, jclass, jint addr, jstring javaText, jintArray offsets) {
     MatcherAccessor matcher(env, addr, javaText, false);
     if (matcher.status() != U_ZERO_ERROR) {
         return -1;
@@ -142,17 +142,17 @@ static jint RegexMatcher_findNextImpl(JNIEnv* env, jclass, jint addr, jstring ja
     return result;
 }
 
-static jint RegexMatcher_groupCountImpl(JNIEnv* env, jclass, jint addr) {
+static jint Matcher_groupCountImpl(JNIEnv* env, jclass, jint addr) {
     MatcherAccessor matcher(env, addr);
     return matcher->groupCount();
 }
 
-static jint RegexMatcher_hitEndImpl(JNIEnv* env, jclass, jint addr) {
+static jint Matcher_hitEndImpl(JNIEnv* env, jclass, jint addr) {
     MatcherAccessor matcher(env, addr);
     return matcher->hitEnd();
 }
 
-static jint RegexMatcher_lookingAtImpl(JNIEnv* env, jclass, jint addr, jstring javaText, jintArray offsets) {
+static jint Matcher_lookingAtImpl(JNIEnv* env, jclass, jint addr, jstring javaText, jintArray offsets) {
     MatcherAccessor matcher(env, addr, javaText, false);
     UBool result = matcher->lookingAt(matcher.status());
     if (result) {
@@ -161,7 +161,7 @@ static jint RegexMatcher_lookingAtImpl(JNIEnv* env, jclass, jint addr, jstring j
     return result;
 }
 
-static jint RegexMatcher_matchesImpl(JNIEnv* env, jclass, jint addr, jstring javaText, jintArray offsets) {
+static jint Matcher_matchesImpl(JNIEnv* env, jclass, jint addr, jstring javaText, jintArray offsets) {
     MatcherAccessor matcher(env, addr, javaText, false);
     UBool result = matcher->matches(matcher.status());
     if (result) {
@@ -170,7 +170,7 @@ static jint RegexMatcher_matchesImpl(JNIEnv* env, jclass, jint addr, jstring jav
     return result;
 }
 
-static jint RegexMatcher_openImpl(JNIEnv* env, jclass, jint patternAddr) {
+static jint Matcher_openImpl(JNIEnv* env, jclass, jint patternAddr) {
     RegexPattern* pattern = reinterpret_cast<RegexPattern*>(static_cast<uintptr_t>(patternAddr));
     UErrorCode status = U_ZERO_ERROR;
     RegexMatcher* result = pattern->matcher(status);
@@ -178,39 +178,39 @@ static jint RegexMatcher_openImpl(JNIEnv* env, jclass, jint patternAddr) {
     return static_cast<jint>(reinterpret_cast<uintptr_t>(result));
 }
 
-static jint RegexMatcher_requireEndImpl(JNIEnv* env, jclass, jint addr) {
+static jint Matcher_requireEndImpl(JNIEnv* env, jclass, jint addr) {
     MatcherAccessor matcher(env, addr);
     return matcher->requireEnd();
 }
 
-static void RegexMatcher_setInputImpl(JNIEnv* env, jclass, jint addr, jstring javaText, jint start, jint end) {
+static void Matcher_setInputImpl(JNIEnv* env, jclass, jint addr, jstring javaText, jint start, jint end) {
     MatcherAccessor matcher(env, addr, javaText, true);
     matcher->region(start, end, matcher.status());
 }
 
-static void RegexMatcher_useAnchoringBoundsImpl(JNIEnv* env, jclass, jint addr, jboolean value) {
+static void Matcher_useAnchoringBoundsImpl(JNIEnv* env, jclass, jint addr, jboolean value) {
     MatcherAccessor matcher(env, addr);
     matcher->useAnchoringBounds(value);
 }
 
-static void RegexMatcher_useTransparentBoundsImpl(JNIEnv* env, jclass, jint addr, jboolean value) {
+static void Matcher_useTransparentBoundsImpl(JNIEnv* env, jclass, jint addr, jboolean value) {
     MatcherAccessor matcher(env, addr);
     matcher->useTransparentBounds(value);
 }
 
 static JNINativeMethod gMethods[] = {
-    { "closeImpl", "(I)V", (void*) RegexMatcher_closeImpl },
-    { "findImpl", "(ILjava/lang/String;I[I)Z", (void*) RegexMatcher_findImpl },
-    { "findNextImpl", "(ILjava/lang/String;[I)Z", (void*) RegexMatcher_findNextImpl },
-    { "groupCountImpl", "(I)I", (void*) RegexMatcher_groupCountImpl },
-    { "hitEndImpl", "(I)Z", (void*) RegexMatcher_hitEndImpl },
-    { "lookingAtImpl", "(ILjava/lang/String;[I)Z", (void*) RegexMatcher_lookingAtImpl },
-    { "matchesImpl", "(ILjava/lang/String;[I)Z", (void*) RegexMatcher_matchesImpl },
-    { "openImpl", "(I)I", (void*) RegexMatcher_openImpl },
-    { "requireEndImpl", "(I)Z", (void*) RegexMatcher_requireEndImpl },
-    { "setInputImpl", "(ILjava/lang/String;II)V", (void*) RegexMatcher_setInputImpl },
-    { "useAnchoringBoundsImpl", "(IZ)V", (void*) RegexMatcher_useAnchoringBoundsImpl },
-    { "useTransparentBoundsImpl", "(IZ)V", (void*) RegexMatcher_useTransparentBoundsImpl },
+    { "closeImpl", "(I)V", (void*) Matcher_closeImpl },
+    { "findImpl", "(ILjava/lang/String;I[I)Z", (void*) Matcher_findImpl },
+    { "findNextImpl", "(ILjava/lang/String;[I)Z", (void*) Matcher_findNextImpl },
+    { "groupCountImpl", "(I)I", (void*) Matcher_groupCountImpl },
+    { "hitEndImpl", "(I)Z", (void*) Matcher_hitEndImpl },
+    { "lookingAtImpl", "(ILjava/lang/String;[I)Z", (void*) Matcher_lookingAtImpl },
+    { "matchesImpl", "(ILjava/lang/String;[I)Z", (void*) Matcher_matchesImpl },
+    { "openImpl", "(I)I", (void*) Matcher_openImpl },
+    { "requireEndImpl", "(I)Z", (void*) Matcher_requireEndImpl },
+    { "setInputImpl", "(ILjava/lang/String;II)V", (void*) Matcher_setInputImpl },
+    { "useAnchoringBoundsImpl", "(IZ)V", (void*) Matcher_useAnchoringBoundsImpl },
+    { "useTransparentBoundsImpl", "(IZ)V", (void*) Matcher_useTransparentBoundsImpl },
 };
 int register_java_util_regex_Matcher(JNIEnv* env) {
     return jniRegisterNativeMethods(env, "java/util/regex/Matcher", gMethods, NELEM(gMethods));
diff --git a/luni/src/main/native/java_util_regex_Pattern.cpp b/luni/src/main/native/java_util_regex_Pattern.cpp
index 9d48b08..b03d564 100644
--- a/luni/src/main/native/java_util_regex_Pattern.cpp
+++ b/luni/src/main/native/java_util_regex_Pattern.cpp
@@ -41,11 +41,11 @@ static void throwPatternSyntaxException(JNIEnv* env, UErrorCode status, jstring
     env->Throw(reinterpret_cast<jthrowable>(exception));
 }
 
-static void RegexPattern_closeImpl(JNIEnv*, jclass, jint addr) {
+static void Pattern_closeImpl(JNIEnv*, jclass, jint addr) {
     delete toRegexPattern(addr);
 }
 
-static jint RegexPattern_compileImpl(JNIEnv* env, jclass, jstring javaRegex, jint flags) {
+static jint Pattern_compileImpl(JNIEnv* env, jclass, jstring javaRegex, jint flags) {
     flags |= UREGEX_ERROR_ON_UNKNOWN_ESCAPES;
 
     UErrorCode status = U_ZERO_ERROR;
@@ -62,8 +62,8 @@ static jint RegexPattern_compileImpl(JNIEnv* env, jclass, jstring javaRegex, jin
 }
 
 static JNINativeMethod gMethods[] = {
-    { "closeImpl", "(I)V", (void*) RegexPattern_closeImpl },
-    { "compileImpl", "(Ljava/lang/String;I)I", (void*) RegexPattern_compileImpl },
+    { "closeImpl", "(I)V", (void*) Pattern_closeImpl },
+    { "compileImpl", "(Ljava/lang/String;I)I", (void*) Pattern_compileImpl },
 };
 int register_java_util_regex_Pattern(JNIEnv* env) {
     return jniRegisterNativeMethods(env, "java/util/regex/Pattern", gMethods, NELEM(gMethods));
diff --git a/luni/src/main/native/org_apache_harmony_luni_platform_OSMemory.cpp b/luni/src/main/native/org_apache_harmony_luni_platform_OSMemory.cpp
index edfaba0..960b581 100644
--- a/luni/src/main/native/org_apache_harmony_luni_platform_OSMemory.cpp
+++ b/luni/src/main/native/org_apache_harmony_luni_platform_OSMemory.cpp
@@ -18,12 +18,12 @@
 
 #include "JNIHelp.h"
 #include "JniConstants.h"
-#include "utils/misc.h"
-#include "utils/Log.h"
-#include <sys/mman.h>
+#include "UniquePtr.h"
+
+#include <errno.h>
 #include <stdlib.h>
 #include <string.h>
-#include <errno.h>
+#include <sys/mman.h>
 
 /*
  * Cached dalvik.system.VMRuntime pieces.
@@ -39,138 +39,82 @@ static const int MMAP_READ_ONLY = 1;
 static const int MMAP_READ_WRITE = 2;
 static const int MMAP_WRITE_COPY = 4;
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    littleEndian
- * Signature: ()Z
- */
-static jboolean harmony_nio_littleEndian(JNIEnv*, jclass) {
+template <typename T> static T cast(jint address) {
+    return reinterpret_cast<T>(static_cast<uintptr_t>(address));
+}
+
+static jboolean OSMemory_isLittleEndianImpl(JNIEnv*, jclass) {
     long l = 0x01020304;
-    unsigned char* c = (unsigned char*)&l;
+    unsigned char* c = reinterpret_cast<unsigned char*>(&l);
     return (*c == 0x04) ? JNI_TRUE : JNI_FALSE;
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    getPointerSizeImpl
- * Signature: ()I
- */
-static jint harmony_nio_getPointerSizeImpl(JNIEnv*, jclass) {
-    return sizeof(void *);
+static jint OSMemory_getPointerSizeImpl(JNIEnv*, jclass) {
+    return sizeof(void*);
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    mallocImpl
- * Signature: (I)I
- */
-static jint harmony_nio_mallocImpl(JNIEnv* _env, jobject, jint size) {
-    jboolean allowed = _env->CallBooleanMethod(gIDCache.runtimeInstance,
+static jint OSMemory_malloc(JNIEnv* env, jobject, jint size) {
+    jboolean allowed = env->CallBooleanMethod(gIDCache.runtimeInstance,
         gIDCache.method_trackExternalAllocation, (jlong) size);
     if (!allowed) {
         LOGW("External allocation of %d bytes was rejected\n", size);
-        jniThrowException(_env, "java/lang/OutOfMemoryError", NULL);
+        jniThrowException(env, "java/lang/OutOfMemoryError", NULL);
         return 0;
     }
 
     LOGV("OSMemory alloc %d\n", size);
-    void *returnValue = malloc(size + sizeof(jlong));
-    if (returnValue == NULL) {
-        jniThrowException(_env, "java/lang/OutOfMemoryError", NULL);
+    void* block = malloc(size + sizeof(jlong));
+    if (block == NULL) {
+        jniThrowException(env, "java/lang/OutOfMemoryError", NULL);
         return 0;
     }
 
     /*
      * Tuck a copy of the size at the head of the buffer.  We need this
-     * so harmony_nio_freeImpl() knows how much memory is being freed.
+     * so OSMemory_free() knows how much memory is being freed.
      */
-    jlong* adjptr = (jlong*) returnValue;
-    *adjptr++ = size;
-    return (jint)adjptr;
+    jlong* result = reinterpret_cast<jlong*>(block);
+    *result++ = size;
+    return static_cast<jint>(reinterpret_cast<uintptr_t>(result));
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    freeImpl
- * Signature: (I)V
- */
-static void harmony_nio_freeImpl(JNIEnv* _env, jobject, jint pointer) {
-    jlong* adjptr = (jlong*) pointer;
-    jint size = *--adjptr;
-    LOGV("OSMemory free %d\n", size);
-    _env->CallVoidMethod(gIDCache.runtimeInstance,
-        gIDCache.method_trackExternalFree, (jlong) size);
-    free((void *)adjptr);
+static void OSMemory_free(JNIEnv* env, jobject, jint address) {
+    jlong* p = reinterpret_cast<jlong*>(static_cast<uintptr_t>(address));
+    jlong size = *--p;
+    LOGV("OSMemory free %ld\n", size);
+    env->CallVoidMethod(gIDCache.runtimeInstance, gIDCache.method_trackExternalFree, size);
+    free(reinterpret_cast<void*>(p));
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    memset
- * Signature: (IBJ)V
- */
-static void harmony_nio_memset(JNIEnv*, jobject, jint address,
-        jbyte value, jlong length) {
-    memset ((void *) ((jint) address), (jbyte) value, (jlong) length);
+static void OSMemory_memset(JNIEnv*, jobject, jint dstAddress, jbyte value, jlong length) {
+    memset(cast<void*>(dstAddress), value, length);
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    memmove
- * Signature: (IIJ)V
- */
-static void harmony_nio_memmove(JNIEnv*, jobject, jint destAddress,
-        jint srcAddress, jlong length) {
-    memmove ((void *) ((jint) destAddress), (const void *) ((jint) srcAddress),
-        (jlong) length);
+static void OSMemory_memmove(JNIEnv*, jobject, jint dstAddress, jint srcAddress, jlong length) {
+    memmove(cast<void*>(dstAddress), cast<const void*>(srcAddress), length);
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    getByteImpl
- * Signature: (I)B
- */
-static jbyte harmony_nio_getByteImpl(JNIEnv*, jobject,
-        jint pointer) {
-    jbyte returnValue = *((jbyte *)pointer);
-    return returnValue;
+static jbyte OSMemory_getByte(JNIEnv*, jobject, jint srcAddress) {
+    return *cast<const jbyte*>(srcAddress);
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    getBytesImpl
- * Signature: (I[BII)V
- */
-static void harmony_nio_getBytesImpl(JNIEnv* _env, jobject, jint pointer,
+static void OSMemory_getByteArray(JNIEnv* env, jobject, jint srcAddress,
         jbyteArray dst, jint offset, jint length) {
-    jbyte* src = reinterpret_cast<jbyte*>(static_cast<uintptr_t>(pointer));
-    _env->SetByteArrayRegion(dst, offset, length, src);
+    env->SetByteArrayRegion(dst, offset, length, cast<const jbyte*>(srcAddress));
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    putByteImpl
- * Signature: (IB)V
- */
-static void harmony_nio_putByteImpl(JNIEnv*, jobject, jint pointer,
-        jbyte val) {
-    *((jbyte *)pointer) = val;
+static void OSMemory_setByte(JNIEnv*, jobject, jint dstAddress, jbyte value) {
+    *cast<jbyte*>(dstAddress) = value;
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    putBytesImpl
- * Signature: (I[BII)V
- */
-static void harmony_nio_putBytesImpl(JNIEnv* _env, jobject,
-        jint pointer, jbyteArray src, jint offset, jint length) {
-    jbyte* dst = reinterpret_cast<jbyte*>(static_cast<uintptr_t>(pointer));
-    _env->GetByteArrayRegion(src, offset, length, dst);
+static void OSMemory_setByteArray(JNIEnv* env, jobject,
+        jint dstAddress, jbyteArray src, jint offset, jint length) {
+    env->GetByteArrayRegion(src, offset, length, cast<jbyte*>(dstAddress));
 }
 
-static void
-swapShorts(jshort *shorts, int count) {
-    jbyte *src = (jbyte *) shorts;
-    jbyte *dst = src;
+static void swapShorts(jshort* shorts, int count) {
+    jbyte* src = reinterpret_cast<jbyte*>(shorts);
+    jbyte* dst = src;
     for (int i = 0; i < count; ++i) {
         jbyte b0 = *src++;
         jbyte b1 = *src++;
@@ -179,10 +123,9 @@ swapShorts(jshort *shorts, int count) {
     }
 }
 
-static void
-swapInts(jint *ints, int count) {
-    jbyte *src = (jbyte *) ints;
-    jbyte *dst = src;
+static void swapInts(jint* ints, int count) {
+    jbyte* src = reinterpret_cast<jbyte*>(ints);
+    jbyte* dst = src;
     for (int i = 0; i < count; ++i) {
         jbyte b0 = *src++;
         jbyte b1 = *src++;
@@ -195,108 +138,73 @@ swapInts(jint *ints, int count) {
     }
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    setShortArrayImpl
- * Signature: (I[SIIZ)V
- */
-static void harmony_nio_setShortArrayImpl(JNIEnv* _env, jobject,
-       jint pointer, jshortArray src, jint offset, jint length, jboolean swap) {
-    jshort* dst = reinterpret_cast<jshort*>(static_cast<uintptr_t>(pointer));
-    _env->GetShortArrayRegion(src, offset, length, dst);
+static void OSMemory_setShortArray(JNIEnv* env, jobject,
+       jint dstAddress, jshortArray src, jint offset, jint length, jboolean swap) {
+    jshort* dst = cast<jshort*>(dstAddress);
+    env->GetShortArrayRegion(src, offset, length, dst);
     if (swap) {
         swapShorts(dst, length);
     }
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    setIntArrayImpl
- * Signature: (I[IIIZ)V
- */
-static void harmony_nio_setIntArrayImpl(JNIEnv* _env, jobject,
-       jint pointer, jintArray src, jint offset, jint length, jboolean swap) {
-    jint* dst = reinterpret_cast<jint*>(static_cast<uintptr_t>(pointer));
-    _env->GetIntArrayRegion(src, offset, length, dst);
+static void OSMemory_setIntArray(JNIEnv* env, jobject,
+       jint dstAddress, jintArray src, jint offset, jint length, jboolean swap) {
+    jint* dst = cast<jint*>(dstAddress);
+    env->GetIntArrayRegion(src, offset, length, dst);
     if (swap) {
         swapInts(dst, length);
     }
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    getShortImpl
- * Signature: (I)S
- */
-static jshort harmony_nio_getShortImpl(JNIEnv*, jobject,
-        jint pointer) {
-    if ((pointer & 0x1) == 0) {
-        jshort returnValue = *((jshort *)pointer);
-        return returnValue;
+static jshort OSMemory_getShort(JNIEnv*, jobject, jint srcAddress) {
+    if ((srcAddress & 0x1) == 0) {
+        return *cast<const jshort*>(srcAddress);
     } else {
         // Handle unaligned memory access one byte at a time
-        jshort s;
-        unsigned char *src = (unsigned char *) pointer;
-        unsigned char *dst = (unsigned char *) &s;
+        jshort result;
+        const jbyte* src = cast<const jbyte*>(srcAddress);
+        jbyte* dst = reinterpret_cast<jbyte*>(&result);
         dst[0] = src[0];
         dst[1] = src[1];
-        return s;
+        return result;
     }
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    petShortImpl
- * Signature: (IS)V
- */
-static void harmony_nio_putShortImpl(JNIEnv*, jobject, jint pointer,
-        jshort value) {
-    if ((pointer & 0x1) == 0) {
-        *((jshort *)pointer) = value;
+static void OSMemory_setShort(JNIEnv*, jobject, jint dstAddress, jshort value) {
+    if ((dstAddress & 0x1) == 0) {
+        *cast<jshort*>(dstAddress) = value;
     } else {
         // Handle unaligned memory access one byte at a time
-        unsigned char *src = (unsigned char *) &value;
-        unsigned char *dst = (unsigned char *) pointer;
+        const jbyte* src = reinterpret_cast<const jbyte*>(&value);
+        jbyte* dst = cast<jbyte*>(dstAddress);
         dst[0] = src[0];
         dst[1] = src[1];
     }
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    getIntImpl
- * Signature: (I)I
- */
-static jint harmony_nio_getIntImpl(JNIEnv*, jobject, jint pointer) {
-    if ((pointer & 0x3) == 0) {
-        jint returnValue = *((jint *)pointer);
-        return returnValue;
+static jint OSMemory_getInt(JNIEnv*, jobject, jint srcAddress) {
+    if ((srcAddress & 0x3) == 0) {
+        return *cast<const jint*>(srcAddress);
     } else {
         // Handle unaligned memory access one byte at a time
-        jint i;
-        unsigned char *src = (unsigned char *) pointer;
-        unsigned char *dst = (unsigned char *) &i;
+        jint result;
+        const jbyte* src = cast<const jbyte*>(srcAddress);
+        jbyte* dst = reinterpret_cast<jbyte*>(&result);
         dst[0] = src[0];
         dst[1] = src[1];
         dst[2] = src[2];
         dst[3] = src[3];
-        return i;
+        return result;
     }
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    putIntImpl
- * Signature: (II)V
- */
-static void harmony_nio_putIntImpl(JNIEnv*, jobject, jint pointer,
-        jint value) {
-    if ((pointer & 0x3) == 0) {
-        *((jint *)pointer) = value;
+static void OSMemory_setInt(JNIEnv*, jobject, jint dstAddress, jint value) {
+    if ((dstAddress & 0x3) == 0) {
+        *cast<jint*>(dstAddress) = value;
     } else {
         // Handle unaligned memory access one byte at a time
-        unsigned char *src = (unsigned char *) &value;
-        unsigned char *dst = (unsigned char *) pointer;
+        const jbyte* src = reinterpret_cast<const jbyte*>(&value);
+        jbyte* dst = cast<jbyte*>(dstAddress);
         dst[0] = src[0];
         dst[1] = src[1];
         dst[2] = src[2];
@@ -304,131 +212,57 @@ static void harmony_nio_putIntImpl(JNIEnv*, jobject, jint pointer,
     }
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    getLongImpl
- * Signature: (I)Ljava/lang/Long;
- */
-static jlong harmony_nio_getLongImpl(JNIEnv*, jobject,
-        jint pointer) {
-    if ((pointer & 0x7) == 0) {
-        jlong returnValue = *((jlong *)pointer);
-        return returnValue;
+template <typename T> static T get(jint srcAddress) {
+    if ((srcAddress & (sizeof(T) - 1)) == 0) {
+        return *cast<const T*>(srcAddress);
     } else {
-        // Handle unaligned memory access one byte at a time
-        jlong l;
-        memcpy((void *) &l, (void *) pointer, sizeof(jlong));
-        return l;
+        T result;
+        memcpy(&result, cast<const T*>(srcAddress), sizeof(T));
+        return result;
     }
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    putLongImpl
- * Signature: (IJ)V
- */
-static void harmony_nio_putLongImpl(JNIEnv*, jobject, jint pointer,
-        jlong value) {
-    if ((pointer & 0x7) == 0) {
-        *((jlong *)pointer) = value;
+template <typename T> static void set(jint dstAddress, T value) {
+    if ((dstAddress & (sizeof(T) - 1)) == 0) {
+        *cast<T*>(dstAddress) = value;
     } else {
-        // Handle unaligned memory access one byte at a time
-        memcpy((void *) pointer, (void *) &value, sizeof(jlong));
+        memcpy(cast<void*>(dstAddress), &value, sizeof(T));
     }
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    getFloatImpl
- * Signature: (I)F
- */
-static jfloat harmony_nio_getFloatImpl(JNIEnv*, jobject,
-        jint pointer) {
-    if ((pointer & 0x3) == 0) {
-        jfloat returnValue = *((jfloat *)pointer);
-        return returnValue;
-    } else {
-        // Handle unaligned memory access one byte at a time
-        jfloat f;
-        memcpy((void *) &f, (void *) pointer, sizeof(jfloat));
-        return f;
-    }
+static jlong OSMemory_getLong(JNIEnv*, jobject, jint srcAddress) {
+    return get<jlong>(srcAddress);
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    setFloatImpl
- * Signature: (IF)V
- */
-static void harmony_nio_putFloatImpl(JNIEnv*, jobject, jint pointer,
-        jfloat value) {
-    if ((pointer & 0x3) == 0) {
-        *((jfloat *)pointer) = value;
-    } else {
-        // Handle unaligned memory access one byte at a time
-        memcpy((void *) pointer, (void *) &value, sizeof(jfloat));
-    }
+static void OSMemory_setLong(JNIEnv*, jobject, jint dstAddress, jlong value) {
+    set<jlong>(dstAddress, value);
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    getDoubleImpl
- * Signature: (I)D
- */
-static jdouble harmony_nio_getDoubleImpl(JNIEnv*, jobject,
-        jint pointer) {
-    if ((pointer & 0x7) == 0) {
-        jdouble returnValue = *((jdouble *)pointer);
-        return returnValue;
-    } else {
-        // Handle unaligned memory access one byte at a time
-        jdouble d;
-        memcpy((void *) &d, (void *) pointer, sizeof(jdouble));
-        return d;
-    }
+static jfloat OSMemory_getFloat(JNIEnv*, jobject, jint srcAddress) {
+    return get<jfloat>(srcAddress);
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    putDoubleImpl
- * Signature: (ID)V
- */
-static void harmony_nio_putDoubleImpl(JNIEnv*, jobject, jint pointer,
-        jdouble value) {
-    if ((pointer & 0x7) == 0) {
-        *((jdouble *)pointer) = value;
-    } else {
-        // Handle unaligned memory access one byte at a time
-        memcpy((void *) pointer, (void *) &value, sizeof(jdouble));
-    }
+static void OSMemory_setFloat(JNIEnv*, jobject, jint dstAddress, jfloat value) {
+    set<jfloat>(dstAddress, value);
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    getAddress
- * Signature: (I)I
- */
-static jint harmony_nio_getAddress(JNIEnv*, jobject, jint pointer) {
-    return (jint) * (int *) pointer;
+static jdouble OSMemory_getDouble(JNIEnv*, jobject, jint srcAddress) {
+    return get<jdouble>(srcAddress);
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    setAddress
- * Signature: (II)V
- */
-static void harmony_nio_setAddress(JNIEnv*, jobject, jint pointer,
-        jint value) {
-    *(int *) pointer = (int) value;
+static void OSMemory_setDouble(JNIEnv*, jobject, jint dstAddress, jdouble value) {
+    set<jdouble>(dstAddress, value);
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    mmapImpl
- * Signature: (IJJI)I
- */
-static jint harmony_nio_mmapImpl(JNIEnv* env, jobject, jint fd,
-        jlong offset, jlong size, jint mapMode) {
+static jint OSMemory_getAddress(JNIEnv*, jobject, jint srcAddress) {
+    return *cast<const jint*>(srcAddress);
+}
+
+static void OSMemory_setAddress(JNIEnv*, jobject, jint dstAddress, jint value) {
+    *cast<jint*>(dstAddress) = value;
+}
+
+static jint OSMemory_mmapImpl(JNIEnv* env, jobject, jint fd, jlong offset, jlong size, jint mapMode) {
     int prot, flags;
     switch (mapMode) {
     case MMAP_READ_ONLY:
@@ -456,115 +290,80 @@ static jint harmony_nio_mmapImpl(JNIEnv* env, jobject, jint fd,
     return reinterpret_cast<uintptr_t>(mapAddress);
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    unmapImpl
- * Signature: (IJ)V
- */
-static void harmony_nio_unmapImpl(JNIEnv*, jobject, jint address,
-        jlong size) {
-    munmap((void *)address, (size_t)size);
+static void OSMemory_unmapImpl(JNIEnv*, jobject, jint address, jlong size) {
+    munmap(cast<void*>(address), size);
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    loadImpl
- * Signature: (IJ)I
- */
-static jint harmony_nio_loadImpl(JNIEnv*, jobject, jint address,
-        jlong size) {
-
-    if(mlock((void *)address, (size_t)size)!=-1) {
-        if(munlock((void *)address, (size_t)size)!=-1) {
+static jint OSMemory_loadImpl(JNIEnv*, jobject, jint address, jlong size) {
+    if (mlock(cast<void*>(address), size) != -1) {
+        if (munlock(cast<void*>(address), size) != -1) {
               return 0;  /* normally */
         }
-    }
-    else {
+    } else {
          /* according to linux sys call, only root can mlock memory. */
-         if(errno == EPERM) {
+         if (errno == EPERM) {
              return 0;
          }
     }
-
     return -1;
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    isLoadedImpl
- * Signature: (IJ)Z
- */
-static jboolean harmony_nio_isLoadedImpl(JNIEnv*, jobject,
-        jint address, jlong size) {
-
+static jboolean OSMemory_isLoadedImpl(JNIEnv*, jobject, jint address, jlong size) {
     static int page_size = getpagesize();
-    jboolean result = 0;
-    jint m_addr = (jint)address;
-
-    int align_offset = m_addr%page_size;// addr should align with the boundary of a page.
-    m_addr -= align_offset;
-    size   += align_offset;
-    int page_count = (size+page_size-1)/page_size;
-
-    unsigned char* vec = (unsigned char *) malloc(page_count*sizeof(char));
-
-    if (mincore((void *)m_addr, size, (MINCORE_POINTER_TYPE) vec)==0) {
-        // or else there is error about the mincore and return false;
-        int i;
-        for(i=0 ;i<page_count;i++) {
-            if(vec[i]!=1) {
-                break;
-            }
-        }
-        if(i==page_count) {
-            result = 1;
-        }
-    }
 
-    free(vec);
+    int align_offset = address % page_size;// addr should align with the boundary of a page.
+    address -= align_offset;
+    size += align_offset;
+    int page_count = (size + page_size - 1) / page_size;
 
-    return result;
+    UniquePtr<unsigned char[]> vec(new unsigned char[page_count]);
+    int rc = mincore(cast<void*>(address), size, (MINCORE_POINTER_TYPE) vec.get());
+    if (rc == -1) {
+        return false;
+    }
+
+    for (int i = 0; i < page_count; ++i) {
+        if (vec[i] != 1) {
+            return false;
+        }
+    }
+    return true;
 }
 
-/*
- * Class:     org_apache_harmony_luni_platform_OSMemory
- * Method:    flushImpl
- * Signature: (IJ)I
- */
-static jint harmony_nio_flushImpl(JNIEnv *, jobject, jint address, jlong size) {
-    return msync((void *)address, size, MS_SYNC);
+static jint OSMemory_flushImpl(JNIEnv*, jobject, jint address, jlong size) {
+    return msync(cast<const void*>(address), size, MS_SYNC);
 }
 
 static JNINativeMethod gMethods[] = {
-    { "isLittleEndianImpl", "()Z",     (void*) harmony_nio_littleEndian },
-    { "getPointerSizeImpl", "()I",     (void*) harmony_nio_getPointerSizeImpl },
-    { "malloc",             "(I)I",    (void*) harmony_nio_mallocImpl },
-    { "free",               "(I)V",    (void*) harmony_nio_freeImpl },
-    { "memset",             "(IBJ)V",  (void*) harmony_nio_memset },
-    { "memmove",            "(IIJ)V",  (void*) harmony_nio_memmove },
-    { "getByteArray",       "(I[BII)V",(void*) harmony_nio_getBytesImpl },
-    { "setByteArray",       "(I[BII)V",(void*) harmony_nio_putBytesImpl },
-    { "setShortArray",     "(I[SIIZ)V",(void*) harmony_nio_setShortArrayImpl },
-    { "setIntArray",       "(I[IIIZ)V",(void*) harmony_nio_setIntArrayImpl },
-    { "getByte",            "(I)B",    (void*) harmony_nio_getByteImpl },
-    { "setByte",            "(IB)V",   (void*) harmony_nio_putByteImpl },
-    { "getShort",           "(I)S",    (void*) harmony_nio_getShortImpl },
-    { "setShort",           "(IS)V",   (void*) harmony_nio_putShortImpl },
-    { "getInt",             "(I)I",    (void*) harmony_nio_getIntImpl },
-    { "setInt",             "(II)V",   (void*) harmony_nio_putIntImpl },
-    { "getLong",            "(I)J",    (void*) harmony_nio_getLongImpl },
-    { "setLong",            "(IJ)V",   (void*) harmony_nio_putLongImpl },
-    { "getFloat",           "(I)F",    (void*) harmony_nio_getFloatImpl },
-    { "setFloat",           "(IF)V",   (void*) harmony_nio_putFloatImpl },
-    { "getDouble",          "(I)D",    (void*) harmony_nio_getDoubleImpl },
-    { "setDouble",          "(ID)V",   (void*) harmony_nio_putDoubleImpl },
-    { "getAddress",         "(I)I",    (void*) harmony_nio_getAddress },
-    { "setAddress",         "(II)V",   (void*) harmony_nio_setAddress },
-    { "mmapImpl",           "(IJJI)I", (void*) harmony_nio_mmapImpl },
-    { "unmapImpl",          "(IJ)V",   (void*) harmony_nio_unmapImpl },
-    { "loadImpl",           "(IJ)I",   (void*) harmony_nio_loadImpl },
-    { "isLoadedImpl",       "(IJ)Z",   (void*) harmony_nio_isLoadedImpl },
-    { "flushImpl",          "(IJ)I",   (void*) harmony_nio_flushImpl }
+    { "flushImpl",          "(IJ)I",   (void*) OSMemory_flushImpl },
+    { "free",               "(I)V",    (void*) OSMemory_free },
+    { "getAddress",         "(I)I",    (void*) OSMemory_getAddress },
+    { "getByte",            "(I)B",    (void*) OSMemory_getByte },
+    { "getByteArray",       "(I[BII)V",(void*) OSMemory_getByteArray },
+    { "getDouble",          "(I)D",    (void*) OSMemory_getDouble },
+    { "getFloat",           "(I)F",    (void*) OSMemory_getFloat },
+    { "getInt",             "(I)I",    (void*) OSMemory_getInt },
+    { "getLong",            "(I)J",    (void*) OSMemory_getLong },
+    { "getPointerSizeImpl", "()I",     (void*) OSMemory_getPointerSizeImpl },
+    { "getShort",           "(I)S",    (void*) OSMemory_getShort },
+    { "isLittleEndianImpl", "()Z",     (void*) OSMemory_isLittleEndianImpl },
+    { "isLoadedImpl",       "(IJ)Z",   (void*) OSMemory_isLoadedImpl },
+    { "loadImpl",           "(IJ)I",   (void*) OSMemory_loadImpl },
+    { "malloc",             "(I)I",    (void*) OSMemory_malloc },
+    { "memmove",            "(IIJ)V",  (void*) OSMemory_memmove },
+    { "memset",             "(IBJ)V",  (void*) OSMemory_memset },
+    { "mmapImpl",           "(IJJI)I", (void*) OSMemory_mmapImpl },
+    { "setAddress",         "(II)V",   (void*) OSMemory_setAddress },
+    { "setByte",            "(IB)V",   (void*) OSMemory_setByte },
+    { "setByteArray",       "(I[BII)V",(void*) OSMemory_setByteArray },
+    { "setDouble",          "(ID)V",   (void*) OSMemory_setDouble },
+    { "setFloat",           "(IF)V",   (void*) OSMemory_setFloat },
+    { "setInt",             "(II)V",   (void*) OSMemory_setInt },
+    { "setIntArray",       "(I[IIIZ)V",(void*) OSMemory_setIntArray },
+    { "setLong",            "(IJ)V",   (void*) OSMemory_setLong },
+    { "setShort",           "(IS)V",   (void*) OSMemory_setShort },
+    { "setShortArray",     "(I[SIIZ)V",(void*) OSMemory_setShortArray },
+    { "unmapImpl",          "(IJ)V",   (void*) OSMemory_unmapImpl },
 };
 int register_org_apache_harmony_luni_platform_OSMemory(JNIEnv* env) {
     /*