moFileReader.hpp

Go to the documentation of this file.

/*
 * moFileReader - A simple .mo-File-Reader
 * Copyright (C) 2009 Domenico Gentner (scorcher24@gmail.com)
 * Copyright (C) 2018-2021 Edgar (Edgar@AnotherFoxGuy.com)
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 *   3. The names of its contributors may not be used to endorse or promote
 *      products derived from this software without specific prior written
 *      permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef __MOFILEREADER_SINGLE_INCLUDE_H_INCLUDED__
#define __MOFILEREADER_SINGLE_INCLUDE_H_INCLUDED__
 
#if defined(_MSC_VER)
    #pragma warning(disable : 4267)
#endif /* _MSC_VER */
 
#include <cstring> // this is for memset when compiling with gcc.
#include <deque>
#include <fstream>
#include <map>
#include <sstream>
#include <string>
 
//-------------------------------------------------------------
// Path-Seperators are different on other OS.
//-------------------------------------------------------------
#ifndef MO_PATHSEP
    #ifdef WIN32
        #define MO_PATHSEP std::string("\\")
    #else
        #define MO_PATHSEP std::string("/")
    #endif
#endif
 
//-------------------------------------------------------------
// Defines the beginning of the namespace moFileLib.
//-------------------------------------------------------------
#ifndef MO_BEGIN_NAMESPACE
    #define MO_BEGIN_NAMESPACE                                                                                                   \
        namespace moFileLib                                                                                                      \
        {
#endif
//-------------------------------------------------------------
// Ends the current namespace.
//-------------------------------------------------------------
#ifndef MO_END_NAMESPACE
    #define MO_END_NAMESPACE }
#endif
 
MO_BEGIN_NAMESPACE
 
const std::string g_css = R"(
body {
     background-color: black;
     color: silver;
}
table {
     width: 80%;
}
th {
     background-color: orange;
     color: black;
}
hr {
     color: red;
    width: 80%;
     size: 5px;
}
a:link{
    color: gold;
}
a:visited{
    color: grey;
}
a:hover{
    color:blue;
}
.copyleft{
     font-size: 12px;
     text-align: center;
})";
 
struct moTranslationPairInformation
{
    moTranslationPairInformation() : m_orLength(0), m_orOffset(0), m_trLength(0), m_trOffset(0)
    {
    }
 
    int m_orLength;
 
    int m_orOffset;
 
    int m_trLength;
 
    int m_trOffset;
};
 
struct moFileInfo
{
    typedef std::deque<moTranslationPairInformation> moTranslationPairList;
 
    moFileInfo()
        : m_magicNumber(0), m_fileVersion(0), m_numStrings(0), m_offsetOriginal(0), m_offsetTranslation(0), m_sizeHashtable(0),
          m_offsetHashtable(0), m_reversed(false)
    {
    }
 
    int m_magicNumber;
 
    int m_fileVersion;
 
    int m_numStrings;
 
    int m_offsetOriginal;
 
    int m_offsetTranslation;
 
    int m_sizeHashtable;
 
    int m_offsetHashtable;
 
    bool m_reversed;
 
    moTranslationPairList m_translationPairInformation;
};
 
class moFileReader
{
  protected:
    typedef std::map<std::string, std::string> moLookupList;
 
    typedef std::map<std::string, moLookupList> moContextLookupList;
 
  public:
    static const unsigned int MagicNumber = 0x950412DE;
 
    static const unsigned int MagicReversed = 0xDE120495;
 
    static const char ContextSeparator = '\x04';
 
    enum eErrorCode
    {
        EC_SUCCESS = 0,
 
        EC_ERROR,
 
        EC_FILENOTFOUND,
 
        EC_FILEINVALID,
 
        EC_TABLEEMPTY,
 
        EC_MAGICNUMBER_NOMATCH,
 
        EC_MAGICNUMBER_REVERSED,
    };
 
    moFileReader::eErrorCode ParseData(const std::string &data)
    {
        // Opening the file.
        std::stringstream stream(data);
 
        return ReadStream(stream);
    }
 
    eErrorCode ReadFile(const char *filename)
    {
        // Opening the file.
        std::ifstream stream(filename, std::ios_base::binary | std::ios_base::in);
        if (!stream.is_open())
        {
            m_error = std::string("Cannot open File ") + std::string(filename);
            return moFileReader::EC_FILENOTFOUND;
        }
 
        eErrorCode res = ReadStream(stream);
        stream.close();
 
        return res;
    }
 
    template <typename T> eErrorCode ReadStream(T &stream)
    {
        // Creating a file-description.
        moFileInfo moInfo;
 
        // Reference to the List inside moInfo.
        moFileInfo::moTranslationPairList &TransPairInfo = moInfo.m_translationPairInformation;
 
        // Read in all the 4 bytes of fire-magic, offsets and stuff...
        stream.read((char *)&moInfo.m_magicNumber, 4);
        stream.read((char *)&moInfo.m_fileVersion, 4);
        stream.read((char *)&moInfo.m_numStrings, 4);
        stream.read((char *)&moInfo.m_offsetOriginal, 4);
        stream.read((char *)&moInfo.m_offsetTranslation, 4);
        stream.read((char *)&moInfo.m_sizeHashtable, 4);
        stream.read((char *)&moInfo.m_offsetHashtable, 4);
 
        if (stream.bad())
        {
            m_error = "Stream bad during reading. The .mo-file seems to be invalid or has bad descriptions!";
            return moFileReader::EC_FILEINVALID;
        }
 
        // Checking the Magic Number
        if (MagicNumber != moInfo.m_magicNumber)
        {
            if (MagicReversed != moInfo.m_magicNumber)
            {
                m_error = "The Magic Number does not match in all cases!";
                return moFileReader::EC_MAGICNUMBER_NOMATCH;
            }
            else
            {
                moInfo.m_reversed = true;
                m_error           = "Magic Number is reversed. We do not support this yet!";
                return moFileReader::EC_MAGICNUMBER_REVERSED;
            }
        }
 
        // Now we search all Length & Offsets of the original strings
        for (int i = 0; i < moInfo.m_numStrings; i++)
        {
            moTranslationPairInformation _str;
            stream.read((char *)&_str.m_orLength, 4);
            stream.read((char *)&_str.m_orOffset, 4);
            if (stream.bad())
            {
                m_error = "Stream bad during reading. The .mo-file seems to be invalid or has bad descriptions!";
                return moFileReader::EC_FILEINVALID;
            }
 
            TransPairInfo.push_back(_str);
        }
 
        // Get all Lengths & Offsets of the translated strings
        // Be aware: The Descriptors already exist in our list, so we just mod. refs from the deque.
        for (int i = 0; i < moInfo.m_numStrings; i++)
        {
            moTranslationPairInformation &_str = TransPairInfo[i];
            stream.read((char *)&_str.m_trLength, 4);
            stream.read((char *)&_str.m_trOffset, 4);
            if (stream.bad())
            {
                m_error = "Stream bad during reading. The .mo-file seems to be invalid or has bad descriptions!";
                return moFileReader::EC_FILEINVALID;
            }
        }
 
        // Normally you would read the hash-table here, but we don't use it. :)
 
        // Now to the interesting part, we read the strings-pairs now
        for (int i = 0; i < moInfo.m_numStrings; i++)
        {
            // We need a length of +1 to catch the trailing \0.
            int orLength = TransPairInfo[i].m_orLength + 1;
            int trLength = TransPairInfo[i].m_trLength + 1;
 
            int orOffset = TransPairInfo[i].m_orOffset;
            int trOffset = TransPairInfo[i].m_trOffset;
 
            // Original
            char *original = new char[orLength];
            memset(original, 0, sizeof(char) * orLength);
 
            stream.seekg(orOffset);
            stream.read(original, orLength);
 
            if (stream.bad())
            {
                m_error = "Stream bad during reading. The .mo-file seems to be invalid or has bad descriptions!";
                return moFileReader::EC_FILEINVALID;
            }
 
            // Translation
            char *translation = new char[trLength];
            memset(translation, 0, sizeof(char) * trLength);
 
            stream.seekg(trOffset);
            stream.read(translation, trLength);
 
            if (stream.bad())
            {
                m_error = "Stream bad during reading. The .mo-file seems to be invalid or has bad descriptions!";
                return moFileReader::EC_FILEINVALID;
            }
 
            std::string original_str    = original;
            std::string translation_str = translation;
            auto        ctxSeparator    = original_str.find(ContextSeparator);
 
            // Store it in the map.
            if (ctxSeparator == std::string::npos)
            {
                m_lookup[original_str] = translation_str;
                numStrings++;
            }
            else
            {
                // try-catch for handling out_of_range exceptions
                try
                {
                    m_lookup_context[original_str.substr(0, ctxSeparator)]
                                    [original_str.substr(ctxSeparator + 1, original_str.length())] = translation_str;
                    numStrings++;
                }
                catch (...)
                {
                    m_error = "Stream bad during reading. The .mo-file seems to be invalid or has bad descriptions!";
                    return moFileReader::EC_ERROR;
                }
            }
 
            // Cleanup...
            delete[] original;
            delete[] translation;
        }
 
        // Done :)
        return moFileReader::EC_SUCCESS;
    }
 
    std::string Lookup(const char *id) const
    {
        if (m_lookup.empty()) return id;
        auto iterator = m_lookup.find(id);
 
        return iterator == m_lookup.end() ? id : iterator->second;
    }
 
    std::string LookupWithContext(const char *context, const char *id) const
    {
        if (m_lookup_context.empty()) return id;
        auto iterator = m_lookup_context.find(context);
 
        if (iterator == m_lookup_context.end()) return id;
        auto iterator2 = iterator->second.find(id);
 
        return iterator2 == iterator->second.end() ? id : iterator2->second;
    }
 
    const std::string &GetErrorDescription() const
    {
        return m_error;
    }
 
    void ClearTable()
    {
        m_lookup.clear();
        m_lookup_context.clear();
        numStrings = 0;
    }
 
    unsigned int GetNumStrings() const
    {
        return numStrings;
    }
 
    static eErrorCode ExportAsHTML(const std::string &infile, const std::string &filename = "", const std::string &css = g_css)
    {
        // Read the file
        moFileReader             reader;
        moFileReader::eErrorCode r = reader.ReadFile(infile.c_str());
        if (r != moFileReader::EC_SUCCESS) { return r; }
        if (reader.m_lookup.empty()) { return moFileReader::EC_TABLEEMPTY; }
 
        // Beautify Output
        std::string  fname;
        unsigned int pos = infile.find_last_of(MO_PATHSEP);
        if (pos != std::string::npos) { fname = infile.substr(pos + 1, infile.length()); }
        else
        {
            fname = infile;
        }
 
        // if there is no filename given, we set it to the .mo + html, e.g. test.mo.html
        std::string htmlfile(filename);
        if (htmlfile.empty()) { htmlfile = infile + std::string(".html"); }
 
        // Ok, now prepare output.
        std::ofstream stream(htmlfile.c_str());
        if (stream.is_open())
        {
            stream << R"(<!DOCTYPE HTML PUBLIC "- //W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">)"
                   << std::endl;
            stream << "<html><head><style type=\"text/css\">\n" << std::endl;
            stream << css << std::endl;
            stream << "</style>" << std::endl;
            stream << R"(<meta http-equiv="content-type" content="text/html; charset=utf-8">)" << std::endl;
            stream << "<title>Dump of " << fname << "</title></head>" << std::endl;
            stream << "<body>" << std::endl;
            stream << "<center>" << std::endl;
            stream << "<h1>" << fname << "</h1>" << std::endl;
            stream << R"(<table border="1"><th colspan="2">Project Info</th>)" << std::endl;
 
            std::stringstream parsee;
            parsee << reader.Lookup("");
 
            while (!parsee.eof())
            {
                char buffer[1024];
                parsee.getline(buffer, 1024);
                std::string name;
                std::string value;
 
                reader.GetPoEditorString(buffer, name, value);
                if (!(name.empty() || value.empty()))
                {
                    stream << "<tr><td>" << name << "</td><td>" << value << "</td></tr>" << std::endl;
                }
            }
            stream << "</table>" << std::endl;
            stream << "<hr noshade/>" << std::endl;
 
            // Now output the content
            stream << R"(<table border="1"><th colspan="2">Content</th>)" << std::endl;
            for (const auto &it : reader.m_lookup)
            {
                if (!it.first.empty()) // Skip the empty msgid, its the table we handled above.
                {
                    stream << "<tr><td>" << it.first << "</td><td>" << it.second << "</td></tr>" << std::endl;
                }
            }
            stream << "</table><br/>" << std::endl;
 
            // Separate tables for each context
            for (const auto &it : reader.m_lookup_context)
            {
                stream << R"(<table border="1"><th colspan="2">)" << it.first << "</th>" << std::endl;
                for (const auto &its : it.second)
                {
                    stream << "<tr><td>" << its.first << "</td><td>" << its.second << "</td></tr>" << std::endl;
                }
                stream << "</table><br/>" << std::endl;
            }
 
            stream << "</center>" << std::endl;
            stream << "<div class=\"copyleft\">File generated by <a href=\"https://github.com/AnotherFoxGuy/MofileReader\" "
                      "target=\"_blank\">moFileReaderSDK</a></div>"
                   << std::endl;
            stream << "</body></html>" << std::endl;
            stream.close();
        }
        else
        {
            return moFileReader::EC_FILENOTFOUND;
        }
 
        return moFileReader::EC_SUCCESS;
    }
 
  protected:
    std::string m_error;
 
    unsigned long SwapBytes(unsigned long in)
    {
        unsigned long b0 = (in >> 0) & 0xff;
        unsigned long b1 = (in >> 8) & 0xff;
        unsigned long b2 = (in >> 16) & 0xff;
        unsigned long b3 = (in >> 24) & 0xff;
 
        return (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
    }
 
  private:
    // Holds the lookup-table
    moLookupList        m_lookup;
    moContextLookupList m_lookup_context;
 
    int numStrings = 0;
 
    // Replaces < with ( to satisfy html-rules.
    static void MakeHtmlConform(std::string &_inout)
    {
        std::string temp = _inout;
        for (unsigned int i = 0; i < temp.length(); i++)
        {
            if (temp[i] == '>') { _inout.replace(i, 1, ")"); }
            if (temp[i] == '<') { _inout.replace(i, 1, "("); }
        }
    }
 
    // Extracts a value-pair from the po-edit-information
    bool GetPoEditorString(const char *_buffer, std::string &_name, std::string &_value)
    {
        std::string line(_buffer);
        size_t      first = line.find_first_of(':');
 
        if (first != std::string::npos)
        {
            _name  = line.substr(0, first);
            _value = line.substr(first + 1, line.length());
 
            // Replace <> with () for Html-Conformity.
            MakeHtmlConform(_value);
            MakeHtmlConform(_name);
 
            // Remove spaces from front and end.
            Trim(_value);
            Trim(_name);
 
            return true;
        }
        return false;
    }
 
    // Removes spaces from front and end.
    static void Trim(std::string &_in)
    {
        while (_in[0] == ' ')
        {
            _in = _in.substr(1, _in.length());
        }
        while (_in[_in.length()] == ' ')
        {
            _in = _in.substr(0, _in.length() - 1);
        }
    }
};
 
#ifndef MO_NO_CONVENIENCE_CLASS
class moFileReaderSingleton : public moFileReader
{
  private:
    // Private Contructor and Copy-Constructor to avoid
    // that this class is instanced.
    moFileReaderSingleton()
    {
    }
 
    moFileReaderSingleton(const moFileReaderSingleton &);
 
    moFileReaderSingleton &operator=(const moFileReaderSingleton &)
    {
        return *this;
    }
 
  public:
    static moFileReaderSingleton &GetInstance()
    {
        static moFileReaderSingleton theoneandonly;
        return theoneandonly;
    }
};
 
inline moFileReader::eErrorCode moReadMoFile(const char *_filename)
{
    moFileReader::eErrorCode r = moFileReaderSingleton::GetInstance().ReadFile(_filename);
    return r;
}
 
inline std::string _(const char *id)
{
    std::string r = moFileReaderSingleton::GetInstance().Lookup(id);
    return r;
}
 
inline void moFileClearTable()
{
    moFileReaderSingleton::GetInstance().ClearTable();
}
 
inline std::string moFileGetErrorDescription()
{
    std::string r = moFileReaderSingleton::GetInstance().GetErrorDescription();
    return r;
}
 
inline int moFileGetNumStrings()
{
    int r = moFileReaderSingleton::GetInstance().GetNumStrings();
    return r;
}
#endif
 
#if defined(_MSC_VER)
    #pragma warning(default : 4251)
#endif /* _MSC_VER */
 
MO_END_NAMESPACE
 
#endif /* __MOFILEREADER_SINGLE_INCLUDE_H_INCLUDED__ */