MemoryCopy streamers and CMake features

Athena.pro

@@ -36,9 +36,6 @@ ATHENA_PRO=true
 include(Athena.pri)
 
 
-OTHER_FILES += \
-    .travis.yml
-
 unix {
     isEmpty(PREFIX) {
         PREFIX = /usr/local

AthenaConfig.cmake.in

@@ -0,0 +1,22 @@
+# - Config file for the Athena package
+# It defines the following variables
+#  ATHENA_INCLUDE_DIR  - include directory for Athena
+#  ATHENA_LIBRARIES    - libraries to link against
+#  ATHENA_ICON         - path to Athena.ico
+ 
+# Compute paths
+get_filename_component(ATHENA_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+set(ATHENA_INCLUDE_DIR "@CONF_INCLUDE_DIR@")
+ 
+# Our library dependencies (contains definitions for IMPORTED targets)
+if(NOT TARGET AthenaCore AND NOT Athena_BINARY_DIR)
+  include("${ATHENA_CMAKE_DIR}/AthenaTargets.cmake")
+endif()
+ 
+# These are IMPORTED targets created by AthenaTargets.cmake
+set(ATHENA_LIBRARIES AthenaCore AthenaSakura AthenaZelda AthenaWiiSave)
+
+# Set icon location if on windows
+if(WIN32 AND NOT CYGWIN)
+set(ATHENA_ICON "@CONF_ICON_DIR@")
+endif()

AthenaConfigVersion.cmake.in

@@ -0,0 +1,11 @@
+set(PACKAGE_VERSION "@ATHENA_VERSION@")
+ 
+# Check whether the requested PACKAGE_FIND_VERSION is compatible
+if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+  set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}")
+    set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+endif()

AthenaCore.pri

@@ -56,10 +56,6 @@ HEADERS += \
     $$PWD/include/LZ77/LZLookupTable.hpp \
     $$PWD/include/LZ77/LZType10.hpp \
     $$PWD/include/LZ77/LZType11.hpp \
-    $$PWD/include/utf8.h \
-    $$PWD/include/utf8/checked.h \
-    $$PWD/include/utf8/core.h \
-    $$PWD/include/utf8/unchecked.h \
     $$PWD/include/Athena/FileInfo.hpp \
     $$PWD/include/Athena/Dir.hpp \
     $$PWD/include/gekko_support.h \

CMakeLists.txt

@@ -1,10 +1,24 @@
 cmake_minimum_required(VERSION 3.0)
 project(Athena)
 
+##################
+# Athena Version #
+##################
+
+set(ATHENA_MAJOR_VERSION 2)
+set(ATHENA_MINOR_VERSION 0)
+set(ATHENA_PATCH_VERSION 0)
+set(ATHENA_VERSION
+  ${ATHENA_MAJOR_VERSION}.${ATHENA_MINOR_VERSION}.${ATHENA_PATCH_VERSION})
+
+################
+# Athena Build #
+################
+
 add_subdirectory(extern)
 file(GLOB ATHENA_HEADERS include/Athena/*.hpp)
 
-include_directories(include)
+include_directories(include ${LZO_INCLUDE_DIR} ${ZLIB_INCLUDE_DIR})
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 
 if(WIN32)
@@ -134,8 +148,94 @@ add_library(AthenaZelda
     include/Athena/SkywardSwordQuest.hpp
 )
 
+# Offer the user the choice of overriding the installation directories
+set(INSTALL_LIB_DIR lib CACHE PATH "Installation directory for libraries")
+set(INSTALL_INCLUDE_DIR include CACHE PATH "Installation directory for header files")
+if(WIN32 AND NOT CYGWIN)
+  set(DEF_INSTALL_CMAKE_DIR cmake)
+else()
+  set(DEF_INSTALL_CMAKE_DIR lib/cmake/Athena)
+endif()
+set(INSTALL_CMAKE_DIR ${DEF_INSTALL_CMAKE_DIR} CACHE PATH "Installation directory for CMake files")
 
-install(DIRECTORY include DESTINATION include/Athena)
+# Make relative paths absolute (needed later on)
+foreach(p LIB INCLUDE CMAKE)
+  set(var INSTALL_${p}_DIR)
+  if(NOT IS_ABSOLUTE "${${var}}")
+    set(ABS_${var} "${CMAKE_INSTALL_PREFIX}/${${var}}")
+  else()
+    set(ABS_${var} "${${var}}")
+  endif()
+endforeach()
+
+# Define installs
+install(DIRECTORY include/ DESTINATION ${INSTALL_INCLUDE_DIR}/Athena)
 install(TARGETS AthenaCore AthenaSakura AthenaWiiSave AthenaZelda
-        DESTINATION lib/Athena)
+        DESTINATION ${INSTALL_LIB_DIR} EXPORT AthenaTargets)
+if(WIN32 AND NOT CYGWIN)
+install(FILES Athena.ico DESTINATION ${INSTALL_LIB_DIR})
+elseif(UNIX)
+install(FILES lib/pkgconfig/libAthena.pc 
+        DESTINATION ${INSTALL_LIB_DIR}/pkgconfig)
+endif()
+
+##################
+# Package Export #
+##################
+
+# Add all targets to the build-tree export set
+export(TARGETS AthenaCore AthenaSakura AthenaWiiSave AthenaZelda
+  FILE "${PROJECT_BINARY_DIR}/AthenaTargets.cmake")
+
+# Export the package for use from the build-tree
+# (this registers the build-tree with a global CMake-registry)
+export(PACKAGE Athena)
+
+# Create the AthenaConfig.cmake
+# ... for the build tree
+set(CONF_INCLUDE_DIR "${PROJECT_SOURCE_DIR}/include")
+set(CONF_ICON_DIR "${PROJECT_SOURCE_DIR}/Athena.ico")
+configure_file(AthenaConfig.cmake.in "${PROJECT_BINARY_DIR}/AthenaConfig.cmake" @ONLY)
+# ... for the install tree
+file(RELATIVE_PATH REL_INCLUDE_DIR "${ABS_INSTALL_CMAKE_DIR}" "${ABS_INSTALL_INCLUDE_DIR}")
+file(RELATIVE_PATH REL_ICON_DIR "${ABS_INSTALL_CMAKE_DIR}" "${ABS_INSTALL_LIB_DIR}/Athena.ico")
+set(CONF_INCLUDE_DIR "\${ATHENA_CMAKE_DIR}/${REL_INCLUDE_DIR}")
+set(CONF_ICON_DIR "\${ATHENA_CMAKE_DIR}/${REL_ICON_DIR}")
+configure_file(AthenaConfig.cmake.in "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/AthenaConfig.cmake" @ONLY)
+# ... for both
+configure_file(AthenaConfigVersion.cmake.in "${PROJECT_BINARY_DIR}/AthenaConfigVersion.cmake" @ONLY)
+
+# Install AthenaConfig.cmake
+install(FILES
+  "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/AthenaConfig.cmake"
+  "${PROJECT_BINARY_DIR}/AthenaConfigVersion.cmake"
+  DESTINATION ${INSTALL_CMAKE_DIR} COMPONENT dev)
+
+# Install the export set for use with the install-tree
+install(EXPORT AthenaTargets DESTINATION ${INSTALL_CMAKE_DIR} COMPONENT dev)
+
+#########
+# CPack #
+#########
+
+include(InstallRequiredSystemLibraries)
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Athena")
+set(CPACK_PACKAGE_VENDOR "2015 Antidote / Jackoalan")
+set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
+set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
+set(CPACK_PACKAGE_VERSION_MAJOR ${ATHENA_MAJOR_VERSION})
+set(CPACK_PACKAGE_VERSION_MINOR ${ATHENA_MINOR_VERSION})
+set(CPACK_PACKAGE_VERSION_PATCH ${ATHENA_PATCH_VERSION})
+set(CPACK_PACKAGE_INSTALL_DIRECTORY "Athena")
+if(WIN32 AND NOT UNIX)
+    # There is a bug in NSI that does not handle full unix paths properly. Make
+    # sure there is at least one set of four (4) backlasshes.
+    set(CPACK_PACKAGE_ICON "${CMAKE_CURRENT_SOURCE_DIR}/Athena.ico")
+    set(CPACK_NSIS_INSTALLED_ICON_NAME "Athena.ico")
+    set(CPACK_NSIS_DISPLAY_NAME "Athena")
+    set(CPACK_NSIS_URL_INFO_ABOUT "http://libathena.github.io")
+    set(CPACK_NSIS_CONTACT "antidote.crk@gmail.com")
+    set(CPACK_NSIS_MODIFY_PATH ON)
+endif()
+include(CPack)
 

PKGBUILD

@@ -1,14 +1,14 @@
 # PKGBUILD for libAthena
 _pkgname=libathena
 pkgname=$_pkgname-git
-pkgver=1.1.0.59.g582d2ce
+pkgver=1.1.0.60.g8ca7027
 pkgrel=1
 pkgdesc="Basic cross platform IO library"
 arch=('i686' 'x86_64')
 source=("${pkgname%-*}::git+https://github.com/libAthena/Athena.git")
 options=(staticlibs)
 license="MIT"
-makedepends=('git qt5-base sed')
+makedepends=('git cmake sed')
 md5sums=('SKIP')
 sha256sums=('SKIP')
 
@@ -19,11 +19,13 @@ pkgver() {
 
 build() {
     cd "$srcdir/$_pkgname"
-    qmake PREFIX="$pkgdir/usr" && make
+    mkdir build && cd build
+    cmake -DCMAKE_INSTALL_PREFIX="$pkgdir/usr" ..
+    make
 }
 
 package() {
-    cd "$srcdir/$_pkgname"
+    cd "$srcdir/$_pkgname/build"
-	qmake PREFIX="$pkgdir/usr" && make install
+	make install
 }
 

extern/lzo/CMakeLists.txt

@@ -1,4 +1,6 @@
-add_library(lzo
+find_library(LZO_LIB lzo2)
+if(LZO_LIB STREQUAL LZO_LIB-NOTFOUND)
+add_library(lzo2
     src/lzo1.c
     src/lzo1_99.c
     src/lzo1a.c
@@ -71,3 +73,7 @@ add_library(lzo
     include/lzo/lzoconf.h
     include/lzo/lzodefs.h
     include/lzo/lzoutil.h)
+install(DIRECTORY include/lzo DESTINATION include/lzo)
+install(TARGETS lzo2 DESTINATION lib)
+set(LZO_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include CACHE PATH "LZO include path" FORCE)
+endif()

extern/zlib/CMakeLists.txt

@@ -1,4 +1,6 @@
-add_library(zlib
+find_package(ZLIB)
+if(NOT ZLIB_FOUND)
+add_library(z
     adler32.c
     compress.c
     crc32.c
@@ -21,3 +23,7 @@ add_library(zlib
     zconf.h
     zlib.h
     zutil.h)
+install(FILES zconf.h zlib.h DESTINATION include)
+install(TARGETS z DESTINATION lib)
+set(ZLIB_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR} CACHE PATH "Zlib include path" FORCE)
+endif()

include/Athena/ALTTPFileReader.hpp

@@ -35,9 +35,9 @@ namespace io
  *  all work is done using a memory buffer, and not read directly from the disk.
  *  \sa BinaryReader
  */
-class ALTTPFileReader : protected MemoryReader
+class ALTTPFileReader : protected MemoryCopyReader
 {
-    MEMORYREADER_BASE();
+    MEMORYCOPYREADER_BASE();
 
 public:
     /*! \brief This constructor takes an existing buffer to read from.

include/Athena/ALTTPFileWriter.hpp

@@ -34,9 +34,9 @@ namespace io
  *  all work is done using a memory buffer, and not written directly to the disk.
  *  \sa BinaryReader
  */
-class ALTTPFileWriter : protected MemoryWriter
+class ALTTPFileWriter : protected MemoryCopyWriter
 {
-    MEMORYWRITER_BASE();
+    MEMORYCOPYWRITER_BASE();
 
 public:
     /*! \brief This constructor takes an existing buffer to write to.

include/Athena/MCFileReader.hpp

@@ -34,9 +34,9 @@ namespace io
  *  all work is done using a memory buffer, and not read directly from the disk.
  *  \sa BinaryReader
  */
-class MCFileReader : public MemoryReader
+class MCFileReader : public MemoryCopyReader
 {
-    MEMORYREADER_BASE();
+    MEMORYCOPYREADER_BASE();
 public:
     /*!
      *  \brief This constructor takes an existing buffer to read from.

include/Athena/MCFileWriter.hpp

@@ -35,9 +35,9 @@ namespace io
  *  all work is done using a memory buffer, and not written directly from the disk.
  *  \sa BinaryWriter
  */
-class MCFileWriter : protected MemoryWriter
+class MCFileWriter : protected MemoryCopyWriter
 {
-    MEMORYWRITER_BASE();
+    MEMORYCOPYWRITER_BASE();
 public:
     /*!
      * \brief This constructor takes an existing buffer to write to.

include/Athena/MemoryReader.hpp

@@ -20,21 +20,13 @@ namespace io
 class MemoryReader : public IStreamReader
 {
 public:
-    ~MemoryReader();
+    /*! \brief This constructor references an existing buffer to read from.
-
-    /*! \brief This constructor takes an existing buffer to read from.
      *
      *   \param data The existing buffer
      *   \param length The length of the existing buffer
      */
     MemoryReader(const atUint8* data, atUint64 length);
 
-    /*! \brief This constructor creates an instance from a file on disk.
-     *
-     * \param filename The file to create the stream from
-     */
-    MemoryReader(const std::string& filename);
-
     /*! \brief Sets the buffers position relative to the specified position.<br />
      *         It seeks relative to the current position by default.
      *  \param position where in the buffer to seek
@@ -78,14 +70,44 @@ public:
      */
     atUint8* data() const;
 
+    /*! \brief Reads a specified number of bytes to user-allocated buffer
+     *  \param buf User-allocated buffer pointer
+     *  \param len Length to read
+     *  \return Number of bytes read
+     */
     atUint64 readUBytesToBuf(void* buf, atUint64 len);
 
+protected:
+    const atUint8*   m_data;
+    atUint64         m_length;
+    atUint64         m_position;
+};
+
+class MemoryCopyReader : public MemoryReader
+{
+public:
+    /*! \brief This constructor copies an existing buffer to read from.
+     *
+     *   \param data The existing buffer
+     *   \param length The length of the existing buffer
+     */
+    MemoryCopyReader(const atUint8* data, atUint64 length);
+
+    /*! \brief This constructor creates an instance from a file on disk.
+     *
+     * \param filename The file to create the stream from
+     */
+    MemoryCopyReader(const std::string& filename)
+    : MemoryReader(NULL, 0),
+      m_filepath(filename)
+    {loadData();}
+
+    void setData(const atUint8* data, atUint64 length);
+
 protected:
     void loadData();
-    atUint8*      m_data;
+    std::unique_ptr<atUint8[]> m_dataCopy;
-    atUint64      m_length;
     std::string   m_filepath; //!< Path to the target file
-    atUint64      m_position;
 };
 
 } // io
@@ -98,4 +120,11 @@ private: \
 
 #endif // MEMORYREADER_BASE
 
+#ifndef MEMORYCOPYREADER_BASE
+#define MEMORYCOPYREADER_BASE() \
+private: \
+    typedef Athena::io::MemoryCopyReader base
+
+#endif // MEMORYCOPYREADER_BASE
+
 #endif // MEMORYREADER_HPP

include/Athena/MemoryWriter.hpp

@@ -21,21 +21,13 @@ namespace io
 class MemoryWriter : public IStreamWriter
 {
 public:
-    ~MemoryWriter();
 
-    /*! \brief This constructor takes an existing buffer to write to.
+    /*! \brief This constructor references an existing buffer to write to in-place.
      *
      *   \param data The existing buffer
      *   \param length The length of the existing buffer
      */
-    explicit MemoryWriter(atUint8* data = nullptr, atUint64 length = 0x10);
+    explicit MemoryWriter(atUint8* data, atUint64 length);
-
-    /*! \brief This constructor creates an instance from a file on disk.
-     *
-     * \param filename The file to create the stream from
-     */
-    MemoryWriter(const std::string& filename, std::function<void(int)> progressFun = nullptr);
-
 
     /*! \brief Sets the buffers position relative to the specified position.<br />
      *         It seeks relative to the current position by default.
@@ -70,7 +62,7 @@ public:
      *  \param length The length of the new buffer.
      *  \throw IOException
      */
-    void  setData(const atUint8* data, atUint64 length);
+    void  setData(atUint8* data, atUint64 length);
 
 
     /*! \brief Returns a copy of the current buffer.<br />
@@ -111,13 +103,62 @@ public:
     void writeUBytes(const atUint8* data, atUint64 len);
 
 protected:
+    MemoryWriter() {}
     atUint8*      m_data;
     atUint64      m_length;
-    std::string   m_filepath; //!< Path to the target file
     atUint64      m_position;
+    std::string   m_filepath; //!< Path to the target file
+};
+
+class MemoryCopyWriter : public MemoryWriter
+{
+public:
+
+    /*! \brief This constructor copies an existing buffer to write to.
+     *
+     *   \param data The existing buffer
+     *   \param length The length of the existing buffer
+     */
+    explicit MemoryCopyWriter(atUint8* data=nullptr, atUint64 length=0x10);
+
+    /*! \brief This constructor creates an instance from a file on disk.
+     *
+     * \param filename The file to create the stream from
+     */
+    MemoryCopyWriter(const std::string& filename);
+
+    /*! \brief Sets the buffers position relative to the specified position.<br />
+     *         It seeks relative to the current position by default.
+     *  \param position where in the buffer to seek
+     *  \param origin The Origin to seek \sa SeekOrigin
+     */
+    void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current);
+
+    /*! \brief Sets the buffer to the given one, deleting the current one.<br />
+     *         <b>BEWARE:</b> As this deletes the current buffer it WILL cause a loss of data
+     *         if that was not the intent.<br />
+     *         Once you pass the data to setData <b>DO NOT</b> delete the buffer
+     *         as Stream now owns the address, this is done to keep memory usage down.
+     *  \param data The new buffer.
+     *  \param length The length of the new buffer.
+     *  \throw IOException
+     */
+    void  setData(const atUint8* data, atUint64 length);
+
+    /*! \brief Writes the given buffer with the specified length, buffers can be bigger than the length
+     *  however it's undefined behavior to try and write a buffer which is smaller than the given length.
+     *
+     * \param data The buffer to write
+     * \param length The amount to write
+     */
+    void writeUBytes(const atUint8* data, atUint64 len);
+
+protected:
+    std::unique_ptr<atUint8[]> m_dataCopy;
 private:
     void resize(atUint64 newSize);
 };
+
 }
 }
 
@@ -126,4 +167,11 @@ private:
     private: \
         typedef Athena::io::MemoryWriter base
 #endif // BINARYWRITER_BASE
+
+#ifndef MEMORYCOPYWRITER_BASE
+#define MEMORYCOPYWRITER_BASE() \
+    private: \
+        typedef Athena::io::MemoryCopyWriter base
+#endif // BINARYWRITER_BASE
+
 #endif // MEMORYWRITER_HPP

include/Athena/SkywardSwordFileReader.hpp

@@ -24,9 +24,9 @@ namespace Athena
 class SkywardSwordFile;
 namespace io
 {
-class SkywardSwordFileReader : public MemoryReader
+class SkywardSwordFileReader : public MemoryCopyReader
 {
-    MEMORYREADER_BASE();
+    MEMORYCOPYREADER_BASE();
 public:
 
     SkywardSwordFileReader(atUint8* data, atUint64 length);

include/Athena/SkywardSwordFileWriter.hpp

@@ -26,9 +26,9 @@ class SkywardSwordFile;
 namespace io
 {
 
-class SkywardSwordFileWriter : public MemoryWriter
+class SkywardSwordFileWriter : public MemoryCopyWriter
 {
-    MEMORYWRITER_BASE();
+    MEMORYCOPYWRITER_BASE();
 public:
     SkywardSwordFileWriter(atUint8* data, atUint64 len);
     SkywardSwordFileWriter(const std::string& filename);

include/Athena/SpriteFileReader.hpp

@@ -29,9 +29,9 @@ class SpriteFile;
 namespace io
 {
 
-class SpriteFileReader : public MemoryReader
+class SpriteFileReader : public MemoryCopyReader
 {
-    MEMORYREADER_BASE();
+    MEMORYCOPYREADER_BASE();
 public:
     SpriteFileReader(atUint8* data, atUint64 length);
     SpriteFileReader(const std::string& filepath);

include/Athena/SpriteFileWriter.hpp

@@ -29,9 +29,9 @@ class SpriteFile;
 namespace io
 {
 
-class SpriteFileWriter : public MemoryWriter
+class SpriteFileWriter : public MemoryCopyWriter
 {
-    MEMORYWRITER_BASE();
+    MEMORYCOPYWRITER_BASE();
 public:
     SpriteFileWriter(atUint8* data, atUint64 length);
 

include/Athena/WiiSaveReader.hpp

@@ -37,9 +37,9 @@ namespace io
  *  all work is done using a memory buffer, and not read directly from the disk.
  *  \sa BinaryReader
  */
-class WiiSaveReader : protected MemoryReader
+class WiiSaveReader : protected MemoryCopyReader
 {
-    MEMORYREADER_BASE();
+    MEMORYCOPYREADER_BASE();
 public:
     /*! \brief This constructor takes an existing buffer to read from.
      *

include/Athena/WiiSaveWriter.hpp

@@ -36,9 +36,9 @@ namespace io
  *  all work is done using a memory buffer, and not written directly to the disk.
  *  \sa BinaryReader
  */
-class WiiSaveWriter : protected MemoryWriter
+class WiiSaveWriter : protected MemoryCopyWriter
 {
-    MEMORYWRITER_BASE();
+    MEMORYCOPYWRITER_BASE();
 public:
     /*! \brief This constructor creates an instance from a file on disk.
      *

include/Athena/ZQuestFileReader.hpp

@@ -29,9 +29,9 @@ namespace io
 /*!
  * \brief The ZQuestFileReader class
  */
-class ZQuestFileReader : protected MemoryReader
+class ZQuestFileReader : protected MemoryCopyReader
 {
-    MEMORYREADER_BASE();
+    MEMORYCOPYREADER_BASE();
 
 public:
     /*!

include/Athena/ZQuestFileWriter.hpp

@@ -29,9 +29,9 @@ namespace io
 /*!
  * \brief The ZQuestFileWriter class
  */
-class ZQuestFileWriter : protected MemoryWriter
+class ZQuestFileWriter : protected MemoryCopyWriter
 {
-    MEMORYWRITER_BASE();
+    MEMORYCOPYWRITER_BASE();
 
 public:
     /*!

include/utf8.h

@@ -1,34 +0,0 @@
-// Copyright 2006 Nemanja Trifunovic
-
-/*
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-*/
-
-
-#ifndef UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731
-#define UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731
-
-#include "utf8/checked.h"
-#include "utf8/unchecked.h"
-
-#endif // header guard

include/utf8/checked.h

@@ -1,370 +0,0 @@
-// Copyright 2006 Nemanja Trifunovic
-
-/*
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-*/
-
-
-#ifndef UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-#define UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-
-#include "core.h"
-#include <stdexcept>
-
-namespace utf8
-{
-// Base for the exceptions that may be thrown from the library
-class exception : public ::std::exception
-{
-};
-
-// Exceptions that may be thrown from the library functions.
-class invalid_code_point : public exception
-{
-    uint32_t cp;
-public:
-    invalid_code_point(uint32_t cp) : cp(cp) {}
-    virtual const char* what() const throw() { return "Invalid code point"; }
-    uint32_t code_point() const {return cp;}
-};
-
-class invalid_utf8 : public exception
-{
-    uint8_t u8;
-public:
-    invalid_utf8(uint8_t u) : u8(u) {}
-    virtual const char* what() const throw() { return "Invalid UTF-8"; }
-    uint8_t utf8_octet() const {return u8;}
-};
-
-class invalid_utf16 : public exception
-{
-    uint16_t u16;
-public:
-    invalid_utf16(uint16_t u) : u16(u) {}
-    virtual const char* what() const throw() { return "Invalid UTF-16"; }
-    uint16_t utf16_word() const {return u16;}
-};
-
-class not_enough_room : public exception
-{
-public:
-    virtual const char* what() const throw() { return "Not enough space"; }
-};
-
-/// The library API - functions intended to be called by the users
-
-template <typename octet_iterator>
-octet_iterator append(uint32_t cp, octet_iterator result)
-{
-    if (!utf8::internal::is_code_point_valid(cp))
-        throw invalid_code_point(cp);
-
-    if (cp < 0x80)                        // one octet
-        *(result++) = static_cast<uint8_t>(cp);
-    else if (cp < 0x800)                  // two octets
-    {
-        *(result++) = static_cast<uint8_t>((cp >> 6)            | 0xc0);
-        *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
-    }
-    else if (cp < 0x10000)                // three octets
-    {
-        *(result++) = static_cast<uint8_t>((cp >> 12)           | 0xe0);
-        *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f)   | 0x80);
-        *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
-    }
-    else                                  // four octets
-    {
-        *(result++) = static_cast<uint8_t>((cp >> 18)           | 0xf0);
-        *(result++) = static_cast<uint8_t>(((cp >> 12) & 0x3f)  | 0x80);
-        *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f)   | 0x80);
-        *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
-    }
-
-    return result;
-}
-
-template <typename octet_iterator, typename output_iterator>
-output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out, uint32_t replacement)
-{
-    while (start != end)
-    {
-        octet_iterator sequence_start = start;
-        internal::utf_error err_code = utf8::internal::validate_next(start, end);
-
-        switch (err_code)
-        {
-            case internal::UTF8_OK :
-                for (octet_iterator it = sequence_start; it != start; ++it)
-                    *out++ = *it;
-
-                break;
-
-            case internal::NOT_ENOUGH_ROOM:
-                throw not_enough_room();
-
-            case internal::INVALID_LEAD:
-                utf8::append(replacement, out);
-                ++start;
-                break;
-
-            case internal::INCOMPLETE_SEQUENCE:
-            case internal::OVERLONG_SEQUENCE:
-            case internal::INVALID_CODE_POINT:
-                utf8::append(replacement, out);
-                ++start;
-
-                // just one replacement mark for the sequence
-                while (start != end && utf8::internal::is_trail(*start))
-                    ++start;
-
-                break;
-        }
-    }
-
-    return out;
-}
-
-template <typename octet_iterator, typename output_iterator>
-inline output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out)
-{
-    static const uint32_t replacement_marker = utf8::internal::mask16(0xfffd);
-    return utf8::replace_invalid(start, end, out, replacement_marker);
-}
-
-template <typename octet_iterator>
-uint32_t next(octet_iterator& it, octet_iterator end)
-{
-    uint32_t cp = 0;
-    internal::utf_error err_code = utf8::internal::validate_next(it, end, cp);
-
-    switch (err_code)
-    {
-        case internal::UTF8_OK :
-            break;
-
-        case internal::NOT_ENOUGH_ROOM :
-            throw not_enough_room();
-
-        case internal::INVALID_LEAD :
-        case internal::INCOMPLETE_SEQUENCE :
-        case internal::OVERLONG_SEQUENCE :
-            throw invalid_utf8(*it);
-
-        case internal::INVALID_CODE_POINT :
-            throw invalid_code_point(cp);
-    }
-
-    return cp;
-}
-
-template <typename octet_iterator>
-uint32_t peek_next(octet_iterator it, octet_iterator end)
-{
-    return utf8::next(it, end);
-}
-
-template <typename octet_iterator>
-uint32_t prior(octet_iterator& it, octet_iterator start)
-{
-    // can't do much if it == start
-    if (it == start)
-        throw not_enough_room();
-
-    octet_iterator end = it;
-
-    // Go back until we hit either a lead octet or start
-    while (utf8::internal::is_trail(*(--it)))
-        if (it == start)
-            throw invalid_utf8(*it); // error - no lead byte in the sequence
-
-    return utf8::peek_next(it, end);
-}
-
-/// Deprecated in versions that include "prior"
-template <typename octet_iterator>
-uint32_t previous(octet_iterator& it, octet_iterator pass_start)
-{
-    octet_iterator end = it;
-
-    while (utf8::internal::is_trail(*(--it)))
-        if (it == pass_start)
-            throw invalid_utf8(*it); // error - no lead byte in the sequence
-
-    octet_iterator temp = it;
-    return utf8::next(temp, end);
-}
-
-template <typename octet_iterator, typename distance_type>
-void advance(octet_iterator& it, distance_type n, octet_iterator end)
-{
-    for (distance_type i = 0; i < n; ++i)
-        utf8::next(it, end);
-}
-
-template <typename octet_iterator>
-typename std::iterator_traits<octet_iterator>::difference_type
-distance(octet_iterator first, octet_iterator last)
-{
-    typename std::iterator_traits<octet_iterator>::difference_type dist;
-
-    for (dist = 0; first < last; ++dist)
-        utf8::next(first, last);
-
-    return dist;
-}
-
-template <typename u16bit_iterator, typename octet_iterator>
-octet_iterator utf16to8(u16bit_iterator start, u16bit_iterator end, octet_iterator result)
-{
-    while (start != end)
-    {
-        uint32_t cp = utf8::internal::mask16(*start++);
-
-        // Take care of surrogate pairs first
-        if (utf8::internal::is_lead_surrogate(cp))
-        {
-            if (start != end)
-            {
-                uint32_t trail_surrogate = utf8::internal::mask16(*start++);
-
-                if (utf8::internal::is_trail_surrogate(trail_surrogate))
-                    cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;
-                else
-                    throw invalid_utf16(static_cast<uint16_t>(trail_surrogate));
-            }
-            else
-                throw invalid_utf16(static_cast<uint16_t>(cp));
-
-        }
-        // Lone trail surrogate
-        else if (utf8::internal::is_trail_surrogate(cp))
-            throw invalid_utf16(static_cast<uint16_t>(cp));
-
-        result = utf8::append(cp, result);
-    }
-
-    return result;
-}
-
-template <typename u16bit_iterator, typename octet_iterator>
-u16bit_iterator utf8to16(octet_iterator start, octet_iterator end, u16bit_iterator result)
-{
-    while (start != end)
-    {
-        uint32_t cp = utf8::next(start, end);
-
-        if (cp > 0xffff)   //make a surrogate pair
-        {
-            *result++ = static_cast<uint16_t>((cp >> 10)   + internal::LEAD_OFFSET);
-            *result++ = static_cast<uint16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
-        }
-        else
-            *result++ = static_cast<uint16_t>(cp);
-    }
-
-    return result;
-}
-
-template <typename octet_iterator, typename u32bit_iterator>
-octet_iterator utf32to8(u32bit_iterator start, u32bit_iterator end, octet_iterator result)
-{
-    while (start != end)
-        result = utf8::append(*(start++), result);
-
-    return result;
-}
-
-template <typename octet_iterator, typename u32bit_iterator>
-u32bit_iterator utf8to32(octet_iterator start, octet_iterator end, u32bit_iterator result)
-{
-    while (start != end)
-        (*result++) = utf8::next(start, end);
-
-    return result;
-}
-
-// The iterator class
-template <typename octet_iterator>
-class iterator : public std::iterator <std::bidirectional_iterator_tag, uint32_t>
-{
-    octet_iterator it;
-    octet_iterator range_start;
-    octet_iterator range_end;
-public:
-    iterator() {};
-    explicit iterator(const octet_iterator& octet_it,
-                      const octet_iterator& range_start,
-                      const octet_iterator& range_end) :
-        it(octet_it), range_start(range_start), range_end(range_end)
-    {
-        if (it < range_start || it > range_end)
-            throw std::out_of_range("Invalid utf-8 iterator position");
-    }
-    // the default "big three" are OK
-    octet_iterator base() const { return it; }
-    uint32_t operator * () const
-    {
-        octet_iterator temp = it;
-        return utf8::next(temp, range_end);
-    }
-    bool operator == (const iterator& rhs) const
-    {
-        if (range_start != rhs.range_start || range_end != rhs.range_end)
-            throw std::logic_error("Comparing utf-8 iterators defined with different ranges");
-
-        return (it == rhs.it);
-    }
-    bool operator != (const iterator& rhs) const
-    {
-        return !(operator == (rhs));
-    }
-    iterator& operator ++ ()
-    {
-        utf8::next(it, range_end);
-        return *this;
-    }
-    iterator operator ++ (int)
-    {
-        iterator temp = *this;
-        utf8::next(it, range_end);
-        return temp;
-    }
-    iterator& operator -- ()
-    {
-        utf8::prior(it, range_start);
-        return *this;
-    }
-    iterator operator -- (int)
-    {
-        iterator temp = *this;
-        utf8::prior(it, range_start);
-        return temp;
-    }
-}; // class iterator
-
-} // namespace utf8
-
-#endif //header guard
-
-

include/utf8/core.h

@@ -1,347 +0,0 @@
-// Copyright 2006 Nemanja Trifunovic
-
-/*
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-*/
-
-
-#ifndef UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-#define UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-
-#include <iterator>
-
-namespace utf8
-{
-// The typedefs for 8-bit, 16-bit and 32-bit unsigned integers
-// You may need to change them to match your system.
-// These typedefs have the same names as ones from cstdint, or boost/cstdint
-typedef unsigned char   uint8_t;
-typedef unsigned short  uint16_t;
-typedef unsigned int    uint32_t;
-
-// Helper code - not intended to be directly called by the library users. May be changed at any time
-namespace internal
-{
-// Unicode constants
-// Leading (high) surrogates: 0xd800 - 0xdbff
-// Trailing (low) surrogates: 0xdc00 - 0xdfff
-const uint16_t LEAD_SURROGATE_MIN  = 0xd800u;
-const uint16_t LEAD_SURROGATE_MAX  = 0xdbffu;
-const uint16_t TRAIL_SURROGATE_MIN = 0xdc00u;
-const uint16_t TRAIL_SURROGATE_MAX = 0xdfffu;
-const uint16_t LEAD_OFFSET         = LEAD_SURROGATE_MIN - (0x10000 >> 10);
-const uint32_t SURROGATE_OFFSET    = 0x10000u - (LEAD_SURROGATE_MIN << 10) - TRAIL_SURROGATE_MIN;
-
-// Maximum valid value for a Unicode code point
-const uint32_t CODE_POINT_MAX      = 0x0010ffffu;
-
-template<typename octet_type>
-inline uint8_t mask8(octet_type oc)
-{
-    return static_cast<uint8_t>(0xff & oc);
-}
-template<typename u16_type>
-inline uint16_t mask16(u16_type oc)
-{
-    return static_cast<uint16_t>(0xffff & oc);
-}
-template<typename octet_type>
-inline bool is_trail(octet_type oc)
-{
-    return ((utf8::internal::mask8(oc) >> 6) == 0x2);
-}
-
-template <typename u16>
-inline bool is_lead_surrogate(u16 cp)
-{
-    return (cp >= LEAD_SURROGATE_MIN && cp <= LEAD_SURROGATE_MAX);
-}
-
-template <typename u16>
-inline bool is_trail_surrogate(u16 cp)
-{
-    return (cp >= TRAIL_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX);
-}
-
-template <typename u16>
-inline bool is_surrogate(u16 cp)
-{
-    return (cp >= LEAD_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX);
-}
-
-template <typename u32>
-inline bool is_code_point_valid(u32 cp)
-{
-    return (cp <= CODE_POINT_MAX && !utf8::internal::is_surrogate(cp));
-}
-
-template <typename octet_iterator>
-inline typename std::iterator_traits<octet_iterator>::difference_type
-sequence_length(octet_iterator lead_it)
-{
-    uint8_t lead = utf8::internal::mask8(*lead_it);
-
-    if (lead < 0x80)
-        return 1;
-    else if ((lead >> 5) == 0x6)
-        return 2;
-    else if ((lead >> 4) == 0xe)
-        return 3;
-    else if ((lead >> 3) == 0x1e)
-        return 4;
-    else
-        return 0;
-}
-
-template <typename octet_difference_type>
-inline bool is_overlong_sequence(uint32_t cp, octet_difference_type length)
-{
-    if (cp < 0x80)
-    {
-        if (length != 1)
-            return true;
-    }
-    else if (cp < 0x800)
-    {
-        if (length != 2)
-            return true;
-    }
-    else if (cp < 0x10000)
-    {
-        if (length != 3)
-            return true;
-    }
-
-    return false;
-}
-
-enum utf_error {UTF8_OK, NOT_ENOUGH_ROOM, INVALID_LEAD, INCOMPLETE_SEQUENCE, OVERLONG_SEQUENCE, INVALID_CODE_POINT};
-
-/// Helper for get_sequence_x
-template <typename octet_iterator>
-utf_error increase_safely(octet_iterator& it, octet_iterator end)
-{
-    if (++it == end)
-        return NOT_ENOUGH_ROOM;
-
-    if (!utf8::internal::is_trail(*it))
-        return INCOMPLETE_SEQUENCE;
-
-    return UTF8_OK;
-}
-
-#define UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(IT, END) {utf_error ret = increase_safely(IT, END); if (ret != UTF8_OK) return ret;}
-
-/// get_sequence_x functions decode utf-8 sequences of the length x
-template <typename octet_iterator>
-utf_error get_sequence_1(octet_iterator& it, octet_iterator end, uint32_t& code_point)
-{
-    if (it == end)
-        return NOT_ENOUGH_ROOM;
-
-    code_point = utf8::internal::mask8(*it);
-
-    return UTF8_OK;
-}
-
-template <typename octet_iterator>
-utf_error get_sequence_2(octet_iterator& it, octet_iterator end, uint32_t& code_point)
-{
-    if (it == end)
-        return NOT_ENOUGH_ROOM;
-
-    code_point = utf8::internal::mask8(*it);
-
-    UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-    code_point = ((code_point << 6) & 0x7ff) + ((*it) & 0x3f);
-
-    return UTF8_OK;
-}
-
-template <typename octet_iterator>
-utf_error get_sequence_3(octet_iterator& it, octet_iterator end, uint32_t& code_point)
-{
-    if (it == end)
-        return NOT_ENOUGH_ROOM;
-
-    code_point = utf8::internal::mask8(*it);
-
-    UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-    code_point = ((code_point << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);
-
-    UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-    code_point += (*it) & 0x3f;
-
-    return UTF8_OK;
-}
-
-template <typename octet_iterator>
-utf_error get_sequence_4(octet_iterator& it, octet_iterator end, uint32_t& code_point)
-{
-    if (it == end)
-        return NOT_ENOUGH_ROOM;
-
-    code_point = utf8::internal::mask8(*it);
-
-    UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-    code_point = ((code_point << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);
-
-    UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-    code_point += (utf8::internal::mask8(*it) << 6) & 0xfff;
-
-    UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-    code_point += (*it) & 0x3f;
-
-    return UTF8_OK;
-}
-
-#undef UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR
-
-template <typename octet_iterator>
-utf_error validate_next(octet_iterator& it, octet_iterator end, uint32_t& code_point)
-{
-    // Save the original value of it so we can go back in case of failure
-    // Of course, it does not make much sense with i.e. stream iterators
-    octet_iterator original_it = it;
-
-    uint32_t cp = 0;
-    // Determine the sequence length based on the lead octet
-    typedef typename std::iterator_traits<octet_iterator>::difference_type octet_difference_type;
-    const octet_difference_type length = utf8::internal::sequence_length(it);
-
-    // Get trail octets and calculate the code point
-    utf_error err = UTF8_OK;
-
-    switch (length)
-    {
-        case 0:
-            return INVALID_LEAD;
-
-        case 1:
-            err = utf8::internal::get_sequence_1(it, end, cp);
-            break;
-
-        case 2:
-            err = utf8::internal::get_sequence_2(it, end, cp);
-            break;
-
-        case 3:
-            err = utf8::internal::get_sequence_3(it, end, cp);
-            break;
-
-        case 4:
-            err = utf8::internal::get_sequence_4(it, end, cp);
-            break;
-    }
-
-    if (err == UTF8_OK)
-    {
-        // Decoding succeeded. Now, security checks...
-        if (utf8::internal::is_code_point_valid(cp))
-        {
-            if (!utf8::internal::is_overlong_sequence(cp, length))
-            {
-                // Passed! Return here.
-                code_point = cp;
-                ++it;
-                return UTF8_OK;
-            }
-            else
-                err = OVERLONG_SEQUENCE;
-        }
-        else
-            err = INVALID_CODE_POINT;
-    }
-
-    // Failure branch - restore the original value of the iterator
-    it = original_it;
-    return err;
-}
-
-template <typename octet_iterator>
-inline utf_error validate_next(octet_iterator& it, octet_iterator end)
-{
-    uint32_t ignored;
-    return utf8::internal::validate_next(it, end, ignored);
-}
-
-} // namespace internal
-
-/// The library API - functions intended to be called by the users
-
-// Byte order mark
-const uint8_t bom[] = {0xef, 0xbb, 0xbf};
-
-template <typename octet_iterator>
-octet_iterator find_invalid(octet_iterator start, octet_iterator end)
-{
-    octet_iterator result = start;
-
-    while (result != end)
-    {
-        utf8::internal::utf_error err_code = utf8::internal::validate_next(result, end);
-
-        if (err_code != internal::UTF8_OK)
-            return result;
-    }
-
-    return result;
-}
-
-template <typename octet_iterator>
-inline bool is_valid(octet_iterator start, octet_iterator end)
-{
-    return (utf8::find_invalid(start, end) == end);
-}
-
-template <typename octet_iterator>
-inline bool starts_with_bom(octet_iterator it, octet_iterator end)
-{
-    return (
-               ((it != end) && (utf8::internal::mask8(*it++)) == bom[0]) &&
-               ((it != end) && (utf8::internal::mask8(*it++)) == bom[1]) &&
-               ((it != end) && (utf8::internal::mask8(*it))   == bom[2])
-           );
-}
-
-//Deprecated in release 2.3
-template <typename octet_iterator>
-inline bool is_bom(octet_iterator it)
-{
-    return (
-               (utf8::internal::mask8(*it++)) == bom[0] &&
-               (utf8::internal::mask8(*it++)) == bom[1] &&
-               (utf8::internal::mask8(*it))   == bom[2]
-           );
-}
-} // namespace utf8
-
-#endif // header guard
-
-

include/utf8/unchecked.h

@@ -1,251 +0,0 @@
-// Copyright 2006 Nemanja Trifunovic
-
-/*
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-*/
-
-
-#ifndef UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-#define UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-
-#include "core.h"
-
-namespace utf8
-{
-namespace unchecked
-{
-template <typename octet_iterator>
-octet_iterator append(uint32_t cp, octet_iterator result)
-{
-    if (cp < 0x80)                        // one octet
-        *(result++) = static_cast<uint8_t>(cp);
-    else if (cp < 0x800)                  // two octets
-    {
-        *(result++) = static_cast<uint8_t>((cp >> 6)          | 0xc0);
-        *(result++) = static_cast<uint8_t>((cp & 0x3f)        | 0x80);
-    }
-    else if (cp < 0x10000)                // three octets
-    {
-        *(result++) = static_cast<uint8_t>((cp >> 12)         | 0xe0);
-        *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80);
-        *(result++) = static_cast<uint8_t>((cp & 0x3f)        | 0x80);
-    }
-    else                                  // four octets
-    {
-        *(result++) = static_cast<uint8_t>((cp >> 18)         | 0xf0);
-        *(result++) = static_cast<uint8_t>(((cp >> 12) & 0x3f) | 0x80);
-        *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80);
-        *(result++) = static_cast<uint8_t>((cp & 0x3f)        | 0x80);
-    }
-
-    return result;
-}
-
-template <typename octet_iterator>
-uint32_t next(octet_iterator& it)
-{
-    uint32_t cp = utf8::internal::mask8(*it);
-    typename std::iterator_traits<octet_iterator>::difference_type length = utf8::internal::sequence_length(it);
-
-    switch (length)
-    {
-        case 1:
-            break;
-
-        case 2:
-            it++;
-            cp = ((cp << 6) & 0x7ff) + ((*it) & 0x3f);
-            break;
-
-        case 3:
-            ++it;
-            cp = ((cp << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);
-            ++it;
-            cp += (*it) & 0x3f;
-            break;
-
-        case 4:
-            ++it;
-            cp = ((cp << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);
-            ++it;
-            cp += (utf8::internal::mask8(*it) << 6) & 0xfff;
-            ++it;
-            cp += (*it) & 0x3f;
-            break;
-    }
-
-    ++it;
-    return cp;
-}
-
-template <typename octet_iterator>
-uint32_t peek_next(octet_iterator it)
-{
-    return utf8::unchecked::next(it);
-}
-
-template <typename octet_iterator>
-uint32_t prior(octet_iterator& it)
-{
-    while (utf8::internal::is_trail(*(--it))) ;
-
-    octet_iterator temp = it;
-    return utf8::unchecked::next(temp);
-}
-
-// Deprecated in versions that include prior, but only for the sake of consistency (see utf8::previous)
-template <typename octet_iterator>
-inline uint32_t previous(octet_iterator& it)
-{
-    return utf8::unchecked::prior(it);
-}
-
-template <typename octet_iterator, typename distance_type>
-void advance(octet_iterator& it, distance_type n)
-{
-    for (distance_type i = 0; i < n; ++i)
-        utf8::unchecked::next(it);
-}
-
-template <typename octet_iterator>
-typename std::iterator_traits<octet_iterator>::difference_type
-distance(octet_iterator first, octet_iterator last)
-{
-    typename std::iterator_traits<octet_iterator>::difference_type dist;
-
-    for (dist = 0; first < last; ++dist)
-        utf8::unchecked::next(first);
-
-    return dist;
-}
-
-template <typename u16bit_iterator, typename octet_iterator>
-octet_iterator utf16to8(u16bit_iterator start, u16bit_iterator end, octet_iterator result)
-{
-    while (start != end)
-    {
-        uint32_t cp = utf8::internal::mask16(*start++);
-
-        // Take care of surrogate pairs first
-        if (utf8::internal::is_lead_surrogate(cp))
-        {
-            uint32_t trail_surrogate = utf8::internal::mask16(*start++);
-            cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;
-        }
-
-        result = utf8::unchecked::append(cp, result);
-    }
-
-    return result;
-}
-
-template <typename u16bit_iterator, typename octet_iterator>
-u16bit_iterator utf8to16(octet_iterator start, octet_iterator end, u16bit_iterator result)
-{
-    while (start < end)
-    {
-        uint32_t cp = utf8::unchecked::next(start);
-
-        if (cp > 0xffff)   //make a surrogate pair
-        {
-            *result++ = static_cast<uint16_t>((cp >> 10)   + internal::LEAD_OFFSET);
-            *result++ = static_cast<uint16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
-        }
-        else
-            *result++ = static_cast<uint16_t>(cp);
-    }
-
-    return result;
-}
-
-template <typename octet_iterator, typename u32bit_iterator>
-octet_iterator utf32to8(u32bit_iterator start, u32bit_iterator end, octet_iterator result)
-{
-    while (start != end)
-        result = utf8::unchecked::append(*(start++), result);
-
-    return result;
-}
-
-template <typename octet_iterator, typename u32bit_iterator>
-u32bit_iterator utf8to32(octet_iterator start, octet_iterator end, u32bit_iterator result)
-{
-    while (start < end)
-        (*result++) = utf8::unchecked::next(start);
-
-    return result;
-}
-
-// The iterator class
-template <typename octet_iterator>
-class iterator : public std::iterator <std::bidirectional_iterator_tag, uint32_t>
-{
-    octet_iterator it;
-public:
-    iterator() {};
-    explicit iterator(const octet_iterator& octet_it): it(octet_it) {}
-    // the default "big three" are OK
-    octet_iterator base() const { return it; }
-    uint32_t operator * () const
-    {
-        octet_iterator temp = it;
-        return utf8::unchecked::next(temp);
-    }
-    bool operator == (const iterator& rhs) const
-    {
-        return (it == rhs.it);
-    }
-    bool operator != (const iterator& rhs) const
-    {
-        return !(operator == (rhs));
-    }
-    iterator& operator ++ ()
-    {
-        ::std::advance(it, utf8::internal::sequence_length(it));
-        return *this;
-    }
-    iterator operator ++ (int)
-    {
-        iterator temp = *this;
-        ::std::advance(it, utf8::internal::sequence_length(it));
-        return temp;
-    }
-    iterator& operator -- ()
-    {
-        utf8::unchecked::prior(it);
-        return *this;
-    }
-    iterator operator -- (int)
-    {
-        iterator temp = *this;
-        utf8::unchecked::prior(it);
-        return temp;
-    }
-}; // class iterator
-
-} // namespace utf8::unchecked
-} // namespace utf8
-
-
-#endif // header guard
-

src/Athena/MCFileReader.cpp

@@ -39,7 +39,7 @@ MCFile* MCFileReader::readFile()
     base::m_position = 0;
 
     if (isScrambled)
-        MCFile::unscramble(base::m_data, base::m_length);
+        MCFile::unscramble(base::m_dataCopy.get(), base::m_length);
 
     return nullptr;
 }

src/Athena/MemoryReader.cpp

@@ -19,7 +19,8 @@ namespace Athena
 namespace io
 {
 MemoryReader::MemoryReader(const atUint8* data, atUint64 length)
-    : m_length(length),
+    : m_data(data),
+      m_length(length),
       m_position(0)
 {
     if (!data)
@@ -27,24 +28,20 @@ MemoryReader::MemoryReader(const atUint8* data, atUint64 length)
 
     if (length == 0)
         THROW_INVALID_OPERATION_EXCEPTION("length cannot be 0");
-
-    m_data = new atUint8[m_length];
-    memcpy(m_data, data, m_length);
 }
 
-MemoryReader::MemoryReader(const std::string& filename)
+MemoryCopyReader::MemoryCopyReader(const atUint8* data, atUint64 length)
-    : m_data(NULL),
+    : MemoryReader(data, length)
-      m_length(0),
-      m_filepath(filename),
-      m_position(0)
 {
-    loadData();
+    if (!data)
-}
+        THROW_INVALID_DATA_EXCEPTION("data cannot be NULL");
 
-MemoryReader::~MemoryReader()
+    if (length == 0)
-{
+        THROW_INVALID_OPERATION_EXCEPTION("length cannot be 0");
-    delete[] m_data;
+
-    m_data = NULL;
+    m_dataCopy.reset(new atUint8[m_length]);
+    m_data = m_dataCopy.get();
+    memcpy(m_dataCopy.get(), data, m_length);
 }
 
 void MemoryReader::seek(atInt64 position, SeekOrigin origin)
@@ -76,14 +73,20 @@ void MemoryReader::seek(atInt64 position, SeekOrigin origin)
 
 void MemoryReader::setData(const atUint8* data, atUint64 length)
 {
-    if (m_data)
-        delete[] m_data;
-
     m_data = (atUint8*)data;
     m_length = length;
     m_position = 0;
 }
 
+void MemoryCopyReader::setData(const atUint8* data, atUint64 length)
+{
+    m_dataCopy.reset(new atUint8[length]);
+    m_data = m_dataCopy.get();
+    memcpy(m_dataCopy.get(), data, length);
+    m_length = length;
+    m_position = 0;
+}
+
 atUint8* MemoryReader::data() const
 {
     atUint8* ret = new atUint8[m_length];
@@ -94,9 +97,6 @@ atUint8* MemoryReader::data() const
 
 atUint64 MemoryReader::readUBytesToBuf(void* buf, atUint64 length)
 {
-    if (!m_data)
-        loadData();
-
     if (m_position + length > m_length)
         THROW_IO_EXCEPTION_RETURN(0, "Position %0.8X outside stream bounds ", m_position);
 
@@ -105,7 +105,7 @@ atUint64 MemoryReader::readUBytesToBuf(void* buf, atUint64 length)
     return length;
 }
 
-void MemoryReader::loadData()
+void MemoryCopyReader::loadData()
 {
     FILE* in;
     atUint64 length;
@@ -117,7 +117,8 @@ void MemoryReader::loadData()
     rewind(in);
 
     length = utility::fileSize(m_filepath);
-    m_data = new atUint8[length];
+    m_dataCopy.reset(new atUint8[length]);
+    m_data = m_dataCopy.get();
 
     atUint64 done = 0;
     atUint64 blocksize = BLOCKSZ;
@@ -127,7 +128,7 @@ void MemoryReader::loadData()
         if (blocksize > length - done)
             blocksize = length - done;
 
-        atInt64 ret = fread(m_data + done, 1, blocksize, in);
+        atInt64 ret = fread(m_dataCopy.get() + done, 1, blocksize, in);
 
         if (ret < 0)
             THROW_IO_EXCEPTION("Error reading data from disk");

src/Athena/MemoryWriter.cpp

@@ -23,18 +23,36 @@ MemoryWriter::MemoryWriter(atUint8* data, atUint64 length)
       m_length(length),
       m_position(0)
 {
-    if (!m_data && m_length > 0)
+    if (!data)
-        m_data = new atUint8[m_length];
+        THROW_INVALID_DATA_EXCEPTION("data cannot be NULL");
+
+    if (length == 0)
+        THROW_INVALID_OPERATION_EXCEPTION("length cannot be 0");
 }
 
-MemoryWriter::MemoryWriter(const std::string& filename, std::function<void(int)> progressFun)
+MemoryCopyWriter::MemoryCopyWriter(atUint8* data, atUint64 length)
-    : m_length(0),
-      m_filepath(filename),
-      m_position(0)
 {
+    m_data = data;
+    m_length = length;
+    m_position = 0;
+
+    if (length == 0)
+        THROW_INVALID_OPERATION_EXCEPTION("length cannot be 0");
+
+    m_dataCopy.reset(new atUint8[length]);
+    m_data = m_dataCopy.get();
+    if (data)
+        memcpy(m_data, data, length);
+}
+
+MemoryCopyWriter::MemoryCopyWriter(const std::string& filename)
+    : MemoryWriter(NULL, 0)
+{
+    m_filepath = filename;
     m_length = 0x10;
     m_position = 0;
-    m_data = new atUint8[m_length];
+    m_dataCopy.reset(new atUint8[m_length]);
+    m_data = m_dataCopy.get();
 
     if (!m_data)
         THROW_IO_EXCEPTION("Could not allocate memory!");
@@ -42,13 +60,43 @@ MemoryWriter::MemoryWriter(const std::string& filename, std::function<void(int)>
     memset(m_data, 0, m_length);
 }
 
-MemoryWriter::~MemoryWriter()
+void MemoryWriter::seek(atInt64 position, SeekOrigin origin)
 {
-    delete[] m_data;
+    switch (origin)
-    m_data = nullptr;
+    {
+        case SeekOrigin::Begin:
+            if (position < 0)
+                THROW_IO_EXCEPTION("Position outside stream bounds");
+
+            if ((atUint64)position > m_length)
+                THROW_IO_EXCEPTION("data exceeds available buffer space");
+
+            m_position = position;
+            break;
+
+        case SeekOrigin::Current:
+            if ((((atInt64)m_position + position) < 0))
+                THROW_IO_EXCEPTION("Position outside stream bounds");
+
+            if (m_position + position > m_length)
+                THROW_IO_EXCEPTION("data exceeds available buffer space");
+
+            m_position += position;
+            break;
+
+        case SeekOrigin::End:
+            if (((atInt64)m_length - position) < 0)
+                THROW_IO_EXCEPTION("Position outside stream bounds");
+
+            if ((atUint64)position > m_length)
+                THROW_IO_EXCEPTION("data exceeds available buffer space");
+
+            m_position = m_length - position;
+            break;
+    }
 }
 
-void MemoryWriter::seek(atInt64 position, SeekOrigin origin)
+void MemoryCopyWriter::seek(atInt64 position, SeekOrigin origin)
 {
     switch (origin)
     {
@@ -84,16 +132,22 @@ void MemoryWriter::seek(atInt64 position, SeekOrigin origin)
     }
 }
 
-void MemoryWriter::setData(const atUint8* data, atUint64 length)
+void MemoryWriter::setData(atUint8* data, atUint64 length)
 {
-    if (m_data)
-        delete[] m_data;
-
     m_data = (atUint8*)data;
     m_length = length;
     m_position = 0;
 }
 
+void MemoryCopyWriter::setData(const atUint8* data, atUint64 length)
+{
+    m_dataCopy.reset(new atUint8[length]);
+    m_data = m_dataCopy.get();
+    memcpy(m_data, data, length);
+    m_length = length;
+    m_position = 0;
+}
+
 atUint8* MemoryWriter::data() const
 {
     atUint8* ret = new atUint8[m_length];
@@ -105,9 +159,6 @@ atUint8* MemoryWriter::data() const
 
 void MemoryWriter::save(const std::string& filename)
 {
-    if (!isOpen())
-        THROW_INVALID_OPERATION_EXCEPTION("File not open for writing");
-
     if (filename.empty() && m_filepath.empty())
         THROW_INVALID_OPERATION_EXCEPTION("No file specified, cannot save.");
 
@@ -143,9 +194,19 @@ void MemoryWriter::save(const std::string& filename)
 
 void MemoryWriter::writeUBytes(const atUint8* data, atUint64 length)
 {
-    if (!isOpen())
+    if (!data)
-        resize(sizeof(atUint8) * length);
+        THROW_INVALID_DATA_EXCEPTION("data cannnot be NULL");
 
+    if (m_position + length > m_length)
+        THROW_IO_EXCEPTION("data length exceeds available buffer space");
+
+    memcpy((atInt8*)(m_data + m_position), data, length);
+
+    m_position += length;
+}
+
+void MemoryCopyWriter::writeUBytes(const atUint8* data, atUint64 length)
+{
     if (!data)
         THROW_INVALID_DATA_EXCEPTION("data cannnot be NULL");
 
@@ -157,7 +218,7 @@ void MemoryWriter::writeUBytes(const atUint8* data, atUint64 length)
     m_position += length;
 }
 
-void MemoryWriter::resize(atUint64 newSize)
+void MemoryCopyWriter::resize(atUint64 newSize)
 {
     if (newSize < m_length)
         THROW_INVALID_OPERATION_EXCEPTION("Stream::resize() -> New size cannot be less to the old size.");
@@ -166,13 +227,9 @@ void MemoryWriter::resize(atUint64 newSize)
     atUint8* newArray = new atUint8[newSize];
     memset(newArray, 0, newSize);
 
-    if (m_data)
+    if (m_dataCopy)
-    {
+        memcpy(newArray, m_dataCopy.get(), m_length);
-        memcpy(newArray, m_data, m_length);
+    m_dataCopy.reset(newArray);
-
-        // Delete the old one
-        delete[] m_data;
-    }
 
     // Swap the pointer and size out for the new ones.
     m_data = newArray;

src/LZ77/LZType10.cpp

@@ -16,7 +16,7 @@ atUint32 LZType10::compress(const atUint8* src, atUint8** dstBuf, atUint32 srcLe
     atUint32 encodeSize = (srcLength << 8) | (0x10);
     encodeSize = Athena::utility::LittleUint32(encodeSize); //File size needs to be written as little endian always
 
-    Athena::io::MemoryWriter outbuf("tmp");
+    Athena::io::MemoryCopyWriter outbuf("tmp");
     outbuf.writeUint32(encodeSize);
 
     atUint8* ptrStart = (atUint8*)src;

src/LZ77/LZType11.cpp

@@ -13,7 +13,7 @@ LZType11::LZType11(atInt32 minimumOffset, atInt32 slidingWindow, atInt32 minimum
 
 atUint32 LZType11::compress(const atUint8* src, atUint8** dst, atUint32 srcLength)
 {
-    Athena::io::MemoryWriter outbuff("tmp");
+    Athena::io::MemoryCopyWriter outbuff("tmp");
 
     if (srcLength > 0xFFFFFF) // If length is greater than 24 bits or 16 Megs
     {

src/aes.cpp

@@ -400,7 +400,7 @@ void SoftwareAES::setKey(const uint8_t* key)
 }
 
 // CBC mode decryption
-void SoftwareAES::decrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, size_t len)
+void SoftwareAES::decrypt(const uint8_t* iv, const uint8_t* inbuf, uint8_t* outbuf, uint64_t len)
 {
     uint8_t block[16];
     const uint8_t* ctext_ptr;