modules/fxpackager/src/main/native/library/common/Java.cpp

@@ -38,22 +38,22 @@
 
 
 //--------------------------------------------------------------------------------------------------
 
 #ifdef DEBUG
-std::string JavaException::CreateExceptionMessage(JNIEnv* Env, jthrowable Exception,
+TString JavaException::CreateExceptionMessage(JNIEnv* Env, jthrowable Exception,
     jmethodID GetCauseMethod, jmethodID GetStackTraceMethod, jmethodID ThrowableToTStringMethod,
     jmethodID FrameToTStringMethod) {
 
-    std::string result;
+    TString result;
     jobjectArray frames = (jobjectArray)Env->CallObjectMethod(Exception, GetStackTraceMethod);
 
     // Append Throwable.toTString().
     if (0 != frames) {
         jstring jstr = (jstring)Env->CallObjectMethod(Exception, ThrowableToTStringMethod);
         const char* str = Env->GetStringUTFChars(jstr, 0);
-        result += str;
+        result += PlatformString(str).toPlatformString();
         Env->ReleaseStringUTFChars(jstr, str);
         Env->DeleteLocalRef(jstr);
     }
 
     // Append stack trace if one exists.

@@ -64,12 +64,12 @@
             // Get the string from the next frame and append it to
             // the error message.
             jobject frame = Env->GetObjectArrayElement(frames, i);
             jstring obj = (jstring)Env->CallObjectMethod(frame, FrameToTStringMethod);
             const char* str = Env->GetStringUTFChars(obj, 0);
-            result += "\n  ";
-            result += str;
+            result += _T("\n  ");
+            result += PlatformString(str).toPlatformString();
             Env->ReleaseStringUTFChars(obj, str);
             Env->DeleteLocalRef(obj);
             Env->DeleteLocalRef(frame);
         }
     }

@@ -87,31 +87,22 @@
 
     return result;
 }
 #endif //DEBUG
 
-JavaException::JavaException() : std::exception() {}
+JavaException::JavaException() : Exception() {}
 
-//TODO Fix JavaException for all platforms.
-#ifdef WINDOWS
-JavaException::JavaException(const char* const message) : std::exception(message) {}
-#endif //WINDOWS
-#ifdef MAC
-JavaException::JavaException(const char* const message) {}
-#endif //MAC
-
-#ifdef WINDOWS
-JavaException::JavaException(JNIEnv *Env, const char* const message) : std::exception(message) {
-#endif //WINDOWS
-#ifdef POSIX
-JavaException::JavaException(JNIEnv *Env, const char* const message) {
-#endif //POSIX
+//#ifdef WINDOWS
+JavaException::JavaException(JNIEnv *Env, const TString Message) : Exception(Message) {
+//#endif //WINDOWS
+//#ifdef POSIX
+//JavaException::JavaException(JNIEnv *Env, TString message) {
+//#endif //POSIX
 
     FEnv = Env;
     FException = Env->ExceptionOccurred();
     Env->ExceptionClear();
-    FMessage = message;
 
 #ifdef DEBUG
     Platform& platform = Platform::GetInstance();
 
     if (platform.GetDebugState() == dsNone) {

@@ -163,26 +154,17 @@
         if (FEnv->ExceptionCheck() == JNI_TRUE) {
             Env->ExceptionClear();
             return;
         }
 
-        std::string lmessage = CreateExceptionMessage(Env, FException, GetCauseMethod,
+        TString lmessage = CreateExceptionMessage(Env, FException, GetCauseMethod,
             GetStackTraceMethod, ThrowableToTStringMethod, FrameToTStringMethod);
-        FMessage = lmessage.c_str();
+        SetMessage(lmessage);
     }
 #endif //DEBUG
 }
 
-const char* JavaException::what() {
-    if (FMessage.empty() == true) {
-        return std::exception::what();
-    }
-    else {
-        return FMessage.c_str();
-    }
-}
-
 void JavaException::Rethrow() {
     FEnv->Throw(FException);
 }
 
 //--------------------------------------------------------------------------------------------------

@@ -199,12 +181,11 @@
     FEnv->CallStaticVoidMethodV(FClass, FMethod, args);
     va_end(args);
 
     if (FEnv->ExceptionCheck() == JNI_TRUE) {
         Messages& messages = Messages::GetInstance();
-        std::string message = PlatformString(messages.GetMessage(ERROR_INVOKING_METHOD)).toStdString();
-        throw JavaException(FEnv, message.c_str());
+        throw JavaException(FEnv, messages.GetMessage(ERROR_INVOKING_METHOD));
     }
 }
 
 JavaStaticMethod::operator jmethodID () {
     return FMethod;

@@ -224,12 +205,11 @@
     FEnv->CallVoidMethodV(FObj, FMethod, args);
     va_end(args);
 
     if (FEnv->ExceptionCheck() == JNI_TRUE) {
         Messages& messages = Messages::GetInstance();
-        std::string message = PlatformString(messages.GetMessage(ERROR_INVOKING_METHOD)).toStdString();
-        throw JavaException(FEnv, message.c_str());
+        throw JavaException(FEnv, messages.GetMessage(ERROR_INVOKING_METHOD));
     }
 }
 
 JavaMethod::operator jmethodID () {
     return FMethod;

@@ -242,35 +222,32 @@
     FClassName = Name;
     FClass = FEnv->FindClass(PlatformString(FClassName));
 
     if (FClass == NULL || FEnv->ExceptionCheck() == JNI_TRUE) {
         Messages& messages = Messages::GetInstance();
-        std::string message = PlatformString(messages.GetMessage(CLASS_NOT_FOUND)).toStdString();
-        message = PlatformString::Format(message,
-            PlatformString(FClassName).c_str());
-        throw JavaException(FEnv, message.c_str());
+        TString message = messages.GetMessage(CLASS_NOT_FOUND);
+        message = PlatformString::Format(message, FClassName.data());
+        throw JavaException(FEnv, message);
     }
 }
 
 JavaClass::~JavaClass() {
     FEnv->DeleteLocalRef(FClass);
 
     if (FEnv->ExceptionCheck() == JNI_TRUE) {
-        throw JavaException(FEnv, "Error");
+        throw JavaException(FEnv, _T("Error"));
     }
 }
 
 JavaStaticMethod JavaClass::GetStaticMethod(TString Name, TString Signature) {
     jmethodID method = FEnv->GetStaticMethodID(FClass, PlatformString(Name), PlatformString(Signature));
 
     if (method == NULL || FEnv->ExceptionCheck() == JNI_TRUE) {
         Messages& messages = Messages::GetInstance();
-        std::string message = PlatformString(messages.GetMessage(METHOD_NOT_FOUND)).toStdString();
-        message = PlatformString::Format(message,
-            PlatformString(Name).c_str(),
-            PlatformString(FClassName).c_str());
-        throw JavaException(FEnv, message.c_str());
+        TString message = messages.GetMessage(METHOD_NOT_FOUND);
+        message = PlatformString::Format(message, Name.data(), FClassName.data());
+        throw JavaException(FEnv, message);
     }
 
     return JavaStaticMethod(FEnv, FClass, method);
 }
 

@@ -283,20 +260,20 @@
 void JavaStringArray::Initialize(size_t Size) {
     JavaClass jstringClass(FEnv, _T("java/lang/String"));
 
     if (FEnv->ExceptionCheck() == JNI_TRUE) {
         Messages& messages = Messages::GetInstance();
-        std::string message = PlatformString(messages.GetMessage(CLASS_NOT_FOUND)).toStdString();
-        message = PlatformString::Format(message, "String");
-        throw JavaException(FEnv, message.c_str());
+        TString message = messages.GetMessage(CLASS_NOT_FOUND);
+        message = PlatformString::Format(message, _T("String"));
+        throw JavaException(FEnv, message.data());
     }
 
     jstring str = PlatformString("").toJString(FEnv);
     FData = (jobjectArray)FEnv->NewObjectArray((jsize)Size, jstringClass, str);
 
     if (FEnv->ExceptionCheck() == JNI_TRUE) {
-        throw JavaException(FEnv, "Error");
+        throw JavaException(FEnv, _T("Error"));
     }
 }
 
 JavaStringArray::JavaStringArray(JNIEnv *Env, size_t Size) {
     FEnv = Env;

@@ -326,29 +303,29 @@
 
 void JavaStringArray::SetValue(jsize Index, jstring Item) {
     FEnv->SetObjectArrayElement(FData, Index, Item);
 
     if (FEnv->ExceptionCheck() == JNI_TRUE) {
-        throw JavaException(FEnv, "Error");
+        throw JavaException(FEnv, _T("Error"));
     }
 }
 
 jstring JavaStringArray::GetValue(jsize Index) {
     jstring result = (jstring)FEnv->GetObjectArrayElement(FData, Index);
 
     if (FEnv->ExceptionCheck() == JNI_TRUE) {
-        throw JavaException(FEnv, "Error");
+        throw JavaException(FEnv, _T("Error"));
     }
 
     return result;
 }
 
 unsigned int JavaStringArray::Count() {
     unsigned int result = FEnv->GetArrayLength(FData);
 
     if (FEnv->ExceptionCheck() == JNI_TRUE) {
-        throw JavaException(FEnv, "Error");
+        throw JavaException(FEnv, _T("Error"));
     }
 
     return result;
 }