Subversion Repositories openrisc

// natFileChannelImplWin32.cc - Native part of FileChannelImpl class.

/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004  Free Software

   Foundation, Inc.

   This file is part of libgcj.

This software is copyrighted work licensed under the terms of the

Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for

details.  */

// FIXME: In order to support interrupting of IO operations, we

// need to change to use the windows asynchronous IO functions

#include <config.h>

#include <platform.h>

#include <gcj/cni.h>

#include <gcj/javaprims.h>

#include <jvm.h>

#include <stdio.h>

#include <gnu/gcj/RawData.h>

#include <gnu/java/nio/FileLockImpl.h>

#include <gnu/java/nio/channels/FileChannelImpl.h>

#include <java/io/FileNotFoundException.h>

#include <java/io/IOException.h>

#include <java/io/SyncFailedException.h>

#include <java/io/InterruptedIOException.h>

#include <java/io/EOFException.h>

#include <java/lang/ArrayIndexOutOfBoundsException.h>

#include <java/lang/NullPointerException.h>

#include <java/lang/System.h>

#include <java/lang/String.h>

#include <java/lang/Thread.h>

#include <java/nio/ByteBuffer.h>

#include <java/nio/MappedByteBufferImpl.h>

#include <java/nio/channels/FileChannel.h>

#include <java/nio/channels/FileLock.h>

#include <gnu/java/nio/channels/FileChannelImpl.h>

using gnu::gcj::RawData;

using java::io::IOException;

using java::nio::MappedByteBufferImpl;

using java::io::InterruptedIOException;

using java::io::FileNotFoundException;

using java::lang::ArrayIndexOutOfBoundsException;

using gnu::java::nio::channels::FileChannelImpl;

#undef STRICT

static bool testCanUseGetHandleInfo()

{

  /* Test to see whether GetHandleInformation can be used

     for console input or screen buffers. This is better

     a kludgy OS version check. */

  DWORD dwFlags;

  return GetHandleInformation (GetStdHandle (STD_INPUT_HANDLE),

    &dwFlags) != 0;

}

// FIXME: casting a FILE (pointer) to a jint will not work on Win64 --

//        we should be using gnu.gcj.RawData's.

void

FileChannelImpl::init(void)

{

  in = new FileChannelImpl((jint)(GetStdHandle (STD_INPUT_HANDLE)),

                           FileChannelImpl::READ);

  out = new FileChannelImpl((jint)(GetStdHandle (STD_OUTPUT_HANDLE)),

                            FileChannelImpl::WRITE);

  err = new FileChannelImpl((jint)(GetStdHandle (STD_ERROR_HANDLE)),

                            FileChannelImpl::WRITE);

}

#if 0

FileChannelImpl::sync (void) {

  if (! FlushFileBuffers ((HANDLE)fd))

  {

    DWORD dwErrorCode = GetLastError ();

    throw new SyncFailedException (_Jv_WinStrError (dwErrorCode));

  }

}

#endif

jint

FileChannelImpl::open (jstring path, jint jflags) {

  HANDLE handle = NULL;

  DWORD access = 0;

  DWORD create = OPEN_EXISTING;

  JV_TEMP_STRING_WIN32(cpath, path)

  JvAssert((jflags & READ) || (jflags & WRITE));

  if ((jflags & READ) && (jflags & WRITE))

    {

      access = GENERIC_READ | GENERIC_WRITE;

      if (jflags & EXCL)

        create = CREATE_NEW; // this will raise error if file exists.

      else

        create = OPEN_ALWAYS; // equivalent to O_CREAT

    }

  else if (jflags & READ)

    {

      access = GENERIC_READ;

      create = OPEN_EXISTING; // ignore EXCL

    }

  else

    {

      access = GENERIC_WRITE;

      if (jflags & EXCL)

        create = CREATE_NEW;

      else if (jflags & APPEND)

        create = OPEN_ALWAYS;

      else

        create = CREATE_ALWAYS;

    }

  handle = CreateFile(cpath, access, FILE_SHARE_READ | FILE_SHARE_WRITE,

    NULL, create, 0, NULL);

  if (handle == INVALID_HANDLE_VALUE)

    {

       DWORD dwErrorCode = GetLastError ();

       throw new FileNotFoundException (_Jv_WinStrError (cpath, dwErrorCode));

    }

  // For APPEND mode, move the file pointer to the end of the file.

  if (jflags & APPEND)

    {

      DWORD low = SetFilePointer (handle, 0, NULL, FILE_END);

      if ((low == (DWORD) 0xffffffff) && (GetLastError () != NO_ERROR))

      {

        DWORD dwErrorCode = GetLastError ();

        throw new FileNotFoundException (_Jv_WinStrError (cpath, dwErrorCode));

      }

    }

  // Make this handle non-inheritable so that child

  // processes don't inadvertently prevent us from

  // closing this file.

  _Jv_platform_close_on_exec (handle);

  return (jint) handle;

}

void

FileChannelImpl::write (jint b)

{

  DWORD bytesWritten;

  jbyte buf = (jbyte)b;

  if (WriteFile ((HANDLE)fd, &buf, 1, &bytesWritten, NULL))

    {

      if (::java::lang::Thread::interrupted())

        {

          InterruptedIOException *iioe = new InterruptedIOException (JvNewStringLatin1 ("write interrupted"));

          iioe->bytesTransferred = bytesWritten;

    throw iioe;

        }

      if (bytesWritten != 1)

        _Jv_ThrowIOException ();

    }

  else

    _Jv_ThrowIOException ();

  // FIXME: loop until bytesWritten == 1

}

void

FileChannelImpl::write(jbyteArray b, jint offset, jint len)

{

  if (! b)

    throw new ::java::lang::NullPointerException;

  if(offset < 0 || len < 0 || offset + len > JvGetArrayLength (b))

    throw new ArrayIndexOutOfBoundsException;

  jbyte *buf = elements (b) + offset;

  DWORD bytesWritten;

  if (WriteFile ((HANDLE)fd, buf, len, &bytesWritten, NULL))

    {

      if (::java::lang::Thread::interrupted())

        {

          InterruptedIOException *iioe = new InterruptedIOException (JvNewStringLatin1 ("write interrupted"));

          iioe->bytesTransferred = bytesWritten;

          throw iioe;

        }

    }

  else

    _Jv_ThrowIOException ();

  // FIXME: loop until bytesWritten == len

}

void

FileChannelImpl::implCloseChannel (void)

{

  HANDLE save = (HANDLE)fd;

  fd = (jint)INVALID_HANDLE_VALUE;

  if (! CloseHandle (save))

    _Jv_ThrowIOException ();

}

void

FileChannelImpl::implTruncate (jlong size)

{

  LONG liOrigFilePointer;

  LONG liNewFilePointer;

  LONG liEndFilePointer;

  // Get the original file pointer.

  if (SetFilePointer((HANDLE) fd, (LONG) 0, &liOrigFilePointer,

         FILE_CURRENT) != (BOOL) 0

      && (GetLastError() != NO_ERROR))

    _Jv_ThrowIOException ();

  // Get the length of the file.

  if (SetFilePointer((HANDLE) fd, (LONG) 0, &liEndFilePointer,

         FILE_END) != (BOOL) 0

      && (GetLastError() != NO_ERROR))

    _Jv_ThrowIOException ();

  if ((jlong)liEndFilePointer == size)

    {

      // Restore the file pointer.

      if (liOrigFilePointer != liEndFilePointer)

  {

    if (SetFilePointer((HANDLE) fd, liOrigFilePointer, &liNewFilePointer,

           FILE_BEGIN) != (BOOL) 0

        && (GetLastError() != NO_ERROR))

      _Jv_ThrowIOException ();

  }

      return;

    }

  // Seek to the new end of file.

  if (SetFilePointer((HANDLE) fd, (LONG) size, &liNewFilePointer,

         FILE_BEGIN) != (BOOL) 0

      && (GetLastError() != NO_ERROR))

    _Jv_ThrowIOException ();

  // Truncate the file at this point.

  if (SetEndOfFile((HANDLE) fd) != (BOOL) 0 && (GetLastError() != NO_ERROR))

    _Jv_ThrowIOException ();

  if (liOrigFilePointer < liNewFilePointer)

    {

      // Restore the file pointer.

      if (SetFilePointer((HANDLE) fd, liOrigFilePointer, &liNewFilePointer,

        FILE_BEGIN) != (BOOL) 0

        && (GetLastError() != NO_ERROR))

        _Jv_ThrowIOException ();

    }

}

void

FileChannelImpl::seek (jlong newPos)

{

  LONG high = pos >> 32;

  DWORD low = SetFilePointer ((HANDLE)fd, (DWORD)(0xffffffff & newPos), &high, FILE_BEGIN);

  if ((low == 0xffffffff) && (GetLastError () != NO_ERROR))

    _Jv_ThrowIOException ();

}

jlong

FileChannelImpl::implPosition (void)

{

  LONG high = 0;

  DWORD low = SetFilePointer ((HANDLE)fd, 0, &high, FILE_CURRENT);

  if ((low == 0xffffffff) && (GetLastError() != NO_ERROR))

    _Jv_ThrowIOException ();

  return (((jlong)high) << 32L) | (jlong)low;

}

jlong

FileChannelImpl::size (void)

{

  DWORD high;

  DWORD low;

  low = GetFileSize ((HANDLE)fd, &high);

  // FIXME: Error checking

  return (((jlong)high) << 32L) | (jlong)low;

}

jint

FileChannelImpl::read (void)

{

  CHAR buf;

  DWORD read;

  if (! ReadFile ((HANDLE)fd, &buf, 1, &read, NULL))

    {

      if (GetLastError () == ERROR_BROKEN_PIPE)

        return -1;

      else

        _Jv_ThrowIOException ();

    }

  if (! read)

    return -1;

  else

    return (jint)(buf & 0xff);

}

jint

FileChannelImpl::read (jbyteArray buffer, jint offset, jint count)

{

  if (! buffer)

    throw new ::java::lang::NullPointerException;

  jsize bsize = JvGetArrayLength (buffer);

  if (offset < 0 || count < 0 || offset + count > bsize)

    throw new ArrayIndexOutOfBoundsException;

  // Must return 0 if an attempt is made to read 0 bytes.

  if (count == 0)

    return 0;

  jbyte *bytes = elements (buffer) + offset;

  DWORD read;

  if (! ReadFile((HANDLE)fd, bytes, count, &read, NULL))

    {

      if (GetLastError () == ERROR_BROKEN_PIPE)

        return -1;

      else

        _Jv_ThrowIOException ();

    }

  if (read == 0) return -1;

  return (jint)read;

}

jint

FileChannelImpl::available (void)

{

  // FIXME:

  return size() - position();

}

jboolean

FileChannelImpl::lock (jlong pos, jlong len, jboolean shared, jboolean wait)

{

  DWORD flags = 0;

  OVERLAPPED ovlpd;

  ZeroMemory(&ovlpd,sizeof(OVERLAPPED));

  if(!shared)

    flags |= LOCKFILE_EXCLUSIVE_LOCK;

  if(!wait)

    flags |= LOCKFILE_FAIL_IMMEDIATELY;

  ovlpd.Offset = (DWORD)pos;

  ovlpd.OffsetHigh = pos>>32;

  DWORD lenlow = (DWORD)len;

  DWORD lenhigh = len>>32;

  BOOL ret = LockFileEx((HANDLE)fd,flags,0,lenlow,lenhigh,&ovlpd);

  if(ret==ERROR_IO_PENDING && !shared && wait)

    ret = GetOverlappedResult((HANDLE)fd,&ovlpd,NULL,wait);

  if(!ret)

    _Jv_ThrowIOException(GetLastError());

  return true;

}

void

FileChannelImpl::unlock (jlong pos, jlong len)

{

  OVERLAPPED ovlpd;

  ZeroMemory(&ovlpd,sizeof(OVERLAPPED));

  ovlpd.Offset = (DWORD)pos;

  ovlpd.OffsetHigh = pos>>32;

  DWORD lenlow = (DWORD)len;

  DWORD lenhigh = len>>32;

  BOOL ret = UnlockFileEx((HANDLE)fd,0,lenlow,lenhigh,&ovlpd);

  if(!ret)

    _Jv_ThrowIOException(GetLastError());

}

java::nio::MappedByteBuffer *

FileChannelImpl::mapImpl (jchar mmode, jlong position, jint size)

{

  SYSTEM_INFO siSysInfo;

  GetSystemInfo(&siSysInfo);

  DWORD page_size = siSysInfo.dwPageSize;

  jlong offset = position & ~(page_size-1);

  jint align = position - offset;

  jlong high = position + size;

  jlong max_size;

  if (mmode == '+')

    max_size = high - offset;

  else

    max_size = 0;

  DWORD access, protect;

  if (mmode == 'r')

    {

      access = FILE_MAP_READ;

      protect = PAGE_READONLY;

    }

  else if (mmode == '+')

    {

      access = FILE_MAP_WRITE;

      protect = PAGE_READWRITE;

    }

  else

    {

      access = FILE_MAP_COPY;

      protect = PAGE_WRITECOPY;

    }

  HANDLE hFileMapping = CreateFileMapping((HANDLE) fd,

                                          (LPSECURITY_ATTRIBUTES) NULL,

                                          protect,

                                          (DWORD) (max_size >> 32),

                                          (DWORD) max_size,

                                          (LPCTSTR) NULL);

  if (hFileMapping == NULL)

    throw new IOException();

  void *ptr = MapViewOfFile(hFileMapping, access,

                            (DWORD) (offset >> 32), (DWORD) offset,

                            (SIZE_T) (high - offset));

  if (ptr == NULL)

    throw new IOException();

  MappedByteBufferImpl *buf

    = new MappedByteBufferImpl((RawData *) ((char *) ptr + align),

                               size, mode == 'r');

  buf->implPtr = reinterpret_cast<RawData*> (ptr);

  buf->implLen = (jlong) (size_t) hFileMapping;

  return buf;

}

void

MappedByteBufferImpl::unmapImpl ()

{

  UnmapViewOfFile((void*)implPtr);

  CloseHandle((HANDLE) (size_t) implLen);

}

void

MappedByteBufferImpl::loadImpl ()

{

}

jboolean

MappedByteBufferImpl::isLoadedImpl ()

{

  return true;

}

void

MappedByteBufferImpl::forceImpl ()

{

}