Amebis/ZRCola
Amebis/ZRCola
1
1
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases 49 Wiki Activity

Backport gcc changes to MSVC

Browse Source 
wchar_t is not char16_t on MSVC, requiring a lot of typecasting when
interfacing ZRCola database strings with GUI.

Signed-off-by: Simon Rozman <simon@rozman.si>
This commit is contained in:
Simon Rozman 2022-09-15 15:33:08 +02:00
parent ba4ff3cd42
commit 35eb472e6b
18 changed files with 236 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ZRCola/zrcolachrcatpnl.cpp
View File

@ -148,7 +148,7 @@ void wxZRColaCharacterCatalogPanel::Update()
wxArrayShort(reinterpret_cast<const short*>(cg.chrshow()), reinterpret_cast<const short*>(cg.chrshow_end())));
} else {
// Select frequently used characters only.
const wchar_t *src = cg.chrlst();
const auto *src = cg.chrlst();
const uint16_t *shown = cg.chrshow();
wxArrayString chars;
for (size_t i = 0, i_end = cg.chrlst_len(), j = 0; i < i_end; j++) {

2
ZRCola/zrcolachrgrid.cpp
View File

@ -110,7 +110,7 @@ wxString wxZRColaCharGrid::GetToolTipText(int idx)
const auto &chr = m_chars[idx];
// See if this character has a key sequence registered.
std::unique_ptr<ZRCola::keyseq_db::keyseq> ks((ZRCola::keyseq_db::keyseq*)new char[sizeof(ZRCola::keyseq_db::keyseq) + sizeof(wchar_t)*chr.length()]);
std::unique_ptr<ZRCola::keyseq_db::keyseq> ks((ZRCola::keyseq_db::keyseq*)new char[sizeof(ZRCola::keyseq_db::keyseq) + sizeof(ZRCola::char_t)*chr.length()]);
ks->ZRCola::keyseq_db::keyseq::keyseq(NULL, 0, chr.data(), chr.length());
ZRCola::keyseq_db::indexKey::size_type start;
if (app->m_ks_db.idxChr.find(*ks, start)) {

28
ZRCola/zrcolachrslct.cpp
View File

@ -13,7 +13,7 @@
wxIMPLEMENT_DYNAMIC_CLASS(wxZRColaUTF16CharValidator, wxValidator);
wxZRColaUTF16CharValidator::wxZRColaUTF16CharValidator(wchar_t *val) :
wxZRColaUTF16CharValidator::wxZRColaUTF16CharValidator(ZRCola::char_t *val) :
m_val(val),
wxValidator()
{
@ -58,11 +58,11 @@ bool wxZRColaUTF16CharValidator::TransferFromWindow()
}
bool wxZRColaUTF16CharValidator::Parse(const wxString &val_in, size_t i_start, size_t i_end, wxTextCtrl *ctrl, wxWindow *parent, wchar_t *val_out)
bool wxZRColaUTF16CharValidator::Parse(const wxString &val_in, size_t i_start, size_t i_end, wxTextCtrl *ctrl, wxWindow *parent, ZRCola::char_t *val_out)
{
const wxStringCharType *buf = val_in;
wchar_t chr = 0;
ZRCola::char_t chr = 0;
for (size_t i = i_start;;) {
if (i >= i_end) {
// End of Unicode found.
@ -156,7 +156,7 @@ bool wxZRColaUnicodeDumpValidator::Parse(const wxString &val_in, size_t i_start,
wxString str;
for (size_t i = i_start;;) {
const wxStringCharType *buf_next;
wchar_t chr;
ZRCola::char_t chr;
if ((buf_next = wmemchr(buf + i, L'+', i_end - i)) != NULL) {
// Unicode dump separator found.
if (!wxZRColaUTF16CharValidator::Parse(val_in, i, buf_next - buf, ctrl, parent, &chr))
@ -242,7 +242,7 @@ void wxZRColaCharSelect::OnIdle(wxIdleEvent& event)
m_gridPreview->SetCellValue(0, 0, m_char);
std::unique_ptr<ZRCola::character_db::character> ch((ZRCola::character_db::character*)new char[sizeof(ZRCola::character_db::character) + sizeof(wchar_t)*m_char.length()]);
std::unique_ptr<ZRCola::character_db::character> ch((ZRCola::character_db::character*)new char[sizeof(ZRCola::character_db::character) + sizeof(ZRCola::char_t)*m_char.length()]);
ch->ZRCola::character_db::character::character(m_char.data(), m_char.length());
ZRCola::character_db::indexChr::size_type ch_start;
if (app->m_chr_db.idxChr.find(*ch, ch_start)) {
@ -251,7 +251,7 @@ void wxZRColaCharSelect::OnIdle(wxIdleEvent& event)
m_description->SetValue(wxString(chr.desc(), chr.desc_len()));
{
// See if this character has a key sequence registered.
std::unique_ptr<ZRCola::keyseq_db::keyseq> ks((ZRCola::keyseq_db::keyseq*)new char[sizeof(ZRCola::keyseq_db::keyseq) + sizeof(wchar_t)*m_char.length()]);
std::unique_ptr<ZRCola::keyseq_db::keyseq> ks((ZRCola::keyseq_db::keyseq*)new char[sizeof(ZRCola::keyseq_db::keyseq) + sizeof(ZRCola::char_t)*m_char.length()]);
ks->ZRCola::keyseq_db::keyseq::keyseq(NULL, 0, m_char.data(), m_char.length());
ZRCola::keyseq_db::indexKey::size_type ks_start;
if (app->m_ks_db.idxChr.find(*ks, ks_start)) {
@ -284,7 +284,7 @@ void wxZRColaCharSelect::OnIdle(wxIdleEvent& event)
// Find character tags.
std::list<std::wstring> tag_names;
std::unique_ptr<ZRCola::chrtag_db::chrtag> ct((ZRCola::chrtag_db::chrtag*)new char[sizeof(ZRCola::chrtag_db::chrtag) + sizeof(wchar_t)*m_char.length()]);
std::unique_ptr<ZRCola::chrtag_db::chrtag> ct((ZRCola::chrtag_db::chrtag*)new char[sizeof(ZRCola::chrtag_db::chrtag) + sizeof(ZRCola::char_t)*m_char.length()]);
ct->ZRCola::chrtag_db::chrtag::chrtag(m_char.data(), m_char.length());
ZRCola::chrtag_db::indexChr::size_type ct_start, ct_end;
if (app->m_ct_db.idxChr.find(*ct, ct_start, ct_end)) {
@ -766,14 +766,14 @@ wxThread::ExitCode wxZRColaCharSelect::SearchThread::Entry()
int __cdecl wxZRColaCharSelect::SearchThread::CompareHits(const void *a, const void *b)
{
const std::pair<ZRCola::charrank_t, wchar_t> *_a = (const std::pair<ZRCola::charrank_t, wchar_t>*)a;
const std::pair<ZRCola::charrank_t, wchar_t> *_b = (const std::pair<ZRCola::charrank_t, wchar_t>*)b;
const std::pair<ZRCola::charrank_t, ZRCola::char_t> *_a = (const std::pair<ZRCola::charrank_t, ZRCola::char_t>*)a;
const std::pair<ZRCola::charrank_t, ZRCola::char_t> *_b = (const std::pair<ZRCola::charrank_t, ZRCola::char_t>*)b;
if (_a->first > _b->first) return -1;
else if (_a->first < _b->first) return 1;
if (_a->first > _b->first) return -1;
if (_a->first < _b->first) return 1;
if (_a->second < _b->second) return -1;
else if (_a->second > _b->second) return 1;
if (_a->second < _b->second) return -1;
if (_a->second > _b->second) return 1;
return 0;
}
@ -843,7 +843,7 @@ bool wxPersistentZRColaCharSelect::Restore()
for (wxStringTokenizer tok(str, wxT("|")); tok.HasMoreTokens(); ) {
wxString chr;
for (wxStringTokenizer tok_chr(tok.GetNextToken(), wxT("+")); tok_chr.HasMoreTokens(); )
chr += (wchar_t)_tcstoul(tok_chr.GetNextToken().c_str(), NULL, 16);
chr += (ZRCola::char_t)_tcstoul(tok_chr.GetNextToken().c_str(), NULL, 16);
val.Add(chr);
}
wnd->m_gridRecent->SetCharacters(val);

2
ZRCola/zrcolachrslct.h
View File

@ -40,7 +40,7 @@ public:
///
/// Construct the validator with a value to store data
///
wxZRColaUTF16CharValidator(wchar_t *val = NULL);
wxZRColaUTF16CharValidator(ZRCola::char_t *val = NULL);
///
/// Copies this validator

86
lib/libZRCola/include/zrcola/character.h
View File

@ -29,14 +29,14 @@ namespace ZRCola {
///
typedef double charrank_t;
inline bool ispua(_In_ char16_t c)
inline bool ispua(_In_ char_t c)
{
return u'\ue000' <= c && c <= u'\uf8ff';
}
#ifndef _WIN32
size_t wcslen(_In_z_ const char16_t *str);
size_t wcsnlen(_In_z_count_(count) const char16_t *str, _In_ size_t count);
size_t wcslen(_In_z_ const char_t* str);
size_t wcsnlen(_In_z_count_(count) const char_t* str, _In_ size_t count);
#endif
#pragma pack(push)
@ -188,7 +188,7 @@ namespace ZRCola {
uint16_t chr_to; ///< Character end in \c data
uint16_t desc_to; ///< Character description end in \c data
uint16_t rel_to; ///< Related characters end in \c data
char16_t data[]; ///< Character, character description
char_t data[]; ///< Character, character description
private:
inline character(_In_ const character &other);
@ -207,40 +207,40 @@ namespace ZRCola {
/// \param[in] rel_len Number of UTF-16 characters in \p rel (including zero delimiters)
///
inline character(
_In_opt_z_count_(chr_len) const char16_t *chr = NULL,
_In_opt_z_count_(chr_len) const char_t *chr = NULL,
_In_opt_ size_t chr_len = 0,
_In_opt_ chrcatid_t cat = chrcatid_t::blank,
_In_opt_z_count_(desc_len) const char16_t *desc = NULL,
_In_opt_z_count_(desc_len) const char_t *desc = NULL,
_In_opt_ size_t desc_len = 0,
_In_opt_z_count_(rel_len) const char16_t *rel = NULL,
_In_opt_z_count_(rel_len) const char_t *rel = NULL,
_In_opt_ size_t rel_len = 0)
{
this->cat = cat;
this->chr_to = static_cast<uint16_t>(chr_len);
if (chr && chr_len) memcpy(this->data, chr, sizeof(char16_t)*chr_len);
if (chr && chr_len) memcpy(this->data, chr, sizeof(char_t)*chr_len);
this->desc_to = static_cast<uint16_t>(this->chr_to + desc_len);
if (desc && desc_len) memcpy(this->data + this->chr_to, desc, sizeof(char16_t)*desc_len);
if (desc && desc_len) memcpy(this->data + this->chr_to, desc, sizeof(char_t)*desc_len);
this->rel_to = static_cast<uint16_t>(this->desc_to + rel_len);
if (rel && rel_len) memcpy(this->data + this->desc_to, rel, sizeof(char16_t)*rel_len);
if (rel && rel_len) memcpy(this->data + this->desc_to, rel, sizeof(char_t)*rel_len);
}
inline const char16_t* chr () const { return data; };
inline char16_t* chr () { return data; };
inline const char16_t* chr_end() const { return data + chr_to; };
inline char16_t* chr_end() { return data + chr_to; };
inline uint16_t chr_len() const { return chr_to; };
inline const char_t* chr () const { return data; };
inline char_t* chr () { return data; };
inline const char_t* chr_end() const { return data + chr_to; };
inline char_t* chr_end() { return data + chr_to; };
inline uint16_t chr_len() const { return chr_to; };
inline const char16_t* desc () const { return data + chr_to; };
inline char16_t* desc () { return data + chr_to; };
inline const char16_t* desc_end() const { return data + desc_to; };
inline char16_t* desc_end() { return data + desc_to; };
inline uint16_t desc_len() const { return desc_to - chr_to; };
inline const char_t* desc () const { return data + chr_to; };
inline char_t* desc () { return data + chr_to; };
inline const char_t* desc_end() const { return data + desc_to; };
inline char_t* desc_end() { return data + desc_to; };
inline uint16_t desc_len() const { return desc_to - chr_to; };
inline const char16_t* rel () const { return data + desc_to; };
inline char16_t* rel () { return data + desc_to; };
inline const char16_t* rel_end() const { return data + rel_to; };
inline char16_t* rel_end() { return data + rel_to; };
inline uint16_t rel_len() const { return rel_to - desc_to; };
inline const char_t* rel () const { return data + desc_to; };
inline char_t* rel () { return data + desc_to; };
inline const char_t* rel_end() const { return data + rel_to; };
inline char_t* rel_end() { return data + rel_to; };
inline uint16_t rel_len() const { return rel_to - desc_to; };
};
#pragma pack(pop)
@ -277,9 +277,9 @@ namespace ZRCola {
}
} idxChr; ///< Character index
textindex<char16_t, char16_t, uint32_t> idxDsc; ///< Description index
textindex<char16_t, char16_t, uint32_t> idxDscSub; ///< Description index (sub-terms)
std::vector<uint16_t> data; ///< Character data
textindex<char_t, char_t, uint32_t> idxDsc; ///< Description index
textindex<char_t, char_t, uint32_t> idxDscSub; ///< Description index (sub-terms)
std::vector<uint16_t> data; ///< Character data
public:
///
@ -308,7 +308,7 @@ namespace ZRCola {
/// \param[in ] fn_abort Pointer to function to periodically test for search cancellation
/// \param[in ] cookie Cookie for \p fn_abort call
///
bool Search(_In_z_ const char16_t *str, _In_ const std::set<chrcatid_t> &cats, _Inout_ std::map<std::u16string, charrank_t> &hits, _Inout_ std::map<std::u16string, charrank_t> &hits_sub, _In_opt_ bool (__cdecl *fn_abort)(void *cookie) = NULL, _In_opt_ void *cookie = NULL) const;
bool Search(_In_z_ const char_t *str, _In_ const std::set<chrcatid_t> &cats, _Inout_ std::map<string_t, charrank_t> &hits, _Inout_ std::map<string_t, charrank_t> &hits_sub, _In_opt_ bool (__cdecl *fn_abort)(void *cookie) = NULL, _In_opt_ void *cookie = NULL) const;
///
/// Get character category
@ -320,10 +320,10 @@ namespace ZRCola {
/// - Character category if character found
/// - `ZRCola::chrcatid_t::blank` otherwise
///
inline chrcatid_t GetCharCat(_In_z_count_(len) const char16_t *chr, _In_ const size_t len) const
inline chrcatid_t GetCharCat(_In_z_count_(len) const char_t *chr, _In_ const size_t len) const
{
assert(len <= 0xffff);
std::unique_ptr<character> c((character*)new char[sizeof(character) + sizeof(char16_t)*len]);
std::unique_ptr<character> c((character*)new char[sizeof(character) + sizeof(char_t)*len]);
new (c.get()) character(chr, len);
indexChr::size_type start;
return idxChr.find(*c, start) ? idxChr[start].cat : chrcatid_t::blank;
@ -348,7 +348,7 @@ namespace ZRCola {
protected:
uint16_t name_to; ///< Character category name end in \c data
char16_t data[]; ///< Character category name
char_t data[]; ///< Character category name
private:
inline chrcat(_In_ const chrcat &other);
@ -364,22 +364,22 @@ namespace ZRCola {
/// \param[in] name_len Number of UTF-16 characters in \p name
///
inline chrcat(
_In_opt_ chrcatid_t cat = chrcatid_t::blank,
_In_opt_ uint16_t rank = 0,
_In_opt_z_count_(name_len) const char16_t *name = NULL,
_In_opt_ size_t name_len = 0)
_In_opt_ chrcatid_t cat = chrcatid_t::blank,
_In_opt_ uint16_t rank = 0,
_In_opt_z_count_(name_len) const char_t *name = NULL,
_In_opt_ size_t name_len = 0)
{
this->cat = cat;
this->rank = rank;
this->name_to = static_cast<uint16_t>(name_len);
if (name && name_len) memcpy(this->data, name, sizeof(char16_t)*name_len);
if (name && name_len) memcpy(this->data, name, sizeof(char_t)*name_len);
}
inline const char16_t* name () const { return data; };
inline char16_t* name () { return data; };
inline const char16_t* name_end() const { return data + name_to; };
inline char16_t* name_end() { return data + name_to; };
inline uint16_t name_len() const { return name_to; };
inline const char_t* name () const { return data; };
inline char_t* name () { return data; };
inline const char_t* name_end() const { return data + name_to; };
inline char_t* name_end() { return data + name_to; };
inline uint16_t name_len() const { return name_to; };
};
#pragma pack(pop)
@ -464,7 +464,7 @@ namespace ZRCola {
if (a.rank < b.rank) return -1;
else if (a.rank > b.rank) return +1;
auto &coll = std::use_facet<std::collate<char16_t>>(std::locale());
auto &coll = std::use_facet<std::collate<char_t>>(std::locale());
return coll.compare(a.name(), a.name_end(), b.name(), b.name_end());
}
} idxRank; ///< Rank index

26
lib/libZRCola/include/zrcola/common.h
View File

@ -49,6 +49,26 @@ namespace ZRCola {
typedef uint32_t recordsize_t;
///
/// ZRCola database character type
///
#ifdef _WIN32
typedef wchar_t char_t;
#else
typedef char16_t char_t;
#endif
///
/// ZRCola database string type
///
#ifdef _WIN32
typedef std::wstring string_t;
#else
typedef std::u16string string_t;
#endif
#pragma pack(push)
#pragma pack(2)
///
@ -571,7 +591,7 @@ namespace ZRCola {
/// 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.
///
int CompareString(_In_ const char16_t* str_a, _In_ size_t count_a, _In_ const char16_t* str_b, _In_ size_t count_b);
int CompareString(_In_ const char_t* str_a, _In_ size_t count_a, _In_ const char_t* str_b, _In_ size_t count_b);
///
/// Generates and returns Unicode representation of the string using hexadecimal codes.
@ -580,7 +600,7 @@ namespace ZRCola {
/// \param[in] count Number of characters in string \p str
/// \param[in] sep Separator
///
std::string GetUnicodeDumpA(_In_z_count_(count) const char16_t* str, _In_ size_t count, _In_z_ const char* sep = "+");
std::string GetUnicodeDumpA(_In_z_count_(count) const char_t* str, _In_ size_t count, _In_z_ const char* sep = "+");
///
/// Generates and returns Unicode representation of the string using hexadecimal codes.
@ -589,7 +609,7 @@ namespace ZRCola {
/// \param[in] count Number of characters in string \p str
/// \param[in] sep Separator
///
std::wstring GetUnicodeDumpW(_In_z_count_(count) const char16_t* str, _In_ size_t count, _In_z_ const wchar_t* sep = L"+");
std::wstring GetUnicodeDumpW(_In_z_count_(count) const char_t* str, _In_ size_t count, _In_z_ const wchar_t* sep = L"+");
#ifdef _UNICODE
#define GetUnicodeDump GetUnicodeDumpW

20
lib/libZRCola/include/zrcola/highlight.h
View File

@ -45,7 +45,7 @@ namespace ZRCola {
protected:
uint16_t chr_to; ///< Character end in \c data
char16_t data[]; ///< Character
char_t data[]; ///< Character
private:
inline highlight(_In_ const highlight &other);
@ -61,21 +61,21 @@ namespace ZRCola {
///
inline highlight(
_In_opt_ hlghtsetid_t set = 0,
_In_opt_z_count_(chr_len) const char16_t *chr = NULL,
_In_opt_z_count_(chr_len) const char_t *chr = NULL,
_In_opt_ size_t chr_len = 0)
{
this->set = set;
this->chr_to = static_cast<uint16_t>(chr_len);
if (chr && chr_len) memcpy(this->data, chr, sizeof(char16_t)*chr_len);
if (chr && chr_len) memcpy(this->data, chr, sizeof(char_t)*chr_len);
}
inline const char16_t* chr () const { return data; };
inline char16_t* chr () { return data; };
inline const char16_t* chr_end() const { return data + chr_to; };
inline char16_t* chr_end() { return data + chr_to; };
inline uint16_t chr_len() const { return chr_to; };
inline const char_t* chr () const { return data; };
inline char_t* chr () { return data; };
inline const char_t* chr_end() const { return data + chr_to; };
inline char_t* chr_end() { return data + chr_to; };
inline uint16_t chr_len() const { return chr_to; };
inline char16_t chr_at(_In_ size_t i) const
inline char_t chr_at(_In_ size_t i) const
{
return i < chr_to ? data[i] : 0;
}
@ -160,7 +160,7 @@ namespace ZRCola {
/// \param[in] inputMax Length of the input string in characters. Can be (size_t)-1 if \p input is zero terminated.
/// \param[in] callback Function to be called on highlight switch
///
void Highlight(_In_z_count_(inputMax) const char16_t* input, _In_ size_t inputMax, _In_ std::function<void (hlghtsetid_t set, size_t start, size_t end)> callback) const;
void Highlight(_In_z_count_(inputMax) const char_t* input, _In_ size_t inputMax, _In_ std::function<void (hlghtsetid_t set, size_t start, size_t end)> callback) const;
};
};

34
lib/libZRCola/include/zrcola/language.h
View File

@ -35,7 +35,7 @@ namespace ZRCola {
protected:
uint16_t chr_to; ///< Character end in \c data
char16_t data[]; ///< Character
char_t data[]; ///< Character
private:
inline langchar(_In_ const langchar &other);
@ -51,19 +51,19 @@ namespace ZRCola {
///
inline langchar(
_In_opt_ langid_t lang = langid_t::blank,
_In_opt_z_count_(chr_len) const char16_t *chr = NULL,
_In_opt_z_count_(chr_len) const char_t *chr = NULL,
_In_opt_ size_t chr_len = 0)
{
this->lang = lang;
this->chr_to = static_cast<uint16_t>(chr_len);
if (chr && chr_len) memcpy(this->data, chr, sizeof(char16_t)*chr_len);
if (chr && chr_len) memcpy(this->data, chr, sizeof(char_t)*chr_len);
}
inline const char16_t* chr () const { return data; };
inline char16_t* chr () { return data; };
inline const char16_t* chr_end() const { return data + chr_to; };
inline char16_t* chr_end() { return data + chr_to; };
inline uint16_t chr_len() const { return chr_to; };
inline const char_t* chr () const { return data; };
inline char_t* chr () { return data; };
inline const char_t* chr_end() const { return data + chr_to; };
inline char_t* chr_end() { return data + chr_to; };
inline uint16_t chr_len() const { return chr_to; };
};
#pragma pack(pop)
@ -176,7 +176,7 @@ namespace ZRCola {
/// \returns
/// - \c true when character is used in language
/// - \c false otherwise
bool IsLocalCharacter(_In_ const char16_t *chr, _In_ const char16_t *chr_end, _In_ langid_t lang) const;
bool IsLocalCharacter(_In_ const char_t *chr, _In_ const char_t *chr_end, _In_ langid_t lang) const;
};
@ -196,7 +196,7 @@ namespace ZRCola {
protected:
uint16_t name_to; ///< Language name end in \c data
char16_t data[]; ///< Language name
char_t data[]; ///< Language name
private:
inline language(_In_ const language &other);
@ -212,19 +212,19 @@ namespace ZRCola {
///
inline language(
_In_opt_ langid_t lang = langid_t::blank,
_In_opt_z_count_(name_len) const char16_t *name = NULL,
_In_opt_z_count_(name_len) const char_t *name = NULL,
_In_opt_ size_t name_len = 0)
{
this->lang = lang;
this->name_to = static_cast<uint16_t>(name_len);
if (name && name_len) memcpy(this->data, name, sizeof(char16_t)*name_len);
if (name && name_len) memcpy(this->data, name, sizeof(char_t)*name_len);
}
inline const char16_t* name () const { return data; };
inline char16_t* name () { return data; };
inline const char16_t* name_end() const { return data + name_to; };
inline char16_t* name_end() { return data + name_to; };
inline uint16_t name_len() const { return name_to; };
inline const char_t* name () const { return data; };
inline char_t* name () { return data; };
inline const char_t* name_end() const { return data + name_to; };
inline char_t* name_end() { return data + name_to; };
inline uint16_t name_len() const { return name_to; };
};
#pragma pack(pop)

54
lib/libZRCola/include/zrcola/tag.h
View File

@ -38,7 +38,7 @@ namespace ZRCola {
protected:
uint16_t chr_to; ///< Character end in \c data
char16_t data[]; ///< Character
char_t data[]; ///< Character
private:
inline chrtag(_In_ const chrtag &other);
@ -53,20 +53,20 @@ namespace ZRCola {
/// \param[in] tag Tag
///
inline chrtag(
_In_opt_z_count_(chr_len) const char16_t *chr = NULL,
_In_opt_ size_t chr_len = 0,
_In_opt_ tagid_t tag = 0)
_In_opt_z_count_(chr_len) const char_t *chr = NULL,
_In_opt_ size_t chr_len = 0,
_In_opt_ tagid_t tag = 0)
{
this->tag = tag;
this->chr_to = static_cast<uint16_t>(chr_len);
if (chr && chr_len) memcpy(this->data, chr, sizeof(char16_t)*chr_len);
if (chr && chr_len) memcpy(this->data, chr, sizeof(char_t)*chr_len);
}
inline const char16_t* chr () const { return data; };
inline char16_t* chr () { return data; };
inline const char16_t* chr_end() const { return data + chr_to; };
inline char16_t* chr_end() { return data + chr_to; };
inline uint16_t chr_len() const { return chr_to; };
inline const char_t* chr () const { return data; };
inline char_t* chr () { return data; };
inline const char_t* chr_end() const { return data + chr_to; };
inline char_t* chr_end() { return data + chr_to; };
inline uint16_t chr_len() const { return chr_to; };
};
#pragma pack(pop)
@ -209,7 +209,7 @@ namespace ZRCola {
/// \param[in ] fn_abort Pointer to function to periodically test for search cancellation
/// \param[in ] cookie Cookie for \p fn_abort call
///
bool Search(_In_ const std::map<tagid_t, uint16_t> &tags, _In_ const character_db &ch_db, _In_ const std::set<chrcatid_t> &cats, _Inout_ std::map<std::u16string, charrank_t> &hits, _In_opt_ bool (__cdecl *fn_abort)(void *cookie) = NULL, _In_opt_ void *cookie = NULL) const;
bool Search(_In_ const std::map<tagid_t, uint16_t> &tags, _In_ const character_db &ch_db, _In_ const std::set<chrcatid_t> &cats, _Inout_ std::map<string_t, charrank_t> &hits, _In_opt_ bool (__cdecl *fn_abort)(void *cookie) = NULL, _In_opt_ void *cookie = NULL) const;
};
@ -230,7 +230,7 @@ namespace ZRCola {
protected:
uint16_t name_to; ///< Tag name end in \c data
char16_t data[]; ///< Tag name
char_t data[]; ///< Tag name
private:
inline tagname(_In_ const tagname &other);
@ -246,22 +246,22 @@ namespace ZRCola {
/// \param[in] name_len Number of UTF-16 characters in \p name
///
inline tagname(
_In_opt_ tagid_t tag = 0,
_In_opt_ uint32_t locale = 0,
_In_opt_z_count_(name_len) const char16_t *name = NULL,
_In_opt_ size_t name_len = 0)
_In_opt_ tagid_t tag = 0,
_In_opt_ uint32_t locale = 0,
_In_opt_z_count_(name_len) const char_t *name = NULL,
_In_opt_ size_t name_len = 0)
{
this->tag = tag;
this->locale = locale;
this->name_to = static_cast<uint16_t>(name_len);
if (name && name_len) memcpy(this->data, name, sizeof(char16_t)*name_len);
if (name && name_len) memcpy(this->data, name, sizeof(char_t)*name_len);
}
inline const char16_t* name () const { return data; };
inline char16_t* name () { return data; };
inline const char16_t* name_end() const { return data + name_to; };
inline char16_t* name_end() { return data + name_to; };
inline uint16_t name_len() const { return name_to; };
inline const char_t* name () const { return data; };
inline char_t* name () { return data; };
inline const char_t* name_end() const { return data + name_to; };
inline char_t* name_end() { return data + name_to; };
inline uint16_t name_len() const { return name_to; };
///
/// Compares two names
@ -281,7 +281,7 @@ namespace ZRCola {
/// 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(_In_ uint32_t locale, _In_z_count_(count_a) const char16_t *str_a, _In_ uint16_t count_a, _In_z_count_(count_b) const char16_t *str_b, _In_ uint16_t count_b)
static inline int CompareName(_In_ uint32_t locale, _In_z_count_(count_a) const char_t *str_a, _In_ uint16_t count_a, _In_z_count_(count_b) const char_t *str_b, _In_ uint16_t count_b)
{
#ifdef _WIN32
switch (::CompareString(locale, SORT_STRINGSORT | NORM_IGNORECASE, str_a, count_a, str_b, count_b)) {
@ -292,13 +292,13 @@ namespace ZRCola {
}
#else
assert(0); // TODO: 1. Should honour locale. 2. Should use ICU for lowercase conversion. 3. Should be UTF-16-aware.
std::u16string
string_t
a(str_a, count_a),
b(str_b, count_b);
auto tolower = [](char16_t c){ return std::towlower(c); };
auto tolower = [](char_t c){ return std::towlower(c); };
std::transform(a.begin(), a.end(), a.begin(), tolower);
std::transform(b.begin(), b.end(), b.begin(), tolower);
auto &coll = std::use_facet<std::collate<char16_t>>(std::locale());
auto &coll = std::use_facet<std::collate<char_t>>(std::locale());
return coll.compare(&*a.cbegin(), &*a.cend(), &*b.cbegin(), &*b.cend());
#endif
}
@ -431,7 +431,7 @@ namespace ZRCola {
/// \param[in ] fn_abort Pointer to function to periodically test for search cancellation
/// \param[in ] cookie Cookie for \p fn_abort call
///
bool Search(_In_z_ const char16_t *str, _In_ uint32_t locale, _Inout_ std::map<tagid_t, uint16_t> &hits, _In_opt_ bool (__cdecl *fn_abort)(void *cookie) = NULL, _In_opt_ void *cookie = NULL) const;
bool Search(_In_z_ const char_t *str, _In_ uint32_t locale, _Inout_ std::map<tagid_t, uint16_t> &hits, _In_opt_ bool (__cdecl *fn_abort)(void *cookie) = NULL, _In_opt_ void *cookie = NULL) const;
};
};

88
lib/libZRCola/include/zrcola/translate.h
View File

@ -84,7 +84,7 @@ namespace ZRCola {
protected:
uint16_t dst_to; ///< Destination character end in \c data
uint16_t src_to; ///< Source string end in \c data
char16_t data[]; ///< Destination string and source character
char_t data[]; ///< Destination string and source character
private:
inline translation(_In_ const translation &other);
@ -105,39 +105,39 @@ namespace ZRCola {
inline translation(
_In_opt_ transetid_t set = 0,
_In_opt_ uint16_t dst_rank = 0,
_In_opt_z_count_(dst_len) const char16_t *dst = NULL,
_In_opt_z_count_(dst_len) const char_t *dst = NULL,
_In_opt_ size_t dst_len = 0,
_In_opt_ uint16_t src_rank = 0,
_In_opt_z_count_(src_len) const char16_t *src = NULL,
_In_opt_z_count_(src_len) const char_t *src = NULL,
_In_opt_ size_t src_len = 0)
{
this->set = set;
this->dst_rank = dst_rank;
this->src_rank = src_rank;
this->dst_to = static_cast<uint16_t>(dst_len);
if (dst && dst_len) memcpy(this->data, dst, sizeof(char16_t)*dst_len);
if (dst && dst_len) memcpy(this->data, dst, sizeof(char_t)*dst_len);
this->src_to = static_cast<uint16_t>(this->dst_to + src_len);
if (src && src_len) memcpy(this->data + this->dst_to, src, sizeof(char16_t)*src_len);
if (src && src_len) memcpy(this->data + this->dst_to, src, sizeof(char_t)*src_len);
}
inline const char16_t* dst () const { return data; };
inline char16_t* dst () { return data; };
inline const char16_t* dst_end() const { return data + dst_to; };
inline char16_t* dst_end() { return data + dst_to; };
inline uint16_t dst_len() const { return dst_to; };
inline const char_t* dst () const { return data; };
inline char_t* dst () { return data; };
inline const char_t* dst_end() const { return data + dst_to; };
inline char_t* dst_end() { return data + dst_to; };
inline uint16_t dst_len() const { return dst_to; };
inline char16_t dst_at(_In_ size_t i) const
inline char_t dst_at(_In_ size_t i) const
{
return i < dst_to ? data[i] : 0;
}
inline const char16_t* src () const { return data + dst_to; };
inline char16_t* src () { return data + dst_to; };
inline const char16_t* src_end() const { return data + src_to; };
inline char16_t* src_end() { return data + src_to; };
inline uint16_t src_len() const { return src_to - dst_to; };
inline const char_t* src () const { return data + dst_to; };
inline char_t* src () { return data + dst_to; };
inline const char_t* src_end() const { return data + src_to; };
inline char_t* src_end() { return data + src_to; };
inline uint16_t src_len() const { return src_to - dst_to; };
inline char16_t src_at(_In_ size_t i) const
inline char_t src_at(_In_ size_t i) const
{
size_t ii = i + dst_to; // absolute index
return ii < src_to ? data[ii] : 0;
@ -302,7 +302,7 @@ namespace ZRCola {
/// \param[out] output Output string (UTF-16)
/// \param[out] map The vector of source to destination index mappings (optional)
///
void Translate(_In_ transetid_t set, _In_z_count_(inputMax) const char16_t* input, _In_ size_t inputMax, _Out_ std::u16string &output, _Out_opt_ std::vector<mapping>* map = NULL) const;
void Translate(_In_ transetid_t set, _In_z_count_(inputMax) const char_t* input, _In_ size_t inputMax, _Out_ string_t &output, _Out_opt_ std::vector<mapping>* map = NULL) const;
///
/// Inverse translates string
@ -313,7 +313,7 @@ namespace ZRCola {
/// \param[out] output Output string (UTF-16)
/// \param[out] map The vector of source to destination index mappings (optional)
///
inline void TranslateInv(_In_ transetid_t set, _In_z_count_(inputMax) const char16_t* input, _In_ size_t inputMax, _Out_ std::u16string &output, _Out_opt_ std::vector<mapping>* map = NULL) const
inline void TranslateInv(_In_ transetid_t set, _In_z_count_(inputMax) const char_t* input, _In_ size_t inputMax, _Out_ string_t &output, _Out_opt_ std::vector<mapping>* map = NULL) const
{
TranslateInv(set, input, inputMax, NULL, langid_t::blank, output, map);
}
@ -329,7 +329,7 @@ namespace ZRCola {
/// \param[out] output Output string (UTF-16)
/// \param[out] map The vector of source to destination index mappings (optional)
///
void TranslateInv(_In_ transetid_t set, _In_z_count_(inputMax) const char16_t* input, _In_ size_t inputMax, _In_opt_ const langchar_db *lc_db, _In_opt_ langid_t lang, _Out_ std::u16string &output, _Out_opt_ std::vector<mapping>* map = NULL) const;
void TranslateInv(_In_ transetid_t set, _In_z_count_(inputMax) const char_t* input, _In_ size_t inputMax, _In_opt_ const langchar_db *lc_db, _In_opt_ langid_t lang, _Out_ string_t &output, _Out_opt_ std::vector<mapping>* map = NULL) const;
};
@ -350,7 +350,7 @@ namespace ZRCola {
protected:
uint16_t src_to; ///< Source name end in \c data
uint16_t dst_to; ///< Sestination name end in \c data
char16_t data[]; ///< Source and destination names
char_t data[]; ///< Source and destination names
private:
inline transet(_In_ const transet &other);
@ -368,29 +368,29 @@ namespace ZRCola {
///
inline transet(
_In_opt_ transetid_t set = 0,
_In_opt_z_count_(src_len) const char16_t *src = NULL,
_In_opt_z_count_(src_len) const char_t *src = NULL,
_In_opt_ size_t src_len = 0,
_In_opt_z_count_(dst_len) const char16_t *dst = NULL,
_In_opt_z_count_(dst_len) const char_t *dst = NULL,
_In_opt_ size_t dst_len = 0)
{
this->set = set;
this->src_to = static_cast<uint16_t>(src_len);
if (src && src_len) memcpy(this->data, src, sizeof(char16_t)*src_len);
if (src && src_len) memcpy(this->data, src, sizeof(char_t)*src_len);
this->dst_to = static_cast<uint16_t>(this->src_to + dst_len);
if (dst && dst_len) memcpy(this->data + this->src_to, dst, sizeof(char16_t)*dst_len);
if (dst && dst_len) memcpy(this->data + this->src_to, dst, sizeof(char_t)*dst_len);
}
inline const char16_t* src () const { return data; };
inline char16_t* src () { return data; };
inline const char16_t* src_end() const { return data + src_to; };
inline char16_t* src_end() { return data + src_to; };
inline uint16_t src_len() const { return src_to; };
inline const char_t* src () const { return data; };
inline char_t* src () { return data; };
inline const char_t* src_end() const { return data + src_to; };
inline char_t* src_end() { return data + src_to; };
inline uint16_t src_len() const { return src_to; };
inline const char16_t* dst () const { return data + src_to; };
inline char16_t* dst () { return data + src_to; };
inline const char16_t* dst_end() const { return data + dst_to; };
inline char16_t* dst_end() { return data + dst_to; };
inline uint16_t dst_len() const { return dst_to - src_to; };
inline const char_t* dst () const { return data + src_to; };
inline char_t* dst () { return data + src_to; };
inline const char_t* dst_end() const { return data + dst_to; };
inline char_t* dst_end() { return data + dst_to; };
inline uint16_t dst_len() const { return dst_to - src_to; };
};
#pragma pack(pop)
@ -464,7 +464,7 @@ namespace ZRCola {
protected:
uint16_t name_to; ///< Translation sequence name end in \c data
uint16_t sets_to; ///< Translation sequence sets end in \c data
char16_t data[]; ///< Translation sequence name and sets
char_t data[]; ///< Translation sequence name and sets
private:
inline transeq(_In_ const transeq &other);
@ -484,7 +484,7 @@ namespace ZRCola {
inline transeq(
_In_opt_ transeqid_t seq = 0,
_In_opt_ uint16_t rank = 0,
_In_opt_z_count_(name_len) const char16_t *name = NULL,
_In_opt_z_count_(name_len) const char_t *name = NULL,
_In_opt_ size_t name_len = 0,
_In_opt_count_ (sets_len) const transetid_t *sets = NULL,
_In_opt_ size_t sets_len = 0)
@ -492,16 +492,16 @@ namespace ZRCola {
this->seq = seq;
this->rank = rank;
this->name_to = static_cast<uint16_t>(name_len);
if (name && name_len) memcpy(this->data, name, sizeof(char16_t)*name_len);
if (name && name_len) memcpy(this->data, name, sizeof(char_t)*name_len);
this->sets_to = static_cast<uint16_t>(this->name_to + sets_len);
if (sets && sets_len) memcpy(this->data + this->name_to, sets, sizeof(transetid_t)*sets_len);
}
inline const char16_t* name () const { return data; };
inline char16_t* name () { return data; };
inline const char16_t* name_end() const { return data + name_to; };
inline char16_t* name_end() { return data + name_to; };
inline uint16_t name_len() const { return name_to; };
inline const char_t* name () const { return data; };
inline char_t* name () { return data; };
inline const char_t* name_end() const { return data + name_to; };
inline char_t* name_end() { return data + name_to; };
inline uint16_t name_len() const { return name_to; };
inline const transetid_t* sets () const { return reinterpret_cast<const transetid_t*>(data + name_to); };
inline transetid_t* sets () { return reinterpret_cast< transetid_t*>(data + name_to); };
@ -592,7 +592,7 @@ namespace ZRCola {
if (a.rank < b.rank) return -1;
else if (a.rank > b.rank) return +1;
auto &coll = std::use_facet<std::collate<char16_t>>(std::locale());
auto &coll = std::use_facet<std::collate<char_t>>(std::locale());
return coll.compare(a.name(), a.name_end(), b.name(), b.name_end());
}
} idxRank; ///< Rank index

18
lib/libZRCola/src/character.cpp
View File

@ -12,7 +12,7 @@ const ZRCola::chrcatid_t ZRCola::chrcatid_t::blank = {};
#ifndef _WIN32
_Use_decl_annotations_
size_t ZRCola::wcslen(const char16_t *str)
size_t ZRCola::wcslen(const char_t *str)
{
for (size_t i = 0; ; ++i)
if (!str[i])
@ -20,7 +20,7 @@ size_t ZRCola::wcslen(const char16_t *str)
}
_Use_decl_annotations_
size_t ZRCola::wcsnlen(const char16_t *str, size_t count)
size_t ZRCola::wcsnlen(const char_t *str, size_t count)
{
for (size_t i = 0; ; ++i)
if (i >= count || !str[i])
@ -31,7 +31,7 @@ size_t ZRCola::wcsnlen(const char16_t *str, size_t count)
_Use_decl_annotations_
bool ZRCola::character_db::Search(const char16_t *str, const std::set<chrcatid_t> &cats, std::map<std::u16string, charrank_t> &hits, std::map<std::u16string, charrank_t> &hits_sub, bool (__cdecl *fn_abort)(void *cookie), void *cookie) const
bool ZRCola::character_db::Search(const char_t *str, const std::set<chrcatid_t> &cats, std::map<string_t, charrank_t> &hits, std::map<string_t, charrank_t> &hits_sub, bool (__cdecl *fn_abort)(void *cookie), void *cookie) const
{
assert(str);
@ -49,9 +49,9 @@ bool ZRCola::character_db::Search(const char16_t *str, const std::set<chrcatid_t
}
// Get term.
std::u16string term;
string_t term;
if (*str == u'"') {
const char16_t *str_end = ++str;
const auto *str_end = ++str;
for (;;) {
if (*str_end == 0) {
term.assign(str, str_end);
@ -65,7 +65,7 @@ bool ZRCola::character_db::Search(const char16_t *str, const std::set<chrcatid_t
}
str = str_end;
} else {
const char16_t *str_end = str + 1;
const auto *str_end = str + 1;
for (; *str_end && !iswspace(*str_end); str_end++);
term.assign(str, str_end);
str = str_end;
@ -79,7 +79,7 @@ bool ZRCola::character_db::Search(const char16_t *str, const std::set<chrcatid_t
if (fn_abort && fn_abort(cookie)) return false;
const char16_t *val;
const char_t *val;
size_t val_len;
if (idxDsc.find(term.c_str(), term.size(), &val, &val_len)) {
@ -88,7 +88,7 @@ bool ZRCola::character_db::Search(const char16_t *str, const std::set<chrcatid_t
if (fn_abort && fn_abort(cookie)) return false;
j = wcsnlen(val + i, val_len - i);
if (cats.find(GetCharCat(val + i, j)) != cats.end()) {
std::u16string c(val + i, j);
string_t c(val + i, j);
auto idx = hits.find(c);
if (idx == hits.end()) {
// New character.
@ -107,7 +107,7 @@ bool ZRCola::character_db::Search(const char16_t *str, const std::set<chrcatid_t
if (fn_abort && fn_abort(cookie)) return false;
j = wcsnlen(val + i, val_len - i);
if (cats.find(GetCharCat(val + i, j)) != cats.end()) {
std::u16string c(val + i, j);
string_t c(val + i, j);
auto idx = hits_sub.find(c);
if (idx == hits_sub.end()) {
// New character.

6
lib/libZRCola/src/common.cpp
View File

@ -10,7 +10,7 @@ const ZRCola::langid_t ZRCola::langid_t::blank = {};
_Use_decl_annotations_
int ZRCola::CompareString(const char16_t* str_a, size_t count_a, const char16_t* str_b, size_t count_b)
int ZRCola::CompareString(const char_t* str_a, size_t count_a, const char_t* str_b, size_t count_b)
{
for (size_t i = 0; ; i++) {
if (i >= count_a && i >= count_b) return 0;
@ -23,7 +23,7 @@ int ZRCola::CompareString(const char16_t* str_a, size_t count_a, const char16_t*
_Use_decl_annotations_
inline std::string ZRCola::GetUnicodeDumpA(const char16_t* str, size_t count, const char* sep)
inline std::string ZRCola::GetUnicodeDumpA(const char_t* str, size_t count, const char* sep)
{
std::string out;
size_t sep_len = strlen(sep);
@ -54,7 +54,7 @@ inline std::string ZRCola::GetUnicodeDumpA(const char16_t* str, size_t count, co
_Use_decl_annotations_
std::wstring ZRCola::GetUnicodeDumpW(const char16_t* str, size_t count, const wchar_t* sep)
std::wstring ZRCola::GetUnicodeDumpW(const char_t* str, size_t count, const wchar_t* sep)
{
std::wstring out;
size_t sep_len = ::wcslen(sep);

6
lib/libZRCola/src/highlight.cpp
View File

@ -6,7 +6,7 @@
#include "pch.h"
_Use_decl_annotations_
void ZRCola::highlight_db::Highlight(const char16_t* input, size_t inputMax, std::function<void (hlghtsetid_t set, size_t start, size_t end)> callback) const
void ZRCola::highlight_db::Highlight(const char_t* input, size_t inputMax, std::function<void (hlghtsetid_t set, size_t start, size_t end)> callback) const
{
size_t start = 0;
hlghtsetid_t set = ZRCOLA_HLGHTSETID_DEFAULT;
@ -15,7 +15,7 @@ void ZRCola::highlight_db::Highlight(const char16_t* input, size_t inputMax, std
// Find the longest matching highlight at i-th character.
size_t l_match = (size_t)-1;
for (size_t l = 0, r = idxChr.size(), ii = i, j = 0; ii < inputMax && l < r; ii++, j++) {
char16_t c = input[ii];
auto c = input[ii];
while (l < r) {
// Test the highlight in the middle of the search area.
size_t m = (l + r) / 2;
@ -23,7 +23,7 @@ void ZRCola::highlight_db::Highlight(const char16_t* input, size_t inputMax, std
// Get the j-th character of the highlight.
// All highlights that get short on characters are lexically ordered before.
// Thus the j-th character is considered 0.
char16_t s = idxChr[m].chr_at(j);
auto s = idxChr[m].chr_at(j);
// Do the bisection test.
if (c < s) r = m;

4
lib/libZRCola/src/language.cpp
View File

@ -57,11 +57,11 @@ void ZRCola::LangConvert(_In_ LANGID lang_win, _Inout_ ZRCola::langid_t &lang)
#endif
bool ZRCola::langchar_db::IsLocalCharacter(_In_ const char16_t *chr, _In_ const char16_t *chr_end, _In_ ZRCola::langid_t lang) const
bool ZRCola::langchar_db::IsLocalCharacter(_In_ const char_t *chr, _In_ const char_t *chr_end, _In_ ZRCola::langid_t lang) const
{
size_t n = chr_end - chr;
assert(n <= 0xffff);
std::unique_ptr<langchar> lc((langchar*)new char[sizeof(langchar) + sizeof(char16_t)*n]);
std::unique_ptr<langchar> lc((langchar*)new char[sizeof(langchar) + sizeof(char_t)*n]);
new (lc.get()) langchar(lang, chr, n);
indexChr::size_type start;
return idxChr.find(*lc, start);

14
lib/libZRCola/src/tag.cpp
View File

@ -6,7 +6,7 @@
#include "pch.h"
bool ZRCola::chrtag_db::Search(_In_ const std::map<tagid_t, uint16_t> &tags, _In_ const character_db &ch_db, _In_ const std::set<chrcatid_t> &cats, _Inout_ std::map<std::u16string, charrank_t> &hits, _In_opt_ bool (__cdecl *fn_abort)(void *cookie), _In_opt_ void *cookie) const
bool ZRCola::chrtag_db::Search(_In_ const std::map<tagid_t, uint16_t> &tags, _In_ const character_db &ch_db, _In_ const std::set<chrcatid_t> &cats, _Inout_ std::map<string_t, charrank_t> &hits, _In_opt_ bool (__cdecl *fn_abort)(void *cookie), _In_opt_ void *cookie) const
{
for (auto tag = tags.cbegin(), tag_end = tags.cend(); tag != tag_end; ++tag) {
if (fn_abort && fn_abort(cookie)) return false;
@ -19,7 +19,7 @@ bool ZRCola::chrtag_db::Search(_In_ const std::map<tagid_t, uint16_t> &tags, _In
const chrtag &ct = idxTag[i];
uint16_t len = ct.chr_len();
if (cats.find(ch_db.GetCharCat(ct.chr(), len)) != cats.end()) {
std::u16string chr(ct.chr(), len);
string_t chr(ct.chr(), len);
auto idx = hits.find(chr);
if (idx == hits.end()) {
// New character.
@ -37,7 +37,7 @@ bool ZRCola::chrtag_db::Search(_In_ const std::map<tagid_t, uint16_t> &tags, _In
}
bool ZRCola::tagname_db::Search(_In_z_ const char16_t *str, _In_ uint32_t locale, _Inout_ std::map<tagid_t, uint16_t> &hits, _In_opt_ bool (__cdecl *fn_abort)(void *cookie), _In_opt_ void *cookie) const
bool ZRCola::tagname_db::Search(_In_z_ const char_t *str, _In_ uint32_t locale, _Inout_ std::map<tagid_t, uint16_t> &hits, _In_opt_ bool (__cdecl *fn_abort)(void *cookie), _In_opt_ void *cookie) const
{
assert(str);
@ -55,9 +55,9 @@ bool ZRCola::tagname_db::Search(_In_z_ const char16_t *str, _In_ uint32_t locale
}
// Get name.
std::u16string name;
string_t name;
if (*str == u'"') {
const char16_t *str_end = ++str;
const auto *str_end = ++str;
for (;;) {
if (*str_end == 0) {
name.assign(str, str_end);
@ -71,7 +71,7 @@ bool ZRCola::tagname_db::Search(_In_z_ const char16_t *str, _In_ uint32_t locale
}
str = str_end;
} else {
const char16_t *str_end = str + 1;
const auto *str_end = str + 1;
for (; *str_end && !iswspace(*str_end); str_end++);
name.assign(str, str_end);
str = str_end;
@ -81,7 +81,7 @@ bool ZRCola::tagname_db::Search(_In_z_ const char16_t *str, _In_ uint32_t locale
if (fn_abort && fn_abort(cookie)) return false;
// Find the name.
std::unique_ptr<tagname> tn(reinterpret_cast<tagname*>(new char[sizeof(tagname) + sizeof(char16_t)*name.length()]));
std::unique_ptr<tagname> tn(reinterpret_cast<tagname*>(new char[sizeof(tagname) + sizeof(char_t)*name.length()]));
new (tn.get()) tagname(0, locale, name.data(), name.length());
size_t start, end;
if (idxName.find(*tn, start, end)) {

12
lib/libZRCola/src/translate.cpp
View File

@ -6,7 +6,7 @@
#include "pch.h"
void ZRCola::translation_db::Translate(_In_ transetid_t set, _In_z_count_(inputMax) const char16_t* input, _In_ size_t inputMax, _Out_ std::u16string &output, _Out_opt_ std::vector<mapping>* map) const
void ZRCola::translation_db::Translate(_In_ transetid_t set, _In_z_count_(inputMax) const char_t* input, _In_ size_t inputMax, _Out_ string_t &output, _Out_opt_ std::vector<mapping>* map) const
{
assert(input || inputMax == 0);
@ -28,7 +28,7 @@ void ZRCola::translation_db::Translate(_In_ transetid_t set, _In_z_count_(inputM
// Find the longest matching translation at i-th character.
size_t l_match = (size_t)-1;
for (size_t l = l_set, r = r_set, ii = i, j = 0; ii < inputMax && l < r; ii++, j++) {
char16_t c = input[ii];
auto c = input[ii];
while (l < r) {
// Test the translation in the middle of the search area.
size_t m = (l + r) / 2;
@ -36,7 +36,7 @@ void ZRCola::translation_db::Translate(_In_ transetid_t set, _In_z_count_(inputM
// Get the j-th character of the translation.
// All translations that get short on characters are lexically ordered before.
// Thus the j-th character is considered 0.
char16_t s = idxSrc[m].src_at(j);
auto s = idxSrc[m].src_at(j);
// Do the bisection test.
if (c < s) r = m;
@ -84,7 +84,7 @@ void ZRCola::translation_db::Translate(_In_ transetid_t set, _In_z_count_(inputM
}
void ZRCola::translation_db::TranslateInv(_In_ transetid_t set, _In_z_count_(inputMax) const char16_t* input, _In_ size_t inputMax, _In_opt_ const langchar_db *lc_db, _In_opt_ langid_t lang, _Out_ std::u16string &output, _Out_opt_ std::vector<mapping>* map) const
void ZRCola::translation_db::TranslateInv(_In_ transetid_t set, _In_z_count_(inputMax) const char_t* input, _In_ size_t inputMax, _In_opt_ const langchar_db *lc_db, _In_opt_ langid_t lang, _Out_ string_t &output, _Out_opt_ std::vector<mapping>* map) const
{
assert(input || inputMax == 0);
@ -106,7 +106,7 @@ void ZRCola::translation_db::TranslateInv(_In_ transetid_t set, _In_z_count_(inp
// Find the longest matching inverse translation at i-th character.
size_t l_match = (size_t)-1;
for (size_t l = l_set, r = r_set, ii = i, j = 0; ii < inputMax && l < r; ii++, j++) {
char16_t c = input[ii];
auto c = input[ii];
while (l < r) {
// Test the inverse translation in the middle of the search area.
size_t m = (l + r) / 2;
@ -114,7 +114,7 @@ void ZRCola::translation_db::TranslateInv(_In_ transetid_t set, _In_z_count_(inp
// Get the j-th character of the inverse translation.
// All inverse translations that get short on characters are lexically ordered before.
// Thus the j-th character is considered 0.
char16_t s = idxDst[m].dst_at(j);
auto s = idxDst[m].dst_at(j);
// Do the bisection test.
if (c < s) r = m;

28
lib/libZRColaUI/include/zrcolaui/chargroup.h
View File

@ -46,7 +46,7 @@ namespace ZRCola {
protected:
uint16_t name_to; ///< Character group name end in \c data
uint16_t chrlst_to; ///< Character list end in \c data
wchar_t data[]; ///< Character group name, character list, bit vector if particular character is displayed initially
char_t data[]; ///< Character group name, character list, bit vector if particular character is displayed initially
public:
///
@ -63,33 +63,33 @@ namespace ZRCola {
inline chrgrp(
_In_opt_ chrgrpid_t grp = 0,
_In_opt_ uint16_t rank = 0,
_In_opt_z_count_(name_len) const wchar_t *name = NULL,
_In_opt_z_count_(name_len) const char_t *name = NULL,
_In_opt_ size_t name_len = 0,
_In_opt_z_count_(chrlst_len) const wchar_t *chrlst = NULL,
_In_opt_z_count_(chrlst_len) const char_t *chrlst = NULL,
_In_opt_ size_t chrlst_len = 0,
_In_opt_count_x_((chrlst_len + 15)/16) const uint16_t *chrshow = NULL)
{
this->grp = grp;
this->rank = rank;
this->name_to = static_cast<uint16_t>(name_len);
if (name && name_len) memcpy(this->data, name, sizeof(wchar_t)*name_len);
if (name && name_len) memcpy(this->data, name, sizeof(char_t)*name_len);
this->chrlst_to = static_cast<uint16_t>(this->name_to + chrlst_len);
if (chrlst && chrshow && chrlst_len) {
memcpy(this->data + this->name_to, chrlst, sizeof(wchar_t)*chrlst_len);
memcpy(this->data + this->name_to, chrlst, sizeof(char_t)*chrlst_len);
memcpy(this->data + this->chrlst_to, chrshow, (chrlst_len + sizeof(*data)*8 - 1)/8);
}
}
inline const wchar_t* name () const { return data; };
inline wchar_t* name () { return data; };
inline const wchar_t* name_end() const { return data + name_to; };
inline wchar_t* name_end() { return data + name_to; };
inline const char_t* name () const { return data; };
inline char_t* name () { return data; };
inline const char_t* name_end() const { return data + name_to; };
inline char_t* name_end() { return data + name_to; };
inline uint16_t name_len() const { return name_to; };
inline const wchar_t* chrlst () const { return data + name_to; };
inline wchar_t* chrlst () { return data + name_to; };
inline const wchar_t* chrlst_end() const { return data + chrlst_to; };
inline wchar_t* chrlst_end() { return data + chrlst_to; };
inline const char_t* chrlst () const { return data + name_to; };
inline char_t* chrlst () { return data + name_to; };
inline const char_t* chrlst_end() const { return data + chrlst_to; };
inline char_t* chrlst_end() { return data + chrlst_to; };
inline uint16_t chrlst_len() const { return chrlst_to - name_to; };
inline const uint16_t* chrshow () const { return reinterpret_cast<const uint16_t*>(data + chrlst_to ); };
@ -148,7 +148,7 @@ namespace ZRCola {
if (a.rank < b.rank) return -1;
else if (a.rank > b.rank) return +1;
auto &coll = std::use_facet<std::collate<wchar_t>>(std::locale());
auto &coll = std::use_facet<std::collate<char_t>>(std::locale());
return coll.compare(a.name(), a.name_end(), b.name(), b.name_end());
}
} idxRank; ///< Rank index

22
lib/libZRColaUI/include/zrcolaui/keyboard.h
View File

@ -45,14 +45,14 @@ namespace ZRCola {
};
struct key_t {
wchar_t key; ///< Key
char_t key; ///< Key
uint16_t modifiers; ///< Modifiers (bitwise combination of SHIFT, CTRL and ALT)
};
protected:
uint16_t chr_to; ///< Character end in \c data
uint16_t seq_to; ///< Key sequence end in \c data
wchar_t data[]; ///< Character and key sequence
char_t data[]; ///< Character and key sequence
public:
///
@ -64,21 +64,21 @@ namespace ZRCola {
/// \param[in] chr_len Number of UTF-16 characters in \p chr
///
inline keyseq(
_In_opt_count_(seq_count) const key_t *seq = NULL,
_In_opt_ size_t seq_count = 0,
_In_opt_z_count_(chr_len) const wchar_t *chr = NULL,
_In_opt_ size_t chr_len = 0)
_In_opt_count_(seq_count) const key_t *seq = NULL,
_In_opt_ size_t seq_count = 0,
_In_opt_z_count_(chr_len) const char_t *chr = NULL,
_In_opt_ size_t chr_len = 0)
{
this->chr_to = static_cast<uint16_t>(chr_len);
if (chr && chr_len) memcpy(this->data, chr, sizeof(wchar_t)*chr_len);
if (chr && chr_len) memcpy(this->data, chr, sizeof(char_t)*chr_len);
this->seq_to = static_cast<uint16_t>(this->chr_to + seq_count * sizeof(key_t) / sizeof(*data));
if (seq && seq_count) memcpy(this->data + this->chr_to, seq, sizeof(key_t)*seq_count);
}
inline const wchar_t* chr () const { return data; };
inline wchar_t* chr () { return data; };
inline const wchar_t* chr_end() const { return data + chr_to; };
inline wchar_t* chr_end() { return data + chr_to; };
inline const char_t* chr () const { return data; };
inline char_t* chr () { return data; };
inline const char_t* chr_end() const { return data + chr_to; };
inline char_t* chr_end() { return data + chr_to; };
inline uint16_t chr_len() const { return chr_to; };
inline const key_t* seq () const { return reinterpret_cast<const key_t*>(data + chr_to); };