+#ifdef MINGW_LIBGCJ_UNICODE
+
+// We're using the OS W (UNICODE) API, which means that we're speaking
+// the same language....
+jstring
+_Jv_Win32NewString (LPCTSTR pcsz)
+{
+ return JvNewString ((jchar*) pcsz, _tcslen (pcsz));
+}
+
+#else
+
+// We're using the OS A functions, which means we need to translate between
+// UNICODE and the native character set.
+
+// First, let's set up some helper translation functions....
+
+// Converts the native string to any specified jstring, returning the
+// length of the jstring. If the specified jstring is null, we simply
+// compute and return the length.
+static int nativeToUnicode(LPCSTR pcsz, jstring jstr = 0)
+{
+ jchar* buf = 0;
+ int len = 0;
+ if (jstr)
+ {
+ len = jstr->length();
+ buf = JvGetStringChars(jstr);
+ }
+ return ::MultiByteToWideChar(GetACP(), 0, pcsz,
+ strlen(pcsz), (LPWSTR) buf, len);
+}
+
+// Does the inverse of nativeToUnicode, with the same calling semantics.
+static int unicodeToNative(jstring jstr, LPSTR buf, int buflen)
+{
+ return ::WideCharToMultiByte(GetACP(), 0, (LPWSTR) JvGetStringChars(jstr),
+ jstr->length(), buf, buflen, NULL, NULL);
+}
+
+// Convenience function when the caller only wants to compute the length
+// of the native string.
+static int unicodeToNative(jstring jstr)
+{
+ return unicodeToNative(jstr, 0, 0);
+}
+
+jstring
+_Jv_Win32NewString (LPCTSTR pcsz)
+{
+ // Compute the length, allocate the jstring, then perform the conversion.
+ int len = nativeToUnicode(pcsz);
+ jstring jstr = JvAllocString(len);
+ nativeToUnicode(pcsz, jstr);
+ return jstr;
+}
+
+#endif // MINGW_LIBGCJ_UNICODE
+
+// class _Jv_Win32TempString
+_Jv_Win32TempString::_Jv_Win32TempString(jstring jstr):
+ buf_(0)
+{
+ if (jstr == 0)
+ return;
+
+ // We need space for the string length plus a null terminator.
+ // Determine whether to use our stack-allocated buffer or a heap-
+ // allocated one.
+#ifdef MINGW_LIBGCJ_UNICODE
+ // A UNICODE character is a UNICODE character is a UNICODE character....
+ int len = jstr->length();
+#else
+ // Compute the length of the native character string.
+ int len = unicodeToNative(jstr);
+#endif // MINGW_LIBGCJ_UNICODE
+
+ int bytesNeeded = (len + 1) * sizeof(TCHAR);
+ if (bytesNeeded <= (int) sizeof(stackbuf_))
+ buf_ = stackbuf_;
+ else
+ buf_ = (LPTSTR) _Jv_Malloc(bytesNeeded);
+
+#ifdef MINGW_LIBGCJ_UNICODE
+ // Copy the UNICODE characters to our buffer.
+ _tcsncpy(buf_, (LPCTSTR) JvGetStringChars (jstr), len);
+#else
+ // Convert the UNICODE string to a native one.
+ unicodeToNative(jstr, buf_, len);
+#endif // MINGW_LIBGCJ_UNICODE
+
+ buf_[len] = 0;
+}
+
+_Jv_Win32TempString::~_Jv_Win32TempString()
+{
+ if (buf_ && buf_ != stackbuf_)
+ _Jv_Free (buf_);
+}
+