File.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
    #include <windows.h>
    #include <wchar.h>          // _wmktemp
    #include <errno.h>          // EINVAL
#else
    #include <stdlib.h>         // mkstemp
    #include <sys/ioctl.h>      // available
    #include <dcl/_fcntl.h>
    #include <dcl/_stat.h>
    #include <dcl/_unistd.h>
#endif
#ifdef __sun__
    #include <sys/filio.h>      // FIONREAD
#endif
 
#include <dcl/File.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/File.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(File, Object)
 
#ifndef INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE    -1
#endif
 
String File::toString() const
{
    StringBuilder r = className();
    if (__handle == INVALID_HANDLE_VALUE)
        r += __T(" closed");
    else
        r += __T(" ") + __path;
 
    return r;
}
 
File::~File()
{
    if (__handle != INVALID_HANDLE_VALUE && __closeOnClose) {
        try {
            close();
        }
        catch (Exception* e) {
            __DCL_TRACE1(__T("Error! File::~File %ls\n"), e->toString().data());
            e->destroy();
        }
    }
}
 
File::File()
{
    __handle = INVALID_HANDLE_VALUE;
    __closeOnClose = true;
#ifdef __WINNT__
    __fileType = UNKNOWN;
    __readEvent = NULL;
    __writeEvent = NULL;
#endif
}
 
File::File(const String& _path, int _oflags, int _mode)
    __DCL_THROWS1(IOException*)
{
    __handle = INVALID_HANDLE_VALUE;
    open(_path, _oflags, _mode);
}
 
void File::open(const String& _path, int _oflags, int _mode)
    __DCL_THROWS1(IOException*)
{
    if (__handle != INVALID_HANDLE_VALUE)
        close();
 
    __closeOnClose = true;
#ifdef __WINNT__
    __fileType = UNKNOWN;
    __readEvent = NULL;
    __writeEvent = NULL;
 
    FileType fileType = UNKNOWN;
    // Console, COMM 을 검사한다.
    HANDLE handle = CreateFileW(_path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
    if (handle != INVALID_HANDLE_VALUE) {
        DWORD dw;
        DCB dcb;
        if (GetNamedPipeInfo(handle, NULL, NULL, NULL, NULL))
            fileType = PIPE;
        else if (GetConsoleMode(handle, &dw))
            fileType = CONSOLE;
        else if (GetCommState(handle, &dcb))
            fileType = COMM;
        else
            fileType = REGULAR;
 
        CloseHandle(handle);
        handle = INVALID_HANDLE_VALUE;
    }
 
    DWORD dwDesiredAccess = GENERIC_READ;
    DWORD dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
    SECURITY_ATTRIBUTES securityAttributes = { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
    DWORD dwCreationDisposition = OPEN_EXISTING;
    DWORD dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
 
    switch (_oflags & (READONLY | WRITEONLY | READWRITE)) {
        default:
            // _oflags == 0 이면 READONLY 인 것으로 간주한다.
        case READONLY:
            dwDesiredAccess = GENERIC_READ;
            break;
        case WRITEONLY:
            if (_oflags & APPEND)
                dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
            else
                dwDesiredAccess = GENERIC_WRITE;
            break;
        case READWRITE:
            dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
            break;
    }
 
    if (_oflags & EXCLUSIVE) {
        dwShareMode = 0;
    }
 
    switch (_oflags & (CREATE | EXCLUSIVE | TRUNCATE)) {
        default:
        case EXCLUSIVE:
            dwCreationDisposition = OPEN_EXISTING;
            break;
        case CREATE:
        case CREATE | TRUNCATE:
            dwCreationDisposition = OPEN_ALWAYS;
            break;
        case CREATE | EXCLUSIVE:
        case CREATE | EXCLUSIVE | TRUNCATE:
            dwCreationDisposition = CREATE_NEW;
            break;
        case TRUNCATE:
        case TRUNCATE | EXCLUSIVE:
            dwCreationDisposition = TRUNCATE_EXISTING;
            break;
    }
 
    if (_oflags & NONBLOCK)
        dwFlagsAndAttributes |= FILE_FLAG_OVERLAPPED;
 
    if (_oflags & SYNC)
        dwFlagsAndAttributes |= FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH;
 
    if (fileType == CONSOLE || fileType == PIPE) {
 
        handle = CreateFileW(_path, dwDesiredAccess, dwShareMode, &securityAttributes,
            OPEN_EXISTING, dwFlagsAndAttributes, NULL);
    }
    else if (fileType == COMM) {
        handle = CreateFileW(_path, dwDesiredAccess, dwShareMode, &securityAttributes,
            OPEN_EXISTING, dwFlagsAndAttributes, NULL);
    }
    else {
        // UNKNOWN, maybe REGULAR
        switch (dwDesiredAccess & (GENERIC_READ | GENERIC_WRITE)) {
        case GENERIC_READ:
            dwFlagsAndAttributes |= FILE_FLAG_SEQUENTIAL_SCAN;
            break;
        case GENERIC_READ | GENERIC_WRITE:
            dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS;
            break;
        }
 
        if ((_oflags & TRUNCATE) && ((dwDesiredAccess & GENERIC_WRITE) == GENERIC_WRITE))
            handle = CreateFileW(_path, dwDesiredAccess, dwShareMode,
                &securityAttributes, TRUNCATE_EXISTING, dwFlagsAndAttributes, NULL);
 
        if (handle == INVALID_HANDLE_VALUE)
            handle = CreateFileW(_path, dwDesiredAccess, dwShareMode,
                &securityAttributes, dwCreationDisposition, dwFlagsAndAttributes, NULL);
 
        if ((handle != INVALID_HANDLE_VALUE)
            && (_oflags & APPEND) && ((dwDesiredAccess & GENERIC_READ) == GENERIC_READ)) {
            fileType = REGULAR;
            if (SetFilePointer(handle, 0, NULL, FILE_END) == INVALID_SET_FILE_POINTER) {
                DWORD dwSaveError = GetLastError();
                CloseHandle(handle);
                handle = INVALID_HANDLE_VALUE;
                SetLastError(dwSaveError);
            }
        }
    }
 
    // _oflags에 NONBLOCK이 있으면 read, write Overrlapped Io 하도록 Event 객체를 생성한다.
    HANDLE readEvent = NULL, writeEvent = NULL;
    if (handle != INVALID_HANDLE_VALUE && _oflags & NONBLOCK) {
        __DCL_ASSERT(dwFlagsAndAttributes & FILE_FLAG_OVERLAPPED);
        if (_oflags & (WRITEONLY | READWRITE))
            writeEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 
        // _oflags == 0 이면 READONLY 인 것으로 간주한다.
        if (_oflags & (READONLY | READWRITE) || writeEvent == NULL)
            readEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 
        if (readEvent == NULL && writeEvent == NULL) {
            DWORD dwSaveError = GetLastError();
            if (readEvent)
                CloseHandle(readEvent);
            if (writeEvent)
                CloseHandle(writeEvent);
 
            CloseHandle(handle);
            handle = INVALID_HANDLE_VALUE;
            SetLastError(dwSaveError);
        }
    }
 
    if (handle == INVALID_HANDLE_VALUE)
        throw new IOException(_path, GetLastError());
 
    __fileType = fileType;
    __readEvent = readEvent;
    __writeEvent = writeEvent;
#else
    int oflags = 0;
    if (_oflags & READONLY)
        oflags |= O_RDONLY;
    if (_oflags & WRITEONLY)
        oflags |= O_WRONLY;
    if (_oflags & READWRITE)
        oflags |= O_RDWR;
    if (_oflags & CREATE)
        oflags |= O_CREAT;
    if (_oflags & EXCLUSIVE)
        oflags |= O_EXCL;
    if (_oflags & NOCTTY)
        oflags |= O_NOCTTY;
    if (_oflags & APPEND)
        oflags |= O_APPEND;
    if (_oflags & TRUNCATE)
        oflags |= O_TRUNC;
    if (_oflags & NONBLOCK)
        oflags |= O_NONBLOCK;
    if (_oflags & SYNC)
        oflags |= O_SYNC;
 
    int handle = __open(_path, oflags, _mode);
    if (handle == -1)
        throw new IOException(_path, errno);
#endif
    __handle = handle;
    __path = _path;
}
 
File::File(HandleType _handle, const String& _path)
{
    __handle = _handle;
    __path = _path;
    __closeOnClose = true;
}
 
File::File(HandleType _handle, int _ohints, bool _closeOnClose)
    __DCL_THROWS1(IOException*)
{
    __handle = INVALID_HANDLE_VALUE;
    open(_handle, _ohints, _closeOnClose);
}
 
void File::open(HandleType _handle, int _ohints, bool _closeOnClose)
    __DCL_THROWS1(IOException*)
{
    if (__handle != INVALID_HANDLE_VALUE)
        close();
 
#ifdef __WINNT__
    __fileType = UNKNOWN;
    __readEvent = NULL;
    __writeEvent = NULL;
 
    StringBuilder path;
    FileType fileType = UNKNOWN;
 
    wchar_t nameInfo[PATH_MAX + 1 + 4] = { L'\0' };
    DWORD dwConsoleMode;
    DCB dcb;
    if (GetFileInformationByHandleEx(_handle, FileNameInfo, nameInfo, sizeof(nameInfo))) {
        fileType = REGULAR;
        path.assign(((FILE_NAME_INFO*)nameInfo)->FileName);
    }
    else if (GetNamedPipeInfo(_handle, NULL, NULL, NULL, NULL)) {
        path.format(__T("(pipe: %d)"), _handle);
        fileType = PIPE;
    }
    else if (GetConsoleMode(_handle, &dwConsoleMode)) {
        path = __T("CON");
        fileType = CONSOLE;
    }
    else if (GetCommState(_handle, &dcb)) {
        path = __T("COM#N");
        fileType = COMM;
    }
    else {
        path.format(__T("(HANDLE: %p)"), _handle);
        throw new IOException(path, ERROR_INVALID_HANDLE);
    }
 
    HANDLE readEvent = NULL, writeEvent = NULL;
    if (_ohints & NONBLOCK) {
        if (_ohints & (WRITEONLY | READWRITE))
            writeEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 
        // _oflags == 0 이면 READONLY 인 것으로 간주한다.
        if (_ohints & (READONLY | READWRITE) || writeEvent == NULL)
            readEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
 
        if (readEvent == NULL && writeEvent == NULL) {
            DWORD dwSaveError = GetLastError();
            if (readEvent)
                CloseHandle(readEvent);
            if (writeEvent)
                CloseHandle(writeEvent);
 
            throw new IOException(path, dwSaveError);
        }
    }
 
    __path = path.toString();
    __fileType = fileType;
    __readEvent = readEvent;
    __writeEvent = writeEvent;
#else
    if (isatty(_handle)) {
        if (__ttyname(_handle, __path) != 0)
            throw new IOException(className(), errno);
    }
    else
        __path = String::format(__T("(fd: %d)"), _handle);
#endif
 
    __handle = _handle;
    __closeOnClose = _closeOnClose;
}
 
void File::sync()
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
 
#ifdef __WINNT__
    if (!FlushFileBuffers(__handle))
        // 콘솔과 같이 버러링을 하지 않는 장치
        throw new IOException(__path, GetLastError());
#else
    if (fsync(__handle) == -1)
        // EINVAL, EBADF, EROFS, EIO
        throw new IOException(__path, errno);
#endif
}
 
void File::close()
    __DCL_THROWS1(IOException*)
 
{
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
 
#ifdef __WINNT__
    if (__fileType == COMM)
        PurgeComm(__handle, PURGE_RXABORT | PURGE_RXCLEAR
            | PURGE_TXABORT | PURGE_TXCLEAR);
    __fileType = UNKNOWN;
    if (__readEvent) {
        CloseHandle(__readEvent);
        __readEvent = NULL;
    }
    if (__writeEvent) {
        CloseHandle(__writeEvent);
        __writeEvent = NULL;
    }
#endif
 
    if (!__closeOnClose)
        return;
 
    HandleType handle = __handle;
    String path = __path;
    __handle = INVALID_HANDLE_VALUE;
    __path.clear();
 
#ifdef __WINNT__
    if (!CloseHandle(handle))
        throw new IOException(path, GetLastError());
#else
    if (::close(handle))
        throw(new IOException(path, errno));
#endif
}
 
size_t File::available() const
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
 
#ifdef __WINNT__
    size_t nbytes = 0;
    switch (__fileType) {
        case REGULAR: {
            LARGE_INTEGER fileSize;
            if (GetFileSizeEx(__handle, &fileSize)) {
                LARGE_INTEGER distanceToMove;
                LARGE_INTEGER newFilePointer;
                distanceToMove.QuadPart = 0;
                if (SetFilePointerEx(__handle, distanceToMove, &newFilePointer, FILE_CURRENT))
                    nbytes = (size_t)(fileSize.QuadPart - newFilePointer.QuadPart);
            }
            break;
        }
        case PIPE: {
            DWORD dwTotalBytesAvail;
            if (PeekNamedPipe(__handle, NULL, 0, NULL, &dwTotalBytesAvail, NULL))
                nbytes = (size_t)dwTotalBytesAvail;
            break;
        }
        case CONSOLE: {
            INPUT_RECORD buf[200];      // 200 * (sizeof(INPUT_RECORD) == 20) 4000
            DWORD dwEvents = 0;
            if (PeekConsoleInput(__handle, buf, __countof(buf, INPUT_RECORD), &dwEvents)) {
                size_t n = 0;
                for (size_t i = 0; i < __countof(buf, INPUT_RECORD); i++) {
                    if (buf[i].EventType == KEY_EVENT) {
                        KEY_EVENT_RECORD& ev = buf[i].Event.KeyEvent;
                        if (ev.bKeyDown && ev.uChar.AsciiChar != 0) {
                            if (ev.uChar.AsciiChar == 13) {
                                nbytes = n + 2;     // ReadFile에서 \r\n으로 변환되어 읽힌다.
                                break;
                            }
                            n += ev.wRepeatCount;
                        }
                    }
                }
                // NONBLOCK
                if (nbytes == 0 && __readEvent)
                    nbytes = n;
            }
            break;
        }
        case COMM: {
            DWORD dwErrors;
            COMSTAT stat;
            if (ClearCommError(__handle, &dwErrors, &stat))
                nbytes = (size_t)stat.cbInQue;
            break;
        }
        case SOCKET: {
            u_long n = 0;
            if (ioctlsocket((::SOCKET)__handle, FIONREAD, &n))
                throw new IOException(__path, WSAGetLastError());
            nbytes = (size_t)n;
            break;
        }
        default: {
            __DCL_ASSERT(false);
        }
    }
    return nbytes;
#else
    // x64 nbytes를 off_t(long long int)로 하면 안된다.
    unsigned int nbytes = 0;
    ioctl(__handle, FIONREAD, &nbytes);
    return (size_t)nbytes;
#endif
}
 
size_t File::read(void* _buf, size_t _n)
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
    __DCL_ASSERT_PARAM(_buf != NULL);
 
#ifdef __WINNT__
    DWORD n = 0;
    if (__readEvent) {
        // NONBLOCK, Overrapped Read
        OVERLAPPED ov;
        ZeroMemory(&ov, sizeof(ov));        // cf. memset(&ov, 0, sizeof(ov));
        ov.hEvent = __readEvent;
        if (ReadFile(__handle, _buf, (DWORD)_n, &n, &ov)) {
            // GetOverlappedResult가 성공하면 이벤트는 Set 된다.
            SetEvent(ov.hEvent);
 
            // 다른 스레드에서 WriteFile을 호출했을 경우 n == 0일 수 있다.
            return n;
        }
        if (GetLastError() == ERROR_IO_PENDING) {
            // 읽기가 진행중이다. 마칠때까지 기다린 후 결과를 확인한다.
            switch (WaitForSingleObject(ov.hEvent, INFINITE)) {
                case WAIT_OBJECT_0:
                    if (GetOverlappedResult(__handle, &ov, &n, FALSE))
                        return n;
                    break;
                case WAIT_TIMEOUT:      // 이것은 결코 도달하지 않는다. INFINITE
                    CancelIo(__handle);
                    SetLastError(ERROR_TIMEOUT);
                    break;
                default:
                    __DCL_ASSERT(false);
            }
        }
        // ERROR!
        throw new IOException(__path, GetLastError());
    }
    else {
        // __readEvent == NULL, Blocked Read
        if (!ReadFile(__handle, _buf, (DWORD)_n, &n, NULL))
            throw new IOException(__path, GetLastError());
    }
    return n;
#else
    ssize_t n = 0;
    while ((n = ::read(__handle, _buf, _n)) == -1) {
        // errno가 EAGAIN or EWOULDBLOCK인 경우
        // fd가 O_NONBLOCK으로 열렸고, 읽기가 차단되었다.
        // EAGAIN이면 0바이트를 읽었고, 읽기를 다시 시도한다.
        // 그 외에는 오류이다.
        if (!(errno == EAGAIN || errno == EWOULDBLOCK)) {
            throw new IOException(__path, errno);
        }
    }
    return n;
#endif
}
 
size_t File::write(const void* _buf, size_t _n)
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
    __DCL_ASSERT_PARAM(_buf != NULL);
 
#ifdef __WINNT__
    DWORD n = 0;
    if (__writeEvent) {
        // NONBLOCK, Overrapped Write
        OVERLAPPED ov;
        ZeroMemory(&ov, sizeof(ov));        // cf. memset(&ov, 0, sizeof(ov));
        ov.hEvent = __writeEvent;
        if (WriteFile(__handle, _buf, (DWORD)_n, &n, &ov)) {
            // GetOverlappedResult가 성공하면 이벤트는 Set 된다.
            SetEvent(ov.hEvent);
            // 다른 스레드에서 ReadFile을 호출했을 경우 n == 0일 수 있다.
            return n;
        }
        if (GetLastError() == ERROR_IO_PENDING) {
            // 쓰기가 진행중이다. 마칠때까지 기다린 후 결과를 확인한다.
            switch (WaitForSingleObject(ov.hEvent, INFINITE)) {
                case WAIT_OBJECT_0:
                    if (GetOverlappedResult(__handle, &ov, &n, FALSE))
                        return n;
                    break;
                case WAIT_TIMEOUT:      // 이것은 결코 도달하지 않는다. INFINITE
                    CancelIo(__handle);
                    SetLastError(ERROR_TIMEOUT);
                default:
                    __DCL_ASSERT(false);
            }
        }
        // ERROR!
        throw new IOException(__path, GetLastError());
    }
    else {
        // __writeEvent == NULL, Blocked Write
        if (!WriteFile(__handle, _buf, (DWORD)_n, &n, NULL))
            throw new IOException(__path, GetLastError());
    }
    return n;
#else
    ssize_t n = ::write(__handle, _buf, _n);
    if (n == -1) {
        // 파일이 nonblocking으로 표시되었고 오퍼레이션이 블록되었다.
        if (errno == EAGAIN || errno == EWOULDBLOCK)
            return 0;
        else
            throw new IOException(__path, errno);
    }
    return n;
#endif
}
 
File::off_t File::seek(off_t _offset, int _whence)
    __DCL_THROWS1(IOException*)
{ 
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
 
#ifdef __WINNT__
    DWORD dwMoveMethod = FILE_BEGIN;
    switch (_whence) {
        case BEGIN:
            dwMoveMethod = FILE_BEGIN;
            break;
        case CURRENT:
            dwMoveMethod = FILE_CURRENT;
            break;
        case END:
            dwMoveMethod = FILE_END;
            break;
        default:
            __DCL_ASSERT(false);
    }
    LARGE_INTEGER distanceToMove;
    LARGE_INTEGER newFilePointer;
    distanceToMove.QuadPart = _offset;
    if (!SetFilePointerEx(__handle, distanceToMove, &newFilePointer, dwMoveMethod))
        throw new IOException(__path, GetLastError());
    return newFilePointer.QuadPart;
#else
    int whence = 0;
    switch (_whence) {
        case BEGIN :
            whence = SEEK_SET;
            break;
        case CURRENT :
            whence = SEEK_CUR;
            break;
        case END :
            whence = SEEK_END;
            break;
        default :
            __DCL_ASSERT(false);
    }
 
    off_t r = lseek(__handle, _offset, whence);
    if (r == (off_t)-1)
        throw (new IOException(__path, errno));
    return r;
#endif
}
 
File::off_t File::size() const
    __DCL_THROWS1(IOException*)
{
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
 
#ifdef __WINNT__
    LARGE_INTEGER fileSize;
    if (!GetFileSizeEx(__handle, &fileSize))
        throw new IOException(__path, GetLastError());
    return fileSize.QuadPart;
#else
    struct stat st;
    int r = fstat(__handle, &st);
    if (r == -1)
        throw (new IOException(__path, errno));
 
    return st.st_size;
#endif
}
 
DateTime File::mtime() const
    __DCL_THROWS1(IOException*)
{
    time_t mtime;
    if (!time((time_t * )NULL, &mtime, (time_t * )NULL)) {
#ifdef __WINNT__
        throw new IOException(__path, GetLastError());
#else
        throw (new IOException(__path, errno));
#endif
    }
    return DateTime(mtime);
}
 
bool File::time(time_t* _atime, time_t* _mtime, time_t* _ctime) const
{
    __DCL_ASSERT_HANDLE(__handle != INVALID_HANDLE_VALUE);
 
#ifdef __WINNT__
    FILETIME atime;
    FILETIME mtime;
    FILETIME ctime;
    if (!GetFileTime(__handle, &atime, &mtime, &ctime)) {
        return false;
    }
 
    ULARGE_INTEGER n;
    if (_atime) {
        n.HighPart = atime.dwHighDateTime;
        n.LowPart = atime.dwLowDateTime;
        *_atime = n.QuadPart;
    }
    if (_mtime) {
        n.HighPart = mtime.dwHighDateTime;
        n.LowPart = mtime.dwLowDateTime;
        *_mtime = n.QuadPart;
    }
    if (_ctime) {
        n.HighPart = ctime.dwHighDateTime;
        n.LowPart = ctime.dwLowDateTime;
        *_ctime = n.QuadPart;
    }
#else
    struct stat sb;
    int r = fstat(__handle, &sb);
    if (r == -1) {
        return false;
    }
    if (_atime) {
        *_atime = sb.st_atime;
    }
    if (_mtime) {
        *_mtime = sb.st_mtime;
    }
    if (_ctime) {
        *_ctime = sb.st_ctime;
    }
#endif
    return true;
}
 
// "dir/prefixXXXXX" 이름의 파일을 생성하여 파일 기술자를 리턴
File* File::openTempFile(
    const String& _dirname,
    const String& _prefix,
    unsigned int _mode              // = 0666
) __DCL_THROWS1(IOException*)
{
    File* r = NULL;
 
    StringBuilder sbTemplate;
    if (!_dirname.isEmpty()) {
        sbTemplate = _dirname;
        if (!_dirname.endsWith(L"/")) {
            sbTemplate += L"/";
        }
    }
 
    if (!_prefix.isEmpty()) {
        sbTemplate += _prefix;
    }
    else {
        sbTemplate += L"dcl";
    }
 
    sbTemplate += L"XXXXXX";
 
#ifdef __WINNT__
    if (::_wmktemp((wchar_t*)sbTemplate.data())) {
        r = new File(sbTemplate, READWRITE | CREATE | EXCLUSIVE, _mode);
    }
    else {
        throw new IOException(sbTemplate, EINVAL);
    }
#else
    ByteString bsbTemplate = UTF8Encoder::encode(sbTemplate.toString());
    int handle = ::mkstemp((char*)bsbTemplate.data());
    if (handle == -1) {
        throw new IOException(sbTemplate, errno);
    }
 
    struct stat st;
    if (::fstat(handle, &st)) {
        throw new IOException(sbTemplate, errno);
    }
 
    if (st.st_mode != _mode) {
        if (::fchmod(handle, _mode)) {
            throw new IOException(sbTemplate, errno);
        }
    }
 
    r = new File(handle, UTF8Decoder::decode(bsbTemplate));
#endif
    return r;
}
 
__DCL_END_NAMESPACE