Moving most libcore .c files to .cpp

This change moves most of the libcore .c files to .cpp enough for them
to compile. This was largely motivated by the desire to avoid using
things like __attribute__ ((unused)) in .c files to supress warnings
in a recent change.

Change-Id: Ib967d9e16764ff805764e81362f945332080a06c

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