X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fsupport%2Fdocstream.h;h=b7e30409b368f6304bf97d00e4e69673b75e2582;hb=90f7007a2e6c78ffd031e4636ff909ab1bc2ddec;hp=c1f4f1ad8b056bbfcdd8930b36f77519021fd9d6;hpb=0d449056ef9ace3ef737e4b9aba8d3994615dc18;p=lyx.git diff --git a/src/support/docstream.h b/src/support/docstream.h index c1f4f1ad8b..b7e30409b3 100644 --- a/src/support/docstream.h +++ b/src/support/docstream.h @@ -12,13 +12,27 @@ #ifndef LYX_DOCSTREAM_H #define LYX_DOCSTREAM_H +#include "TexRow.h" #include "support/docstring.h" +#if defined(_MSC_VER) && (_MSC_VER >= 1600) +// Ugly workaround for MSVC10 STL bug: +// std::numpunct has a hardcoded dllimport in definition, but we wanna it with 32 bit +// so we can't import it and must define it but then the compiler complains. +#include "support/numpunct_lyx_char_type.h" +#endif + #include #include namespace lyx { +class iconv_codecvt_facet_exception : public std::exception { +public: + virtual ~iconv_codecvt_facet_exception() throw() {} + virtual const char * what() const throw(); +}; + /// Base class for UCS4 input streams typedef std::basic_istream idocstream; @@ -28,46 +42,146 @@ typedef std::basic_istream idocstream; \endcode, not \code os << c; \endcode . The latter will not output the character, but the code point - as number. This is because we can't overload operator<< (our character - type is not a real type but a typedef). Narrow characters of type char - can be output as usual. + as number if USE_WCHAR_T is not defined. This is because we can't overload + operator<< (our character type is not always a real type but sometimes a + typedef). Narrow characters of type char can be output as usual. */ typedef std::basic_ostream odocstream; /// File stream for reading UTF8-encoded files with automatic conversion to /// UCS4. -class idocfstream : public std::basic_ifstream { +class ifdocstream : public std::basic_ifstream { typedef std::basic_ifstream base; public: - idocfstream(); - explicit idocfstream(const char* s, - std::ios_base::openmode mode = std::ios_base::in); - ~idocfstream() {} + ifdocstream(); + explicit ifdocstream(const char* s, + std::ios_base::openmode mode = std::ios_base::in, + std::string const & encoding = "UTF-8"); + ~ifdocstream() {} }; -/// File stream for writing UTF8-encoded files with automatic conversion from -/// UCS4. -class odocfstream : public std::basic_ofstream { +/// File stream for writing files in 8bit encoding \p encoding with automatic +/// conversion from UCS4. + +class ofdocstream : public std::basic_ofstream { typedef std::basic_ofstream base; public: - odocfstream(); - explicit odocfstream(const char* s, - std::ios_base::openmode mode = std::ios_base::out|std::ios_base::trunc); - ~odocfstream() {} + ofdocstream(); + explicit ofdocstream(const char* s, + std::ios_base::openmode mode = std::ios_base::out|std::ios_base::trunc, + std::string const & encoding = "UTF-8"); + ~ofdocstream() {} + /// + void reset(std::string const & encoding); }; + + /// UCS4 input stringstream typedef std::basic_istringstream idocstringstream; /// UCS4 output stringstream typedef std::basic_ostringstream odocstringstream; -inline -odocstream & operator<<(odocstream & os, char c) -{ - os.put(c); - return os; -} +/// UCS4 output manipulator +typedef odocstream & (*odocstream_manip)(odocstream &); + +/** Wrapper class for odocstream. + This class is used to automatically count the lines of the exported latex + code and also to ensure that no blank lines may be inadvertently output. + To this end, use the special variables "breakln" and "safebreakln" as if + they were iomanip's to ensure that the next output will start at the + beginning of a line. Using "breakln", a '\n' char will be output if needed, + while using "safebreakln", "%\n" will be output if needed. + The class also records the last output character. + */ + +class otexstream { +public: + /// + otexstream(odocstream & os, TexRow & texrow) + : os_(os), texrow_(texrow), + canbreakline_(false), protectspace_(false), lastchar_(0) {} + /// + odocstream & os() { return os_; } + /// + TexRow & texrow() { return texrow_; } + /// + void put(char_type const & c); + /// + void canBreakLine(bool breakline) { canbreakline_ = breakline; } + /// + bool canBreakLine() const { return canbreakline_; } + /// + void protectSpace(bool protectspace) { protectspace_ = protectspace; } + /// + bool protectSpace() const { return protectspace_; } + /// + void lastChar(char_type const & c) { lastchar_ = c; } + /// + char_type lastChar() const { return lastchar_; } +private: + /// + odocstream & os_; + /// + TexRow & texrow_; + /// + bool canbreakline_; + /// + bool protectspace_; + /// + char_type lastchar_; +}; + +/// Helper structs for breaking a line +struct BreakLine { + char n; +}; + +struct SafeBreakLine { + char n; +}; + +extern BreakLine breakln; +extern SafeBreakLine safebreakln; + +/// +otexstream & operator<<(otexstream &, BreakLine); +/// +otexstream & operator<<(otexstream &, SafeBreakLine); +/// +otexstream & operator<<(otexstream &, odocstream_manip); +/// +otexstream & operator<<(otexstream &, docstring const &); +/// +otexstream & operator<<(otexstream &, std::string const &); +/// +otexstream & operator<<(otexstream &, char const *); +/// +otexstream & operator<<(otexstream &, char); +/// +template +otexstream & operator<<(otexstream & ots, Type value); + +/// Helper struct for changing stream encoding +struct SetEnc { + SetEnc(std::string const & e) : encoding(e) {} + std::string encoding; +}; + +/// Helper function for changing stream encoding +SetEnc setEncoding(std::string const & encoding); + +/** Change the encoding of \p os to \p e.encoding. + \p e.encoding must be a valid iconv name of an 8bit encoding. + This does nothing if the stream is not a file stream, since only + file streams do have an associated 8bit encoding. + Usage: \code + os << setEncoding("ISO-8859-1"); + \endcode + */ +odocstream & operator<<(odocstream & os, SetEnc e); +idocstream & operator<<(idocstream & os, SetEnc e); }