an example for the sweave module, prepared by Gregor Gorjanc

[lyx.git] / src / support / docstream.cpp

diff --git a/src/support/docstream.cpp b/src/support/docstream.cpp
index 4f390dedc0d8d40bab517c0fa6a6f579b0b3122e..ed2ddfe88b4bd6f8c1323f003c9c28c4e104dff3 100644 (file)
--- a/src/support/docstream.cpp
+++ b/src/support/docstream.cpp
@@ -15,6 +15,7 @@
 
 #include <cerrno>
 #include <cstdio>
+#include <cstring>
 #include <iconv.h>
 #include <locale>
 
@@ -83,13 +84,50 @@ protected:
                        extern_type * to, extern_type * to_end,
                        extern_type *& to_next) const
        {
+#define WORKAROUND_ICONV_BUG 1
+#if WORKAROUND_ICONV_BUG
+               // Due to a bug in some iconv versions, when the last char
+               // in the buffer is a wide char and the output encoding is
+               // ISO-2022-JP and we are going to switch to another encoding,
+               // the appropriate escape sequence for changing the character
+               // set is not output (see bugs 5216, 5280, and also 5489).
+               // 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 const * from_old = from;
+               size_t extra = 0;
+               if (*(from_end - 1) >= 0x80 && encoding_ == "ISO-2022-JP") {
+                       size_t len = from_end - from;
+                       from_new = new intern_type[len + 1];
+                       memcpy(from_new, from, len * sizeof(intern_type));
+                       from_new[len] = 0;
+                       from_end = from_new + len + 1;
+                       from = from_new;
+                       extra = 1;
+               }
+#endif
                size_t inbytesleft = (from_end - from) * sizeof(intern_type);
                size_t outbytesleft = (to_end - to) * sizeof(extern_type);
+#if WORKAROUND_ICONV_BUG
+               outbytesleft += extra * sizeof(extern_type);
+#endif
                from_next = from;
                to_next = to;
                result const retval = do_iconv(out_cd_,
                                reinterpret_cast<char const **>(&from_next),
                                &inbytesleft, &to_next, &outbytesleft);
+#if WORKAROUND_ICONV_BUG
+               // Remove from output the nul char that we inserted at the end
+               // of the input buffer in order to circumvent an iconv bug.
+               if (from_new) {
+                       --to_next;
+                       --from_next;
+                       from_next = from_old + (from_next - from);
+                       from = from_old;
+                       delete[] from_new;
+               }
+#endif
                if (retval == base::error) {
                        fprintf(stderr,
                                "Error %d returned from iconv when converting from %s to %s: %s\n",
@@ -221,12 +259,13 @@ protected:
                        return 4;
                else if (encoding_ == "EUC-JP")
                        return 3;
+               else if (encoding_ == "ISO-2022-JP")
+                       return 8;
                else if (encoding_ == "BIG5" ||
                         encoding_ == "EUC-KR" ||
                         encoding_ == "EUC-CN" ||
                         encoding_ == "SJIS" ||
-                        encoding_ == "GBK" ||
-                        encoding_ == "JIS" )
+                        encoding_ == "GBK")
                        return 2;
                else
                        return 1;
@@ -242,6 +281,14 @@ private:
                                inbytesleft, to, outbytesleft);
                if (converted == (size_t)(-1)) {
                        switch(errno) {
+                       case 0: 
+                               // As strange as it may seem, this
+                               // does happen on windows when parsing
+                               // comments with accented chars in
+                               // tex2lyx. See the following thread
+                               // for details
+                               // http://thread.gmane.org/gmane.editors.lyx.devel/117636
+                               break;
                        case EINVAL:
                        case E2BIG:
                                return base::partial;
@@ -281,13 +328,13 @@ const char * iconv_codecvt_facet_exception::what() const throw()
 }
 
 
-idocfstream::idocfstream(string const & encoding) : base()
+ifdocstream::ifdocstream() : base()
 {
-       setEncoding(*this, encoding, in);
+       setEncoding(*this, "UTF-8", in);
 }
 
 
-idocfstream::idocfstream(const char* s, ios_base::openmode mode,
+ifdocstream::ifdocstream(const char* s, ios_base::openmode mode,
                         string const & encoding)
        : base()
 {
@@ -296,18 +343,13 @@ idocfstream::idocfstream(const char* s, ios_base::openmode mode,
 }
 
 
-odocfstream::odocfstream(): base()
+ofdocstream::ofdocstream(): base()
 {
+       setEncoding(*this, "UTF-8", out);
 }
 
 
-odocfstream::odocfstream(string const & encoding) : base()
-{
-       setEncoding(*this, encoding, out);
-}
-
-
-odocfstream::odocfstream(const char* s, ios_base::openmode mode,
+ofdocstream::ofdocstream(const char* s, ios_base::openmode mode,
                         string const & encoding)
        : base()
 {
@@ -316,7 +358,7 @@ odocfstream::odocfstream(const char* s, ios_base::openmode mode,
 }
 
 
-void odocfstream::reset(string const & encoding)
+void ofdocstream::reset(string const & encoding)
 {
        setEncoding(*this, encoding, out);
 }
@@ -349,6 +391,28 @@ odocstream & operator<<(odocstream & os, SetEnc e)
 }
 
 
+//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();
+               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;
+}
+
+
 #if ! defined(USE_WCHAR_T)
 odocstream & operator<<(odocstream & os, char c)
 {