CharsetConverter.cpp
3.53 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#include <vector>
#include <iterator>
#include <algorithm>
#include <stdint.h>
#include "utf8.h"
#include "CharsetConverter.hpp"
#include "conversion_tables.hpp"
using namespace std;
const char DEFAULT_UNDEFINED_CHAR = static_cast<char>(0xF7);
uint32_t UTF8CharsetConverter::peek(const char*& it, const char* end) const {
return utf8::peek_next(it, end);
}
uint32_t UTF8CharsetConverter::next(const char*& it, const char* end) const {
return utf8::next(it, end);
}
void UTF8CharsetConverter::append(uint32_t cp, string& result) const {
utf8::append(cp, back_inserter(result));
}
uint32_t UTF16CharsetConverter::peek(const char*& it, const char* end) const {
/*
* Borrowed from utfcpp
*/
uint32_t cp = utf8::internal::mask16(*it);
// Take care of surrogate pairs first
if (utf8::internal::is_lead_surrogate(cp)) {
uint32_t trail_surrogate = utf8::internal::mask16(*(it + 1));
cp = (cp << 10) + trail_surrogate + utf8::internal::SURROGATE_OFFSET;
}
return cp;
}
uint32_t UTF16CharsetConverter::next(const char*& it, const char* end) const {
/*
* Borrowed from utfcpp
*/
uint32_t cp = utf8::internal::mask16(*it++);
// Take care of surrogate pairs first
if (utf8::internal::is_lead_surrogate(cp)) {
uint32_t trail_surrogate = utf8::internal::mask16(*it++);
cp = (cp << 10) + trail_surrogate + utf8::internal::SURROGATE_OFFSET;
}
return cp;
}
static void appendWCharToString(uint16_t wchar, string& result) {
uint8_t b[2] = {
static_cast<uint8_t>(wchar & 0x00FF),
static_cast<uint8_t>((wchar & 0xFF00) >> 8)};
char* chars = reinterpret_cast<char*>(b);
result.push_back(chars[0]);
result.push_back(chars[1]);
}
void UTF16CharsetConverter::append(uint32_t cp, string& result) const {
/*
* borrowed from utfcpp
*/
if (cp > 0xffff) { //make a surrogate pair
uint16_t wchar1 = static_cast<uint16_t> ((cp >> 10) + utf8::internal::LEAD_OFFSET);
uint16_t wchar2 = static_cast<uint16_t> ((cp & 0x3ff) + utf8::internal::TRAIL_SURROGATE_MIN);
appendWCharToString(wchar1, result);
appendWCharToString(wchar2, result);
} else {
uint16_t wchar = static_cast<uint16_t> (cp);
appendWCharToString(wchar, result);
}
}
static vector<char> reverseArray(const uint32_t* array) {
vector<char> res;
unsigned char c = 0;
do {
uint32_t codepoint = array[c];
res.resize(max(static_cast<uint32_t>(res.size()), codepoint), DEFAULT_UNDEFINED_CHAR);
res[codepoint] = static_cast<char>(c);
c++;
}
while (c != 255);
return res;
}
OneByteCharsetConverter::OneByteCharsetConverter(const uint32_t* array)
: array(array),
codepoint2Char(reverseArray(array))
{
}
// TODO - sprawdzanie zakresu
uint32_t OneByteCharsetConverter::peek(const char*& it, const char* end) const {
return this->array[static_cast<unsigned char>(*it)];
}
uint32_t OneByteCharsetConverter::next(const char*& it, const char* end) const {
return this->array[static_cast<unsigned char>(*(it++))];
}
void OneByteCharsetConverter::append(uint32_t cp, std::string& result) const {
if (cp < this->codepoint2Char.size()) {
result.push_back(this->codepoint2Char[cp]);
}
else {
result.push_back(DEFAULT_UNDEFINED_CHAR);
}
}
ISO8859_2_CharsetConverter::ISO8859_2_CharsetConverter()
: OneByteCharsetConverter(ISO_8859_2_TO_CODEPOINT) {
}
Windows_1250_CharsetConverter::Windows_1250_CharsetConverter()
: OneByteCharsetConverter(WINDOWS_1250_TO_CODEPOINT) {
}