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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
|
/**************************************************************************
* *
* Regina - A Normal Surface Theory Calculator *
* Computational Engine *
* *
* Copyright (c) 1999-2008, Ben Burton *
* For further details contact Ben Burton (bab@debian.org). *
* *
* This program 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 2 of the *
* License, or (at your option) any later version. *
* *
* This program 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 this program; if not, write to the Free *
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, *
* MA 02110-1301, USA. *
* *
**************************************************************************/
/* end stub */
#include <cerrno>
#include <cstring>
#include <langinfo.h>
#include <locale.h>
#include "utilities/i18nutils.h"
namespace regina {
namespace i18n {
bool Locale::initialised = false;
#ifdef HAVE_ICONV
const iconv_t IConvStreamBuffer::cdNone((iconv_t)(-1));
#endif
const char* Locale::codeset() {
if (! initialised) {
::setlocale(LC_ALL, "");
initialised = true;
}
return nl_langinfo(CODESET);
}
IConvStreamBuffer* IConvStreamBuffer::open(std::ostream& dest,
const char* srcCode, const char* destCode) {
if (sink)
if (! close())
return 0;
sink = &dest;
#ifdef HAVE_ICONV
cd = iconv_open(destCode, srcCode);
if (cd == cdNone) {
if (errno != EINVAL)
return 0;
// The given encodings are not supported.
// This is fine; we'll just pass data through to sink untranslated.
}
#endif
// When we give the buffer to std::streambuf, leave space for an
// extra overflow character; this will make the implementation of
// overflow() simpler.
setp(preBuffer, preBuffer + (sizeof(preBuffer) - 1));
return this;
}
IConvStreamBuffer* IConvStreamBuffer::close() throw() {
sync();
#ifdef HAVE_ICONV
if (cd == cdNone) {
// We're passing data through untranslated; nothing more to do.
return this;
}
// Close down the internal iconv workings.
if (iconv_close(cd) == 0) {
cd = cdNone;
return this;
} else
return 0;
#else
return this;
#endif
}
IConvStreamBuffer::int_type IConvStreamBuffer::overflow(
IConvStreamBuffer::int_type c) {
// Are we even open?
if (sink == 0)
return traits_type::eof();
// Add the extra character to the end of the buffer before processing.
if (c != traits_type::eof()) {
*pptr() = c;
pbump(1);
}
#ifdef HAVE_ICONV
// Do we know how to translate between encodings? If not, just
// send the data straight through to the destination stream.
if (cd == cdNone) {
ptrdiff_t n = pptr() - preBuffer;
sink->write(preBuffer, n);
pbump(-n);
if (sink->fail())
return traits_type::eof();
else
return 0;
}
// Convert the data through iconv().
// We might need more than one run through this.
while (pptr() > preBuffer) {
size_t inBytes = pptr() - preBuffer;
size_t outBytes = sizeof(postBuffer);
ICONV_CONST char* inPtr = preBuffer;
char* outPtr = postBuffer;
::iconv(cd, &inPtr, &inBytes, &outPtr, &outBytes);
int iconvErr = errno;
errno = 0;
// If we got any output, write it to the destination stream.
if (outPtr > postBuffer) {
sink->write(postBuffer, outPtr - postBuffer);
if (sink->fail())
return traits_type::eof();
}
// Are we completely finished?
if (inBytes == 0) {
// Yes!
pbump(- (inPtr - preBuffer));
return 0;
}
// Something went wrong.
if (iconvErr == E2BIG) {
// The output buffer filled up. This shouldn't happen, but
// anyway; move the leftover input to the front of the input
// buffer and try again.
::memmove(preBuffer, inPtr, inBytes);
pbump(- (inPtr - preBuffer));
continue;
}
if (iconvErr == EINVAL) {
// We hit an incomplete multibyte sequence. Move the
// leftover input to the front of the buffer and stop, since
// we need more input before we can continue translating.
::memmove(preBuffer, inPtr, inBytes);
pbump(- (inPtr - preBuffer));
return 0;
}
if (iconvErr == EILSEQ) {
// We hit an invalid multibyte sequence.
// Try to recover gracefully by just skipping over it.
::memmove(preBuffer, inPtr + 1, inBytes - 1);
pbump(- (inPtr + 1 - preBuffer));
sink->write("?", 1);
if (sink->fail())
return traits_type::eof();
continue;
}
// We should never reach this point, since it indicates an error
// state that iconv() should not set.
std::cerr << "ERROR: Unexpected state after call to iconv().\n";
std::cerr << "Please report this as a bug to the Regina author(s).\n";
std::cerr.flush();
return traits_type::eof();
}
// We can never reach this point, but keep the compiler happy.
return 0;
#else
// We're building without iconv support.
// Just send everything straight through to sink.
ptrdiff_t n = pptr() - preBuffer;
sink->write(preBuffer, n);
pbump(-n);
if (sink->fail())
return traits_type::eof();
else
return 0;
#endif
}
int IConvStreamBuffer::sync() {
if (sink) {
IConvStreamBuffer::int_type ret = overflow(traits_type::eof());
sink->flush();
return (ret == traits_type::eof() || sink->fail()) ? -1 : 0;
} else
return -1;
}
} } // namespace regina::i18n
|
