Remove STL dependency (#161)

Author: ebraminio

README.md

@@ -78,10 +78,10 @@ CPU Architectures
 
 The native library is built for the following CPU architectures:
 
-- `armeabi-v7a` ~1.4 MB
-- `arm64-v8a` ~2 MB
-- `x86` ~2.1 MB
-- `x86_64` ~2.1 MB
+- `armeabi-v7a` ~1.2 MB
+- `arm64-v8a` ~1.7 MB
+- `x86` ~1.7 MB
+- `x86_64` ~1.8 MB
 
 However you may not want to include all binaries in your apk. You can exclude certain variants by
 using `packagingOptions`:
@@ -97,7 +97,7 @@ android {
 }
 ```
 
-The size of the artifacts with only the armeabi-v7a binary is **~1.4 MB**. In general you can use
+The size of the artifacts with only the armeabi-v7a binary is **~1.2 MB**. In general you can use
 armeabi-v7a on the majority of Android devices including Intel Atom which provides a native
 translation layer, however performance under the translation layer is worse than using the x86
 binary.
@@ -146,6 +146,7 @@ Changes
 - Made the AOSP code (mostly) warning free but still mergable from source
 - Deprecated classes/methods removed
 - Loadable extension support
+- STL dependency removed
 
 License
 -------

sqlite-android/src/main/jni/Application.mk

@@ -1,4 +1,4 @@
-APP_STL:=c++_static
+APP_STL:=none
 APP_OPTIM := release
 APP_ABI := armeabi-v7a,arm64-v8a,x86,x86_64
 NDK_TOOLCHAIN_VERSION := clang

sqlite-android/src/main/jni/sqlite/CursorWindow.cpp

@@ -27,16 +27,18 @@
 
 namespace android {
 
-CursorWindow::CursorWindow(const std::string& name, void* data, size_t size, bool readOnly) :
-        mName(name), mData(data), mSize(size), mReadOnly(readOnly) {
+CursorWindow::CursorWindow(const char* name, void* data, size_t size, bool readOnly) :
+        mData(data), mSize(size), mReadOnly(readOnly) {
+    mName = strdup(name);
     mHeader = static_cast<Header*>(mData);
 }
 
 CursorWindow::~CursorWindow() {
+    free(mName);
     free(mData);
 }
 
-status_t CursorWindow::create(const std::string& name, size_t size, CursorWindow** outWindow) {
+status_t CursorWindow::create(const char* name, size_t size, CursorWindow** outWindow) {
     status_t result;
     void* data = malloc(size);
     if (!data) {
@@ -54,6 +56,7 @@ status_t CursorWindow::create(const std::string& name, size_t size, CursorWindow
         *outWindow = window;
         return OK;
     }
+    delete window;
     return result;
 }
 

sqlite-android/src/main/jni/sqlite/CursorWindow.h

@@ -23,7 +23,6 @@
 #include <stdint.h>
 
 #include "Errors.h"
-#include <string>
 
 #if LOG_NDEBUG
 
@@ -50,7 +49,7 @@ namespace android {
  * Strings are stored in UTF-8.
  */
 class CursorWindow {
-    CursorWindow(const std::string& name, void* data, size_t size, bool readOnly);
+    CursorWindow(const char* name, void* data, size_t size, bool readOnly);
 
 public:
     /* Field types. */
@@ -80,9 +79,9 @@ class CursorWindow {
 
     ~CursorWindow();
 
-    static status_t create(const std::string& name, size_t size, CursorWindow** outCursorWindow);
+    static status_t create(const char* name, size_t size, CursorWindow** outCursorWindow);
 
-    inline std::string name() { return mName; }
+    inline const char* name() { return mName; }
     inline size_t size() { return mSize; }
     inline size_t freeSpace() { return mSize - mHeader->freeOffset; }
     inline uint32_t getNumRows() { return mHeader->numRows; }
@@ -156,7 +155,7 @@ class CursorWindow {
         uint32_t nextChunkOffset;
     };
 
-    std::string mName;
+    char* mName;
     void* mData;
     size_t mSize;
     bool mReadOnly;

sqlite-android/src/main/jni/sqlite/JNIHelp.cpp

@@ -24,8 +24,6 @@
 #include <string.h>
 #include <assert.h>
 
-#include <string>
-
 /**
  * Equivalent to ScopedLocalRef, but for C_JNIEnv instead. (And slightly more powerful.)
  */
@@ -94,7 +92,8 @@ extern "C" int jniRegisterNativeMethods(C_JNIEnv* env, const char* className,
  * be populated with the "binary" class name and, if present, the
  * exception message.
  */
-static bool getExceptionSummary(C_JNIEnv* env, jthrowable exception, std::string& result) {
+static bool logExceptionSummary(C_JNIEnv *env, jthrowable exception,
+                                const char* exceptionClassName) {
     JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
 
     /* get the name of the exception's class */
@@ -107,16 +106,17 @@ static bool getExceptionSummary(C_JNIEnv* env, jthrowable exception, std::string
             (jstring) (*env)->CallObjectMethod(e, exceptionClass.get(), classGetNameMethod));
     if (classNameStr.get() == NULL) {
         (*env)->ExceptionClear(e);
-        result = "<error getting class name>";
+        ALOGW("Discarding pending exception (%s) to throw %s", "<error getting class name>",
+              exceptionClassName);
         return false;
     }
     const char* classNameChars = (*env)->GetStringUTFChars(e, classNameStr.get(), NULL);
     if (classNameChars == NULL) {
         (*env)->ExceptionClear(e);
-        result = "<error getting class name UTF-8>";
+        ALOGW("Discarding pending exception (%s) to throw %s", "<error getting class name UTF-8>",
+              exceptionClassName);
         return false;
     }
-    result += classNameChars;
     (*env)->ReleaseStringUTFChars(e, classNameStr.get(), classNameChars);
 
     /* if the exception has a detail message, get that */
@@ -128,81 +128,23 @@ static bool getExceptionSummary(C_JNIEnv* env, jthrowable exception, std::string
         return true;
     }
 
-    result += ": ";
-
     const char* messageChars = (*env)->GetStringUTFChars(e, messageStr.get(), NULL);
     if (messageChars != NULL) {
-        result += messageChars;
+        ALOGW("Discarding pending exception (%s: %s) to throw %s",
+              classNameChars,
+              messageChars,
+              exceptionClassName);
         (*env)->ReleaseStringUTFChars(e, messageStr.get(), messageChars);
     } else {
-        result += "<error getting message>";
+        ALOGW("Discarding pending exception (%s: <error getting message>) to throw %s",
+              classNameChars,
+              exceptionClassName);
         (*env)->ExceptionClear(e); // clear OOM
     }
 
     return true;
 }
 
-/*
- * Returns an exception (with stack trace) as a string.
- */
-static bool getStackTrace(C_JNIEnv* env, jthrowable exception, std::string& result) {
-    JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
-
-    scoped_local_ref<jclass> stringWriterClass(env, findClass(env, "java/io/StringWriter"));
-    if (stringWriterClass.get() == NULL) {
-        return false;
-    }
-
-    jmethodID stringWriterCtor = (*env)->GetMethodID(e, stringWriterClass.get(), "<init>", "()V");
-    jmethodID stringWriterToStringMethod =
-            (*env)->GetMethodID(e, stringWriterClass.get(), "toString", "()Ljava/lang/String;");
-
-    scoped_local_ref<jclass> printWriterClass(env, findClass(env, "java/io/PrintWriter"));
-    if (printWriterClass.get() == NULL) {
-        return false;
-    }
-
-    jmethodID printWriterCtor =
-            (*env)->GetMethodID(e, printWriterClass.get(), "<init>", "(Ljava/io/Writer;)V");
-
-    scoped_local_ref<jobject> stringWriter(env,
-            (*env)->NewObject(e, stringWriterClass.get(), stringWriterCtor));
-    if (stringWriter.get() == NULL) {
-        return false;
-    }
-
-    jobject printWriter =
-            (*env)->NewObject(e, printWriterClass.get(), printWriterCtor, stringWriter.get());
-    if (printWriter == NULL) {
-        return false;
-    }
-
-    scoped_local_ref<jclass> exceptionClass(env, (*env)->GetObjectClass(e, exception)); // can't fail
-    jmethodID printStackTraceMethod =
-            (*env)->GetMethodID(e, exceptionClass.get(), "printStackTrace", "(Ljava/io/PrintWriter;)V");
-    (*env)->CallVoidMethod(e, exception, printStackTraceMethod, printWriter);
-
-    if ((*env)->ExceptionCheck(e)) {
-        return false;
-    }
-
-    scoped_local_ref<jstring> messageStr(env,
-            (jstring) (*env)->CallObjectMethod(e, stringWriter.get(), stringWriterToStringMethod));
-    if (messageStr.get() == NULL) {
-        return false;
-    }
-
-    const char* utfChars = (*env)->GetStringUTFChars(e, messageStr.get(), NULL);
-    if (utfChars == NULL) {
-        return false;
-    }
-
-    result = utfChars;
-
-    (*env)->ReleaseStringUTFChars(e, messageStr.get(), utfChars);
-    return true;
-}
-
 extern "C" int jniThrowException(C_JNIEnv* env, const char* className, const char* msg) {
     JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
 
@@ -212,9 +154,7 @@ extern "C" int jniThrowException(C_JNIEnv* env, const char* className, const cha
         (*env)->ExceptionClear(e);
 
         if (exception.get() != NULL) {
-            std::string text;
-            getExceptionSummary(env, exception.get(), text);
-            ALOGW("Discarding pending exception (%s) to throw %s", text.c_str(), className);
+            logExceptionSummary(env, exception.get(), className);
         }
     }
 
@@ -254,39 +194,6 @@ int jniThrowIOException(C_JNIEnv* env, int errnum) {
     return jniThrowException(env, "java/io/IOException", message);
 }
 
-static std::string jniGetStackTrace(C_JNIEnv* env, jthrowable exception) {
-    JNIEnv* e = reinterpret_cast<JNIEnv*>(env);
-
-    scoped_local_ref<jthrowable> currentException(env, (*env)->ExceptionOccurred(e));
-    if (exception == NULL) {
-        exception = currentException.get();
-        if (exception == NULL) {
-          return "<no pending exception>";
-        }
-    }
-
-    if (currentException.get() != NULL) {
-        (*env)->ExceptionClear(e);
-    }
-
-    std::string trace;
-    if (!getStackTrace(env, exception, trace)) {
-        (*env)->ExceptionClear(e);
-        getExceptionSummary(env, exception, trace);
-    }
-
-    if (currentException.get() != NULL) {
-        (*env)->Throw(e, currentException.get()); // rethrow
-    }
-
-    return trace;
-}
-
-void jniLogException(C_JNIEnv* env, int priority, const char* tag, jthrowable exception) {
-    std::string trace(jniGetStackTrace(env, exception));
-    __android_log_write(priority, tag, trace.c_str());
-}
-
 const char* jniStrError(int errnum, char* buf, size_t buflen) {
 #if __GLIBC__
     // Note: glibc has a nonstandard strerror_r that returns char* rather than POSIX's int.
@@ -303,3 +210,8 @@ const char* jniStrError(int errnum, char* buf, size_t buflen) {
     return buf;
 #endif
 }
+
+void* operator new (size_t size)        { return malloc(size); }
+void* operator new [] (size_t size)     { return malloc(size); }
+void operator delete (void* pointer)    { free(pointer); }
+void operator delete [] (void* pointer) { free(pointer); }

sqlite-android/src/main/jni/sqlite/JNIHelp.h

@@ -102,12 +102,6 @@ void jniSetFileDescriptorOfFD(C_JNIEnv* env, jobject fileDescriptor, int value);
  */
 jobject jniGetReferent(C_JNIEnv* env, jobject ref);
 
-/*
- * Log a message and an exception.
- * If exception is NULL, logs the current exception in the JNI environment.
- */
-void jniLogException(C_JNIEnv* env, int priority, const char* tag, jthrowable exception);
-
 #ifdef __cplusplus
 }
 #endif
@@ -167,10 +161,6 @@ inline jobject jniGetReferent(JNIEnv* env, jobject ref) {
     return jniGetReferent(&env->functions, ref);
 }
 
-inline void jniLogException(JNIEnv* env, int priority, const char* tag, jthrowable exception = NULL) {
-    jniLogException(&env->functions, priority, tag, exception);
-}
-
 #endif
 
 #define FIND_CLASS(var, className) \

sqlite-android/src/main/jni/sqlite/android_database_CursorWindow.cpp

@@ -23,7 +23,7 @@
 #include <jni.h>
 #include <JNIHelp.h>
 #include <stdio.h>
-#include <string>
+#include <stdlib.h>
 #include <unistd.h>
 
 #include "CursorWindow.h"
@@ -51,12 +51,11 @@ static void throwUnknownTypeException(JNIEnv * env, jint type) {
 }
 
 static jlong nativeCreate(JNIEnv* env, jclass clazz, jstring nameObj, jint cursorWindowSize) {
+    CursorWindow* window;
     const char* nameStr = env->GetStringUTFChars(nameObj, NULL);
-    std::string name(nameStr);
+    status_t status = CursorWindow::create(nameStr, cursorWindowSize, &window);
     env->ReleaseStringUTFChars(nameObj, nameStr);
 
-    CursorWindow* window;
-    status_t status = CursorWindow::create(name, cursorWindowSize, &window);
     if (status || !window) {
         ALOGE("Could not allocate CursorWindow of size %d due to error %d.",
         cursorWindowSize, status);
@@ -77,7 +76,7 @@ static void nativeDispose(JNIEnv* env, jclass clazz, jlong windowPtr) {
 
 static jstring nativeGetName(JNIEnv* env, jclass clazz, jlong windowPtr) {
     CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
-    return env->NewStringUTF(window->name().c_str());
+    return env->NewStringUTF(window->name());
 }
 
 static void nativeClear(JNIEnv * env, jclass clazz, jlong windowPtr) {