Index: /trunk/src/VBox/Main/include/QMTranslator.h =================================================================== --- /trunk/src/VBox/Main/include/QMTranslator.h (revision 52559) +++ /trunk/src/VBox/Main/include/QMTranslator.h (revision 52559) @@ -0,0 +1,57 @@ +/* $Id$ */ +/** @file + * VirtualBox API translation handling class + */ + +/* + * Copyright (C) 2014 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#ifndef ____H_QMTRANSLATOR +#define ____H_QMTRANSLATOR + +class QMTranslator_Impl; + +class QMTranslator +{ +public: + QMTranslator(); + virtual ~QMTranslator(); + + /* Gets translation from loaded QM file + * + * @param context QM context to look for translation + * @param source Source string in one-byte encoding + * @param disamb Disambiguationg comment, empty by default + * + * @returns Pointer to a translation in UTF-8 encoding, empty string on failure */ + + const char *translate(const char *pszContext, const char *pszSource, const char *pszDisamb = "") const throw(); + + /* Loads and parses QM file + * + * @param filename The name of the file to load + * + * @returns VINF_SUCCESS if successful */ + int load(const char *pszFilename) throw(); + +private: + /* QMTranslator implementation. + * To separate all the code from the interface */ + QMTranslator_Impl *_impl; + + /* If copying is required, please define the following operators */ + void operator=(QMTranslator &); + QMTranslator(const QMTranslator &); +}; + +#endif /* !____H_QMTRANSLATOR */ +/* vi: set tabstop=4 shiftwidth=4 expandtab: */ Index: /trunk/src/VBox/Main/src-all/QMTranslatorImpl.cpp =================================================================== --- /trunk/src/VBox/Main/src-all/QMTranslatorImpl.cpp (revision 52559) +++ /trunk/src/VBox/Main/src-all/QMTranslatorImpl.cpp (revision 52559) @@ -0,0 +1,433 @@ +/* $Id$ */ +/** @file + * VirtualBox API translation handling class + */ + +/* + * Copyright (C) 2014 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* QM File Magic Number */ +static const size_t MagicLength = 16; +static const uint8_t Magic[MagicLength] = { + 0x3c, 0xb8, 0x64, 0x18, 0xca, 0xef, 0x9c, 0x95, + 0xcd, 0x21, 0x1c, 0xbf, 0x60, 0xa1, 0xbd, 0xdd +}; + +/* Used internally */ +class QMException : public std::exception +{ + const char *m_str; +public: + QMException(const char *str) : m_str(str) {} + virtual const char *what() const throw() { return m_str; } +}; + +/* Bytes stream. Used by the parser to iterate through the data */ +class QMBytesStream +{ + size_t m_cbSize; + const uint8_t * const m_dataStart; + const uint8_t *m_iter; + const uint8_t *m_end; + + /* Function stub for transform method */ + static uint16_t func_BE2H_U16(uint16_t value) + { + return RT_BE2H_U16(value); + } + +public: + + QMBytesStream(const uint8_t *const dataStart, size_t cbSize) : + m_cbSize(dataStart ? cbSize : 0), + m_dataStart(dataStart), + m_iter(dataStart) + { + setEnd(); + } + + /* Sets end pointer + * Used in message reader to detect the end of message block */ + inline void setEnd(size_t pos = 0) + { + m_end = m_dataStart + (pos && pos < m_cbSize ? pos : m_cbSize); + } + + inline uint8_t read8() + { + checkSize(1); + return *m_iter++; + } + + inline uint32_t read32() + { + checkSize(4); + uint32_t result = *reinterpret_cast(m_iter); + m_iter += 4; + return RT_BE2H_U32(result); + } + + /* Reads string in UTF16 and converts it into a UTF8 string */ + inline com::Utf8Str readUtf16String() + { + uint32_t size = read32(); + checkSize(size); + if (size & 1) throw QMException("Incorrect string size"); + std::vector wstr; + wstr.reserve(size / 2); + + /* We cannot convert to host endianess without copying the data + * since the file might be mapped to the memory and any memory + * change will lead to the change of the file. */ + std::transform(reinterpret_cast(m_iter), + reinterpret_cast(m_iter + size), + std::back_inserter(wstr), + func_BE2H_U16); + m_iter += size; + return com::Utf8Str((CBSTR) &wstr.front(), wstr.size()); + } + + /* Reads string in one-byte encoding + * The string is assumed to be in ISO-8859-1 encoding */ + inline com::Utf8Str readString() + { + uint32_t size = read32(); + checkSize(size); + com::Utf8Str result(reinterpret_cast(m_iter), size); + m_iter += size; + return result; + } + + /* Checks the magic number + * Should be called when in the beginning of the data */ + inline void checkMagic() + { + checkSize(MagicLength); + if (memcmp(&(*m_iter), Magic, MagicLength)) throw QMException("Wrong magic number"); + m_iter += MagicLength; + } + + /* Has we reached the end pointer? */ + inline bool hasFinished() { return m_iter == m_end; } + + /* Returns current stream position */ + inline size_t tellPos() { return m_iter - m_dataStart; } + + /* Moves current pointer to a desired position */ + inline void seek(int pos) { m_iter += pos; } + + /* Checks whether stream has enough data to read size bytes */ + inline void checkSize(int size) + { + if (m_end - m_iter < size) throw QMException("Incorrect item size"); + } +}; + +/* Internal QMTranslator implementation */ +class QMTranslator_Impl +{ + struct QMMessage + { + /* Everything is in UTF-8 */ + com::Utf8Str strContext; + com::Utf8Str strTranslation; + com::Utf8Str strComment; + com::Utf8Str strSource; + uint32_t hash; + QMMessage() : hash(0) {} + }; + + struct HashOffset + { + uint32_t hash; + uint32_t offset; + + HashOffset(uint32_t _hash = 0, uint32_t _offs = 0) : hash(_hash), offset(_offs) {} + + bool operator<(const HashOffset &obj) const + { + return (hash != obj.hash ? hash < obj.hash : offset < obj.offset); + } + + }; + + typedef std::set QMHashSet; + typedef QMHashSet::const_iterator QMHashSetConstIter; + typedef std::vector QMMessageArray; + + QMHashSet m_hashSet; + QMMessageArray m_messageArray; + +public: + + QMTranslator_Impl() {} + + const char *translate(const char *pszContext, + const char *pszSource, + const char *pszDisamb) const + { + QMHashSetConstIter iter; + QMHashSetConstIter lowerIter, upperIter; + + do { + uint32_t hash = calculateHash(pszSource, pszDisamb); + lowerIter = m_hashSet.lower_bound(HashOffset(hash, 0)); + upperIter = m_hashSet.upper_bound(HashOffset(hash, ~0)); + + for (iter = lowerIter; iter != upperIter; ++iter) + { + const QMMessage &message = m_messageArray[iter->offset]; + if ((!pszContext || !*pszContext || message.strContext == pszContext) && + message.strSource == pszSource && + ((pszDisamb && !*pszDisamb) || message.strComment == pszDisamb)) + break; + } + + /* Try without disambiguating comment if it isn't empty */ + if (pszDisamb) + { + if (!*pszDisamb) pszDisamb = 0; + else pszDisamb = ""; + } + + } while (iter == upperIter && pszDisamb); + + return (iter != upperIter ? m_messageArray[iter->offset].strTranslation.c_str() : ""); + } + + void load(QMBytesStream &stream) + { + /* Load into local variables. If we failed during the load, + * it would allow us to keep the object in a valid (previous) state. */ + QMHashSet hashSet; + QMMessageArray messageArray; + + stream.checkMagic(); + + while (!stream.hasFinished()) + { + uint32_t sectionCode = stream.read8(); + uint32_t sLen = stream.read32(); + + /* Hashes and Context sections are ignored. They contain hash tables + * to speed-up search which is not useful since we recalculate all hashes + * and don't perform context search by hash */ + switch (sectionCode) + { + case Messages: + parseMessages(stream, &hashSet, &messageArray, sLen); + break; + case Hashes: + /* Only get size information to speed-up vector filling + * if Hashes section goes in the file before Message section */ + m_messageArray.reserve(sLen >> 3); + /* NB! NO BREAK HERE */ + case Context: + stream.seek(sLen); + break; + default: + throw QMException("Unkown section"); + } + } + /* Store the data into member variables. + * The following functions never generate exceptions */ + m_hashSet.swap(hashSet); + m_messageArray.swap(messageArray); + } + +private: + + /* Some QM stuff */ + enum SectionType + { + Hashes = 0x42, + Messages = 0x69, + Contexts = 0x2f + }; + + enum MessageType + { + End = 1, + SourceText16 = 2, + Translation = 3, + Context16 = 4, + Hash = 5, + SourceText = 6, + Context = 7, + Comment = 8 + }; + + /* Read messages from the stream. */ + static void parseMessages(QMBytesStream &stream, QMHashSet * const hashSet, QMMessageArray * const messageArray, size_t cbSize) + { + stream.setEnd(stream.tellPos() + cbSize); + uint32_t cMessage = 0; + while (!stream.hasFinished()) + { + QMMessage message; + HashOffset hashOffs; + + parseMessageRecord(stream, &message); + if (!message.hash) + message.hash = calculateHash(message.strSource.c_str(), message.strComment.c_str()); + + hashOffs.hash = message.hash; + hashOffs.offset = cMessage++; + + hashSet->insert(hashOffs); + messageArray->push_back(message); + } + stream.setEnd(); + } + + /* Parse one message from the stream */ + static void parseMessageRecord(QMBytesStream &stream, QMMessage * const message) + { + while(!stream.hasFinished()) + { + uint8_t type = stream.read8(); + switch(type) + { + case End: + return; + /* Ignored as obsolete */ + case Context16: + case SourceText16: + stream.seek(stream.read32()); + break; + case Translation: + { + com::Utf8Str str = stream.readUtf16String(); + message->strTranslation.swap(str); + break; + } + case Hash: + message->hash = stream.read32(); + break; + + case SourceText: + { + com::Utf8Str str = stream.readString(); + message->strSource.swap(str); + break; + } + + case Context: + { + com::Utf8Str str = stream.readString(); + message->strContext.swap(str); + break; + } + + case Comment: + { + com::Utf8Str str = stream.readString(); + message->strComment.swap(str); + break; + } + + default: + /* Ignore unknown block */ + LogRel(("QMTranslator::parseMessageRecord(): Unkown message block %x\n", type)); + break; + } + } + } + + /* Defines the so called `hashpjw' function by P.J. Weinberger + [see Aho/Sethi/Ullman, COMPILERS: Principles, Techniques and Tools, + 1986, 1987 Bell Telephone Laboratories, Inc.] */ + static uint32_t calculateHash(const char *pszStr1, const char *pszStr2 = 0) + { + uint32_t hash = 0, g; + + for (const char *pszStr = pszStr1; pszStr != pszStr2; pszStr = pszStr2) + for (; pszStr && *pszStr; pszStr++) + { + hash = (hash << 4) + static_cast(*pszStr); + + if ((g = hash & 0xf0000000ul) != 0) + { + hash ^= g >> 24; + hash ^= g; + } + } + + return (hash != 0 ? hash : 1); + } +}; + +/* Inteface functions implementation */ +QMTranslator::QMTranslator() : _impl(new QMTranslator_Impl) {} + +QMTranslator::~QMTranslator() { delete _impl; } + +const char *QMTranslator::translate(const char *pszContext, const char *pszSource, const char *pszDisamb) const throw() +{ + return _impl->translate(pszContext, pszSource, pszDisamb); +} + +/* The function is noexcept for now but it may be changed + * to throw exceptions if required to catch them in another + * place. */ +int QMTranslator::load(const char *pszFilename) throw() +{ + /* To free safely the file in case of exception */ + struct FileLoader + { + uint8_t *data; + size_t cbSize; + int rc; + FileLoader(const char *pszFname) + { + rc = RTFileReadAll(pszFname, (void**) &data, &cbSize); + } + + ~FileLoader() + { + if (isSuccess()) + RTFileReadAllFree(data, cbSize); + } + bool isSuccess() { return RT_SUCCESS(rc); } + }; + + try + { + FileLoader loader(pszFilename); + if (loader.isSuccess()) + { + QMBytesStream stream(loader.data, loader.cbSize); + _impl->load(stream); + } + return loader.rc; + } + catch(std::exception &e) + { + LogRel(("QMTranslator::load() failed to load file '%s', reason: %s\n", pszFilename, e.what())); + return VERR_INTERNAL_ERROR; + } + catch(...) + { + LogRel(("QMTranslator::load() failed to load file '%s'\n", pszFilename)); + return VERR_GENERAL_FAILURE; + } +}