This is the mail archive of the java-patches@gcc.gnu.org mailing list for the Java project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH] [MinGW] for Review: Make MinGW libgcj use UNICODE natively


Hi People,

This is the MinGW libjava UNICODE patch I've been talking about.
I've forwarded this message I've sent out to the MinGW Developer
list because it summarizes the situation nicely.

IMPORTANT NOTE: I want someone else to review and approve/reject this.
I can vouch for the technical correctness of the patch, but not
the well-foundedness of it.

To recap:

- with this patch, libunicows.a would be a required external
  library needed to build mingw-gcj. libunicows.a is open
  source and free (http://libunicows.sourceforge.net)

- developers wanting to distribute applications which run on
  Win9X would need to distribute unicows.dll, available for
  download from Microsoft. This DLL need not be redistributed
  for WinNT / Win2K / WinXP.

  Here is an excerpt from the unicows license agreement which
  could be construed as restrictive:

	* Distribution Terms.  You may reproduce and distribute an unlimited number of copies of the Sample Code and/or 
	Redistributable Code (collectively "Redistributable Components") as described above in object code form, provided that (a) 
	you distribute the Redistributable Components only in conjunction with and as a part of your Application solely for use with a 
	Microsoft Operating System Product; (b) your Application adds significant and primary functionality to the Redistributable 
	Components; (c) you distribute your Application containing the Redistributable Components pursuant to an End-User License 
	Agreement (which may be "break-the-seal", "click-wrap" or signed), with terms no less protective than those contained herein; 
	(d) you do not permit further redistribution of the Redistributable Components by your end-user customers; (e) you do not use 
	Microsoft's name, logo, or trademarks to market your Application; (f) you include a valid copyright notice on your 
	Application; and (g) you agree to indemnify, hold harmless, and defend Microsoft from and against any claims or lawsuits, 
	including attorneys' fees, that arise or result from the use or distribution of your Application.  Contact Microsoft for the 
	applicable licensing terms for all other uses and/or distribution of the Redistributable Components.

  João doesn't like this:

  http://gcc.gnu.org/ml/java/2003-11/msg00256.html

  As noted previously, however, such executables will run on Wine
  without unicows.dll if Wine is configured to behave like NT 4.0 and
  above.

What do you think?

I'll put out a build in a few hours.

-- Mohan
http://www.thisiscool.com/
http://www.animalsong.org/

------- Start of forwarded message -------
From: Mohan Embar <gnustuff@thisiscool.com>
To: mingw-dvlpr@lists.sourceforge.net
Reply-To: mingw-dvlpr@lists.sourceforge.net
Subject: Fwd: [MinGW-dvlpr] Required UNICOWS for MinGW gcj?
Date: 11/21/2003 2:03:00 AM

Hi People,

I thought I'd give you a heads-up on a thread on the gcc java
mailing list:

- http://gcc.gnu.org/ml/java/2003-11/threads.html#00160
- http://gcc.gnu.org/ml/java/2003-11/threads.html#00247

For the impatient, here are the salient posts from these:

- http://gcc.gnu.org/ml/java/2003-11/msg00231.html
- http://gcc.gnu.org/ml/java/2003-11/msg00250.html

In a nutshell, I plan to submit a patch:

http://www.thisiscool.com/temp/unicode.diff.tar.bz2
(this is a prior version, but is essentially the same)

...which would require MS' unicows.dll for any MinGW gcj-produced
executable running on Win9X. unicows.dll would not be required
for WinNT / 2K / XP. In addition, developers would need to add
libunicows.a to mingw32/lib:

http://libunicows.sourceforge.net

By requiring this, I am able to refactor (almost) the entire Win32
libjava layer to use UNICODE natively. Since Java uses UNICODE,
this was more aesthetically pleasing to me than doing UNICODE <-> ANSI,
then ANSI <-> UNICODE via the Windows system calls on NT and above.

This is a somewhat controversial decision because:

- You can achieve the same result using WideCharToMultiByte / MultiByteToWideChar,
  thereby going the UNICODE <-> ANSI <-> UNICODE route, but supporting
  Win9X without unicows.dll

- My patch is coded for the possibility of a non-UNICODE build,
  but I don't follow through on this and am lukewarm to the idea because
  it would be another build configuration to test and maintain.

I am disqualifying myself from making the final decision about this
and will instead ask another gcj person to review this. I am interested
in your feedback concerning this, though.

-- Mohan
http://www.thisiscool.com/
http://www.animalsong.org/


ChangeLog
2003-11-21  Mohan Embar  <gnustuff@thisiscool.com>

	* configure.in: Added -lunicows to MinGW SYSTEMSPEC.
	* configure: Rebuilt.
	* win32.cc (_Jv_Win32NewString): Implemented.
	(_Jv_Win32TempString): Implemented.
	(lots): Refactored using tchar.h macros.
	(WSAEventWrapper): Use _Jv_Win32NewString.
	(_Jv_platform_initialize): Use GetModuleFileNameA instead
	of GetModuleFileName.
	(_Jv_platform_initProperties): Use _Jv_Win32NewString.
	Use temporary stack buffer instead of a heap buffer.
	* include/win32.h
	Added defines for UNICODE, _UNICODE and tchar.h.
	(_Jv_Win32TempString): Declared new helper class.
	(JV_TEMP_STRING_WIN32): New helper macro.
	(_Jv_Win32NewString): Declared new helper method.
	* java/io/natFileDescriptorWin32.cc (open): Use
	JV_TEMP_STRING_WIN32 instead of JV_TEMP_UTF_STRING.
	(write): Reformatted slightly.
	* java/io/natFileWin32.cc (lots): Use tchar.h macros;
	use JV_TEMP_STRING_WIN32 instead of JV_TEMP_UTF_STRING.
	(getCanonicalPath): Use _Jv_Win32NewString instead of
	JvNewStringUTF.
	(performList): Likewise.
	* java/lang/natWin32Process.cc (ChildProcessPipe):
	Use tchar.h macros.
	(startProcess): Use tchar.h macros, JV_TEMP_STRING_WIN32,
	and UNICODE environment flag for CreateProcess.
	* java/net/natNetworkInterfaceWin32.cc
	(winsock2GetRealNetworkInterfaces): Use tchar.h macros and
	_Jv_Win32NewString.

Index: configure.in
===================================================================
RCS file: /cvs/gcc/gcc/libjava/configure.in,v
retrieving revision 1.174
diff -u -2 -r1.174 configure.in
--- configure.in	11 Nov 2003 11:49:11 -0000	1.174
+++ configure.in	21 Nov 2003 07:20:24 -0000
@@ -313,5 +313,5 @@
 case "${host}" in
     *mingw*)
-      SYSTEMSPEC="-lgdi32 -lwsock32 -lws2_32"
+      SYSTEMSPEC="-lunicows -lgdi32 -lwsock32 -lws2_32"
     ;;
     *)
Index: win32.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/win32.cc,v
retrieving revision 1.19
diff -u -2 -r1.19 win32.cc
--- win32.cc	7 Nov 2003 03:13:55 -0000	1.19
+++ win32.cc	21 Nov 2003 07:20:25 -0000
@@ -41,6 +41,48 @@
 }
 
+jstring
+_Jv_Win32NewString (LPTSTR psz)
+{
+#ifdef UNICODE
+  return JvNewString ((jchar*) psz, _tcslen (psz));
+#else
+  return JvNewStringUTF (psz);
+#endif // UNICODE
+}
+
 // Helper classes and methods implementation
   
+// 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.
+  int len = jstr->length();
+  int bytesNeeded = (len + 1) * sizeof(TCHAR);
+  if (bytesNeeded <= (int) sizeof(stackbuf_))
+    buf_ = stackbuf_;
+  else
+    buf_ = (LPTSTR) _Jv_Malloc(bytesNeeded);
+    
+#ifdef UNICODE
+  _tcsncpy(buf_, (LPCTSTR) JvGetStringChars (jstr), len);
+#else
+  JvGetStringUTFRegion (jstr, 0, len, buf_);
+#endif // UNICODE
+
+  buf_[jstr->length()] = 0;
+}
+
+_Jv_Win32TempString::~_Jv_Win32TempString()
+{
+  if (buf_ && buf_ != stackbuf_)
+    _Jv_Free (buf_);
+}
+
 // class WSAEventWrapper
 WSAEventWrapper::WSAEventWrapper (int fd, DWORD dwSelFlags):
@@ -93,14 +135,15 @@
     {
       LPTSTR lpszTemp =
-        (LPTSTR) _Jv_Malloc (strlen (lpszPrologue) +
-          strlen (lpMsgBuf) + 3);
-      strcpy (lpszTemp, lpszPrologue);
-      strcat (lpszTemp, ": ");
-      strcat (lpszTemp, lpMsgBuf);
-      ret = JvNewStringLatin1 (lpszTemp);
+        (LPTSTR) _Jv_Malloc ((_tcslen (lpszPrologue) +
+          _tcslen (lpMsgBuf) + 3) * sizeof(TCHAR) );
+      _tcscpy (lpszTemp, lpszPrologue);
+      _tcscat (lpszTemp, _T(": "));
+      _tcscat (lpszTemp, lpMsgBuf);
+      ret = _Jv_Win32NewString (lpszTemp);
+      _Jv_Free (lpszTemp);
     } 
   else
     {
-      ret = JvNewStringLatin1 (lpMsgBuf);
+      ret = _Jv_Win32NewString (lpMsgBuf);
     }
 
@@ -144,5 +187,5 @@
   WSADATA data;
   if (WSAStartup (MAKEWORD (1, 1), &data))
-    MessageBox (NULL, "Error initialising winsock library.", "Error",
+    MessageBox (NULL, _T("Error initialising winsock library."), _T("Error"),
     MB_OK | MB_ICONEXCLAMATION);
 
@@ -150,6 +193,9 @@
   SetUnhandledExceptionFilter (win32_exception_handler);
 
-  // Initialize our executable name
-  GetModuleFileName(NULL, exec_name, sizeof(exec_name));
+  // Initialize our executable name.
+  // FIXME: We unconditionally use the ANSI function because
+  // _Jv_ThisExecutable returns a const char*. We should really
+  // change _Jv_ThisExecutable to return a jstring.
+  GetModuleFileNameA(NULL, exec_name, sizeof(exec_name));
 }
 
@@ -178,5 +224,5 @@
 }
 
-static bool dirExists (const char* dir)
+static bool dirExists (LPCTSTR dir)
 {
   DWORD dwAttrs = ::GetFileAttributes (dir);
@@ -185,10 +231,10 @@
 }
 
-static void getUserHome(char* userHome, const char* userId)
+static void getUserHome(LPTSTR userHome, LPCTSTR userId)
 {
-  char* uh = ::getenv ("USERPROFILE");
+  LPTSTR uh = _tgetenv (_T("USERPROFILE"));
   if (uh)
     {
-      strcpy(userHome, uh);
+      _tcscpy(userHome, uh);
     }
   else
@@ -203,13 +249,13 @@
       // Windows version, but if we did that, then this attempt
       // wouldn't be half-hearted.
-      char userHomePath[MAX_PATH], winHome[MAX_PATH];
+      TCHAR userHomePath[MAX_PATH], winHome[MAX_PATH];
       ::GetWindowsDirectory(winHome, MAX_PATH);
         // assume this call always succeeds
 
-      sprintf(userHomePath, "%s\\Profiles\\%s", winHome, userId);
+      _stprintf(userHomePath, _T("%s\\Profiles\\%s"), winHome, userId);
       if (dirExists (userHomePath))
-        strcpy(userHome, userHomePath);
+        _tcscpy(userHome, userHomePath);
       else
-        strcpy(userHome, winHome);
+        _tcscpy(userHome, winHome);
     }
 }
@@ -221,13 +267,13 @@
   // A convenience define.
 #define SET(Prop,Val) \
-  newprops->put(JvNewStringLatin1 (Prop), JvNewStringLatin1 (Val))
+  newprops->put(JvNewStringLatin1 (Prop), _Jv_Win32NewString (Val))
 
-  SET ("file.separator", "\\");
-  SET ("path.separator", ";");
-  SET ("line.separator", "\r\n");
+  SET ("file.separator", _T("\\"));
+  SET ("path.separator", _T(";"));
+  SET ("line.separator", _T("\r\n"));
 
   // Use GetCurrentDirectory to set 'user.dir'.
   DWORD buflen = MAX_PATH;
-  char *buffer = (char *) _Jv_MallocUnchecked (buflen);
+  TCHAR buffer[buflen];
   if (buffer != NULL)
     {
@@ -237,16 +283,14 @@
       if (GetTempPath (buflen, buffer))
   SET ("java.io.tmpdir", buffer);
-
-      _Jv_Free (buffer);
     }
 
   // Use GetUserName to set 'user.name'.
   buflen = 257;  // UNLEN + 1
-  char userName[buflen];
+  TCHAR userName[buflen];
   if (GetUserName (userName, &buflen))
     SET ("user.name", userName);
 
   // Set user.home
-  char userHome[MAX_PATH];
+  TCHAR userHome[MAX_PATH];
   getUserHome(userHome, userName);
   SET ("user.home", userHome);
@@ -258,11 +302,9 @@
   if (GetVersionEx (&osvi))
     {
-      char *buffer = (char *) _Jv_MallocUnchecked (30);
       if (buffer != NULL)
         {
-          sprintf (buffer, "%d.%d", (int) osvi.dwMajorVersion,
+          _stprintf (buffer, _T("%d.%d"), (int) osvi.dwMajorVersion,
            (int) osvi.dwMinorVersion);
           SET ("os.version", buffer);
-          _Jv_Free (buffer);
         }
 
@@ -271,26 +313,26 @@
           case VER_PLATFORM_WIN32_WINDOWS:
             if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)
-              SET ("os.name", "Windows 95");
+              SET ("os.name", _T("Windows 95"));
             else if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10)
-              SET ("os.name", "Windows 98");
+              SET ("os.name", _T("Windows 98"));
             else if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90)
-              SET ("os.name", "Windows Me");
+              SET ("os.name", _T("Windows Me"));
             else
-              SET ("os.name", "Windows ??");
+              SET ("os.name", _T("Windows ??"));
             break;
 
           case VER_PLATFORM_WIN32_NT:
             if (osvi.dwMajorVersion <= 4 )
-              SET ("os.name", "Windows NT");
+              SET ("os.name", _T("Windows NT"));
             else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0)
-              SET ("os.name", "Windows 2000");
+              SET ("os.name", _T("Windows 2000"));
             else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1)
-              SET ("os.name", "Windows XP");
+              SET ("os.name", _T("Windows XP"));
             else
-              SET ("os.name", "Windows NT ??");
+              SET ("os.name", _T("Windows NT ??"));
             break;
 
           default:
-            SET ("os.name", "Windows UNKNOWN");
+            SET ("os.name", _T("Windows UNKNOWN"));
             break;
        }
@@ -303,21 +345,21 @@
     {
       case PROCESSOR_ARCHITECTURE_INTEL:
-        SET ("os.arch", "x86");
+        SET ("os.arch", _T("x86"));
         break;
       case PROCESSOR_ARCHITECTURE_MIPS:
-        SET ("os.arch", "mips");
+        SET ("os.arch", _T("mips"));
         break;
       case PROCESSOR_ARCHITECTURE_ALPHA:
-        SET ("os.arch", "alpha");
+        SET ("os.arch", _T("alpha"));
         break;
-      case PROCESSOR_ARCHITECTURE_PPC:	
-        SET ("os.arch", "ppc");
+      case PROCESSOR_ARCHITECTURE_PPC:  
+        SET ("os.arch", _T("ppc"));
         break;
       case PROCESSOR_ARCHITECTURE_IA64:
-        SET ("os.arch", "ia64");
+        SET ("os.arch", _T("ia64"));
         break;
       case PROCESSOR_ARCHITECTURE_UNKNOWN:
       default:
-        SET ("os.arch", "unknown");
+        SET ("os.arch", _T("unknown"));
         break;
     }
Index: include/win32.h
===================================================================
RCS file: /cvs/gcc/gcc/libjava/include/win32.h,v
retrieving revision 1.24
diff -u -2 -r1.24 win32.h
--- include/win32.h	7 Nov 2003 03:13:55 -0000	1.24
+++ include/win32.h	21 Nov 2003 07:20:28 -0000
@@ -12,4 +12,12 @@
 #define __JV_WIN32_H__
 
+// Enable UNICODE Support.
+
+#define UNICODE
+#define _UNICODE
+
+#include <tchar.h>
+
+// Includes
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
@@ -23,4 +31,41 @@
 
 #include <io.h>
+
+/* Begin UNICODE Support Classes and Functions */
+
+/* Helper class which creates a temporary, null-terminated,
+   wide-character C string. */
+class _Jv_Win32TempString
+{
+public:
+  _Jv_Win32TempString(jstring jstr);
+  ~_Jv_Win32TempString();
+
+// Accessors
+  operator LPCTSTR() const
+  {
+    return buf_;
+  }
+  LPCTSTR buf() const
+  {
+    return buf_;
+  }
+  LPTSTR buf()
+  {
+    return buf_;
+  }
+
+private:
+  TCHAR stackbuf_[500];
+  LPTSTR buf_;
+};
+
+// Mimics the JV_TEMP_STRING_UTF macro in jvm.h
+#define JV_TEMP_STRING_WIN32(x,y) _Jv_Win32TempString x(y);
+
+// Creates a jstring from a LPTSTR
+extern jstring _Jv_Win32NewString (LPTSTR psz);
+
+/* End UNICODE Helpers */
 
 // Prefix and suffix for shared libraries.
Index: java/io/natFileDescriptorWin32.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/io/natFileDescriptorWin32.cc,v
retrieving revision 1.16
diff -u -2 -r1.16 natFileDescriptorWin32.cc
--- java/io/natFileDescriptorWin32.cc	7 Nov 2003 03:13:56 -0000	1.16
+++ java/io/natFileDescriptorWin32.cc	21 Nov 2003 07:20:30 -0000
@@ -88,5 +88,5 @@
   DWORD create = OPEN_EXISTING;
   
-  JV_TEMP_UTF_STRING(cpath, path)
+  JV_TEMP_STRING_WIN32(cpath, path)
 
   JvAssert((jflags & READ) || (jflags & WRITE));
@@ -116,5 +116,6 @@
     }
 
-  handle = CreateFile(cpath, access, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, create, 0, NULL);
+  handle = CreateFile(cpath, access, FILE_SHARE_READ | FILE_SHARE_WRITE,
+    NULL, create, 0, NULL);
 
   if (handle == INVALID_HANDLE_VALUE)
@@ -175,4 +176,5 @@
   jbyte *buf = elements (b) + offset;
   DWORD bytesWritten;
+
   if (WriteFile ((HANDLE)fd, buf, len, &bytesWritten, NULL))
     {
@@ -181,5 +183,5 @@
           InterruptedIOException *iioe = new InterruptedIOException (JvNewStringLatin1 ("write interrupted"));
           iioe->bytesTransferred = bytesWritten;
-    throw iioe;
+          throw iioe;
         }
     }
Index: java/io/natFileWin32.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/io/natFileWin32.cc,v
retrieving revision 1.18
diff -u -2 -r1.18 natFileWin32.cc
--- java/io/natFileWin32.cc	31 Oct 2003 03:02:47 -0000	1.18
+++ java/io/natFileWin32.cc	21 Nov 2003 07:20:31 -0000
@@ -41,5 +41,5 @@
 java::io::File::_access (jint query)
 {
-  JV_TEMP_UTF_STRING (canon, getCanonicalPath());
+  JV_TEMP_STRING_WIN32 (canon, getCanonicalPath());
   if (!canon)
     return false;
@@ -55,5 +55,6 @@
     return (attributes == 0xffffffff) ? false : true;
   else
-    return ((attributes != 0xffffffff) && ((attributes & FILE_ATTRIBUTE_READONLY) == 0)) ? true : false;
+    return ((attributes != 0xffffffff) &&
+      ((attributes & FILE_ATTRIBUTE_READONLY) == 0)) ? true : false;
 }
 
@@ -61,5 +62,5 @@
 java::io::File::_stat (jint query)
 {
-  JV_TEMP_UTF_STRING (canon, getCanonicalPath());
+  JV_TEMP_STRING_WIN32 (canon, getCanonicalPath());
   if (!canon)
     return false;
@@ -80,5 +81,5 @@
 java::io::File::attr (jint query)
 {
-  JV_TEMP_UTF_STRING (canon, getCanonicalPath());
+  JV_TEMP_STRING_WIN32 (canon, getCanonicalPath());
   if (!canon)
     return false;
@@ -109,19 +110,17 @@
 java::io::File::getCanonicalPath (void)
 {
-  JV_TEMP_UTF_STRING (cpath, path);
+  JV_TEMP_STRING_WIN32 (cpath, path);
   
   // If the filename is blank, use the current directory.
-  const char* thepath = cpath.buf();
-  if (*thepath == '\0')
-    thepath = ".";
+  LPCTSTR thepath = cpath.buf();
+  if (*thepath == 0)
+    thepath = _T(".");
 
   LPTSTR unused;
-  char buf2[MAX_PATH];
+  TCHAR buf2[MAX_PATH];
   if(!GetFullPathName(thepath, MAX_PATH, buf2, &unused))
     throw new IOException (JvNewStringLatin1 ("GetFullPathName failed"));
 
-  // FIXME: what encoding to assume for file names?  This affects many
-  // calls.
-  return JvNewStringUTF(buf2);
+  return _Jv_Win32NewString (buf2);
 }
 
@@ -162,10 +161,15 @@
   if (! canon)
     return NULL;
-  char *buf = (char *) __builtin_alloca (JvGetStringUTFLength (canon) + 5);
-  jsize total = JvGetStringUTFRegion (canon, 0, canon->length(), buf);
-  if (buf[total-1] == '\\')
-    strcpy (&buf[total], "*.*");
+
+  int len = canon->length();
+  TCHAR buf[len + 5];
+  
+  JV_TEMP_STRING_WIN32(canonstr, canon);
+  
+  _tcscpy(buf, canonstr);
+  if (buf[len - 1] == _T('\\'))
+    _tcscpy (&buf[len], _T("*.*"));
   else
-    strcpy (&buf[total], "\\*.*");
+    _tcscpy (&buf[len], _T("\\*.*"));
 
   WIN32_FIND_DATA data;
@@ -178,19 +182,20 @@
   do
     {
-      if (strcmp (data.cFileName, ".") && strcmp (data.cFileName, ".."))
+      if (_tcscmp (data.cFileName, _T(".")) &&
+        _tcscmp (data.cFileName, _T("..")))
         {
-          jstring name = JvNewStringUTF (data.cFileName);
+          jstring name = _Jv_Win32NewString (data.cFileName);
 
           if (filter && !filter->accept(this, name))
-      continue;
+            continue;
           if (clazz == &java::io::File::class$)
-      {
+            {
               java::io::File *file = new java::io::File (this, name);
               if (fileFilter && !fileFilter->accept(file))
-    continue;
-        vec->addElement (file);
-      }
-    else
-      vec->addElement (name);
+                continue;
+              vec->addElement (file);
+            }
+          else
+            vec->addElement (name);
         }
     }
@@ -210,5 +215,5 @@
 java::io::File::performMkdir (void)
 {
-  JV_TEMP_UTF_STRING (cpath, path);
+  JV_TEMP_STRING_WIN32 (cpath, path);
   return (CreateDirectory(cpath, NULL)) ? true : false;
 }
@@ -217,6 +222,6 @@
 java::io::File::performRenameTo (File *dest)
 {
-  JV_TEMP_UTF_STRING (pathFrom, path);
-  JV_TEMP_UTF_STRING (pathTo, dest->path);
+  JV_TEMP_STRING_WIN32 (pathFrom, path);
+  JV_TEMP_STRING_WIN32 (pathTo, dest->path);
   return (MoveFile(pathFrom, pathTo)) ? true : false;
 }
@@ -225,5 +230,5 @@
 java::io::File::performDelete ()
 {
-  JV_TEMP_UTF_STRING (canon, getCanonicalPath());
+  JV_TEMP_STRING_WIN32 (canon, getCanonicalPath());
   if (!canon)
     return false;
@@ -241,5 +246,5 @@
 jboolean java::io::File::performCreate (void) 
 {
-  JV_TEMP_UTF_STRING (canon, getCanonicalPath());
+  JV_TEMP_STRING_WIN32 (canon, getCanonicalPath());
   if (!canon)
     return false;
@@ -263,5 +268,5 @@
 jboolean java::io::File::performSetReadOnly ()
 {
-  JV_TEMP_UTF_STRING (canon, getCanonicalPath());
+  JV_TEMP_STRING_WIN32 (canon, getCanonicalPath());
   if (!canon)
     return false;
@@ -281,5 +286,5 @@
 jboolean java::io::File::performSetLastModified (jlong time)
 {
-  JV_TEMP_UTF_STRING (canon, getCanonicalPath());
+  JV_TEMP_STRING_WIN32 (canon, getCanonicalPath());
   if (!canon)
     return false;
Index: java/lang/natWin32Process.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/natWin32Process.cc,v
retrieving revision 1.8
diff -u -2 -r1.8 natWin32Process.cc
--- java/lang/natWin32Process.cc	14 Nov 2003 01:48:30 -0000	1.8
+++ java/lang/natWin32Process.cc	21 Nov 2003 07:20:32 -0000
@@ -174,5 +174,5 @@
       DWORD dwErrorCode = GetLastError ();
       throw new java::io::IOException (
-        _Jv_WinStrError ("Error creating pipe", dwErrorCode));
+        _Jv_WinStrError (_T("Error creating pipe"), dwErrorCode));
     }
 
@@ -221,21 +221,23 @@
 
   for (int i = 0; i < progarray->length; ++i)
-    cmdLineLen += (_Jv_GetStringUTFLength (elts[i]) + 1);
+    cmdLineLen += (elts[i]->length() + 1);
 
-  char *cmdLine = (char *) _Jv_Malloc (cmdLineLen + 1);
-  char *cmdLineCurPos = cmdLine;
+  LPTSTR cmdLine = (LPTSTR) _Jv_Malloc ((cmdLineLen + 1) * sizeof(TCHAR));
+  LPTSTR cmdLineCurPos = cmdLine;
 
   for (int i = 0; i < progarray->length; ++i)
     {
       if (i > 0)
-        *cmdLineCurPos++ = ' ';
-      jsize s = _Jv_GetStringUTFLength (elts[i]);
-      _Jv_GetStringUTFRegion (elts[i], 0, elts[i]->length(), cmdLineCurPos);
-      cmdLineCurPos += s;
+        *cmdLineCurPos++ = _T(' ');
+        
+      jint len = elts[i]->length();
+      JV_TEMP_STRING_WIN32(thiselt, elts[i]);
+      _tcscpy(cmdLineCurPos, thiselt);
+      cmdLineCurPos += len;
     }
-  *cmdLineCurPos = '\0';
+  *cmdLineCurPos = _T('\0');
 
   // Get the environment, if any.
-  char *env = NULL;
+  LPTSTR env = NULL;
   if (envp)
     {
@@ -244,23 +246,26 @@
       int envLen = 0;
       for (int i = 0; i < envp->length; ++i)
-        envLen += (_Jv_GetStringUTFLength (elts[i]) + 1);
+        envLen += (elts[i]->length() + 1);
 
-      env = (char *) _Jv_Malloc (envLen + 1);
+      env = (LPTSTR) _Jv_Malloc ((envLen + 1) * sizeof(TCHAR));
 
       int j = 0;
       for (int i = 0; i < envp->length; ++i)
         {
-          jsize s = _Jv_GetStringUTFLength (elts[i]);
-          _Jv_GetStringUTFRegion (elts[i], 0, elts[i]->length(), (env + j));
-
-          j += s;
-          *(env + j) = '\0';
+          jint len = elts[i]->length();
+          
+          JV_TEMP_STRING_WIN32(thiselt, elts[i]);
+          _tcscpy(env + j, thiselt);
+          
+          j += len;
+          
+          // Skip past the null terminator that _tcscpy just inserted.
           j++;
         }
-      *(env + j) = '\0';
+      *(env + j) = _T('\0');
     }
 
   // Get the working directory path, if specified.
-  JV_TEMP_UTF_STRING (wdir, dir ? dir->getPath () : 0);
+  JV_TEMP_STRING_WIN32 (wdir, dir ? dir->getPath () : 0);
 
   errorStream = NULL;
@@ -305,4 +310,5 @@
       // creation of a console window. This flag is ignored on
       // Win9X.
+      
       if (CreateProcess (NULL,
                          cmdLine,
@@ -310,5 +316,5 @@
                          NULL,
                          1,
-                         CREATE_NO_WINDOW,
+                         CREATE_NO_WINDOW | CREATE_UNICODE_ENVIRONMENT,
                          env,
                          wdir,
@@ -318,5 +324,5 @@
           DWORD dwErrorCode = GetLastError ();
           throw new IOException (
-            _Jv_WinStrError ("Error creating child process", dwErrorCode));
+            _Jv_WinStrError (_T("Error creating child process"), dwErrorCode));
         }
 
Index: java/net/natNetworkInterfaceWin32.cc
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/net/natNetworkInterfaceWin32.cc,v
retrieving revision 1.4
diff -u -2 -r1.4 natNetworkInterfaceWin32.cc
--- java/net/natNetworkInterfaceWin32.cc	29 Aug 2003 04:21:01 -0000	1.4
+++ java/net/natNetworkInterfaceWin32.cc	21 Nov 2003 07:20:35 -0000
@@ -71,16 +71,16 @@
       // "lo" for the loopback interface and ethX for the
       // real ones.
-      char szName[30];
+      TCHAR szName[30];
       u_long lFlags = arInterfaceInfo[i].iiFlags;
 
       if (lFlags & IFF_LOOPBACK)
-        strcpy (szName, "lo");
+        _tcscpy (szName, _T("lo"));
       else
         {
-          strcpy (szName, "eth");
-          wsprintf(szName+3, "%d", nCurETHInterface++);
+          _tcscpy (szName, _T("eth"));
+          wsprintf(szName+3, _T("%d"), nCurETHInterface++);
         }
 
-      jstring if_name = JvNewStringLatin1 (szName);
+      jstring if_name = _Jv_Win32NewString (szName);
       java::net::Inet4Address* address =
         new java::net::Inet4Address (baddr, JvNewStringLatin1 (""));




Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]