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

19 files changed, 674 insertions, 698 deletions

diff --git a/dalvik/src/main/native/org_apache_harmony_dalvik_NativeTestTarget.c b/dalvik/src/main/native/org_apache_harmony_dalvik_NativeTestTarget.cpp
index 8cef72e..46e18ae 100644
--- a/dalvik/src/main/native/org_apache_harmony_dalvik_NativeTestTarget.c
+++ b/dalvik/src/main/native/org_apache_harmony_dalvik_NativeTestTarget.cpp
@@ -21,7 +21,7 @@
  *
  * For benchmarks, a do-nothing JNI method with no arguments.
  */
-static void emptyJniStaticMethod0(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)))
+static void emptyJniStaticMethod0(JNIEnv*, jclass)
 {
     // This space intentionally left blank.
 }
@@ -32,8 +32,8 @@ static void emptyJniStaticMethod0(JNIEnv* env __attribute__ ((unused)), jclass c
  *
  * For benchmarks, a do-nothing JNI method with six arguments.
  */
-static void emptyJniStaticMethod6(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)),
-    int a __attribute__ ((unused)), int b __attribute__ ((unused)), int c __attribute__ ((unused)), int d __attribute__ ((unused)), int e __attribute__ ((unused)), int f __attribute__ ((unused)))
+static void emptyJniStaticMethod6(JNIEnv*, jclass,
+    int, int, int, int, int, int)
 {
     // This space intentionally left blank.
 }
@@ -44,19 +44,16 @@ static void emptyJniStaticMethod6(JNIEnv* env __attribute__ ((unused)), jclass c
  *
  * For benchmarks, a do-nothing JNI method with six arguments.
  */
-static void emptyJniStaticMethod6L(JNIEnv* env __attribute__ ((unused)), jclass clazz __attribute__ ((unused)),
-    jobject a __attribute__ ((unused)), jarray b __attribute__ ((unused)), jarray c __attribute__ ((unused)), jobject d __attribute__ ((unused)), jarray e __attribute__ ((unused)), jarray f __attribute__ ((unused)))
+static void emptyJniStaticMethod6L(JNIEnv*, jclass,
+    jobject, jarray, jarray, jobject, jarray, jarray)
 {
     // This space intentionally left blank.
 }
 
 static JNINativeMethod gMethods[] = {
-    { "emptyJniStaticMethod0",  "()V",  emptyJniStaticMethod0 },
-    { "emptyJniStaticMethod6",  "(IIIIII)V", emptyJniStaticMethod6 },
-    { "emptyJniStaticMethod6L",
-      "(Ljava/lang/String;[Ljava/lang/String;[[I"
-      "Ljava/lang/Object;[Ljava/lang/Object;[[[[Ljava/lang/Object;)V",
-      emptyJniStaticMethod6L },
+  { "emptyJniStaticMethod0",  "()V",       (void*)emptyJniStaticMethod0 },
+  { "emptyJniStaticMethod6",  "(IIIIII)V", (void*)emptyJniStaticMethod6 },
+  { "emptyJniStaticMethod6L", "(Ljava/lang/String;[Ljava/lang/String;[[ILjava/lang/Object;[Ljava/lang/Object;[[[[Ljava/lang/Object;)V", (void*)emptyJniStaticMethod6L },
 };
 int register_org_apache_harmony_dalvik_NativeTestTarget(JNIEnv* env) {
     int result = jniRegisterNativeMethods(env,
@@ -65,7 +62,7 @@ int register_org_apache_harmony_dalvik_NativeTestTarget(JNIEnv* env) {
     if (result != 0) {
         /* print warning, but allow to continue */
         LOGW("WARNING: NativeTestTarget not registered\n");
-        (*env)->ExceptionClear(env);
+        env->ExceptionClear();
     }
     return 0;
 }
diff --git a/dalvik/src/main/native/sub.mk b/dalvik/src/main/native/sub.mk
index 67cca39..27d4c9c 100644
--- a/dalvik/src/main/native/sub.mk
+++ b/dalvik/src/main/native/sub.mk
@@ -4,7 +4,7 @@
 
 LOCAL_SRC_FILES := \
 	dalvik_system_TouchDex.cpp \
-	org_apache_harmony_dalvik_NativeTestTarget.c
+	org_apache_harmony_dalvik_NativeTestTarget.cpp
 
 #LOCAL_C_INCLUDES +=
 
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
 
diff --git a/openssl/src/main/native/BNInterface.c b/openssl/src/main/native/BNInterface.cpp
index c267f86..61fa529 100644
--- a/openssl/src/main/native/BNInterface.c
+++ b/openssl/src/main/native/BNInterface.cpp
@@ -25,7 +25,6 @@
 #include <openssl/bn.h>
 #include <stdio.h>
 
-#define mcSignednessBull void *
 #ifndef FALSE
 #define FALSE 0
 #define TRUE 1
@@ -66,27 +65,23 @@ static int fourValidHandles (JNIEnv* env, void* a, void *b, void* c, void* d)
 /**
  * public static native int ERR_get_error();
  */
-static unsigned long NativeBN_ERR_get_error(JNIEnv* env __attribute__ ((unused)), jclass cls __attribute__ ((unused))) {
-    unsigned long e = ERR_get_error();
-    return e;
+static unsigned long NativeBN_ERR_get_error(JNIEnv*, jclass) {
+    return ERR_get_error();
 }
 
 /**
  * public static native String ERR_error_string(int);
  */
-static jstring NativeBN_ERR_error_string(JNIEnv* env, jclass cls __attribute__ ((unused)), unsigned long e) {
-    jstring returnJString = 0;
-    char* errStr;
-    errStr = ERR_error_string(e, NULL);
-    returnJString = ((*env)->NewStringUTF(env, (mcSignednessBull)errStr));
-    return returnJString;
+static jstring NativeBN_ERR_error_string(JNIEnv* env, jclass, unsigned long e) {
+    char* errStr = ERR_error_string(e, NULL);
+    return env->NewStringUTF(errStr);
 }
 
 
 /**
  * public static native int BN_CTX_new()
  */
-static BN_CTX* NativeBN_BN_CTX_new(JNIEnv* env __attribute__ ((unused)), jclass cls __attribute__ ((unused))) {
+static BN_CTX* NativeBN_BN_CTX_new(JNIEnv*, jclass) {
     return BN_CTX_new();
 }
 
@@ -94,14 +89,14 @@ static BN_CTX* NativeBN_BN_CTX_new(JNIEnv* env __attribute__ ((unused)), jclass
 /**
  * public static native int BN_new()
  */
-static BIGNUM* NativeBN_BN_new(JNIEnv* env __attribute__ ((unused)), jclass cls __attribute__ ((unused))) {
+static BIGNUM* NativeBN_BN_new(JNIEnv*, jclass) {
     return BN_new();
 }
 
 /**
  * public static native int BN_free()
  */
-static void NativeBN_BN_free(JNIEnv* env __attribute__ ((unused)), jclass cls __attribute__ ((unused)), BIGNUM* a) {
+static void NativeBN_BN_free(JNIEnv* env, jclass, BIGNUM* a) {
     if (!oneValidHandle(env, a)) return;
     BN_free(a);
 }
@@ -110,7 +105,7 @@ static void NativeBN_BN_free(JNIEnv* env __attribute__ ((unused)), jclass cls __
 /**
  * public static native int BN_cmp(int, int)
  */
-static int NativeBN_BN_cmp(JNIEnv* env __attribute__ ((unused)), jclass cls __attribute__ ((unused)), BIGNUM* a, BIGNUM* b) {
+static int NativeBN_BN_cmp(JNIEnv* env, jclass, BIGNUM* a, BIGNUM* b) {
     if (!twoValidHandles(env, a, b)) return 1;
     return BN_cmp(a, b);
 }
@@ -118,7 +113,7 @@ static int NativeBN_BN_cmp(JNIEnv* env __attribute__ ((unused)), jclass cls __at
 /**
  * public static native int BN_copy(int, int)
  */
-static jboolean NativeBN_BN_copy(JNIEnv* env __attribute__ ((unused)), jclass cls __attribute__ ((unused)), BIGNUM* to, BIGNUM* from) {
+static jboolean NativeBN_BN_copy(JNIEnv* env, jclass, BIGNUM* to, BIGNUM* from) {
     if (!twoValidHandles(env, to, from)) return FALSE;
     return (BN_copy(to, from) != NULL);
 }
@@ -127,7 +122,7 @@ static jboolean NativeBN_BN_copy(JNIEnv* env __attribute__ ((unused)), jclass cl
 /**
  * public static native int putULongInt(int, long, int)
  */
-static jboolean NativeBN_putULongInt(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* a, unsigned long long dw, jboolean neg) {
+static jboolean NativeBN_putULongInt(JNIEnv* env, jclass, BIGNUM* a, unsigned long long dw, jboolean neg) {
     if (!oneValidHandle(env, a)) return FALSE;
     unsigned int hi = dw >> 32; // This shifts without sign extension.
     int lo = (int)dw; // This truncates implicitely.
@@ -156,12 +151,12 @@ static jboolean NativeBN_putLongInt(JNIEnv* env, jclass cls, BIGNUM* a, long lon
 /**
  * public static native int BN_dec2bn(int, java.lang.String)
  */
-static int NativeBN_BN_dec2bn(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* a, jstring str) {
+static int NativeBN_BN_dec2bn(JNIEnv* env, jclass, BIGNUM* a, jstring str) {
     if (!oneValidHandle(env, a)) return -1;
-    char* tmpStr = (char*)(*env)->GetStringUTFChars(env, str, NULL);
+    char* tmpStr = (char*)env->GetStringUTFChars(str, NULL);
     if (tmpStr != NULL) {
         int len = BN_dec2bn(&a, tmpStr);
-        (*env)->ReleaseStringUTFChars(env, str, tmpStr);
+        env->ReleaseStringUTFChars(str, tmpStr);
         return len; // len == 0: Error
     }
     else return -1; // Error outside BN.
@@ -170,12 +165,12 @@ static int NativeBN_BN_dec2bn(JNIEnv* env, jclass cls __attribute__ ((unused)),
 /**
  * public static native int BN_hex2bn(int, java.lang.String)
  */
-static int NativeBN_BN_hex2bn(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* a, jstring str) {
+static int NativeBN_BN_hex2bn(JNIEnv* env, jclass, BIGNUM* a, jstring str) {
    if (!oneValidHandle(env, a)) return -1;
-    char* tmpStr = (char*)(*env)->GetStringUTFChars(env, str, NULL);
+    char* tmpStr = (char*)env->GetStringUTFChars(str, NULL);
     if (tmpStr != NULL) {
         int len = BN_hex2bn(&a, tmpStr);
-        (*env)->ReleaseStringUTFChars(env, str, tmpStr);
+        env->ReleaseStringUTFChars(str, tmpStr);
         return len; // len == 0: Error
     }
     else return -1; // Error outside BN.
@@ -184,17 +179,17 @@ static int NativeBN_BN_hex2bn(JNIEnv* env, jclass cls __attribute__ ((unused)),
 /**
  * public static native boolean BN_bin2bn(byte[], int, int, int)
  */
-static jboolean NativeBN_BN_bin2bn(JNIEnv* env, jclass cls __attribute__ ((unused)), jbyteArray arr, int len, jboolean neg, BIGNUM* ret) {
+static jboolean NativeBN_BN_bin2bn(JNIEnv* env, jclass, jbyteArray arr, int len, jboolean neg, BIGNUM* ret) {
     if (!oneValidHandle(env, ret)) return FALSE;
     jboolean success;
     unsigned char * tmpBytes;
-    tmpBytes = (unsigned char *)((*env)->GetPrimitiveArrayCritical(env, arr, 0));
+    tmpBytes = (unsigned char *)env->GetPrimitiveArrayCritical(arr, 0);
     if (tmpBytes != NULL) {
         success = (BN_bin2bn(tmpBytes, len, ret) != NULL);
         if (neg) {
             BN_set_negative(ret, 1);
         }
-        (*env)->ReleasePrimitiveArrayCritical(env, arr, tmpBytes, JNI_ABORT);
+        env->ReleasePrimitiveArrayCritical(arr, tmpBytes, JNI_ABORT);
         return success;
     }
     else return -1; // Error outside BN. mc FIXME: what to do in this case? Does JNI throw exception itself?
@@ -208,15 +203,15 @@ static jboolean NativeBN_BN_bin2bn(JNIEnv* env, jclass cls __attribute__ ((unuse
  * Also note that the same representation is used in the Cordoba Java Implementation of BigIntegers,
  *        whereof certain functionality is still being used.
  */
-static jboolean NativeBN_litEndInts2bn(JNIEnv* env, jclass cls __attribute__ ((unused)), jintArray arr, int len, jboolean neg, BIGNUM* ret) {
+static jboolean NativeBN_litEndInts2bn(JNIEnv* env, jclass, jintArray arr, int len, jboolean neg, BIGNUM* ret) {
     if (!oneValidHandle(env, ret)) return FALSE;
     bn_check_top(ret);
 	if (len > 0) {
         BN_ULONG* tmpInts; // BN_ULONG is 4 Bytes on this system for sure, i.e. same as jint!
-        tmpInts = (BN_ULONG*)((*env)->GetPrimitiveArrayCritical(env, arr, 0));
+        tmpInts = (BN_ULONG*)env->GetPrimitiveArrayCritical(arr, 0);
         if ((tmpInts != NULL) && (bn_wexpand(ret, len) != NULL)) {
             int i = len; do { i--; ret->d[i] = tmpInts[i]; } while (i > 0);
-            (*env)->ReleasePrimitiveArrayCritical(env, arr, tmpInts, JNI_ABORT);
+            env->ReleasePrimitiveArrayCritical(arr, tmpInts, JNI_ABORT);
             ret->top = len;
             ret->neg = neg;
             // need to call this due to clear byte at top if avoiding
@@ -227,7 +222,7 @@ static jboolean NativeBN_litEndInts2bn(JNIEnv* env, jclass cls __attribute__ ((u
         }
         else {
             if (tmpInts != NULL)
-                (*env)->ReleasePrimitiveArrayCritical(env, arr, tmpInts, JNI_ABORT);
+                env->ReleasePrimitiveArrayCritical(arr, tmpInts, JNI_ABORT);
             return FALSE;
         }
 	}
@@ -244,7 +239,7 @@ static jboolean NativeBN_litEndInts2bn(JNIEnv* env, jclass cls __attribute__ ((u
   | (bytes[k + 1] & 0xFF) << 16 \
   | (bytes[k + 0] & 0xFF) << 24 )
 
-static jboolean negBigEndianBytes2bn(JNIEnv* env __attribute__ ((unused)), jclass cls __attribute__ ((unused)), unsigned char* bytes, int bytesLen, BIGNUM* ret) {
+static jboolean negBigEndianBytes2bn(JNIEnv*, jclass, unsigned char* bytes, int bytesLen, BIGNUM* ret) {
 // We rely on: (BN_BITS2 == 32), i.e. BN_ULONG is unsigned int and has 4 bytes:
 //
     bn_check_top(ret);
@@ -304,7 +299,7 @@ static jboolean NativeBN_twosComp2bn(JNIEnv* env, jclass cls, jbyteArray arr, in
     if (!oneValidHandle(env, ret)) return FALSE;
     jboolean success;
     unsigned char* tmpBytes;
-    tmpBytes = (unsigned char*)((*env)->GetPrimitiveArrayCritical(env, arr, 0));
+    tmpBytes = (unsigned char*)env->GetPrimitiveArrayCritical(arr, 0);
     if (tmpBytes != NULL) {
         if ((tmpBytes[0] & 0X80) == 0) { // Positive value!
             //
@@ -320,7 +315,7 @@ static jboolean NativeBN_twosComp2bn(JNIEnv* env, jclass cls, jbyteArray arr, in
             success = negBigEndianBytes2bn(env, cls, tmpBytes, bytesLen, ret);
             BN_set_negative(ret, TRUE);
         }
-        (*env)->ReleasePrimitiveArrayCritical(env, arr, tmpBytes, JNI_ABORT);
+        env->ReleasePrimitiveArrayCritical(arr, tmpBytes, JNI_ABORT);
         return success;
     }
     else return -1; // Error outside BN. mc FIXME: what to do in this case? Does JNI throw exception itself?
@@ -330,7 +325,7 @@ static jboolean NativeBN_twosComp2bn(JNIEnv* env, jclass cls, jbyteArray arr, in
 /**
  * public static native long longInt(int)
  */
-static long long NativeBN_longInt(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* a) {
+static long long NativeBN_longInt(JNIEnv* env, jclass, BIGNUM* a) {
     if (!oneValidHandle(env, a)) return -1;
     bn_check_top(a);
     int intLen = a->top;
@@ -364,14 +359,14 @@ static char* leadingZerosTrimmed(char* s) {
 /**
  * public static native java.lang.String BN_bn2dec(int)
  */
-static jstring NativeBN_BN_bn2dec(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* a) {
+static jstring NativeBN_BN_bn2dec(JNIEnv* env, jclass, BIGNUM* a) {
     if (!oneValidHandle(env, a)) return NULL;
     char* tmpStr;
     char* retStr;
     tmpStr = BN_bn2dec(a);
     if (tmpStr != NULL) {
         retStr = leadingZerosTrimmed(tmpStr);
-        jstring returnJString = ((*env)->NewStringUTF(env, (mcSignednessBull)retStr));
+        jstring returnJString = env->NewStringUTF(retStr);
         OPENSSL_free(tmpStr);
         return returnJString;
     }
@@ -381,14 +376,14 @@ static jstring NativeBN_BN_bn2dec(JNIEnv* env, jclass cls __attribute__ ((unused
 /**
  * public static native java.lang.String BN_bn2hex(int)
  */
-static jstring NativeBN_BN_bn2hex(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* a) {
+static jstring NativeBN_BN_bn2hex(JNIEnv* env, jclass, BIGNUM* a) {
     if (!oneValidHandle(env, a)) return NULL;
     char* tmpStr;
     char* retStr;
     tmpStr = BN_bn2hex(a);
     if (tmpStr != NULL) {
         retStr = leadingZerosTrimmed(tmpStr);
-        jstring returnJString = ((*env)->NewStringUTF(env, (mcSignednessBull)retStr));
+        jstring returnJString = env->NewStringUTF(retStr);
         OPENSSL_free(tmpStr);
         return returnJString;
     }
@@ -398,19 +393,19 @@ static jstring NativeBN_BN_bn2hex(JNIEnv* env, jclass cls __attribute__ ((unused
 /**
  * public static native byte[] BN_bn2bin(int, byte[])
  */
-static jbyteArray NativeBN_BN_bn2bin(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* a, jbyteArray to) {
+static jbyteArray NativeBN_BN_bn2bin(JNIEnv* env, jclass, BIGNUM* a, jbyteArray to) {
     if (!oneValidHandle(env, a)) return NULL;
     jbyteArray returnJBytes = to;
     unsigned char * tmpBytes;
     int len, byteCnt;
     byteCnt = BN_num_bytes(a);
 // FIXME: Currently ignoring array passed in to:
-    returnJBytes = (*env)->NewByteArray(env, byteCnt);
+    returnJBytes = env->NewByteArray(byteCnt);
 // FIXME: is it neccessary to check for returnJBytes != NULL?
-    tmpBytes = (unsigned char *)((*env)->GetPrimitiveArrayCritical(env, returnJBytes, NULL));
+    tmpBytes = (unsigned char *)env->GetPrimitiveArrayCritical(returnJBytes, NULL);
     if (tmpBytes != NULL) {
         len = BN_bn2bin(a, tmpBytes);
-        (*env)->ReleasePrimitiveArrayCritical(env, returnJBytes, tmpBytes, 0);
+        env->ReleasePrimitiveArrayCritical(returnJBytes, tmpBytes, 0);
         return returnJBytes;
     }
     else return NULL;
@@ -420,19 +415,19 @@ static jbyteArray NativeBN_BN_bn2bin(JNIEnv* env, jclass cls __attribute__ ((unu
  * public static native int[] bn2litEndInts(int, int[])
  * cf. litEndInts2bn
  */
-static jintArray NativeBN_bn2litEndInts(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* a, jintArray to) {
+static jintArray NativeBN_bn2litEndInts(JNIEnv* env, jclass, BIGNUM* a, jintArray to) {
     if (!oneValidHandle(env, a)) return NULL;
     jintArray returnJInts = to;
     bn_check_top(a);
     int len = a->top;
     if (len > 0) {
 // FIXME: Currently ignoring array passed in to:
-        returnJInts = (*env)->NewIntArray(env, len);
+        returnJInts = env->NewIntArray(len);
 // FIXME: is it neccessary to check for returnJBytes != NULL?
-        BN_ULONG* tmpInts = (BN_ULONG*)((*env)->GetPrimitiveArrayCritical(env, returnJInts, NULL));
+        BN_ULONG* tmpInts = (BN_ULONG*)env->GetPrimitiveArrayCritical(returnJInts, NULL);
         if (tmpInts != NULL) {
             int i = len; do { i--; tmpInts[i] = a->d[i]; } while (i > 0);
-            (*env)->ReleasePrimitiveArrayCritical(env, returnJInts, tmpInts, 0);
+            env->ReleasePrimitiveArrayCritical(returnJInts, tmpInts, 0);
             return returnJInts;
         }
         else return NULL;
@@ -446,7 +441,7 @@ static jintArray NativeBN_bn2litEndInts(JNIEnv* env, jclass cls __attribute__ ((
 /**
  * public static native int sign(int)
  */
-static int NativeBN_sign(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* a) {
+static int NativeBN_sign(JNIEnv* env, jclass, BIGNUM* a) {
     if (!oneValidHandle(env, a)) return -2;
     if (BN_is_zero(a)) return 0;
     else if (BN_is_negative(a)) return -1;
@@ -456,7 +451,7 @@ static int NativeBN_sign(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNU
 /**
  * public static native void BN_set_negative(int, int)
  */
-static void NativeBN_BN_set_negative(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* b, int n) {
+static void NativeBN_BN_set_negative(JNIEnv* env, jclass, BIGNUM* b, int n) {
     if (!oneValidHandle(env, b)) return;
     BN_set_negative(b, n);
 }
@@ -464,7 +459,7 @@ static void NativeBN_BN_set_negative(JNIEnv* env, jclass cls __attribute__ ((unu
 /**
  * public static native int bitLength(int)
  */
-static int NativeBN_bitLength(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* a) {
+static int NativeBN_bitLength(JNIEnv* env, jclass, BIGNUM* a) {
 // We rely on: (BN_BITS2 == 32), i.e. BN_ULONG is unsigned int and has 4 bytes:
 //
     if (!oneValidHandle(env, a)) return FALSE;
@@ -487,7 +482,7 @@ static int NativeBN_bitLength(JNIEnv* env, jclass cls __attribute__ ((unused)),
 /**
  * public static native boolean BN_is_bit_set(int, int)
  */
-static jboolean NativeBN_BN_is_bit_set(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* a, int n) {
+static jboolean NativeBN_BN_is_bit_set(JNIEnv* env, jclass, BIGNUM* a, int n) {
     if (!oneValidHandle(env, a)) return FALSE;
     return (jboolean)BN_is_bit_set(a, n);
 }
@@ -495,7 +490,7 @@ static jboolean NativeBN_BN_is_bit_set(JNIEnv* env, jclass cls __attribute__ ((u
 /**
  * public static native void modifyBit(int, int, int)
  */
-static jboolean NativeBN_modifyBit(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* a, int n, int op) {
+static jboolean NativeBN_modifyBit(JNIEnv* env, jclass, BIGNUM* a, int n, int op) {
 // LOGD("NativeBN_BN_modifyBit");
     if (!oneValidHandle(env, a)) return FALSE;
     switch (op) {
@@ -511,7 +506,7 @@ static jboolean NativeBN_modifyBit(JNIEnv* env, jclass cls __attribute__ ((unuse
 /**
  * public static native int BN_shift(int, int, int)
  */
-static jboolean NativeBN_BN_shift(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* r, BIGNUM* a, int n) {
+static jboolean NativeBN_BN_shift(JNIEnv* env, jclass, BIGNUM* r, BIGNUM* a, int n) {
     if (!twoValidHandles(env, r, a)) return FALSE;
     return (n >= 0) ? BN_lshift(r, a, n) : BN_rshift(r, a, -n);
 }
@@ -519,7 +514,7 @@ static jboolean NativeBN_BN_shift(JNIEnv* env, jclass cls __attribute__ ((unused
 /**
  * public static native boolean BN_add_word(int, int)
  */
-static jboolean NativeBN_BN_add_word(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM *a, BN_ULONG w) {
+static jboolean NativeBN_BN_add_word(JNIEnv* env, jclass, BIGNUM *a, BN_ULONG w) {
     if (!oneValidHandle(env, a)) return FALSE;
     return BN_add_word(a, w);
 }
@@ -527,7 +522,7 @@ static jboolean NativeBN_BN_add_word(JNIEnv* env, jclass cls __attribute__ ((unu
 /**
  * public static native boolean BN_sub_word(int, int)
  */
-static jboolean NativeBN_BN_sub_word(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM *a, BN_ULONG w) {
+static jboolean NativeBN_BN_sub_word(JNIEnv* env, jclass, BIGNUM *a, BN_ULONG w) {
     if (!oneValidHandle(env, a)) return FALSE;
     return BN_sub_word(a, w);
 }
@@ -535,7 +530,7 @@ static jboolean NativeBN_BN_sub_word(JNIEnv* env, jclass cls __attribute__ ((unu
 /**
  * public static native boolean BN_mul_word(int, int)
  */
-static jboolean NativeBN_BN_mul_word(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM *a, BN_ULONG w) {
+static jboolean NativeBN_BN_mul_word(JNIEnv* env, jclass, BIGNUM *a, BN_ULONG w) {
     if (!oneValidHandle(env, a)) return FALSE;
     return BN_mul_word(a, w);
 }
@@ -543,7 +538,7 @@ static jboolean NativeBN_BN_mul_word(JNIEnv* env, jclass cls __attribute__ ((unu
 /**
  * public static native boolean BN_div_word(int, int)
  */
-static BN_ULONG NativeBN_BN_div_word(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM *a, BN_ULONG w) {
+static BN_ULONG NativeBN_BN_div_word(JNIEnv* env, jclass, BIGNUM *a, BN_ULONG w) {
     if (!oneValidHandle(env, a)) return FALSE;
     return BN_div_word(a, w);
 }
@@ -551,7 +546,7 @@ static BN_ULONG NativeBN_BN_div_word(JNIEnv* env, jclass cls __attribute__ ((unu
 /**
  * public static native boolean BN_mod_word(int, int)
  */
-static BN_ULONG NativeBN_BN_mod_word(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM *a, BN_ULONG w) {
+static BN_ULONG NativeBN_BN_mod_word(JNIEnv* env, jclass, BIGNUM *a, BN_ULONG w) {
     if (!oneValidHandle(env, a)) return FALSE;
     return BN_mod_word(a, w);
 }
@@ -561,7 +556,7 @@ static BN_ULONG NativeBN_BN_mod_word(JNIEnv* env, jclass cls __attribute__ ((unu
 /**
  * public static native int BN_add(int, int, int)
  */
-static jboolean NativeBN_BN_add(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* r, BIGNUM* a, BIGNUM* b) {
+static jboolean NativeBN_BN_add(JNIEnv* env, jclass, BIGNUM* r, BIGNUM* a, BIGNUM* b) {
     if (!threeValidHandles(env, r, a, b)) return FALSE;
     return BN_add(r, a, b);
 }
@@ -569,7 +564,7 @@ static jboolean NativeBN_BN_add(JNIEnv* env, jclass cls __attribute__ ((unused))
 /**
  * public static native int BN_sub(int, int, int)
  */
-static jboolean NativeBN_BN_sub(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* r, BIGNUM* a, BIGNUM* b) {
+static jboolean NativeBN_BN_sub(JNIEnv* env, jclass, BIGNUM* r, BIGNUM* a, BIGNUM* b) {
     if (!threeValidHandles(env, r, a, b)) return FALSE;
     return BN_sub(r, a, b);
 }
@@ -578,7 +573,7 @@ static jboolean NativeBN_BN_sub(JNIEnv* env, jclass cls __attribute__ ((unused))
 /**
  * public static native int BN_gcd(int, int, int, int)
  */
-static jboolean NativeBN_BN_gcd(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* r, BIGNUM* a, BIGNUM* b, BN_CTX* ctx) {
+static jboolean NativeBN_BN_gcd(JNIEnv* env, jclass, BIGNUM* r, BIGNUM* a, BIGNUM* b, BN_CTX* ctx) {
     if (!threeValidHandles(env, r, a, b)) return FALSE;
     return BN_gcd(r, a, b, ctx);
 }
@@ -586,7 +581,7 @@ static jboolean NativeBN_BN_gcd(JNIEnv* env, jclass cls __attribute__ ((unused))
 /**
  * public static native int BN_mul(int, int, int, int)
  */
-static jboolean NativeBN_BN_mul(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* r, BIGNUM* a, BIGNUM* b, BN_CTX* ctx) {
+static jboolean NativeBN_BN_mul(JNIEnv* env, jclass, BIGNUM* r, BIGNUM* a, BIGNUM* b, BN_CTX* ctx) {
     if (!threeValidHandles(env, r, a, b)) return FALSE;
     return BN_mul(r, a, b, ctx);
 }
@@ -594,7 +589,7 @@ static jboolean NativeBN_BN_mul(JNIEnv* env, jclass cls __attribute__ ((unused))
 /**
  * public static native int BN_exp(int, int, int, int)
  */
-static jboolean NativeBN_BN_exp(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* r, BIGNUM* a, BIGNUM* p, BN_CTX* ctx) {
+static jboolean NativeBN_BN_exp(JNIEnv* env, jclass, BIGNUM* r, BIGNUM* a, BIGNUM* p, BN_CTX* ctx) {
     if (!threeValidHandles(env, r, a, p)) return FALSE;
     return BN_exp(r, a, p, ctx);
 }
@@ -602,7 +597,7 @@ static jboolean NativeBN_BN_exp(JNIEnv* env, jclass cls __attribute__ ((unused))
 /**
  * public static native boolean BN_div(int, int, int, int, int)
  */
-static jboolean NativeBN_BN_div(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* dv, BIGNUM* rem, BIGNUM* m, BIGNUM* d, BN_CTX* ctx) {
+static jboolean NativeBN_BN_div(JNIEnv* env, jclass, BIGNUM* dv, BIGNUM* rem, BIGNUM* m, BIGNUM* d, BN_CTX* ctx) {
     if (!fourValidHandles(env, (rem ? rem : dv), (dv ? dv : rem), m, d)) return FALSE;
     return BN_div(dv, rem, m, d, ctx);
 }
@@ -610,7 +605,7 @@ static jboolean NativeBN_BN_div(JNIEnv* env, jclass cls __attribute__ ((unused))
 /**
  * public static native int BN_nnmod(int, int, int, int)
  */
-static jboolean NativeBN_BN_nnmod(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* r, BIGNUM* a, BIGNUM* m, BN_CTX* ctx) {
+static jboolean NativeBN_BN_nnmod(JNIEnv* env, jclass, BIGNUM* r, BIGNUM* a, BIGNUM* m, BN_CTX* ctx) {
     if (!threeValidHandles(env, r, a, m)) return FALSE;
     return BN_nnmod(r, a, m, ctx);
 }
@@ -618,7 +613,7 @@ static jboolean NativeBN_BN_nnmod(JNIEnv* env, jclass cls __attribute__ ((unused
 /**
  * public static native int BN_mod_exp(int, int, int, int, int)
  */
-static jboolean NativeBN_BN_mod_exp(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* r, BIGNUM* a, BIGNUM* p, BIGNUM* m, BN_CTX* ctx) {
+static jboolean NativeBN_BN_mod_exp(JNIEnv* env, jclass, BIGNUM* r, BIGNUM* a, BIGNUM* p, BIGNUM* m, BN_CTX* ctx) {
     if (!fourValidHandles(env, r, a, p, m)) return FALSE;
     return BN_mod_exp(r, a, p, m, ctx);
 }
@@ -627,7 +622,7 @@ static jboolean NativeBN_BN_mod_exp(JNIEnv* env, jclass cls __attribute__ ((unus
 /**
  * public static native int BN_mod_inverse(int, int, int, int)
  */
-static jboolean NativeBN_BN_mod_inverse(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* ret, BIGNUM* a, BIGNUM* n, BN_CTX* ctx) {
+static jboolean NativeBN_BN_mod_inverse(JNIEnv* env, jclass, BIGNUM* ret, BIGNUM* a, BIGNUM* n, BN_CTX* ctx) {
     if (!threeValidHandles(env, ret, a, n)) return FALSE;
     return (BN_mod_inverse(ret, a, n, ctx) != NULL);
 }
@@ -636,7 +631,7 @@ static jboolean NativeBN_BN_mod_inverse(JNIEnv* env, jclass cls __attribute__ ((
 /**
  * public static native int BN_generate_prime_ex(int, int, boolean, int, int, int)
  */
-static jboolean NativeBN_BN_generate_prime_ex(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* ret, int bits, jboolean safe,
+static jboolean NativeBN_BN_generate_prime_ex(JNIEnv* env, jclass, BIGNUM* ret, int bits, jboolean safe,
         BIGNUM* add, BIGNUM* rem, jint cb) {
     if (!oneValidHandle(env, ret)) return FALSE;
     return BN_generate_prime_ex(ret, bits, safe, add, rem, (BN_GENCB*) cb);
@@ -645,7 +640,7 @@ static jboolean NativeBN_BN_generate_prime_ex(JNIEnv* env, jclass cls __attribut
 /**
  * public static native int BN_mod_inverse(int, int, int, int)
  */
-static jboolean NativeBN_BN_is_prime_ex(JNIEnv* env, jclass cls __attribute__ ((unused)), BIGNUM* p, int nchecks, BN_CTX* ctx, jint cb) {
+static jboolean NativeBN_BN_is_prime_ex(JNIEnv* env, jclass, BIGNUM* p, int nchecks, BN_CTX* ctx, jint cb) {
     if (!oneValidHandle(env, p)) return FALSE;
     return BN_is_prime_ex(p, nchecks, ctx, (BN_GENCB*) cb);
 }
diff --git a/openssl/src/main/native/sub.mk b/openssl/src/main/native/sub.mk
index fccf735..36d779a 100644
--- a/openssl/src/main/native/sub.mk
+++ b/openssl/src/main/native/sub.mk
@@ -3,7 +3,7 @@
 # or BUILD_*_LIBRARY.
 
 LOCAL_SRC_FILES := \
-	BNInterface.c
+	BNInterface.cpp
 
 LOCAL_C_INCLUDES += \
 	external/openssl/include