Filenames with accented characters

[João Garcia]

Hi Mohan,

>This is a known issue. João has solved this problem, but I
>can't find his original post on java-patches. Here is what
>is left of the thread:
>
>http://gcc.gnu.org/ml/java-patches/2003-q3/threads.html#00622
>
>  
>
It seems to be this post:
http://gcc.gnu.org/ml/java-patches/2003-q3/msg00634.html

>My offer to make an unofficial 3.4 build if João gives me a patch
>which applies to 3.4 still stands.
>  
>
And I am still willing to accept it.
I was not able to build neither a cross-compiler nor a native compiler 
for Mingw (different errors) with the 3.4 snapshot that I had got by the 
end of September (and this errors occured before I applied my patch to 
the snapshot)...
Since the begining of October up until now I have run out of spare-time 
to use in this project... I am sorry. I will give it another try as soon 
as possible.

I would not dare to suggest an untested version of the full patch for 
3.4 (char and wchar_t version). But I will do so for a simple char 
version in the following lines...
This works for all win32 desktop flavours (so it is better as a 
temporary solution) and can be done in three simple steps:

1-Replace all references to JV_TEMP_UTF_STRING by 
JV_TEMP_UTF_STRING_WIN32 in files
    libjava/java/io/natFileDescriptorWin32.cc and 
libjava/java/io/natFileWin32.cc.

2-Put the following code (untested code) in libjava/include/win32.h.

////////////////////////////////////////////////
//begin (helper class, macro and function declaration)
/* Helper class which converts a jstring to a temporary char*.
   Uses the supplied buffer, if non-null. Otherwise, allocates
   the buffer on the heap. Use the JV_TEMP_UTF_STRING_WIN32 macro,
   which follows, to automatically allocate a stack buffer if
   the string is small enough. */
class _Jv_TempUTFStringWin32
{
public:
  _Jv_TempUTFStringWin32(jstring jstr, char* buf=0, int offset=0);
  ~_Jv_TempUTFStringWin32();

// Accessors
  operator const char*() const
  {
    return buf_;
  }
  const char* buf() const
  {
    return buf_;
  }
  char* buf()
  {
    return buf_;
  }
  jsize total()
  {
      return len;
  }

private:
  char* buf_;
  bool heapAllocated_;
  jsize len;
};

inline _Jv_TempUTFStringWin32::_Jv_TempUTFStringWin32 (jstring jstr, 
char* buf, int offset)
  : buf_(0), heapAllocated_(false)
{
  if (!jstr) return;
  len = (jsize) WideCharToMultiByte(GetACP(), 0, (const WCHAR*) 
JvGetStringChars(jstr), jstr->length(), NULL, 0, NULL, NULL); 
//JvGetStringUTFLength (jstr);
  if (buf)
    buf_ = buf;
  else
    {
      buf_ = (char*) _Jv_Malloc (len +1 +offset);
      heapAllocated_ = true;
    }

  WideCharToMultiByte(GetACP(), 0, (const WCHAR*) 
JvGetStringChars(jstr), jstr->length(), buf_, (int) len, NULL, NULL);
  if (offset==0) buf_[len] = '\0';
}

inline _Jv_TempUTFStringWin32::~_Jv_TempUTFStringWin32 ()
{
  if (heapAllocated_)
    _Jv_Free (buf_);
}

/* Macro which uses _Jv_TempUTFStringWin32. Allocates a stack-based
   buffer if the string and its null terminator are <= 256
   characters in length. Otherwise, a heap-based buffer is
   used. The parameters to this macro are the variable name
   which is an instance of _Jv_TempUTFStringWin32 (above) and a
   jstring.

   Sample Usage:

   jstring jstr = getAJString();
   JV_TEMP_UTF_STRING_WIN32(utfstr, jstr, offset);
   printf("The string is: %s\n", utfstr.buf());

 */
#define JV_TEMP_UTF_STRING_WIN32(utfstr, jstr, offset) \
  jstring utfstr##thejstr = (jstr); \
  jsize utfstr##_len = utfstr##thejstr ? (jsize) 
WideCharToMultiByte(GetACP(), 0, (const WCHAR*) 
JvGetStringChars(utfstr##thejstr), (utfstr##thejstr)->length(), NULL, 0, 
NULL, NULL) + 1 + (offset) : 0; \
  char utfstr##_buf[utfstr##_len <= 256 ? utfstr##_len : 0]; \
  _Jv_TempUTFStringWin32 utfstr(utfstr##thejstr, sizeof(utfstr##_buf)==0 
? 0 : utfstr##_buf, (offset))


extern jstring
JvNewStringUTFWin32 (const char *bytes);

//end (helper class, macro and function declaration)
/////////////////////////////////////////////////////////////////////////////

3- Put the following code (untested code) in libjava/win32.cc

/////////////////////////////////////////////////////////////////////
//begin (convert win32-locale string to jstring)
jstring
JvNewStringUTFWin32 (const char *bytes)
{

  int length = strlen (bytes);
  if (length < 0)
    return NULL;

  jstring jstr = JvAllocString (MultiByteToWideChar(GetACP(), 0, bytes, 
length, NULL, 0));
  jchar *chrs = JvGetStringChars (jstr);

  MultiByteToWideChar(GetACP(), 0, bytes, length, (WCHAR*) chrs, 
jstr->length());

  return jstr;
}
//end (convert win32-locale string to jstring)
///////////////////////////////////////////////////////////////////


I hope this can be of some help as a temporary solution.

João