Merge "Moving most libcore .c files to .cpp" into dalvik-dev

15 files changed, 601 insertions, 617 deletions

diff --git a/luni/src/main/native/Register.cpp b/luni/src/main/native/Register.cpp
index 5167f6c..ee996c3 100644
--- a/luni/src/main/native/Register.cpp
+++ b/luni/src/main/native/Register.cpp
@@ -32,14 +32,14 @@ extern int register_com_ibm_icu4jni_util_Resources(JNIEnv* env);
 extern int register_java_io_Console(JNIEnv* env);
 extern int register_java_io_File(JNIEnv* env);
 extern "C" int register_java_io_FileDescriptor(JNIEnv* env);
-extern "C" int register_java_io_ObjectInputStream(JNIEnv* env);
-extern "C" int register_java_io_ObjectOutputStream(JNIEnv* env);
-extern "C" int register_java_io_ObjectStreamClass(JNIEnv* env);
-extern "C" int register_java_lang_Double(JNIEnv* env);
-extern "C" int register_java_lang_Float(JNIEnv* env);
-extern "C" int register_java_lang_Math(JNIEnv* env);
+extern int register_java_io_ObjectInputStream(JNIEnv* env);
+extern int register_java_io_ObjectOutputStream(JNIEnv* env);
+extern int register_java_io_ObjectStreamClass(JNIEnv* env);
+extern int register_java_lang_Double(JNIEnv* env);
+extern int register_java_lang_Float(JNIEnv* env);
+extern int register_java_lang_Math(JNIEnv* env);
 extern int register_java_lang_ProcessManager(JNIEnv* env);
-extern "C" int register_java_lang_StrictMath(JNIEnv* env);
+extern int register_java_lang_StrictMath(JNIEnv* env);
 extern int register_java_lang_System(JNIEnv* env);
 extern int register_java_net_InetAddress(JNIEnv* env);
 extern int register_java_net_NetworkInterface(JNIEnv* env);
@@ -47,16 +47,16 @@ extern int register_java_util_zip_Adler32(JNIEnv* env);
 extern int register_java_util_zip_CRC32(JNIEnv* env);
 extern int register_java_util_zip_Deflater(JNIEnv* env);
 extern int register_java_util_zip_Inflater(JNIEnv* env);
-extern "C" int register_org_apache_harmony_dalvik_NativeTestTarget(JNIEnv* env);
+extern int register_org_apache_harmony_dalvik_NativeTestTarget(JNIEnv* env);
 extern int register_org_apache_harmony_luni_platform_OSFileSystem(JNIEnv* env);
 extern int register_org_apache_harmony_luni_platform_OSMemory(JNIEnv* env);
 extern int register_org_apache_harmony_luni_platform_OSNetworkSystem(JNIEnv* env);
-extern "C" int register_org_apache_harmony_luni_util_NumberConvert(JNIEnv* env);
-extern "C" int register_org_apache_harmony_luni_util_fltparse(JNIEnv* env);
+extern int register_org_apache_harmony_luni_util_NumberConvert(JNIEnv* env);
+extern int register_org_apache_harmony_luni_util_fltparse(JNIEnv* env);
 extern int register_org_apache_harmony_text_BidiWrapper(JNIEnv* env);
 extern int register_org_apache_harmony_xml_ExpatParser(JNIEnv* env);
 extern int register_org_apache_harmony_xnet_provider_jsse_NativeCrypto(JNIEnv* env);
-extern "C" int register_org_openssl_NativeBN(JNIEnv* env);
+extern int register_org_openssl_NativeBN(JNIEnv* env);
 
 // DalvikVM calls this on startup, so we can statically register all our native methods.
 extern "C" int registerCoreLibrariesJni(JNIEnv* env) {
diff --git a/luni/src/main/native/cbigint.c b/luni/src/main/native/cbigint.cpp
index 92b2992..92b2992 100644
--- a/luni/src/main/native/cbigint.c
+++ b/luni/src/main/native/cbigint.cpp
diff --git a/luni/src/main/native/commonDblParce.c b/luni/src/main/native/commonDblParce.cpp
index 74debb5..ace365b 100644
--- a/luni/src/main/native/commonDblParce.c
+++ b/luni/src/main/native/commonDblParce.cpp
@@ -343,7 +343,7 @@ createDouble1 (JNIEnv* env, U_64 * f, IDATA length, jint e)
  * then return the original approximation.
  */
 static jdouble
-doubleAlgorithm (JNIEnv* env __attribute__ ((unused)), U_64 * f, IDATA length, jint e, jdouble z)
+doubleAlgorithm (JNIEnv*, U_64 * f, IDATA length, jint e, jdouble z)
 {
   U_64 m;
   IDATA k, comparison, comparison2;
diff --git a/luni/src/main/native/java_io_ObjectInputStream.c b/luni/src/main/native/java_io_ObjectInputStream.cpp
index 1f47742..57f8afe 100644
--- a/luni/src/main/native/java_io_ObjectInputStream.c
+++ b/luni/src/main/native/java_io_ObjectInputStream.cpp
@@ -17,7 +17,7 @@
 
 #include "JNIHelp.h"
 
-static void java_setFieldBool (JNIEnv* env, jclass clazz __attribute__ ((unused)), 
+static void java_setFieldBool (JNIEnv* env, jclass, 
                                          jobject targetObject, 
                                          jclass declaringClass,
                                          jstring fieldName, 
@@ -27,20 +27,20 @@ static void java_setFieldBool (JNIEnv* env, jclass clazz __attribute__ ((unused)
     if(targetObject == NULL) {
         return;
     }
-    fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "Z");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    fid = env->GetFieldID(declaringClass, fieldNameInC, "Z");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused an exception, 
      * or maybe it returned the real value 
      */
     if(fid != 0) {
-        (*env)->SetBooleanField(env, targetObject, fid, newValue);
+        env->SetBooleanField(targetObject, fid, newValue);
     }
 }
 
-static void java_setFieldChar (JNIEnv* env, jclass clazz __attribute__ ((unused)), 
+static void java_setFieldChar (JNIEnv* env, jclass, 
                                          jobject targetObject, 
                                          jclass declaringClass,
                                          jstring fieldName, 
@@ -50,20 +50,20 @@ static void java_setFieldChar (JNIEnv* env, jclass clazz __attribute__ ((unused)
     if(targetObject == NULL) {
         return;
     }
-    fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "C");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    fid = env->GetFieldID(declaringClass, fieldNameInC, "C");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused an exception, 
      * or maybe it returned the real value 
      */
     if(fid != 0) {
-        (*env)->SetCharField(env, targetObject, fid, newValue);
+        env->SetCharField(targetObject, fid, newValue);
     }
 }
 
-static void java_setFieldInt (JNIEnv* env, jclass clazz __attribute__ ((unused)), 
+static void java_setFieldInt (JNIEnv* env, jclass, 
                                          jobject targetObject, 
                                          jclass declaringClass,
                                          jstring fieldName, 
@@ -73,20 +73,20 @@ static void java_setFieldInt (JNIEnv* env, jclass clazz __attribute__ ((unused))
     if(targetObject == NULL) {
         return;
     }
-    fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "I");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    fid = env->GetFieldID(declaringClass, fieldNameInC, "I");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused an exception, 
      * or maybe it returned the real value 
      */
     if(fid != 0) {
-        (*env)->SetIntField(env, targetObject, fid, newValue);
+        env->SetIntField(targetObject, fid, newValue);
     }
 }
 
-static void java_setFieldFloat (JNIEnv* env, jclass clazz __attribute__ ((unused)), 
+static void java_setFieldFloat (JNIEnv* env, jclass, 
                                          jobject targetObject, 
                                          jclass declaringClass,
                                          jstring fieldName, 
@@ -96,20 +96,20 @@ static void java_setFieldFloat (JNIEnv* env, jclass clazz __attribute__ ((unused
     if(targetObject == NULL) {
         return;
     }
-    fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "F");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    fid = env->GetFieldID(declaringClass, fieldNameInC, "F");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused an exception, 
      * or maybe it returned the real value 
      */
     if(fid != 0) {
-        (*env)->SetFloatField(env, targetObject, fid, newValue);
+        env->SetFloatField(targetObject, fid, newValue);
     }
 }
 
-static void java_setFieldDouble (JNIEnv* env, jclass clazz __attribute__ ((unused)), 
+static void java_setFieldDouble (JNIEnv* env, jclass, 
                                          jobject targetObject, 
                                          jclass declaringClass,
                                          jstring fieldName, 
@@ -119,21 +119,21 @@ static void java_setFieldDouble (JNIEnv* env, jclass clazz __attribute__ ((unuse
     if(targetObject == NULL) {
         return;
     }
-    fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "D");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    fid = env->GetFieldID(declaringClass, fieldNameInC, "D");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused an exception, 
      * or maybe it returned the real value 
      */
     if(fid != 0) {
-        (*env)->SetDoubleField(env, targetObject, fid, newValue);
+        env->SetDoubleField(targetObject, fid, newValue);
     }
 
 }
 
-static void java_setFieldShort (JNIEnv* env, jclass clazz __attribute__ ((unused)), 
+static void java_setFieldShort (JNIEnv* env, jclass, 
                                          jobject targetObject, 
                                          jclass declaringClass,
                                          jstring fieldName, 
@@ -143,21 +143,21 @@ static void java_setFieldShort (JNIEnv* env, jclass clazz __attribute__ ((unused
     if(targetObject == NULL) {
         return;
     }
-    fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "S");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    fid = env->GetFieldID(declaringClass, fieldNameInC, "S");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused an exception, 
      * or maybe it returned the real value 
      */
     if(fid != 0) {
-        (*env)->SetShortField(env, targetObject, fid, newValue);
+        env->SetShortField(targetObject, fid, newValue);
     }
 
 }
 
-static void java_setFieldLong (JNIEnv* env, jclass clazz __attribute__ ((unused)),  
+static void java_setFieldLong (JNIEnv* env, jclass,  
                                          jobject targetObject,  
                                          jclass declaringClass, 
                                          jstring fieldName,  
@@ -167,36 +167,36 @@ static void java_setFieldLong (JNIEnv* env, jclass clazz __attribute__ ((unused)
     if(targetObject == NULL) {
         return;
     }
-    fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "J");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    fid = env->GetFieldID(declaringClass, fieldNameInC, "J");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /*
      * Two options now. Maybe getFieldID caused an exception, 
      * or maybe it returned the real value 
      */
     if(fid != 0) {
-        (*env)->SetLongField(env, targetObject, fid, newValue);
+        env->SetLongField(targetObject, fid, newValue);
     }
 }
 
-static jobject java_newInstance (JNIEnv* env, jclass clazz __attribute__ ((unused)), 
+static jobject java_newInstance (JNIEnv* env, jclass, 
                                          jclass instantiationClass, 
                                          jclass constructorClass) {
     jmethodID mid =
-    (*env)->GetMethodID(env, constructorClass, "<init>", "()V");
+    env->GetMethodID(constructorClass, "<init>", "()V");
 
     if(mid == 0) {
       /* Cant newInstance,No empty constructor... */
       return (jobject) 0;
     } else {
         /* Instantiate an object of a given class */
-        return (jobject) (*env)->NewObject(env, instantiationClass, mid);
+        return (jobject) env->NewObject(instantiationClass, mid);
     }
 
 }
 
-static void java_setFieldByte (JNIEnv* env, jclass clazz __attribute__ ((unused)),  
+static void java_setFieldByte (JNIEnv* env, jclass,  
                                          jobject targetObject,  
                                          jclass declaringClass, 
                                          jstring fieldName,  
@@ -206,17 +206,17 @@ static void java_setFieldByte (JNIEnv* env, jclass clazz __attribute__ ((unused)
     if(targetObject == NULL) {
         return;
     }
-    fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "B");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    fid = env->GetFieldID(declaringClass, fieldNameInC, "B");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /* Two options now. Maybe getFieldID caused an exception, or maybe it returned the real value */
     if(fid != 0) {
-        (*env)->SetByteField(env, targetObject, fid, newValue);
+        env->SetByteField(targetObject, fid, newValue);
     }
 }
 
-static void java_setFieldObj (JNIEnv* env, jclass clazz __attribute__ ((unused)),
+static void java_setFieldObj (JNIEnv* env, jclass,
                                             jobject targetObject,
                                             jclass declaringClass,
                                             jstring fieldName,
@@ -227,19 +227,19 @@ static void java_setFieldObj (JNIEnv* env, jclass clazz __attribute__ ((unused))
     if(targetObject == NULL) {
         return;
     }
-    fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    fieldTypeNameInC = (*env)->GetStringUTFChars(env, fieldTypeName, NULL);
-    fid = (*env)->GetFieldID(env, declaringClass, 
+    fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    fieldTypeNameInC = env->GetStringUTFChars(fieldTypeName, NULL);
+    fid = env->GetFieldID(declaringClass, 
             fieldNameInC, fieldTypeNameInC);
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
-    (*env)->ReleaseStringUTFChars(env, fieldTypeName, fieldTypeNameInC);
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
+    env->ReleaseStringUTFChars(fieldTypeName, fieldTypeNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused an exception, 
      * or maybe it returned the real value 
      */
     if(fid != 0) {
-        (*env)->SetObjectField(env, targetObject, fid, newValue);
+        env->SetObjectField(targetObject, fid, newValue);
     }
 }
 
diff --git a/luni/src/main/native/java_io_ObjectOutputStream.c b/luni/src/main/native/java_io_ObjectOutputStream.cpp
index 9294f16..791e041 100644
--- a/luni/src/main/native/java_io_ObjectOutputStream.c
+++ b/luni/src/main/native/java_io_ObjectOutputStream.cpp
@@ -17,13 +17,13 @@
 
 #include "JNIHelp.h"
 
-static jlong java_getFieldLong(JNIEnv * env, jclass clazz __attribute__ ((unused)),
+static jlong java_getFieldLong(JNIEnv * env, jclass,
                                               jobject targetObject,
                                               jclass declaringClass,
                                               jstring fieldName) {
-    const char *fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    jfieldID fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "J");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    const char *fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    jfieldID fid = env->GetFieldID(declaringClass, fieldNameInC, "J");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused an exception, 
@@ -33,17 +33,17 @@ static jlong java_getFieldLong(JNIEnv * env, jclass clazz __attribute__ ((unused
     	// Field not found. I believe we must throw an exception here
         return (jlong) 0L;
     } else {
-        return (*env)->GetLongField (env, targetObject, fid);
+        return env->GetLongField(targetObject, fid);
     }
 }
 
-static jshort java_getFieldShort(JNIEnv* env, jclass clazz __attribute__ ((unused)),
+static jshort java_getFieldShort(JNIEnv* env, jclass,
                                                jobject targetObject,
                                                jclass declaringClass,
                                                jstring fieldName) {
-    const char *fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    jfieldID fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "S");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    const char *fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    jfieldID fid = env->GetFieldID(declaringClass, fieldNameInC, "S");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused an exception, 
@@ -53,17 +53,17 @@ static jshort java_getFieldShort(JNIEnv* env, jclass clazz __attribute__ ((unuse
         // Field not found. I believe we must throw an exception here
         return (jshort) 0;
     } else {
-        return (*env)->GetShortField (env, targetObject, fid);
+        return env->GetShortField(targetObject, fid);
     }
 }
 
-static jdouble java_getFieldDouble(JNIEnv* env, jclass clazz __attribute__ ((unused)),
+static jdouble java_getFieldDouble(JNIEnv* env, jclass,
                                                 jobject targetObject,
                                                 jclass declaringClass,
                                                 jstring fieldName) {
-    const char *fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    jfieldID fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "D");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    const char *fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    jfieldID fid = env->GetFieldID(declaringClass, fieldNameInC, "D");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused an exception, 
@@ -73,17 +73,17 @@ static jdouble java_getFieldDouble(JNIEnv* env, jclass clazz __attribute__ ((unu
         // Field not found. I believe we must throw an exception here
         return (jdouble) 0.0;
     } else {
-        return (*env)->GetDoubleField (env, targetObject, fid);
+        return env->GetDoubleField(targetObject, fid);
     }
 }
 
-static jboolean java_getFieldBool(JNIEnv* env, jclass clazz __attribute__ ((unused)),
+static jboolean java_getFieldBool(JNIEnv* env, jclass,
                                               jobject targetObject,
                                               jclass declaringClass,
                                               jstring fieldName) {
-    const char *fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    jfieldID fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "Z");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    const char *fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    jfieldID fid = env->GetFieldID(declaringClass, fieldNameInC, "Z");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused an exception, 
@@ -93,17 +93,17 @@ static jboolean java_getFieldBool(JNIEnv* env, jclass clazz __attribute__ ((unus
         // Field not found. I believe we must throw an exception here
         return (jboolean) 0;
     } else {
-        return (*env)->GetBooleanField (env, targetObject, fid);
+        return env->GetBooleanField(targetObject, fid);
     }
 }
 
-static jbyte java_getFieldByte(JNIEnv* env, jclass clazz __attribute__ ((unused)),
+static jbyte java_getFieldByte(JNIEnv* env, jclass,
                                               jobject targetObject,
                                               jclass declaringClass,
                                               jstring fieldName) {
-    const char *fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    jfieldID fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "B");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    const char *fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    jfieldID fid = env->GetFieldID(declaringClass, fieldNameInC, "B");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused an exception, 
@@ -113,17 +113,17 @@ static jbyte java_getFieldByte(JNIEnv* env, jclass clazz __attribute__ ((unused)
         // Field not found. I believe we must throw an exception here
         return (jbyte) 0;
     } else {
-        return (*env)->GetByteField (env, targetObject, fid);
+        return env->GetByteField(targetObject, fid);
     }
 }
 
-static jfloat java_getFieldFloat(JNIEnv* env, jclass clazz __attribute__ ((unused)),
+static jfloat java_getFieldFloat(JNIEnv* env, jclass,
                                                jobject targetObject,
                                                jclass declaringClass,
                                                jstring fieldName) {
-    const char *fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    jfieldID fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "F");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    const char *fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    jfieldID fid = env->GetFieldID(declaringClass, fieldNameInC, "F");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused an exception, 
@@ -134,18 +134,18 @@ static jfloat java_getFieldFloat(JNIEnv* env, jclass clazz __attribute__ ((unuse
         return (jfloat) 0.0f;
     }
     else {
-        return (*env)->GetFloatField (env, targetObject, fid);
+        return env->GetFloatField(targetObject, fid);
     }
 
 }
 
-static jchar java_getFieldChar(JNIEnv* env, jclass clazz __attribute__ ((unused)),
+static jchar java_getFieldChar(JNIEnv* env, jclass,
                                               jobject targetObject,
                                               jclass declaringClass,
                                               jstring fieldName) {
-    const char *fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    jfieldID fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "C");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    const char *fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    jfieldID fid = env->GetFieldID(declaringClass, fieldNameInC, "C");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused an exception, 
@@ -155,22 +155,22 @@ static jchar java_getFieldChar(JNIEnv* env, jclass clazz __attribute__ ((unused)
         // Field not found. I believe we must throw an exception here
         return (jchar) 0;
     } else  {
-        return (*env)->GetCharField(env, targetObject, fid);
+        return env->GetCharField(targetObject, fid);
     }
 }
 
-static jobject java_getFieldObj(JNIEnv* env, jclass clazz __attribute__ ((unused)),
+static jobject java_getFieldObj(JNIEnv* env, jclass,
                                              jobject targetObject,
                                              jclass declaringClass,
                                              jstring fieldName,
                                              jstring fieldTypeName) {
-    const char *fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
+    const char *fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
     const char *fieldTypeNameInC =
-    (*env)->GetStringUTFChars(env, fieldTypeName, NULL);
-    jfieldID fid = (*env)->GetFieldID(env, declaringClass, 
+    env->GetStringUTFChars(fieldTypeName, NULL);
+    jfieldID fid = env->GetFieldID(declaringClass, 
             fieldNameInC, fieldTypeNameInC);
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
-    (*env)->ReleaseStringUTFChars(env, fieldTypeName, fieldTypeNameInC);
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
+    env->ReleaseStringUTFChars(fieldTypeName, fieldTypeNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused an exception,
@@ -180,17 +180,17 @@ static jobject java_getFieldObj(JNIEnv* env, jclass clazz __attribute__ ((unused
         // Field not found. I believe we must throw an exception here
         return (jobject) 0;
     } else {
-        return (*env)->GetObjectField (env, targetObject, fid);
+        return env->GetObjectField(targetObject, fid);
     }
 }
 
-static jint java_getFieldInt(JNIEnv* env, jclass clazz __attribute__ ((unused)),
+static jint java_getFieldInt(JNIEnv* env, jclass,
                                              jobject targetObject,
                                              jclass declaringClass,
                                              jstring fieldName) {
-    const char *fieldNameInC = (*env)->GetStringUTFChars(env, fieldName, NULL);
-    jfieldID fid = (*env)->GetFieldID(env, declaringClass, fieldNameInC, "I");
-    (*env)->ReleaseStringUTFChars(env, fieldName, fieldNameInC);
+    const char *fieldNameInC = env->GetStringUTFChars(fieldName, NULL);
+    jfieldID fid = env->GetFieldID(declaringClass, fieldNameInC, "I");
+    env->ReleaseStringUTFChars(fieldName, fieldNameInC);
 
     /* 
      * Two options now. Maybe getFieldID caused 
@@ -200,7 +200,7 @@ static jint java_getFieldInt(JNIEnv* env, jclass clazz __attribute__ ((unused)),
        // Field not found. I believe we must throw an exception here
         return (jint) 0;
     } else {
-        return (*env)->GetIntField(env, targetObject, fid);
+        return env->GetIntField(targetObject, fid);
     }
 }
 
diff --git a/luni/src/main/native/java_io_ObjectStreamClass.c b/luni/src/main/native/java_io_ObjectStreamClass.cpp
index fc442b3..666692d 100644
--- a/luni/src/main/native/java_io_ObjectStreamClass.c
+++ b/luni/src/main/native/java_io_ObjectStreamClass.cpp
@@ -17,78 +17,78 @@
 
 #include "JNIHelp.h"
 
-static jobject java_io_osc_getFieldSignature(JNIEnv* env, jclass clazz __attribute__ ((unused)),
+static jobject java_io_osc_getFieldSignature(JNIEnv* env, jclass,
                                                   jobject reflectField) {
     jclass lookupClass;
     jmethodID mid;
 
-    lookupClass = (*env)->FindClass(env, "java/lang/reflect/Field");
+    lookupClass = env->FindClass("java/lang/reflect/Field");
     if(!lookupClass) {
         return NULL;
     }
 
-    mid = (*env)->GetMethodID(env, lookupClass, "getSignature",
+    mid = env->GetMethodID(lookupClass, "getSignature",
             "()Ljava/lang/String;");
     if(!mid)
     {
         return NULL;
     }
 
-    jclass fieldClass = (*env)->GetObjectClass(env, reflectField);
+    jclass fieldClass = env->GetObjectClass(reflectField);
     
-    return (*env)->CallNonvirtualObjectMethod(env, reflectField, 
+    return env->CallNonvirtualObjectMethod(reflectField, 
             fieldClass, mid);
 }
 
-static jobject java_io_osc_getMethodSignature(JNIEnv* env, jclass clazz __attribute__ ((unused)),
+static jobject java_io_osc_getMethodSignature(JNIEnv* env, jclass,
                                                    jobject reflectMethod)
 {
     jclass lookupClass;
     jmethodID mid;
 
-    lookupClass = (*env)->FindClass(env, "java/lang/reflect/Method");
+    lookupClass = env->FindClass("java/lang/reflect/Method");
     if(!lookupClass) {
         return NULL;
     }
 
-    mid = (*env)->GetMethodID(env, lookupClass, "getSignature",
+    mid = env->GetMethodID(lookupClass, "getSignature",
             "()Ljava/lang/String;");
     if(!mid) {
         return NULL;
     }
   
-    jclass methodClass = (*env)->GetObjectClass(env, reflectMethod);
-    return (*env)->CallNonvirtualObjectMethod(env, reflectMethod, 
+    jclass methodClass = env->GetObjectClass(reflectMethod);
+    return env->CallNonvirtualObjectMethod(reflectMethod, 
             methodClass, mid);
 }
 
 static jobject java_io_osc_getConstructorSignature(JNIEnv* env,
-                                                        jclass clazz __attribute__ ((unused)),
+                                                        jclass,
                                                         jobject
                                                         reflectConstructor)
 {
     jclass lookupClass;
     jmethodID mid;
 
-    lookupClass = (*env)->FindClass(env, "java/lang/reflect/Constructor");
+    lookupClass = env->FindClass("java/lang/reflect/Constructor");
     if(!lookupClass) {
         return NULL;
     }
 
-    mid = (*env)->GetMethodID(env, lookupClass, "getSignature",
+    mid = env->GetMethodID(lookupClass, "getSignature",
             "()Ljava/lang/String;");
     if(!mid) {
         return NULL;
     }
 
-    jclass constructorClass = (*env)->GetObjectClass(env, reflectConstructor);
-    return (*env)->CallNonvirtualObjectMethod(env, reflectConstructor,
+    jclass constructorClass = env->GetObjectClass(reflectConstructor);
+    return env->CallNonvirtualObjectMethod(reflectConstructor,
                                              constructorClass, mid);
 }
 
-static jboolean java_io_osc_hasClinit(JNIEnv * env, jclass clazz, jobject targetClass) {
-    jmethodID mid = (*env)->GetStaticMethodID(env, targetClass, "<clinit>", "()V");
-    (*env)->ExceptionClear(env);
+static jboolean java_io_osc_hasClinit(JNIEnv * env, jclass, jclass targetClass) {
+    jmethodID mid = env->GetStaticMethodID(targetClass, "<clinit>", "()V");
+    env->ExceptionClear();
     return (mid != 0);
 }
 
diff --git a/luni/src/main/native/java_lang_Double.c b/luni/src/main/native/java_lang_Double.cpp
index 6e4041f..65576f7 100644
--- a/luni/src/main/native/java_lang_Double.c
+++ b/luni/src/main/native/java_lang_Double.cpp
@@ -21,7 +21,7 @@ typedef union {
 /*
  * public static native long doubleToLongBits(double value)
  */
-static jlong doubleToLongBits(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble val)
+static jlong doubleToLongBits(JNIEnv*, jclass, jdouble val)
 {
     Double   d;
 
@@ -39,7 +39,7 @@ static jlong doubleToLongBits(JNIEnv* env __attribute__ ((unused)), jclass clazz
 /*
  * public static native long doubleToRawLongBits(double value)
  */
-static jlong doubleToRawLongBits(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble val)
+static jlong doubleToRawLongBits(JNIEnv*, jclass, jdouble val)
 {
     Double   d;
 
@@ -51,7 +51,7 @@ static jlong doubleToRawLongBits(JNIEnv* env __attribute__ ((unused)), jclass cl
 /*
  * public static native double longBitsToDouble(long bits)
  */
-static jdouble longBitsToDouble(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jlong val)
+static jdouble longBitsToDouble(JNIEnv*, jclass, jlong val)
 {
     Double   d;
 
@@ -61,9 +61,9 @@ static jdouble longBitsToDouble(JNIEnv* env __attribute__ ((unused)), jclass cla
 }
 
 static JNINativeMethod gMethods[] = {
-    { "doubleToLongBits",       "(D)J",     doubleToLongBits },
-    { "doubleToRawLongBits",    "(D)J",     doubleToRawLongBits },
-    { "longBitsToDouble",       "(J)D",     longBitsToDouble },
+  { "doubleToLongBits",       "(D)J",     (void*)doubleToLongBits },
+  { "doubleToRawLongBits",    "(D)J",     (void*)doubleToRawLongBits },
+  { "longBitsToDouble",       "(J)D",     (void*)longBitsToDouble },
 };
 int register_java_lang_Double(JNIEnv* env) {
     return jniRegisterNativeMethods(env, "java/lang/Double", gMethods, NELEM(gMethods));
diff --git a/luni/src/main/native/java_lang_Float.c b/luni/src/main/native/java_lang_Float.cpp
index 67b6b5d..08f5464 100644
--- a/luni/src/main/native/java_lang_Float.c
+++ b/luni/src/main/native/java_lang_Float.cpp
@@ -29,7 +29,7 @@ static int IsNaN(unsigned bits)
 /*
  * public static native int floatToIntBits(float value)
  */
-static jint floatToIntBits(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jfloat val)
+static jint floatToIntBits(JNIEnv*, jclass, jfloat val)
 {
     Float   f;
 
@@ -47,7 +47,7 @@ static jint floatToIntBits(JNIEnv* env __attribute__ ((unused)), jclass clazz __
 /*
  * public static native int floatToRawBits(float value)
  */
-static jint floatToRawBits(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jfloat val)
+static jint floatToRawBits(JNIEnv*, jclass, jfloat val)
 {
     Float   f;
 
@@ -59,7 +59,7 @@ static jint floatToRawBits(JNIEnv* env __attribute__ ((unused)), jclass clazz __
 /*
  * public static native float intBitsToFloat(int bits)
  */
-static jfloat intBitsToFloat(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jint val)
+static jfloat intBitsToFloat(JNIEnv*, jclass, jint val)
 {
     Float   f;
 
@@ -69,9 +69,9 @@ static jfloat intBitsToFloat(JNIEnv* env __attribute__ ((unused)), jclass clazz
 }
 
 static JNINativeMethod gMethods[] = {
-    { "floatToIntBits",         "(F)I",     floatToIntBits },
-    { "floatToRawIntBits",      "(F)I",     floatToRawBits },
-    { "intBitsToFloat",         "(I)F",     intBitsToFloat },
+    { "floatToIntBits",         "(F)I",     (void*)floatToIntBits },
+    { "floatToRawIntBits",      "(F)I",     (void*)floatToRawBits },
+    { "intBitsToFloat",         "(I)F",     (void*)intBitsToFloat },
 };
 int register_java_lang_Float(JNIEnv* env) {
     return jniRegisterNativeMethods(env, "java/lang/Float", gMethods, NELEM(gMethods));
diff --git a/luni/src/main/native/java_lang_Math.c b/luni/src/main/native/java_lang_Math.c
deleted file mode 100644
index ae13892..0000000
--- a/luni/src/main/native/java_lang_Math.c
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * Copyright 2006 The Android Open Source Project 
- *
- * Native functions for java.lang.Math.
- */
-#include "jni.h"
-#include "JNIHelp.h"
-
-#include <stdlib.h>
-#include <math.h>
-
-/* native public static double sin(double a); */
-static jdouble jsin(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return sin(a);
-}
-
-/* native public static double cos(double a); */
-static jdouble jcos(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return cos(a);
-}
-
-/* native public static double tan(double a); */
-static jdouble jtan(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return tan(a);
-}
-
-/* native public static double asin(double a); */
-static jdouble jasin(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return asin(a);
-}
-
-/* native public static double acos(double a); */
-static jdouble jacos(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return acos(a);
-}
-
-/* native public static double atan(double a); */
-static jdouble jatan(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return atan(a);
-}
-
-/* native public static double exp(double a); */
-static jdouble jexp(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return exp(a);
-}
-
-/* native public static double log(double a); */
-static jdouble jlog(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return log(a);
-}
-
-/* native public static double sqrt(double a); */
-static jdouble jsqrt(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return sqrt(a);
-}
-
-/* native public static double IEEEremainder(double a, double b); */
-static jdouble jieee_remainder(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a, jdouble b)
-{
-    return remainder(a, b);
-}
-
-/* native public static double floor(double a); */
-static jdouble jfloor(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return floor(a);
-}
-
-/* native public static double ceil(double a); */
-static jdouble jceil(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ceil(a);
-}
-
-/* native public static double rint(double a); */
-static jdouble jrint(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return rint(a);
-}
-
-/* native public static double atan2(double a, double b); */
-static jdouble jatan2(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a, jdouble b)
-{
-    return atan2(a, b);
-}
-
-/* native public static double pow(double a, double b); */
-static jdouble jpow(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a, jdouble b)
-{
-    return pow(a, b);
-}
-
-/* native public static double sinh(double a); */
-static jdouble jsinh(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return sinh(a);
-}
-
-/* native public static double tanh(double a); */
-static jdouble jtanh(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return tanh(a);
-}
-
-/* native public static double cosh(double a); */
-static jdouble jcosh(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return cosh(a);
-}
-
-/* native public static double log10(double a); */
-static jdouble jlog10(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return log10(a);
-}
-
-/* native public static double cbrt(double a); */
-static jdouble jcbrt(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return cbrt(a);
-}
-
-/* native public static double expm1(double a); */
-static jdouble jexpm1(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return expm1(a);
-}
-
-/* native public static double hypot(double a, double b); */
-static jdouble jhypot(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a, jdouble b)
-{
-    return hypot(a, b);
-}
-
-/* native public static double log1p(double a); */
-static jdouble jlog1p(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return log1p(a);
-}
-
-/* native public static double nextafter(double a, double b); */
-static jdouble jnextafter(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a, jdouble b)
-{
-    return nextafter(a, b);
-}
-
-/* native public static float nextafterf(float a, float b); */
-static jfloat jnextafterf(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jfloat a, jfloat b)
-{
-    return nextafterf(a, b);
-}
-
-static jdouble copySign(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), 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* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), 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", jieee_remainder },
-    { "acos",   "(D)D", jacos },
-    { "asin",   "(D)D", jasin },
-    { "atan",   "(D)D", jatan },
-    { "atan2",  "(DD)D", jatan2 },
-    { "cbrt",   "(D)D", jcbrt },
-    { "ceil",   "(D)D", jceil },
-    { "copySign",  "(DD)D", copySign },
-    { "copySign",  "(FF)F", copySign_f },
-    { "cos",    "(D)D", jcos },
-    { "cosh",   "(D)D", jcosh },
-    { "exp",    "(D)D", jexp },
-    { "expm1",  "(D)D", jexpm1 },
-    { "floor",  "(D)D", jfloor },
-    { "hypot",  "(DD)D", jhypot },
-    { "log",    "(D)D", jlog },
-    { "log10",  "(D)D", jlog10 },
-    { "log1p",  "(D)D", jlog1p },
-    { "nextafter",  "(DD)D", jnextafter },
-    { "nextafterf",  "(FF)F", jnextafterf },
-    { "pow",    "(DD)D", jpow },
-    { "rint",   "(D)D", jrint },
-    { "sin",    "(D)D", jsin },
-    { "sinh",   "(D)D", jsinh },
-    { "sqrt",   "(D)D", jsqrt },
-    { "tan",    "(D)D", jtan },
-    { "tanh",   "(D)D", jtanh },
-};
-
-int register_java_lang_Math(JNIEnv* env) {
-    return jniRegisterNativeMethods(env, "java/lang/Math", gMethods, NELEM(gMethods));
-}
diff --git a/luni/src/main/native/java_lang_Math.cpp b/luni/src/main/native/java_lang_Math.cpp
new file mode 100644
index 0000000..7fdce6f
--- /dev/null
+++ b/luni/src/main/native/java_lang_Math.cpp
@@ -0,0 +1,204 @@
+/*
+ * Copyright 2006 The Android Open Source Project 
+ *
+ * Native functions for java.lang.Math.
+ */
+#include "jni.h"
+#include "JNIHelp.h"
+
+#include <stdlib.h>
+#include <math.h>
+
+/* native public static double sin(double a); */
+static jdouble jsin(JNIEnv*, jclass, jdouble a)
+{
+    return sin(a);
+}
+
+/* native public static double cos(double a); */
+static jdouble jcos(JNIEnv*, jclass, jdouble a)
+{
+    return cos(a);
+}
+
+/* native public static double tan(double a); */
+static jdouble jtan(JNIEnv*, jclass, jdouble a)
+{
+    return tan(a);
+}
+
+/* native public static double asin(double a); */
+static jdouble jasin(JNIEnv*, jclass, jdouble a)
+{
+    return asin(a);
+}
+
+/* native public static double acos(double a); */
+static jdouble jacos(JNIEnv*, jclass, jdouble a)
+{
+    return acos(a);
+}
+
+/* native public static double atan(double a); */
+static jdouble jatan(JNIEnv*, jclass, jdouble a)
+{
+    return atan(a);
+}
+
+/* native public static double exp(double a); */
+static jdouble jexp(JNIEnv*, jclass, jdouble a)
+{
+    return exp(a);
+}
+
+/* native public static double log(double a); */
+static jdouble jlog(JNIEnv*, jclass, jdouble a)
+{
+    return log(a);
+}
+
+/* native public static double sqrt(double a); */
+static jdouble jsqrt(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)
+{
+    return remainder(a, b);
+}
+
+/* native public static double floor(double a); */
+static jdouble jfloor(JNIEnv*, jclass, jdouble a)
+{
+    return floor(a);
+}
+
+/* native public static double ceil(double a); */
+static jdouble jceil(JNIEnv*, jclass, jdouble a)
+{
+    return ceil(a);
+}
+
+/* native public static double rint(double a); */
+static jdouble jrint(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)
+{
+    return atan2(a, b);
+}
+
+/* native public static double pow(double a, double b); */
+static jdouble jpow(JNIEnv*, jclass, jdouble a, jdouble b)
+{
+    return pow(a, b);
+}
+
+/* native public static double sinh(double a); */
+static jdouble jsinh(JNIEnv*, jclass, jdouble a)
+{
+    return sinh(a);
+}
+
+/* native public static double tanh(double a); */
+static jdouble jtanh(JNIEnv*, jclass, jdouble a)
+{
+    return tanh(a);
+}
+
+/* native public static double cosh(double a); */
+static jdouble jcosh(JNIEnv*, jclass, jdouble a)
+{
+    return cosh(a);
+}
+
+/* native public static double log10(double a); */
+static jdouble jlog10(JNIEnv*, jclass, jdouble a)
+{
+    return log10(a);
+}
+
+/* native public static double cbrt(double a); */
+static jdouble jcbrt(JNIEnv*, jclass, jdouble a)
+{
+    return cbrt(a);
+}
+
+/* native public static double expm1(double a); */
+static jdouble jexpm1(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)
+{
+    return hypot(a, b);
+}
+
+/* native public static double log1p(double a); */
+static jdouble jlog1p(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)
+{
+    return nextafter(a, b);
+}
+
+/* native public static float nextafterf(float a, float b); */
+static jfloat jnextafterf(JNIEnv*, jclass, jfloat a, jfloat b)
+{
+    return nextafterf(a, b);
+}
+
+static jdouble 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) {
+    // 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 },
+};
+
+int register_java_lang_Math(JNIEnv* env) {
+    return jniRegisterNativeMethods(env, "java/lang/Math", gMethods, NELEM(gMethods));
+}
diff --git a/luni/src/main/native/java_lang_StrictMath.c b/luni/src/main/native/java_lang_StrictMath.c
deleted file mode 100644
index 27773f8..0000000
--- a/luni/src/main/native/java_lang_StrictMath.c
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
- * Copyright 2006 The Android Open Source Project 
- *
- * Native functions for java.lang.StrictMath.
- */
-#include "jni.h"
-#include "JNIHelp.h"
-
-#include <stdlib.h>
-/* This static way is the "best" way to integrate fdlibm without a conflict
- * into the android environment.
- */
-
-#if defined(__P)
-#undef __P
-#endif /* defined(__P) */
-
-#include "../../external/fdlibm/fdlibm.h"
-_LIB_VERSION_TYPE _LIB_VERSION = _IEEE_;
-
-/* native public static double sin(double a); */
-static jdouble jsin(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_sin(a);
-}
-
-/* native public static double cos(double a); */
-static jdouble jcos(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_cos(a);
-}
-
-/* native public static double tan(double a); */
-static jdouble jtan(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_tan(a);
-}
-
-/* native public static double asin(double a); */
-static jdouble jasin(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_asin(a);
-}
-
-/* native public static double acos(double a); */
-static jdouble jacos(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_acos(a);
-}
-
-/* native public static double atan(double a); */
-static jdouble jatan(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_atan(a);
-}
-
-/* native public static double exp(double a); */
-static jdouble jexp(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_exp(a);
-}
-
-/* native public static double log(double a); */
-static jdouble jlog(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_log(a);
-}
-
-/* native public static double sqrt(double a); */
-static jdouble jsqrt2(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_sqrt(a);
-}
-
-/* native public static double IEEEremainder(double a, double b); */
-static jdouble jieee_remainder(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a, jdouble b)
-{
-    return ieee_remainder(a, b);
-}
-
-/* native public static double floor(double a); */
-static jdouble jfloor(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_floor(a);
-}
-
-/* native public static double ceil(double a); */
-static jdouble jceil(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_ceil(a);
-}
-
-/* native public static double rint(double a); */
-static jdouble jrint(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_rint(a);
-}
-
-/* native public static double atan2(double a, double b); */
-static jdouble jatan2(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a, jdouble b)
-{
-    return ieee_atan2(a, b);
-}
-
-/* native public static double pow(double a, double b); */
-static jdouble jpow(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a, jdouble b)
-{
-    return ieee_pow(a,b);
-}
-
-/* native public static double sinh(double a); */
-static jdouble jsinh(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_sinh(a);
-}
-
-/* native public static double tanh(double a); */
-static jdouble jtanh(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_tanh(a);
-}
-
-/* native public static double cosh(double a); */
-static jdouble jcosh(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_cosh(a);
-}
-
-/* native public static double log10(double a); */
-static jdouble jlog10(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_log10(a);
-}
-
-/* native public static double cbrt(double a); */
-static jdouble jcbrt(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_cbrt(a);
-}
-
-/* native public static double expm1(double a); */
-static jdouble jexpm1(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_expm1(a);
-}
-
-/* native public static double hypot(double a, double b); */
-static jdouble jhypot(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a, jdouble b)
-{
-    return ieee_hypot(a, b);
-}
-
-/* native public static double log1p(double a); */
-static jdouble jlog1p(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a)
-{
-    return ieee_log1p(a);
-}
-
-/* native public static double nextafter(double a, double b); */
-static jdouble jnextafter(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jdouble a, jdouble b)
-{
-    return ieee_nextafter(a, b);
-}
-
-/* native public static float nextafterf(float a, float b); */
-static jfloat jnextafterf(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)), jfloat arg1, jfloat arg2)
-{
-    jint hx = *(jint*)&arg1;
-    jint hy = *(jint*)&arg2;
-
-    if (!(hx&0x7fffffff)) { /* arg1 == 0 */
-      *(jint*)&arg1 = (hy & 0x80000000) | 0x1;
-      return arg1;
-    }
-
-    if((hx > 0) ^ (hx > hy)) { /* |arg1| < |arg2| */
-        hx += 1;
-    } else {
-        hx -= 1;
-    }
-    *(jint*)&arg1 = hx;
-    return arg1;
-}
-
-static JNINativeMethod gMethods[] = {
-    { "IEEEremainder", "(DD)D", jieee_remainder },
-    { "acos",   "(D)D", jacos },
-    { "asin",   "(D)D", jasin },
-    { "atan",   "(D)D", jatan },
-    { "atan2",  "(DD)D", jatan2 },
-    { "cbrt",   "(D)D", jcbrt },
-    { "ceil",   "(D)D", jceil },
-    { "cos",    "(D)D", jcos },
-    { "cosh",   "(D)D", jcosh },
-    { "exp",    "(D)D", jexp },
-    { "expm1",  "(D)D", jexpm1 },
-    { "floor",  "(D)D", jfloor },
-    { "hypot",  "(DD)D", jhypot },
-    { "log",    "(D)D", jlog },
-    { "log10",  "(D)D", jlog10 },
-    { "log1p",  "(D)D", jlog1p },
-    { "nextafter",  "(DD)D", jnextafter },
-    { "nextafterf",  "(FF)F", jnextafterf },
-    { "pow",    "(DD)D", jpow },
-    { "rint",   "(D)D", jrint },
-    { "sin",    "(D)D", jsin },
-    { "sinh",   "(D)D", jsinh },
-    { "sqrt",   "(D)D", jsqrt2 },
-    { "tan",    "(D)D", jtan },
-    { "tanh",   "(D)D", jtanh },
-};
-
-int register_java_lang_StrictMath(JNIEnv* env) {
-    return jniRegisterNativeMethods(env, "java/lang/StrictMath", gMethods, NELEM(gMethods));
-}
diff --git a/luni/src/main/native/java_lang_StrictMath.cpp b/luni/src/main/native/java_lang_StrictMath.cpp
new file mode 100644
index 0000000..0077d45
--- /dev/null
+++ b/luni/src/main/native/java_lang_StrictMath.cpp
@@ -0,0 +1,217 @@
+/*
+ * Copyright 2006 The Android Open Source Project 
+ *
+ * Native functions for java.lang.StrictMath.
+ */
+#include "jni.h"
+#include "JNIHelp.h"
+
+#include <stdlib.h>
+/* This static way is the "best" way to integrate fdlibm without a conflict
+ * into the android environment.
+ */
+
+#if defined(__P)
+#undef __P
+#endif /* defined(__P) */
+
+extern "C" {
+#include "../../external/fdlibm/fdlibm.h"
+}
+_LIB_VERSION_TYPE _LIB_VERSION = _IEEE_;
+
+/* native public static double sin(double a); */
+static jdouble jsin(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_sin(a);
+}
+
+/* native public static double cos(double a); */
+static jdouble jcos(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_cos(a);
+}
+
+/* native public static double tan(double a); */
+static jdouble jtan(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_tan(a);
+}
+
+/* native public static double asin(double a); */
+static jdouble jasin(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_asin(a);
+}
+
+/* native public static double acos(double a); */
+static jdouble jacos(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_acos(a);
+}
+
+/* native public static double atan(double a); */
+static jdouble jatan(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_atan(a);
+}
+
+/* native public static double exp(double a); */
+static jdouble jexp(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_exp(a);
+}
+
+/* native public static double log(double a); */
+static jdouble jlog(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_log(a);
+}
+
+/* native public static double sqrt(double a); */
+static jdouble jsqrt2(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_sqrt(a);
+}
+
+/* native public static double IEEEremainder(double a, double b); */
+static jdouble jieee_remainder(JNIEnv*, jclass, jdouble a, jdouble b)
+{
+    return ieee_remainder(a, b);
+}
+
+/* native public static double floor(double a); */
+static jdouble jfloor(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_floor(a);
+}
+
+/* native public static double ceil(double a); */
+static jdouble jceil(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_ceil(a);
+}
+
+/* native public static double rint(double a); */
+static jdouble jrint(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_rint(a);
+}
+
+/* native public static double atan2(double a, double b); */
+static jdouble jatan2(JNIEnv*, jclass, jdouble a, jdouble b)
+{
+    return ieee_atan2(a, b);
+}
+
+/* native public static double pow(double a, double b); */
+static jdouble jpow(JNIEnv*, jclass, jdouble a, jdouble b)
+{
+    return ieee_pow(a,b);
+}
+
+/* native public static double sinh(double a); */
+static jdouble jsinh(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_sinh(a);
+}
+
+/* native public static double tanh(double a); */
+static jdouble jtanh(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_tanh(a);
+}
+
+/* native public static double cosh(double a); */
+static jdouble jcosh(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_cosh(a);
+}
+
+/* native public static double log10(double a); */
+static jdouble jlog10(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_log10(a);
+}
+
+/* native public static double cbrt(double a); */
+static jdouble jcbrt(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_cbrt(a);
+}
+
+/* native public static double expm1(double a); */
+static jdouble jexpm1(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_expm1(a);
+}
+
+/* native public static double hypot(double a, double b); */
+static jdouble jhypot(JNIEnv*, jclass, jdouble a, jdouble b)
+{
+    return ieee_hypot(a, b);
+}
+
+/* native public static double log1p(double a); */
+static jdouble jlog1p(JNIEnv*, jclass, jdouble a)
+{
+    return ieee_log1p(a);
+}
+
+/* native public static double nextafter(double a, double b); */
+static jdouble jnextafter(JNIEnv*, jclass, jdouble a, jdouble b)
+{
+    return ieee_nextafter(a, b);
+}
+
+/* native public static float nextafterf(float a, float b); */
+static jfloat jnextafterf(JNIEnv*, jclass, jfloat arg1, jfloat arg2)
+{
+    jint hx = *(jint*)&arg1;
+    jint hy = *(jint*)&arg2;
+
+    if (!(hx&0x7fffffff)) { /* arg1 == 0 */
+      *(jint*)&arg1 = (hy & 0x80000000) | 0x1;
+      return arg1;
+    }
+
+    if((hx > 0) ^ (hx > hy)) { /* |arg1| < |arg2| */
+        hx += 1;
+    } else {
+        hx -= 1;
+    }
+    *(jint*)&arg1 = hx;
+    return arg1;
+}
+
+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 },
+    { "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*)jsqrt2 },
+    { "tan",           "(D)D",  (void*)jtan },
+    { "tanh",          "(D)D",  (void*)jtanh },
+};
+
+int register_java_lang_StrictMath(JNIEnv* env) {
+    return jniRegisterNativeMethods(env, "java/lang/StrictMath", gMethods, NELEM(gMethods));
+}
diff --git a/luni/src/main/native/org_apache_harmony_luni_util_NumberConvert.c b/luni/src/main/native/org_apache_harmony_luni_util_NumberConvert.cpp
index 496fe6f..3ea8bdc 100644
--- a/luni/src/main/native/org_apache_harmony_luni_util_NumberConvert.c
+++ b/luni/src/main/native/org_apache_harmony_luni_util_NumberConvert.cpp
@@ -26,20 +26,6 @@
 #define USE_LL
 #endif
 
-JNIEXPORT void JNICALL
-Java_org_apache_harmony_luni_util_NumberConverter_bigIntDigitGeneratorInstImpl (JNIEnv *
-                                                                    env,
-                                                                    jobject
-                                                                    inst,
-                                                                    jlong f,
-                                                                    jint e,
-                                                                    jboolean
-                                                                    isDenormalized,
-                                                                    jboolean
-                                                                    mantissaIsZero,
-                                                                    jint p);
-
-
 #define INV_LOG_OF_TEN_BASE_2 (0.30102999566398114) /* Local */
 #define ERROR_OCCURED(x) (HIGH_I32_FROM_VAR(x) < 0) /* Local */
 
@@ -80,18 +66,14 @@ Java_org_apache_harmony_luni_util_NumberConverter_bigIntDigitGeneratorInstImpl (
  * 
  */
 JNIEXPORT void JNICALL
-Java_org_apache_harmony_luni_util_NumberConverter_bigIntDigitGeneratorInstImpl (JNIEnv *
-                                                                    env,
-                                                                    jobject
-                                                                    inst,
-                                                                    jlong f,
-                                                                    jint e,
-                                                                    jboolean
-                                                                    isDenormalized,
-                                                                    jboolean
-                                                                    mantissaIsZero,
-                                                                    jint p)
-{
+Java_org_apache_harmony_luni_util_NumberConverter_bigIntDigitGeneratorInstImpl (
+        JNIEnv* env,
+        jobject inst,
+        jlong f,
+        jint e,
+        jboolean isDenormalized,
+        jboolean mantissaIsZero,
+        jint p) {
   int RLength, SLength, TempLength, mplus_Length, mminus_Length;
   int high, low, i;
   jint k, firstK, U;
@@ -204,10 +186,10 @@ Java_org_apache_harmony_luni_util_NumberConverter_bigIntDigitGeneratorInstImpl (
         --mminus_Length;
     }
 
-  clazz = (*env)->GetObjectClass (env, inst);
-  fid = (*env)->GetFieldID (env, clazz, "uArray", "[I");
-  uArrayObject = (jintArray) (*env)->GetObjectField (env, inst, fid);
-  uArray = (*env)->GetIntArrayElements (env, uArrayObject, 0);
+  clazz = env->GetObjectClass(inst);
+  fid = env->GetFieldID(clazz, "uArray", "[I");
+  uArrayObject = (jintArray) env->GetObjectField(inst, fid);
+  uArray = env->GetIntArrayElements(uArrayObject, 0);
 
   getCount = setCount = 0;
   do
@@ -261,21 +243,21 @@ Java_org_apache_harmony_luni_util_NumberConverter_bigIntDigitGeneratorInstImpl (
   else
     uArray[setCount++] = U + 1;
 
-  (*env)->ReleaseIntArrayElements (env, uArrayObject, uArray, 0);
+  env->ReleaseIntArrayElements(uArrayObject, uArray, 0);
 
-  fid = (*env)->GetFieldID (env, clazz, "setCount", "I");
-  (*env)->SetIntField (env, inst, fid, setCount);
+  fid = env->GetFieldID(clazz, "setCount", "I");
+  env->SetIntField(inst, fid, setCount);
 
-  fid = (*env)->GetFieldID (env, clazz, "getCount", "I");
-  (*env)->SetIntField (env, inst, fid, getCount);
+  fid = env->GetFieldID(clazz, "getCount", "I");
+  env->SetIntField(inst, fid, getCount);
 
-  fid = (*env)->GetFieldID (env, clazz, "firstK", "I");
-  (*env)->SetIntField (env, inst, fid, firstK);
+  fid = env->GetFieldID(clazz, "firstK", "I");
+  env->SetIntField(inst, fid, firstK);
 }
 
 static JNINativeMethod gMethods[] = {
     { "bigIntDigitGeneratorInstImpl", "(JIZZI)V"              ,
-        Java_org_apache_harmony_luni_util_NumberConverter_bigIntDigitGeneratorInstImpl },
+      (void*)Java_org_apache_harmony_luni_util_NumberConverter_bigIntDigitGeneratorInstImpl },
 };
 int register_org_apache_harmony_luni_util_NumberConvert(JNIEnv *env) {
     return jniRegisterNativeMethods(env, "org/apache/harmony/luni/util/NumberConverter",
diff --git a/luni/src/main/native/org_apache_harmony_luni_util_fltparse.c b/luni/src/main/native/org_apache_harmony_luni_util_fltparse.cpp
index 2e7f1c1..e7f3c5b 100644
--- a/luni/src/main/native/org_apache_harmony_luni_util_fltparse.c
+++ b/luni/src/main/native/org_apache_harmony_luni_util_fltparse.cpp
@@ -351,7 +351,7 @@ createFloat1 (JNIEnv* env, U_64 * f, IDATA length, jint e)
  * then return the original approximation.
  */
 jfloat
-floatAlgorithm (JNIEnv* env __attribute__ ((unused)), U_64 * f, IDATA length, jint e, jfloat z)
+floatAlgorithm (JNIEnv*, U_64 * f, IDATA length, jint e, jfloat z)
 {
   U_64 m;
   IDATA k, comparison, comparison2;
@@ -539,13 +539,13 @@ OutOfMemory:
 
 JNIEXPORT jfloat JNICALL
 Java_org_apache_harmony_luni_util_FloatingPointParser_parseFltImpl (JNIEnv* env,
-                                                        jclass clazz __attribute__ ((unused)),
+                                                        jclass,
                                                         jstring s, jint e)
 {
   jfloat flt;
-  const char *str = (*env)->GetStringUTFChars (env, s, 0);
+  const char *str = env->GetStringUTFChars(s, 0);
   flt = createFloat (env, str, e);
-  (*env)->ReleaseStringUTFChars (env, s, str);
+  env->ReleaseStringUTFChars(s, str);
 
   if (((I_32) FLOAT_TO_INTBITS (flt)) >= 0)
     {
@@ -565,13 +565,13 @@ Java_org_apache_harmony_luni_util_FloatingPointParser_parseFltImpl (JNIEnv* env,
 
 JNIEXPORT jdouble JNICALL
 Java_org_apache_harmony_luni_util_FloatingPointParser_parseDblImpl (JNIEnv* env,
-                                                        jclass clazz __attribute__ ((unused)),
+                                                        jclass,
                                                         jstring s, jint e)
 {
   jdouble dbl;
-  const char *str = (*env)->GetStringUTFChars (env, s, 0);
-  dbl = createDouble (env, str, e);
-  (*env)->ReleaseStringUTFChars (env, s, str);
+  const char *str = env->GetStringUTFChars(s, 0);
+  dbl = createDouble(env, str, e);
+  env->ReleaseStringUTFChars(s, str);
 
   if (!ERROR_OCCURED (dbl))
     {
@@ -591,9 +591,9 @@ Java_org_apache_harmony_luni_util_FloatingPointParser_parseDblImpl (JNIEnv* env,
 
 static JNINativeMethod gMethods[] = {
     { "parseFltImpl", "(Ljava/lang/String;I)F",
-        Java_org_apache_harmony_luni_util_FloatingPointParser_parseFltImpl },
+        (void*)Java_org_apache_harmony_luni_util_FloatingPointParser_parseFltImpl },
     { "parseDblImpl", "(Ljava/lang/String;I)D",
-        Java_org_apache_harmony_luni_util_FloatingPointParser_parseDblImpl },
+        (void*)Java_org_apache_harmony_luni_util_FloatingPointParser_parseDblImpl },
 };
 int register_org_apache_harmony_luni_util_fltparse(JNIEnv *env) {
     return jniRegisterNativeMethods(env, "org/apache/harmony/luni/util/FloatingPointParser",
diff --git a/luni/src/main/native/sub.mk b/luni/src/main/native/sub.mk
index 513171c..59f82a7 100644
--- a/luni/src/main/native/sub.mk
+++ b/luni/src/main/native/sub.mk
@@ -15,19 +15,19 @@ LOCAL_SRC_FILES := \
 	NativeRegEx.cpp \
 	Register.cpp \
 	UCharacter.cpp \
-	cbigint.c \
-	commonDblParce.c \
+	cbigint.cpp \
+	commonDblParce.cpp \
 	java_io_Console.cpp \
 	java_io_File.cpp \
 	java_io_FileDescriptor.c \
-	java_io_ObjectInputStream.c \
-	java_io_ObjectOutputStream.c \
-	java_io_ObjectStreamClass.c \
-	java_lang_Double.c \
-	java_lang_Float.c \
-	java_lang_Math.c \
+	java_io_ObjectInputStream.cpp \
+	java_io_ObjectOutputStream.cpp \
+	java_io_ObjectStreamClass.cpp \
+	java_lang_Double.cpp \
+	java_lang_Float.cpp \
+	java_lang_Math.cpp \
 	java_lang_ProcessManager.cpp \
-	java_lang_StrictMath.c \
+	java_lang_StrictMath.cpp \
 	java_lang_System.cpp \
 	java_net_InetAddress.cpp \
 	java_net_NetworkInterface.cpp \
@@ -38,8 +38,8 @@ LOCAL_SRC_FILES := \
 	org_apache_harmony_luni_platform_OSFileSystem.cpp \
 	org_apache_harmony_luni_platform_OSMemory.cpp \
 	org_apache_harmony_luni_platform_OSNetworkSystem.cpp \
-	org_apache_harmony_luni_util_NumberConvert.c \
-	org_apache_harmony_luni_util_fltparse.c \
+	org_apache_harmony_luni_util_NumberConvert.cpp \
+	org_apache_harmony_luni_util_fltparse.cpp \
 	org_apache_harmony_xml_ExpatParser.cpp \
 	org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp