using namespace std;
using lyx::ucs4_codeset;
-using lyx::support::contains;
-using lyx::support::split;
#if defined(_MSC_VER) && (_MSC_VER >= 1600)
std::locale::id numpunct<lyx::char_type>::id;
-#endif
+
+namespace std {
+// Implementation of numpunct<lyx::char_type> defined in numpunct_lyx_char_type.h
+typedef basic_string<lyx::char_type> string_type;
+
+string_type numpunct<lyx::char_type>::truename() const
+{
+ return lyx::from_ascii(numpunct<char>::truename());
+}
+
+string_type numpunct<lyx::char_type>::falsename() const
+{
+ return lyx::from_ascii(numpunct<char>::falsename());
+}
+
+} // namespace std
+
+#endif // _MSC_VER >= 1600
namespace {
} else
out_cd_ = (iconv_t)(-1);
}
+ string const & encoding() const { return encoding_; }
protected:
virtual ~iconv_codecvt_facet()
{
fflush(stderr);
}
}
- virtual result do_out(state_type &, intern_type const * from,
+ result do_out(state_type &, intern_type const * from,
intern_type const * from_end, intern_type const *& from_next,
extern_type * to, extern_type * to_end,
- extern_type *& to_next) const
+ extern_type *& to_next) const override
{
#define WORKAROUND_ICONV_BUG 1
#if WORKAROUND_ICONV_BUG
// As a workaround, we append a nul char in order to force
// a switch to ASCII, and then remove it from output after
// the conversion.
- intern_type * from_new = 0;
+ intern_type * from_new = nullptr;
intern_type const * from_old = from;
size_t extra = 0;
if (*(from_end - 1) >= 0x80 && encoding_ == "ISO-2022-JP") {
fprintf(stderr, "\nStopped at: 0x%04x\n", c);
fputs("Unconverted input:", stderr);
for (intern_type const * i = from_next + 1; i < from_end; ++i) {
- unsigned int const c = *i;
- fprintf(stderr, " 0x%04x", c);
+ unsigned int const cc = *i;
+ fprintf(stderr, " 0x%04x", cc);
}
fputs("\nConverted output:", stderr);
for (extern_type const * i = to; i < to_next; ++i) {
// extern_type may be signed, avoid output of
// something like 0xffffffc2
- unsigned int const c =
+ unsigned int const cc =
*reinterpret_cast<unsigned char const *>(i);
- fprintf(stderr, " 0x%02x", c);
+ fprintf(stderr, " 0x%02x", cc);
}
fputc('\n', stderr);
fflush(stderr);
}
return retval;
}
- virtual result do_unshift(state_type &, extern_type * to,
- extern_type *, extern_type *& to_next) const
+ result do_unshift(state_type &, extern_type * to,
+ extern_type *, extern_type *& to_next) const override
{
// utf8 does not use shifting
to_next = to;
return base::noconv;
}
- virtual result do_in(state_type &,
+ result do_in(state_type &,
extern_type const * from, extern_type const * from_end,
extern_type const *& from_next,
intern_type * to, intern_type * to_end,
- intern_type *& to_next) const
+ intern_type *& to_next) const override
{
size_t inbytesleft = (from_end - from) * sizeof(extern_type);
size_t outbytesleft = (to_end - to) * sizeof(intern_type);
fprintf(stderr, "\nStopped at: 0x%02x\n", c);
fputs("Unconverted input:", stderr);
for (extern_type const * i = from_next + 1; i < from_end; ++i) {
- unsigned int const c =
+ unsigned int const cc =
*reinterpret_cast<unsigned char const *>(i);
- fprintf(stderr, " 0x%02x", c);
+ fprintf(stderr, " 0x%02x", cc);
}
fputs("\nConverted output:", stderr);
for (intern_type const * i = to; i < to_next; ++i) {
- unsigned int const c = *i;
- fprintf(stderr, " 0x%02x", c);
+ unsigned int const cc = *i;
+ fprintf(stderr, " 0x%02x", cc);
}
fputc('\n', stderr);
fflush(stderr);
}
return retval;
}
- virtual int do_encoding() const throw()
+ int do_encoding() const noexcept override
{
return 0;
}
- virtual bool do_always_noconv() const throw()
+ bool do_always_noconv() const noexcept override
{
return false;
}
- virtual int do_length(state_type & /*state*/, extern_type const * from,
- extern_type const * end, size_t max) const
+ int do_length(state_type & /*state*/, extern_type const * from,
+ extern_type const * end, size_t max) const override
{
// The docs are a bit unclear about this method.
// It seems that we should calculate the actual length of the
return min(length, max);
#endif
}
- virtual int do_max_length() const throw()
+ int do_max_length() const noexcept override
{
return lyx::max_encoded_bytes(encoding_);
}
inbytesleft, to, outbytesleft);
if (converted == (size_t)(-1)) {
switch(errno) {
- case 0:
+ case 0:
// As strange as it may seem, this
// does happen on windows when parsing
// comments with accented chars in
string encoding_;
};
-} // namespace anon
+} // namespace
namespace lyx {
template<class Ios>
void setEncoding(Ios & ios, string const & encoding, ios_base::openmode mode)
{
- // We must imbue the stream before openening the file
+ // We must imbue the stream before opening the file
locale global;
locale locale(global, new iconv_codecvt_facet(encoding, mode));
ios.imbue(locale);
}
-const char * iconv_codecvt_facet_exception::what() const throw()
+const char * iconv_codecvt_facet_exception::what() const noexcept
{
return "iconv problem in iconv_codecvt_facet initialization";
}
}
+ifdocstream::ifdocstream(SetEnc const & enc) : base()
+{
+ setEncoding(*this, enc.encoding, in);
+}
+
+
ifdocstream::ifdocstream(const char* s, ios_base::openmode mode,
string const & encoding)
: base()
}
+ofdocstream::ofdocstream(SetEnc const & enc) : base()
+{
+ setEncoding(*this, enc.encoding, out);
+}
+
+
ofdocstream::ofdocstream(const char* s, ios_base::openmode mode,
string const & encoding)
: base()
if (has_facet<iconv_codecvt_facet>(os.rdbuf()->getloc())) {
// This stream must be a file stream, since we never imbue
// any other stream with a locale having a iconv_codecvt_facet.
+ iconv_codecvt_facet const & facet =
+ use_facet<iconv_codecvt_facet>(os.rdbuf()->getloc());
+
+ // FIXME Changing the codecvt facet of an open file is allowed,
+ // but unsafe for facets that use internal state (see the thread
+ // "iostreams: Does imbue() need to be called before open()?"
+ // in comp.std.c++.
+ // Currently it seems to work with gcc and MSVC, but not with
+ // clang on OS X.
+ // Avoid imbueing with the same encoding again if possible.
+ if (facet.encoding() == e.encoding)
+ return os;
+
// Flush the stream so that all pending output is written
// with the old encoding.
os.flush();
+
locale locale(os.rdbuf()->getloc(),
new iconv_codecvt_facet(e.encoding, ios_base::out));
- // FIXME Does changing the codecvt facet of an open file
- // stream always work? It does with gcc 4.1, but I have read
- // somewhere that it does not with MSVC.
- // What does the standard say?
os.imbue(locale);
}
return os;
}
-//CHECKME: I just copied the code above, and have no idea whether it
-//is correct... (JMarc)
idocstream & operator<<(idocstream & is, SetEnc e)
{
if (has_facet<iconv_codecvt_facet>(is.rdbuf()->getloc())) {
// This stream must be a file stream, since we never imbue
// any other stream with a locale having a iconv_codecvt_facet.
- // Flush the stream so that all pending output is written
- // with the old encoding.
- //is.flush();
+ iconv_codecvt_facet const & facet =
+ use_facet<iconv_codecvt_facet>(is.rdbuf()->getloc());
+
+ // FIXME Changing the codecvt facet of an open file is allowed,
+ // but unsafe for facets that use internal state (see the thread
+ // "iostreams: Does imbue() need to be called before open()?"
+ // in comp.std.c++.
+ // Currently it seems to work with gcc and MSVC, but not with
+ // clang on OS X.
+ // Avoid imbueing with the same encoding again if possible.
+ if (facet.encoding() == e.encoding)
+ return is;
+
locale locale(is.rdbuf()->getloc(),
new iconv_codecvt_facet(e.encoding, ios_base::in));
- // FIXME Does changing the codecvt facet of an open file
- // stream always work? It does with gcc 4.1, but I have read
- // somewhere that it does not with MSVC.
- // What does the standard say?
is.imbue(locale);
}
return is;
}
#endif
+} // namespace lyx
-void otexstream::put(char_type const & c)
-{
- if (protectspace_) {
- if (!canbreakline_ && c == ' ')
- os_ << "{}";
- protectspace_ = false;
- }
- os_.put(c);
- lastChar(c);
- if (c == '\n')
- texrow_.newline();
-}
-
-
-BreakLine breakln;
-SafeBreakLine safebreakln;
-
-
-otexstream & operator<<(otexstream & ots, BreakLine)
-{
- if (ots.canBreakLine()) {
- ots.os().put('\n');
- ots.lastChar('\n');
- ots.texrow().newline();
- }
- ots.protectSpace(false);
- return ots;
-}
-
-
-otexstream & operator<<(otexstream & ots, SafeBreakLine)
-{
- if (ots.canBreakLine()) {
- ots.os() << "%\n";
- ots.lastChar('\n');
- ots.texrow().newline();
- }
- ots.protectSpace(false);
- return ots;
-}
-
-
-otexstream & operator<<(otexstream & ots, odocstream_manip pf)
-{
- ots.os() << pf;
- if (pf == static_cast<odocstream_manip>(endl)) {
- ots.lastChar('\n');
- ots.texrow().newline();
- }
- return ots;
-}
-
-
-otexstream & operator<<(otexstream & ots, docstring const & s)
-{
- size_t const len = s.length();
-
- // Check whether there's something to output
- if (len == 0)
- return ots;
-
- if (ots.protectSpace()) {
- if (!ots.canBreakLine() && s[0] == ' ')
- ots.os() << "{}";
- ots.protectSpace(false);
- }
-
- if (contains(s, 0xF0000)) {
- // Some encoding changes for the underlying stream are embedded
- // in the docstring. The encoding names to be used are enclosed
- // between the code points 0xF0000 and 0xF0001, the first two
- // characters of plane 15, which is a Private Use Area whose
- // codepoints don't have any associated glyph.
- docstring s1;
- docstring s2 = split(s, s1, 0xF0000);
- while (true) {
- if (!s1.empty())
- ots.os() << s1;
- if (s2.empty())
- break;
- docstring enc;
- docstring const s3 = split(s2, enc, 0xF0001);
- if (!contains(s2, 0xF0001))
- s2 = split(enc, s1, 0xF0000);
- else {
- ots.os() << setEncoding(to_ascii(enc));
- s2 = split(s3, s1, 0xF0000);
- }
- }
- } else
- ots.os() << s;
-
- if (len > 1)
- ots.canBreakLine(s[len - 2] != '\n');
- ots.lastChar(s[len - 1]);
- ots.texrow().newlines(count(s.begin(), s.end(), '\n'));
- return ots;
-}
-
-
-otexstream & operator<<(otexstream & ots, string const & s)
-{
- ots << from_utf8(s);
- return ots;
-}
-
-
-otexstream & operator<<(otexstream & ots, char const * s)
-{
- ots << from_utf8(s);
- return ots;
-}
-
-
-otexstream & operator<<(otexstream & ots, char c)
-{
- if (ots.protectSpace()) {
- if (!ots.canBreakLine() && c == ' ')
- ots.os() << "{}";
- ots.protectSpace(false);
- }
- ots.os() << c;
- ots.lastChar(c);
- if (c == '\n')
- ots.texrow().newline();
- return ots;
-}
-
-
-template <typename Type>
-otexstream & operator<<(otexstream & ots, Type value)
-{
- ots.os() << value;
- ots.lastChar(0);
- ots.protectSpace(false);
- return ots;
-}
-
-template otexstream & operator<< <SetEnc>(otexstream & os, SetEnc);
-template otexstream & operator<< <double>(otexstream &, double);
-template otexstream & operator<< <int>(otexstream &, int);
-template otexstream & operator<< <unsigned int>(otexstream &, unsigned int);
-template otexstream & operator<< <unsigned long>(otexstream &, unsigned long);
-
-}
#if ! defined(USE_WCHAR_T) && defined(__GNUC__)
// We get undefined references to these virtual methods. This looks like
// a bug in gcc. The implementation here does not do anything useful, since
-// it is overriden in iconv_codecvt_facet.
+// it is overridden in iconv_codecvt_facet.
namespace std {
template<> codecvt<lyx::char_type, char, mbstate_t>::result
template<>
-int codecvt<lyx::char_type, char, mbstate_t>::do_encoding() const throw()
+int codecvt<lyx::char_type, char, mbstate_t>::do_encoding() const noexcept
{
return 0;
}
template<>
-bool codecvt<lyx::char_type, char, mbstate_t>::do_always_noconv() const throw()
+bool codecvt<lyx::char_type, char, mbstate_t>::do_always_noconv() const noexcept
{
return true;
}
-#if __GNUC__ == 3 && __GNUC_MINOR__ < 4
-
-template<>
-int codecvt<lyx::char_type, char, mbstate_t>::do_length(
- mbstate_t const &, const char *, const char *, size_t) const
-{
- return 1;
-}
-
-#else
-
template<>
int codecvt<lyx::char_type, char, mbstate_t>::do_length(
mbstate_t &, const char *, const char *, size_t) const
return 1;
}
-#endif
-
template<>
-int codecvt<lyx::char_type, char, mbstate_t>::do_max_length() const throw()
+int codecvt<lyx::char_type, char, mbstate_t>::do_max_length() const noexcept
{
return 4;
}