mirror
/
openmw
mirror of https://github.com/OpenMW/openmw.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Merge branch 'platform-file' into 'master'

Browse Source 
Move platform specific file code into platform and cleanup LowLevelFile

See merge request OpenMW/openmw!2143
LTO-timing^2
psi29a 2 years ago
parent b032a643f9 03302a8f5b
commit 7c442926f8
7 changed files with 365 additions and 341 deletions
Show Stats Download Patch File Download Diff File

15
components/CMakeLists.txt
Unescape Escape View File

@ -337,8 +337,23 @@ add_component_dir(navmeshtool
add_component_dir(platform
platform
file
)
if (WIN32)
add_component_dir(platform
file.win32
)
elseif (UNIX)
add_component_dir(platform
file.posix
)
else ()
add_component_dir(platform
file.stdio
)
endif()
set (ESM_UI ${CMAKE_SOURCE_DIR}/files/ui/contentselector.ui
)

327
components/files/lowlevelfile.cpp
Unescape Escape View File

@ -4,333 +4,50 @@
#include <sstream>
#include <cassert>
#if FILE_API == FILE_API_STDIO
#include <errno.h>
#include <string.h>
#endif
namespace File = Platform::File;
#if FILE_API == FILE_API_POSIX
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#endif
#if FILE_API == FILE_API_STDIO
/*
*
* Implementation of LowLevelFile methods using c stdio
*
*/
LowLevelFile::LowLevelFile ()
{
mHandle = nullptr;
}
LowLevelFile::~LowLevelFile ()
{
if (mHandle != nullptr)
fclose (mHandle);
}
void LowLevelFile::open (char const * filename)
{
assert (mHandle == nullptr);
mHandle = fopen (filename, "rb");
if (mHandle == nullptr)
{
std::ostringstream os;
os << "Failed to open '" << filename << "' for reading: " << strerror(errno);
throw std::runtime_error (os.str ());
}
}
void LowLevelFile::close ()
{
assert (mHandle != nullptr);
fclose (mHandle);
mHandle = nullptr;
}
size_t LowLevelFile::size ()
{
assert (mHandle != nullptr);
long oldPosition = ftell (mHandle);
if (oldPosition == -1)
{
throw std::runtime_error ("An ftell() call failed: " + std::string(strerror(errno)));
}
if (fseek (mHandle, 0, SEEK_END) != 0)
{
throw std::runtime_error ("An fseek() call failed: " + std::string(strerror(errno)));
}
long size = ftell (mHandle);
if (size == -1)
{
throw std::runtime_error ("An ftell() call failed: " + std::string(strerror(errno)));
}
if (fseek (mHandle, oldPosition, SEEK_SET) != 0)
{
throw std::runtime_error ("An fseek() call failed: " + std::string(strerror(errno)));
}
return size_t (size);
}
void LowLevelFile::seek (size_t position)
{
assert (mHandle != nullptr);
if (fseek (mHandle, position, SEEK_SET) != 0)
{
throw std::runtime_error ("An fseek() call failed: " + std::string(strerror(errno)));
}
}
size_t LowLevelFile::tell ()
{
assert (mHandle != nullptr);
long position = ftell (mHandle);
if (position == -1)
{
throw std::runtime_error ("An ftell() call failed: " + std::string(strerror(errno)));
}
return size_t (position);
}
size_t LowLevelFile::read (void * data, size_t size)
{
assert (mHandle != nullptr);
int amount = fread (data, 1, size, mHandle);
if (amount == 0 && ferror (mHandle))
{
std::ostringstream os;
os << "An attempt to read " << size << " bytes failed: " << strerror(errno);
throw std::runtime_error (os.str ());
}
return amount;
}
#elif FILE_API == FILE_API_POSIX
/*
*
* Implementation of LowLevelFile methods using posix IO calls
*
*/
LowLevelFile::LowLevelFile ()
{
mHandle = -1;
}
LowLevelFile::~LowLevelFile ()
{
if (mHandle != -1)
::close (mHandle);
}
void LowLevelFile::open (char const * filename)
{
assert (mHandle == -1);
#ifdef O_BINARY
static const int openFlags = O_RDONLY | O_BINARY;
#else
static const int openFlags = O_RDONLY;
#endif
mHandle = ::open (filename, openFlags, 0);
if (mHandle == -1)
{
std::ostringstream os;
os << "Failed to open '" << filename << "' for reading: " << strerror(errno);
throw std::runtime_error (os.str ());
}
}
void LowLevelFile::close ()
LowLevelFile::~LowLevelFile()
{
assert (mHandle != -1);
::close (mHandle);
mHandle = -1;
if (mHandle != File::Handle::Invalid)
File::close(mHandle);
}
size_t LowLevelFile::size ()
void LowLevelFile::open(char const* filename)
{
assert (mHandle != -1);
size_t oldPosition = ::lseek (mHandle, 0, SEEK_CUR);
if (oldPosition == size_t (-1))
{
throw std::runtime_error ("An lseek() call failed: " + std::string(strerror(errno)));
}
size_t size = ::lseek (mHandle, 0, SEEK_END);
if (size == size_t (-1))
{
throw std::runtime_error ("An lseek() call failed: " + std::string(strerror(errno)));
}
if (lseek (mHandle, oldPosition, SEEK_SET) == -1)
{
throw std::runtime_error ("An lseek() call failed: " + std::string(strerror(errno)));
}
return size;
mHandle = File::open(filename);
}
void LowLevelFile::seek (size_t position)
void LowLevelFile::close()
{
assert (mHandle != -1);
if (::lseek (mHandle, position, SEEK_SET) == -1)
{
throw std::runtime_error ("An lseek() call failed: " + std::string(strerror(errno)));
}
if (mHandle != File::Handle::Invalid)
File::close(mHandle);
mHandle = File::Handle::Invalid;
}
size_t LowLevelFile::tell ()
size_t LowLevelFile::size()
{
assert (mHandle != -1);
size_t position = ::lseek (mHandle, 0, SEEK_CUR);
assert(mHandle != File::Handle::Invalid);
if (position == size_t (-1))
{
throw std::runtime_error("An lseek() call failed: " + std::string(strerror(errno)));
}
return position;
return File::size(mHandle);
}
size_t LowLevelFile::read (void * data, size_t size)
void LowLevelFile::seek(size_t position)
{
assert (mHandle != -1);
int amount = ::read (mHandle, data, size);
assert(mHandle != File::Handle::Invalid);
if (amount == -1)
{
std::ostringstream os;
os << "An attempt to read " << size << " bytes failed: " << strerror(errno);
throw std::runtime_error (os.str ());
}
return amount;
return File::seek(mHandle, position);
}
#elif FILE_API == FILE_API_WIN32
#include <boost/locale.hpp>
/*
*
* Implementation of LowLevelFile methods using Win32 API calls
*
*/
LowLevelFile::LowLevelFile ()
size_t LowLevelFile::tell()
{
mHandle = INVALID_HANDLE_VALUE;
}
assert(mHandle != File::Handle::Invalid);
LowLevelFile::~LowLevelFile ()
{
if (mHandle != INVALID_HANDLE_VALUE)
CloseHandle (mHandle);
return File::tell(mHandle);
}
void LowLevelFile::open (char const * filename)
size_t LowLevelFile::read(void* data, size_t size)
{
assert (mHandle == INVALID_HANDLE_VALUE);
assert(mHandle != File::Handle::Invalid);
std::wstring wname = boost::locale::conv::utf_to_utf<wchar_t>(filename);
HANDLE handle = CreateFileW (wname.c_str(), GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
if (handle == INVALID_HANDLE_VALUE)
{
std::ostringstream os;
os << "Failed to open '" << filename << "' for reading: " << GetLastError();
throw std::runtime_error (os.str ());
}
mHandle = handle;
return File::read(mHandle, data, size);
}
void LowLevelFile::close ()
{
assert (mHandle != INVALID_HANDLE_VALUE);
CloseHandle (mHandle);
mHandle = INVALID_HANDLE_VALUE;
}
size_t LowLevelFile::size ()
{
assert (mHandle != INVALID_HANDLE_VALUE);
BY_HANDLE_FILE_INFORMATION info;
if (!GetFileInformationByHandle (mHandle, &info))
throw std::runtime_error ("A query operation on a file failed.");
if (info.nFileSizeHigh != 0)
throw std::runtime_error ("Files greater that 4GB are not supported.");
return info.nFileSizeLow;
}
void LowLevelFile::seek (size_t position)
{
assert (mHandle != INVALID_HANDLE_VALUE);
if (SetFilePointer (mHandle, static_cast<LONG>(position), nullptr, SEEK_SET) == INVALID_SET_FILE_POINTER)
if (GetLastError () != NO_ERROR)
throw std::runtime_error ("A seek operation on a file failed.");
}
size_t LowLevelFile::tell ()
{
assert (mHandle != INVALID_HANDLE_VALUE);
DWORD value = SetFilePointer (mHandle, 0, nullptr, SEEK_CUR);
if (value == INVALID_SET_FILE_POINTER && GetLastError () != NO_ERROR)
throw std::runtime_error ("A query operation on a file failed.");
return value;
}
size_t LowLevelFile::read (void * data, size_t size)
{
assert (mHandle != INVALID_HANDLE_VALUE);
DWORD read;
if (!ReadFile (mHandle, data, static_cast<DWORD>(size), &read, nullptr))
throw std::runtime_error ("A read operation on a file failed.");
return read;
}
#endif

46
components/files/lowlevelfile.hpp
Unescape Escape View File

@ -2,53 +2,27 @@
#define COMPONENTS_FILES_LOWLEVELFILE_HPP
#include <cstdlib>
#include <memory>
#define FILE_API_STDIO 0
#define FILE_API_POSIX 1
#define FILE_API_WIN32 2
#if defined(__linux) || defined(__unix) || defined(__posix)
#define FILE_API FILE_API_POSIX
#elif defined(_WIN32)
#define FILE_API FILE_API_WIN32
#else
#define FILE_API FILE_API_STDIO
#endif
#if FILE_API == FILE_API_STDIO
#include <cstdio>
#elif FILE_API == FILE_API_POSIX
#elif FILE_API == FILE_API_WIN32
#include <components/windows.hpp>
#else
#error Unsupported File API
#endif
#include <components/platform/file.hpp>
class LowLevelFile
{
public:
~LowLevelFile();
LowLevelFile ();
~LowLevelFile ();
void open (char const * filename);
void close ();
void open(char const* filename);
void close();
size_t size ();
size_t size();
void seek (size_t Position);
size_t tell ();
void seek(size_t Position);
size_t tell();
size_t read (void * data, size_t size);
size_t read(void* data, size_t size);
private:
#if FILE_API == FILE_API_STDIO
FILE* mHandle;
#elif FILE_API == FILE_API_POSIX
int mHandle;
#elif FILE_API == FILE_API_WIN32
HANDLE mHandle;
#endif
Platform::File::Handle mHandle{ Platform::File::Handle::Invalid };
};
#endif

35
components/platform/file.hpp
Unescape Escape View File

@ -0,0 +1,35 @@
#ifndef OPENMW_COMPONENTS_PLATFORM_FILE_HPP
#define OPENMW_COMPONENTS_PLATFORM_FILE_HPP
#include <cstdlib>
#include <string_view>
namespace Platform::File {
enum class Handle : intptr_t
{
Invalid = -1
};
enum class SeekType
{
Begin,
Current,
End
};
Handle open(const char* filename);
void close(Handle handle);
size_t size(Handle handle);
void seek(Handle handle, size_t Position, SeekType type = SeekType::Begin);
size_t tell(Handle handle);
size_t read(Handle handle, void* data, size_t size);
}
#endif // OPENMW_COMPONENTS_PLATFORM_FILE_HPP

99
components/platform/file.posix.cpp
Unescape Escape View File

@ -0,0 +1,99 @@
#include "file.hpp"
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdexcept>
#include <string>
namespace Platform::File {
static auto getNativeHandle(Handle handle)
{
return static_cast<int>(handle);
}
static int getNativeSeekType(SeekType seek)
{
if (seek == SeekType::Begin)
return SEEK_SET;
if (seek == SeekType::Current)
return SEEK_CUR;
if (seek == SeekType::End)
return SEEK_END;
return -1;
}
Handle open(const char* filename)
{
#ifdef O_BINARY
static const int openFlags = O_RDONLY | O_BINARY;
#else
static const int openFlags = O_RDONLY;
#endif
auto handle = ::open(filename, openFlags, 0);
if (handle == -1)
{
throw std::runtime_error(std::string("Failed to open '") + filename + "' for reading: " + strerror(errno));
}
return static_cast<Handle>(handle);
}
void close(Handle handle)
{
auto nativeHandle = getNativeHandle(handle);
::close(nativeHandle);
}
void seek(Handle handle, size_t position, SeekType type /*= SeekType::Begin*/)
{
const auto nativeHandle = getNativeHandle(handle);
const auto nativeSeekType = getNativeSeekType(type);
if (::lseek(nativeHandle, position, nativeSeekType) == -1)
{
throw std::runtime_error("An lseek() call failed: " + std::string(strerror(errno)));
}
}
size_t size(Handle handle)
{
const auto oldPos = tell(handle);
seek(handle, 0, SeekType::End);
const auto fileSize = tell(handle);
seek(handle, oldPos, SeekType::Begin);
return static_cast<size_t>(fileSize);
}
size_t tell(Handle handle)
{
auto nativeHandle = getNativeHandle(handle);
size_t position = ::lseek(nativeHandle, 0, SEEK_CUR);
if (position == size_t(-1))
{
throw std::runtime_error("An lseek() call failed: " + std::string(strerror(errno)));
}
return position;
}
size_t read(Handle handle, void* data, size_t size)
{
auto nativeHandle = getNativeHandle(handle);
int amount = ::read(nativeHandle, data, size);
if (amount == -1)
{
throw std::runtime_error("An attempt to read " + std::to_string(size) + " bytes failed: " + strerror(errno));
}
return amount;
}
}

88
components/platform/file.stdio.cpp
Unescape Escape View File

@ -0,0 +1,88 @@
#include "file.hpp"
#include <errno.h>
#include <string.h>
#include <string>
#include <stdexcept>
namespace Platform::File {
static auto getNativeHandle(Handle handle)
{
return reinterpret_cast<FILE*>(static_cast<intptr_t>(handle));
}
static int getNativeSeekType(SeekType seek)
{
if (seek == SeekType::Begin)
return SEEK_SET;
if (seek == SeekType::Current)
return SEEK_CUR;
if (seek == SeekType::End)
return SEEK_END;
return -1;
}
Handle open(const char* filename)
{
FILE* handle = fopen(filename, "rb");
if (handle == nullptr)
{
throw std::runtime_error(std::string("Failed to open '") + filename + "' for reading: " + strerror(errno));
}
return static_cast<Handle>(reinterpret_cast<intptr_t>(handle));
}
void close(Handle handle)
{
auto nativeHandle = getNativeHandle(handle);
fclose(nativeHandle);
}
void seek(Handle handle, size_t position, SeekType type /*= SeekType::Begin*/)
{
const auto nativeHandle = getNativeHandle(handle);
const auto nativeSeekType = getNativeSeekType(type);
if (fseek(nativeHandle, position, nativeSeekType) != 0)
{
throw std::runtime_error(std::string("An fseek() call failed: ") + strerror(errno));
}
}
size_t size(Handle handle)
{
auto nativeHandle = getNativeHandle(handle);
const auto oldPos = tell(handle);
seek(handle, 0, SeekType::End);
const auto fileSize = tell(handle);
seek(handle, oldPos, SeekType::Begin);
return static_cast<size_t>(fileSize);
}
size_t tell(Handle handle)
{
auto nativeHandle = getNativeHandle(handle);
long position = ftell(nativeHandle);
if (position == -1)
{
throw std::runtime_error(std::string("An ftell() call failed: ") + strerror(errno));
}
return static_cast<size_t>(position);
}
size_t read(Handle handle, void* data, size_t size)
{
auto nativeHandle = getNativeHandle(handle);
int amount = fread(data, 1, size, nativeHandle);
if (amount == 0 && ferror(nativeHandle))
{
throw std::runtime_error(std::string("An attempt to read ") + std::to_string(size) + " bytes failed: " + strerror(errno));
}
return static_cast<size_t>(amount);
}
}

96
components/platform/file.win32.cpp
Unescape Escape View File

@ -0,0 +1,96 @@
#include "file.hpp"
#include <components/windows.hpp>
#include <string>
#include <stdexcept>
#include <boost/locale.hpp>
namespace Platform::File {
static auto getNativeHandle(Handle handle)
{
return reinterpret_cast<HANDLE>(static_cast<intptr_t>(handle));
}
static int getNativeSeekType(SeekType seek)
{
if (seek == SeekType::Begin)
return FILE_BEGIN;
if (seek == SeekType::Current)
return FILE_CURRENT;
if (seek == SeekType::End)
return FILE_END;
return -1;
}
Handle open(const char* filename)
{
std::wstring wname = boost::locale::conv::utf_to_utf<wchar_t>(filename);
HANDLE handle = CreateFileW(wname.c_str(), GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
if (handle == INVALID_HANDLE_VALUE)
{
throw std::runtime_error(std::string("Failed to open '") + filename + "' for reading: " + std::to_string(GetLastError()));
}
return static_cast<Handle>(reinterpret_cast<intptr_t>(handle));
}
void close(Handle handle)
{
auto nativeHandle = getNativeHandle(handle);
CloseHandle(nativeHandle);
}
void seek(Handle handle, size_t position, SeekType type /*= SeekType::Begin*/)
{
const auto nativeHandle = getNativeHandle(handle);
const auto nativeSeekType = getNativeSeekType(type);
if (SetFilePointer(nativeHandle, static_cast<LONG>(position), nullptr, nativeSeekType) == INVALID_SET_FILE_POINTER)
{
if (auto errCode = GetLastError(); errCode != ERROR_SUCCESS)
{
throw std::runtime_error(std::string("An fseek() call failed: ") + std::to_string(errCode));
}
}
}
size_t size(Handle handle)
{
auto nativeHandle = getNativeHandle(handle);
assert(isValidHandle(mHandle));
BY_HANDLE_FILE_INFORMATION info;
if (!GetFileInformationByHandle(nativeHandle, &info))
throw std::runtime_error("A query operation on a file failed.");
if (info.nFileSizeHigh != 0)
throw std::runtime_error("Files greater that 4GB are not supported.");
return info.nFileSizeLow;
}
size_t tell(Handle handle)
{
auto nativeHandle = getNativeHandle(handle);
DWORD value = SetFilePointer(nativeHandle, 0, nullptr, SEEK_CUR);
if (value == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
throw std::runtime_error("A query operation on a file failed.");
return value;
}
size_t read(Handle handle, void* data, size_t size)
{
auto nativeHandle = getNativeHandle(handle);
DWORD bytesRead{};
if (!ReadFile(nativeHandle, data, static_cast<DWORD>(size), &bytesRead, nullptr))
throw std::runtime_error(std::string("A read operation on a file failed: ") + std::to_string(GetLastError()));
return bytesRead;
}
}
Write Preview
Loading…
Cancel
Save