diff --git a/ZRColaCompile/dbsource.cpp b/ZRColaCompile/dbsource.cpp index c254e2a..e46fc2d 100644 --- a/ZRColaCompile/dbsource.cpp +++ b/ZRColaCompile/dbsource.cpp @@ -539,6 +539,50 @@ bool ZRCola::DBSource::GetChrCat(const com_obj& f, chrcatid_t& cc) con } +bool ZRCola::DBSource::GetTagNames(const winstd::com_obj& f, LCID lcid, list& names) const +{ + wxASSERT_MSG(f, wxT("field is empty")); + + variant v; + wxVERIFY(SUCCEEDED(f->get_Value(&v))); + wxCHECK(SUCCEEDED(v.change_type(VT_BSTR)), false); + + // Parse the field. Must be "name, name, name..." sequence. + names.clear(); + for (UINT i = 0, n = ::SysStringLen(V_BSTR(&v)); i < n && V_BSTR(&v)[i];) { + if (iswspace(V_BSTR(&v)[i])) { + // Skip leading white space. + i++; continue; + } + + // Parse name. + UINT j = i, j_end = i; + for (; i < n && V_BSTR(&v)[i]; i++) { + if (V_BSTR(&v)[i] == L',' || V_BSTR(&v)[i] == L';') { + // Delimiter found. + i++; break; + } else if (!iswspace(V_BSTR(&v)[i])) { + // Remember last non-white space character. + j_end = i + 1; + } + } + wstring name(V_BSTR(&v) + j, V_BSTR(&v) + j_end); + for (auto n = names.cbegin(), n_end = names.cend(); ; ++n) { + if (n == n_end) { + // Add name to the list. + names.push_back(std::move(name)); + break; + } else if (ZRCola::tagname_db::tagname::CompareName(lcid, n->data(), (unsigned __int16)n->length(), name.data(), (unsigned __int16)name.length()) == CSTR_EQUAL) { + // Name is already on the list. + break; + } + } + } + + return true; +} + + bool ZRCola::DBSource::SelectTranslations(com_obj &rs) const { // Create a new recordset. @@ -979,3 +1023,115 @@ bool ZRCola::DBSource::GetCharacterCategory(const com_obj& rs, chr return true; } + + +bool ZRCola::DBSource::SelectCharacterTags(winstd::com_obj& rs) const +{ + // Create a new recordset. + rs.free(); + wxCHECK(SUCCEEDED(::CoCreateInstance(CLSID_CADORecordset, NULL, CLSCTX_ALL, IID_IADORecordset, (LPVOID*)&rs)), false); + + // Open it. + if (FAILED(rs->Open(variant( + L"SELECT DISTINCT [znak], [oznaka] " + L"FROM [VRS_CharTags] " + L"ORDER BY [znak], [oznaka]"), variant(m_db), adOpenStatic, adLockReadOnly, adCmdText))) + { + _ftprintf(stderr, wxT("%s: error ZCC0130: Error loading character tags from database. Please make sure the file is ZRCola.zrc compatible.\n"), m_filename.c_str()); + LogErrors(); + return false; + } + + return true; +} + + +bool ZRCola::DBSource::GetCharacterTag(const winstd::com_obj& rs, chrtag& ct) const +{ + wxASSERT_MSG(rs, wxT("recordset is empty")); + + com_obj flds; + wxVERIFY(SUCCEEDED(rs->get_Fields(&flds))); + wstring id; + + { + com_obj f; + wxVERIFY(SUCCEEDED(flds->get_Item(variant(L"znak"), &f))); + wxCHECK(GetUnicodeCharacter(f, ct.chr), false); + } + + { + com_obj f; + wxVERIFY(SUCCEEDED(flds->get_Item(variant(L"oznaka"), &f))); + wxCHECK(GetValue(f, ct.tag), false); + } + + return true; +} + + +bool ZRCola::DBSource::SelectTagNames(winstd::com_obj& rs) const +{ + // Create a new recordset. + rs.free(); + wxCHECK(SUCCEEDED(::CoCreateInstance(CLSID_CADORecordset, NULL, CLSCTX_ALL, IID_IADORecordset, (LPVOID*)&rs)), false); + + // Open it. + if (FAILED(rs->Open(variant( + L"SELECT DISTINCT [oznaka], [opis_en], [opis_sl], [opis_ru] " + L"FROM [VRS_Tags] " + L"ORDER BY [oznaka]"), variant(m_db), adOpenStatic, adLockReadOnly, adCmdText))) + { + _ftprintf(stderr, wxT("%s: error ZCC0130: Error loading tags from database. Please make sure the file is ZRCola.zrc compatible.\n"), m_filename.c_str()); + LogErrors(); + return false; + } + + return true; +} + + +bool ZRCola::DBSource::GetTagName(const winstd::com_obj& rs, tagname& tn) const +{ + wxASSERT_MSG(rs, wxT("recordset is empty")); + + com_obj flds; + wxVERIFY(SUCCEEDED(rs->get_Fields(&flds))); + wstring id; + tn.names.clear(); + + { + com_obj f; + wxVERIFY(SUCCEEDED(flds->get_Item(variant(L"oznaka"), &f))); + wxCHECK(GetValue(f, tn.tag), false); + } + + { + com_obj f; + wxVERIFY(SUCCEEDED(flds->get_Item(variant(L"opis_en"), &f))); + LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), SORT_DEFAULT); + list names; + wxCHECK(GetTagNames(f, lcid, names), false); + tn.names.insert(std::move(pair >(lcid, std::move(names)))); + } + + { + com_obj f; + wxVERIFY(SUCCEEDED(flds->get_Item(variant(L"opis_sl"), &f))); + LCID lcid = MAKELCID(MAKELANGID(LANG_SLOVENIAN, SUBLANG_DEFAULT), SORT_DEFAULT); + list names; + wxCHECK(GetTagNames(f, lcid, names), false); + tn.names.insert(std::move(pair >(lcid, std::move(names)))); + } + + { + com_obj f; + wxVERIFY(SUCCEEDED(flds->get_Item(variant(L"opis_ru"), &f))); + LCID lcid = MAKELCID(MAKELANGID(LANG_RUSSIAN, SUBLANG_DEFAULT), SORT_DEFAULT); + list names; + wxCHECK(GetTagNames(f, lcid, names), false); + tn.names.insert(std::move(pair >(lcid, std::move(names)))); + } + + return true; +} diff --git a/ZRColaCompile/dbsource.h b/ZRColaCompile/dbsource.h index 337565b..c7c90ed 100644 --- a/ZRColaCompile/dbsource.h +++ b/ZRColaCompile/dbsource.h @@ -26,6 +26,7 @@ #include #include +#include #include #include #include @@ -311,11 +312,30 @@ namespace ZRCola { }; + /// + /// Character tag + /// + class chrtag { + public: + wchar_t chr; ///> Character + int tag; ///< Tag ID + }; + + + /// + /// Tag name + /// + class tagname { + public: + int tag; ///< Tag ID + std::map > names; ///< Names + }; + + public: DBSource(); virtual ~DBSource(); - /// /// Opens the database /// @@ -327,13 +347,11 @@ namespace ZRCola { /// bool Open(LPCTSTR filename); - /// /// Logs errors in database connections /// void LogErrors() const; - /// /// Is recordset at end /// @@ -349,7 +367,6 @@ namespace ZRCola { return FAILED(rs->get_EOF(&eof)) || eof ? true : false; } - /// /// Gets number of records in a recordset /// @@ -363,7 +380,6 @@ namespace ZRCola { return SUCCEEDED(rs->get_RecordCount(&count)) ? count : (size_t)-1; } - /// /// Splits string to individual keywords /// @@ -376,7 +392,6 @@ namespace ZRCola { /// static bool GetKeywords(const wchar_t *str, std::vector< std::wstring > &keywords); - /// /// Gets boolean from ZRCola.zrc database /// @@ -389,7 +404,6 @@ namespace ZRCola { /// bool GetValue(const winstd::com_obj& f, bool& val) const; - /// /// Gets integer from ZRCola.zrc database /// @@ -402,7 +416,6 @@ namespace ZRCola { /// bool GetValue(const winstd::com_obj& f, int& val) const; - /// /// Gets string from ZRCola.zrc database /// @@ -415,7 +428,6 @@ namespace ZRCola { /// bool GetValue(const winstd::com_obj& f, std::wstring& val) const; - /// /// Gets encoded Unicode character from ZRCola.zrc database /// @@ -428,7 +440,6 @@ namespace ZRCola { /// bool GetUnicodeCharacter(const winstd::com_obj& f, wchar_t& chr) const; - /// /// Gets encoded Unicode string from ZRCola.zrc database /// @@ -441,7 +452,6 @@ namespace ZRCola { /// bool GetUnicodeString(const winstd::com_obj& f, std::wstring& str) const; - /// /// Gets language ID from ZRCola.zrc database /// @@ -454,7 +464,6 @@ namespace ZRCola { /// bool GetLanguage(const winstd::com_obj& f, langid_t& lang) const; - /// /// Gets character category ID from ZRCola.zrc database /// @@ -467,6 +476,17 @@ namespace ZRCola { /// bool GetChrCat(const winstd::com_obj& f, chrcatid_t& cc) const; + /// + /// Gets tag names from ZRCola.zrc database + /// + /// \param[in] f Data field + /// \param[out] names Output names + /// + /// \returns + /// - true when successful + /// - false otherwise + /// + bool GetTagNames(const winstd::com_obj& f, LCID lcid, std::list& names) const; /// /// Returns character translations @@ -479,7 +499,6 @@ namespace ZRCola { /// bool SelectTranslations(winstd::com_obj& rs) const; - /// /// Returns translation data /// @@ -492,7 +511,6 @@ namespace ZRCola { /// bool GetTranslation(const winstd::com_obj& rs, translation& t) const; - /// /// Returns key sequences /// @@ -504,7 +522,6 @@ namespace ZRCola { /// bool SelectKeySequences(winstd::com_obj& rs) const; - /// /// Returns key sequence data /// @@ -517,7 +534,6 @@ namespace ZRCola { /// bool GetKeySequence(const winstd::com_obj& rs, keyseq& ks) const; - /// /// Returns languages /// @@ -529,7 +545,6 @@ namespace ZRCola { /// bool SelectLanguages(winstd::com_obj& rs) const; - /// /// Returns language data /// @@ -542,7 +557,6 @@ namespace ZRCola { /// bool GetLanguage(const winstd::com_obj& rs, language& lang) const; - /// /// Returns language character /// @@ -554,7 +568,6 @@ namespace ZRCola { /// bool SelectLanguageCharacters(winstd::com_obj& rs) const; - /// /// Returns language character data /// @@ -567,7 +580,6 @@ namespace ZRCola { /// bool GetLanguageCharacter(const winstd::com_obj& rs, langchar& lc) const; - /// /// Returns character groups /// @@ -579,7 +591,6 @@ namespace ZRCola { /// bool SelectCharacterGroups(winstd::com_obj& rs) const; - /// /// Returns character group data /// @@ -603,7 +614,6 @@ namespace ZRCola { /// bool SelectCharacters(winstd::com_obj& rs) const; - /// /// Returns character data /// @@ -627,7 +637,6 @@ namespace ZRCola { /// bool SelectCharacterCategories(winstd::com_obj& rs) const; - /// /// Returns character category data /// @@ -640,6 +649,52 @@ namespace ZRCola { /// bool GetCharacterCategory(const winstd::com_obj& rs, chrcat& cc) const; + /// + /// Returns character tags + /// + /// \param[out] rs Recordset with results + /// + /// \returns + /// - true when query succeeds + /// - false otherwise + /// + bool SelectCharacterTags(winstd::com_obj& rs) const; + + /// + /// Returns character tag data + /// + /// \param[in] rs Recordset with results + /// \param[out] cc Character tag + /// + /// \returns + /// - true when succeeded + /// - false otherwise + /// + bool GetCharacterTag(const winstd::com_obj& rs, chrtag& tc) const; + + /// + /// Returns tag names + /// + /// \param[out] rs Recordset with results + /// + /// \returns + /// - true when query succeeds + /// - false otherwise + /// + bool SelectTagNames(winstd::com_obj& rs) const; + + /// + /// Returns tag name data + /// + /// \param[in] rs Recordset with results + /// \param[out] tn Tag name + /// + /// \returns + /// - true when succeeded + /// - false otherwise + /// + bool GetTagName(const winstd::com_obj& rs, tagname& tn) const; + protected: std::basic_string m_filename; ///< Database filename winstd::com_obj m_db; ///< Database diff --git a/ZRColaCompile/main.cpp b/ZRColaCompile/main.cpp index bed2081..4050960 100644 --- a/ZRColaCompile/main.cpp +++ b/ZRColaCompile/main.cpp @@ -610,6 +610,103 @@ int _tmain(int argc, _TCHAR *argv[]) } } + { + // Get characters tags. + com_obj rs; + if (src.SelectCharacterTags(rs)) { + size_t count = src.GetRecordsetCount(rs); + if (count < 0xffffffff) { // 4G check (-1 is reserved for error condition) + ZRCola::DBSource::chrtag ct; + ZRCola::chrtag_db db; + + // Preallocate memory. + db.idxChr.reserve(count); + db.idxTag.reserve(count); + db.data .reserve(count*4); + + // Parse characters tags and build index and data. + for (; !ZRCola::DBSource::IsEOF(rs); rs->MoveNext()) { + // Read characters tags from the database. + if (src.GetCharacterTag(rs, ct)) { + // Add characters tags to index and data. + unsigned __int32 idx = db.data.size(); + db.data.push_back(ct.chr); + wxASSERT_MSG((int)0xffff8000 <= ct.tag && ct.tag <= (int)0x00007fff, wxT("tag out of bounds")); + db.data.push_back((unsigned __int16)ct.tag); + db.idxChr.push_back(idx); + db.idxTag.push_back(idx); + } else + has_errors = true; + } + + // Sort indices. + db.idxChr .sort(); + db.idxTag.sort(); + + // Write characters tags to file. + dst << ZRCola::chrtag_rec(db); + } else { + _ftprintf(stderr, wxT("%s: error ZCC0021: Error getting characters tags count from database or too many character tags.\n"), (LPCTSTR)filenameIn.c_str()); + has_errors = true; + } + } else { + _ftprintf(stderr, wxT("%s: error ZCC0020: Error getting characters tags from database. Please make sure the file is ZRCola.zrc compatible.\n"), (LPCTSTR)filenameIn.c_str()); + has_errors = true; + } + } + + { + // Get tag names. + com_obj rs; + if (src.SelectTagNames(rs)) { + size_t count = src.GetRecordsetCount(rs); + if (count < 0xffffffff) { // 4G check (-1 is reserved for error condition) + ZRCola::DBSource::tagname tn; + ZRCola::tagname_db db; + + // Preallocate memory. + db.idxName.reserve(count*3); + db.data .reserve(count*3*4); + + // Parse tags and build index and data. + for (; !ZRCola::DBSource::IsEOF(rs); rs->MoveNext()) { + // Read tag name from the database. + if (src.GetTagName(rs, tn)) { + // Add tag name to index and data. + for (auto ln = tn.names.cbegin(), ln_end = tn.names.cend(); ln != ln_end; ++ln) { + for (auto nm = ln->second.cbegin(), nm_end = ln->second.cend(); nm != nm_end; ++nm) { + unsigned __int32 idx = db.data.size(); + wxASSERT_MSG((int)0xffff8000 <= tn.tag && tn.tag <= (int)0x00007fff, wxT("tag out of bounds")); + db.data.push_back((unsigned __int16)tn.tag); + db.data.push_back(LOWORD(ln->first)); + db.data.push_back(HIWORD(ln->first)); + wstring::size_type n = nm->length(); + wxASSERT_MSG(n <= 0xffff, wxT("tag name too long")); + db.data.push_back((unsigned __int16)n); + for (wstring::size_type i = 0; i < n; i++) + db.data.push_back(nm->at(i)); + db.idxName.push_back(idx); + } + } + } else + has_errors = true; + } + + // Sort indices. + db.idxName.sort(); + + // Write tags to file. + dst << ZRCola::tagname_rec(db); + } else { + _ftprintf(stderr, wxT("%s: error ZCC0023: Error getting tag name count from database or too many tags.\n"), (LPCTSTR)filenameIn.c_str()); + has_errors = true; + } + } else { + _ftprintf(stderr, wxT("%s: error ZCC0022: Error getting tags from database. Please make sure the file is ZRCola.zrc compatible.\n"), (LPCTSTR)filenameIn.c_str()); + has_errors = true; + } + } + idrec::close(dst, dst_start); if (dst.fail()) { diff --git a/ZRColaCompile/stdafx.h b/ZRColaCompile/stdafx.h index 1aab67f..773ac08 100644 --- a/ZRColaCompile/stdafx.h +++ b/ZRColaCompile/stdafx.h @@ -24,6 +24,7 @@ #include #include +#include #include #include diff --git a/lib/libZRCola/build/libZRCola.vcxproj b/lib/libZRCola/build/libZRCola.vcxproj index f077c81..d83ae03 100644 --- a/lib/libZRCola/build/libZRCola.vcxproj +++ b/lib/libZRCola/build/libZRCola.vcxproj @@ -37,6 +37,7 @@ + diff --git a/lib/libZRCola/build/libZRCola.vcxproj.filters b/lib/libZRCola/build/libZRCola.vcxproj.filters index eb80148..6a611b4 100644 --- a/lib/libZRCola/build/libZRCola.vcxproj.filters +++ b/lib/libZRCola/build/libZRCola.vcxproj.filters @@ -56,6 +56,9 @@ Header Files + + Header Files + diff --git a/lib/libZRCola/include/zrcola/tag.h b/lib/libZRCola/include/zrcola/tag.h new file mode 100644 index 0000000..fbd7c1f --- /dev/null +++ b/lib/libZRCola/include/zrcola/tag.h @@ -0,0 +1,444 @@ +/* + Copyright 2015-2016 Amebis + + This file is part of ZRCola. + + ZRCola is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ZRCola is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with ZRCola. If not, see . +*/ + +#pragma once + +#include "common.h" + +#include +#include +#include +#include +#include + +#pragma warning(push) +#pragma warning(disable: 4200) +#pragma warning(disable: 4251) +#pragma warning(disable: 4512) + + +namespace ZRCola { + typedef unsigned __int16 tagid_t; + + /// + /// Character Tag Database + /// + class ZRCOLA_API chrtag_db { + public: +#pragma pack(push) +#pragma pack(2) + /// + /// Character tag data + /// + struct chrtag { + wchar_t chr; ///> Character + tagid_t tag; ///< Tag ID + }; +#pragma pack(pop) + + /// + /// Character Index + /// + class indexChar : public index + { + public: + /// + /// Constructs the index + /// + /// \param[in] h Reference to vector holding the data + /// + indexChar(_In_ std::vector &h) : index(h) {} + + /// + /// Compares two character tags by character (for searching) + /// + /// \param[in] a Pointer to first element + /// \param[in] b Pointer to second element + /// + /// \returns + /// - <0 when a < b + /// - =0 when a == b + /// - >0 when a > b + /// + virtual int compare(_In_ const chrtag &a, _In_ const chrtag &b) const + { + if (a.chr < b.chr) return -1; + else if (a.chr > b.chr) return 1; + + return 0; + } + + /// + /// Compares two character tags by character (for sorting) + /// + /// \param[in] a Pointer to first element + /// \param[in] b Pointer to second element + /// + /// \returns + /// - <0 when a < b + /// - =0 when a == b + /// - >0 when a > b + /// + virtual int compare_sort(_In_ const chrtag &a, _In_ const chrtag &b) const + { + if (a.chr < b.chr) return -1; + else if (a.chr > b.chr) return 1; + + if (a.tag < b.tag) return -1; + else if (a.tag > b.tag) return 1; + + return 0; + } + } idxChr; ///< Character index + + + /// + /// Tag Index + /// + class indexTag : public index + { + public: + /// + /// Constructs the index + /// + /// \param[in] h Reference to vector holding the data + /// + indexTag(_In_ std::vector &h) : index(h) {} + + /// + /// Compares two character tags by tag (for searching) + /// + /// \param[in] a Pointer to first element + /// \param[in] b Pointer to second element + /// + /// \returns + /// - <0 when a < b + /// - =0 when a == b + /// - >0 when a > b + /// + virtual int compare(_In_ const chrtag &a, _In_ const chrtag &b) const + { + if (a.tag < b.tag) return -1; + else if (a.tag > b.tag) return 1; + + return 0; + } + + /// + /// Compares two character tags by tag (for sorting) + /// + /// \param[in] a Pointer to first element + /// \param[in] b Pointer to second element + /// + /// \returns + /// - <0 when a < b + /// - =0 when a == b + /// - >0 when a > b + /// + virtual int compare_sort(_In_ const chrtag &a, _In_ const chrtag &b) const + { + if (a.tag < b.tag) return -1; + else if (a.tag > b.tag) return 1; + + if (a.chr < b.chr) return -1; + else if (a.chr > b.chr) return 1; + + return 0; + } + } idxTag; ///< Tag index + + std::vector data; ///< Character tags data + + public: + /// + /// Constructs the database + /// + inline chrtag_db() : idxChr(data), idxTag(data) {} + }; + + + typedef ZRCOLA_API stdex::idrec::record chrtag_rec; + + + /// + /// Tag name database + /// + class ZRCOLA_API tagname_db { + public: +#pragma pack(push) +#pragma pack(2) + /// + /// Tag name data + /// + struct tagname { + tagid_t tag; ///< Tag ID + LCID lang; ///< Language ID + unsigned __int16 name_len; ///< \c name length (in characters) + wchar_t name[]; ///< Tag localized name + + /// + /// Compares two names + /// + /// \param[in] lcid Locale ID to use for compare + /// \param[in] str_a First name + /// \param[in] count_a Number of characters in string \p str_a + /// \param[in] str_b Second name + /// \param[in] count_b Number of characters in string \p str_b + /// + /// \returns + /// - <0 when str_a < str_b + /// - =0 when str_a == str_b + /// - >0 when str_a > str_b + /// + /// \note + /// The function does not treat \\0 characters as terminators for performance reasons. + /// Therefore \p count_a and \p count_b must represent exact string lengths. + /// + static inline int CompareName(LCID lcid, const wchar_t *str_a, unsigned __int16 count_a, const wchar_t *str_b, unsigned __int16 count_b) + { + switch (CompareString(lcid, LINGUISTIC_IGNORECASE | LINGUISTIC_IGNOREDIACRITIC | NORM_LINGUISTIC_CASING | NORM_IGNOREWIDTH, str_a, count_a, str_b, count_b)) { + case CSTR_LESS_THAN : return -1; + case CSTR_EQUAL : return 0; + case CSTR_GREATER_THAN: return 1; + default : assert(0); return -1; + } + } + }; +#pragma pack(pop) + + /// + /// Name index + /// + class indexName : public index + { + public: + /// + /// Constructs the index + /// + /// \param[in] h Reference to vector holding the data + /// \param[in] lcid Locale used to perform tag name comparison + /// + indexName(_In_ std::vector &h) : index(h) {} + + /// + /// Compares two tag names by name (for searching) + /// + /// \param[in] a Pointer to first element + /// \param[in] b Pointer to second element + /// + /// \returns + /// - <0 when a < b + /// - =0 when a == b + /// - >0 when a > b + /// + virtual int compare(_In_ const tagname &a, _In_ const tagname &b) const + { + if (a.lang < b.lang) return -1; + else if (a.lang > b.lang) return 1; + + int r = tagname::CompareName(a.lang, a.name, a.name_len, b.name, b.name_len); + if (r != 0) return r; + + return 0; + } + + /// + /// Compares two tag names by name (for sorting) + /// + /// \param[in] a Pointer to first element + /// \param[in] b Pointer to second element + /// + /// \returns + /// - <0 when a < b + /// - =0 when a == b + /// - >0 when a > b + /// + virtual int compare_sort(_In_ const tagname &a, _In_ const tagname &b) const + { + if (a.lang < b.lang) return -1; + else if (a.lang > b.lang) return 1; + + int r = tagname::CompareName(a.lang, a.name, a.name_len, b.name, b.name_len); + if (r != 0) return r; + + if (a.tag < b.tag) return -1; + else if (a.tag > b.tag) return 1; + + return 0; + } + } idxName; ///< Name index + + std::vector data; ///< Tag data + + public: + /// + /// Constructs the database + /// + /// \param[in] lcid Locale used to perform tag name comparison + /// + inline tagname_db() : idxName(data) {} + }; + + + typedef ZRCOLA_API stdex::idrec::record tagname_rec; +}; + + +const ZRCola::recordid_t stdex::idrec::record::id = *(ZRCola::recordid_t*)"C-T"; +const ZRCola::recordid_t stdex::idrec::record::id = *(ZRCola::recordid_t*)"TGN"; + + +/// +/// Writes character tag database to a stream +/// +/// \param[in] stream Output stream +/// \param[in] db Character tag database +/// +/// \returns The stream \p stream +/// +inline std::ostream& operator <<(_In_ std::ostream& stream, _In_ const ZRCola::chrtag_db &db) +{ + // Write character index. + if (stream.fail()) return stream; + stream << db.idxChr; + + // Write tag index. + if (stream.fail()) return stream; + stream << db.idxTag; + + // Write data count. + auto data_count = db.data.size(); +#if defined(_WIN64) || defined(__x86_64__) || defined(__ppc64__) + // 4G check + if (data_count > 0xffffffff) { + stream.setstate(std::ios_base::failbit); + return stream; + } +#endif + if (stream.fail()) return stream; + unsigned __int32 count = (unsigned __int32)data_count; + stream.write((const char*)&count, sizeof(count)); + + // Write data. + if (stream.fail()) return stream; + stream.write((const char*)db.data.data(), sizeof(unsigned __int16)*count); + + return stream; +} + + +/// +/// Reads character tag database from a stream +/// +/// \param[in ] stream Input stream +/// \param[out] db Character tag database +/// +/// \returns The stream \p stream +/// +inline std::istream& operator >>(_In_ std::istream& stream, _Out_ ZRCola::chrtag_db &db) +{ + // Read character index. + stream >> db.idxChr; + if (!stream.good()) return stream; + + // Read tag index. + stream >> db.idxTag; + if (!stream.good()) return stream; + + // Read data count. + unsigned __int32 count; + stream.read((char*)&count, sizeof(count)); + if (!stream.good()) return stream; + + if (count) { + // Read data. + db.data.resize(count); + stream.read((char*)db.data.data(), sizeof(unsigned __int16)*count); + } else + db.data.clear(); + + return stream; +} + + +/// +/// Writes tag database to a stream +/// +/// \param[in] stream Output stream +/// \param[in] db Tag database +/// +/// \returns The stream \p stream +/// +inline std::ostream& operator <<(_In_ std::ostream& stream, _In_ const ZRCola::tagname_db &db) +{ + // Write tag index. + if (stream.fail()) return stream; + stream << db.idxName; + + // Write data count. + auto data_count = db.data.size(); +#if defined(_WIN64) || defined(__x86_64__) || defined(__ppc64__) + // 4G check + if (data_count > 0xffffffff) { + stream.setstate(std::ios_base::failbit); + return stream; + } +#endif + if (stream.fail()) return stream; + unsigned __int32 count = (unsigned __int32)data_count; + stream.write((const char*)&count, sizeof(count)); + + // Write data. + if (stream.fail()) return stream; + stream.write((const char*)db.data.data(), sizeof(unsigned __int16)*count); + + return stream; +} + + +/// +/// Reads tag database from a stream +/// +/// \param[in ] stream Input stream +/// \param[out] db Tag database +/// +/// \returns The stream \p stream +/// +inline std::istream& operator >>(_In_ std::istream& stream, _Out_ ZRCola::tagname_db &db) +{ + // Read tag index. + stream >> db.idxName; + if (!stream.good()) return stream; + + // Read data count. + unsigned __int32 count; + stream.read((char*)&count, sizeof(count)); + if (!stream.good()) return stream; + + if (count) { + // Read data. + db.data.resize(count); + stream.read((char*)db.data.data(), sizeof(unsigned __int16)*count); + } else + db.data.clear(); + + return stream; +} + +#pragma warning(pop) diff --git a/lib/libZRCola/src/stdafx.h b/lib/libZRCola/src/stdafx.h index dc4a349..a56adb8 100644 --- a/lib/libZRCola/src/stdafx.h +++ b/lib/libZRCola/src/stdafx.h @@ -25,6 +25,7 @@ #include "../include/zrcola/language.h" #include "../include/zrcola/normalize.h" #include "../include/zrcola/translate.h" +#include "../include/zrcola/tag.h" #include diff --git a/output/data/ZRCola.zrcdb b/output/data/ZRCola.zrcdb index 7448849..6398ee5 100644 Binary files a/output/data/ZRCola.zrcdb and b/output/data/ZRCola.zrcdb differ