]> git.proxmox.com Git - ceph.git/blobdiff - ceph/src/boost/tools/quickbook/src/native_text.cpp
update sources to v12.2.3
[ceph.git] / ceph / src / boost / tools / quickbook / src / native_text.cpp
index 23836c5ce17e4db5d31464caf4a74a2b50a96e30..b16221b7f1247dc2843971b6225bdcbd10b6ae14 100644 (file)
 #include <iostream>
 #include "native_text.hpp"
 #include "utils.hpp"
-#include "files.hpp"
 
 #if QUICKBOOK_WIDE_PATHS || QUICKBOOK_WIDE_STREAMS
 #include <boost/scoped_ptr.hpp>
 #include <windows.h>
-#include <io.h>
-#include <fcntl.h>
-#endif
-
-#if QUICKBOOK_CYGWIN_PATHS
-#include <boost/scoped_array.hpp>
-#include <boost/program_options/errors.hpp>
-#include <sys/cygwin.h>
 #endif
 
 namespace quickbook {
 namespace detail {
-    namespace {
-        bool ms_errors = false;
-    }
-
-    void set_ms_errors(bool x) {
-        ms_errors = x;
-    }
-
 // This is used for converting paths to UTF-8 on cygin.
 // Might be better not to use a windows 
 #if QUICKBOOK_WIDE_PATHS || QUICKBOOK_WIDE_STREAMS
-    namespace {
-        std::string to_utf8(std::wstring const& x)
-        {
-            int buffer_count = WideCharToMultiByte(CP_UTF8, 0, x.c_str(), -1, 0, 0, 0, 0); 
-        
-            if (!buffer_count)
-                throw conversion_error("Error converting wide string to utf-8.");
-    
-            boost::scoped_ptr<char> buffer(new char[buffer_count]);
-    
-            if (!WideCharToMultiByte(CP_UTF8, 0, x.c_str(), -1, buffer.get(), buffer_count, 0, 0))
-                throw conversion_error("Error converting wide string to utf-8.");
-            
-            return std::string(buffer.get());
-        }
-
-        std::wstring from_utf8(boost::string_ref text)
-        {
-            std::string x(text.begin(), text.end());
-            int buffer_count = MultiByteToWideChar(CP_UTF8, 0, x.c_str(), -1, 0, 0); 
-        
-            if (!buffer_count)
-                throw conversion_error("Error converting utf-8 to wide string.");
-    
-            boost::scoped_ptr<wchar_t> buffer(new wchar_t[buffer_count]);
-    
-            if (!MultiByteToWideChar(CP_UTF8, 0, x.c_str(), -1, buffer.get(), buffer_count))
-                throw conversion_error("Error converting utf-8 to wide string.");
-            
-            return std::wstring(buffer.get());
-        }
-    }
-#endif
-
-#if QUICKBOOK_WIDE_PATHS
-    std::string command_line_to_utf8(command_line_string const& x)
+    std::string to_utf8(std::wstring const& x)
     {
-        return to_utf8(x);
-    }
-#else
-    std::string command_line_to_utf8(command_line_string const& x)
-    {
-        return x;
-    }
-#endif
-
-#if QUICKBOOK_WIDE_PATHS
-    fs::path generic_to_path(boost::string_ref x)
-    {
-        return fs::path(from_utf8(x));
-    }
-
-    std::string path_to_generic(fs::path const& x)
-    {
-        return to_utf8(x.generic_wstring());
-    }
-#else
-    fs::path generic_to_path(boost::string_ref x)
-    {
-        return fs::path(x.begin(), x.end());
-    }
-
-    std::string path_to_generic(fs::path const& x)
-    {
-        return x.generic_string();
-    }
-
-#endif
-
-
-#if QUICKBOOK_CYGWIN_PATHS
-    fs::path command_line_to_path(command_line_string const& path)
-    {
-        cygwin_conv_path_t flags = CCP_POSIX_TO_WIN_W | CCP_RELATIVE;
-
-        ssize_t size = cygwin_conv_path(flags, path.c_str(), NULL, 0);
-        
-        if (size < 0)
-            throw conversion_error("Error converting cygwin path to windows.");
-
-        boost::scoped_array<char> result(new char[size]);
-        void* ptr = result.get();
-
-        if(cygwin_conv_path(flags, path.c_str(), ptr, size))
-            throw conversion_error("Error converting cygwin path to windows.");
-
-        return fs::path(static_cast<wchar_t*>(ptr));
-    }
+        int buffer_count = WideCharToMultiByte(CP_UTF8, 0, x.c_str(), -1, 0, 0, 0, 0);
     
-    ostream::string path_to_stream(fs::path const& path)
-    {
-        cygwin_conv_path_t flags = CCP_WIN_W_TO_POSIX | CCP_RELATIVE;
-
-        ssize_t size = cygwin_conv_path(flags, path.native().c_str(), NULL, 0);
-        
-        if (size < 0)
-            throw conversion_error("Error converting windows path to cygwin.");
-
-        boost::scoped_array<char> result(new char[size]);
-
-        if(cygwin_conv_path(flags, path.native().c_str(), result.get(), size))
-            throw conversion_error("Error converting windows path to cygwin.");
-
-        return std::string(result.get());
-    }
-#else
-    fs::path command_line_to_path(command_line_string const& path)
-    {
-        return fs::path(path);
-    }
-
-#if QUICKBOOK_WIDE_PATHS && !QUICKBOOK_WIDE_STREAMS
-    ostream::string path_to_stream(fs::path const& path)
-    {
-        return path.string();
-    }
-#else
-    ostream::string path_to_stream(fs::path const& path)
-    {
-        return path.native();
-    }
-#endif
-
-#endif // QUICKBOOK_CYGWIN_PATHS
-
-#if QUICKBOOK_WIDE_STREAMS
-
-    void initialise_output()
-    {
-        if (_isatty(_fileno(stdout))) _setmode(_fileno(stdout), _O_U16TEXT);
-        if (_isatty(_fileno(stderr))) _setmode(_fileno(stderr), _O_U16TEXT);
-    }
-
-    void write_utf8(ostream::base_ostream& out, boost::string_ref x)
-    {
-        out << from_utf8(x);
-    }
-
-    ostream& out()
-    {
-        static ostream x(std::wcout);
-        return x;
-    }
-
-    namespace
-    {
-        inline ostream& error_stream()
-        {
-            static ostream x(std::wcerr);
-            return x;
-        }
-    }
-
-#else
-
-    void initialise_output()
-    {
-    }
+        if (!buffer_count)
+            throw conversion_error("Error converting wide string to utf-8.");
 
-    void write_utf8(ostream::base_ostream& out, boost::string_ref x)
-    {
-        out << x;
-    }
+        boost::scoped_ptr<char> buffer(new char[buffer_count]);
 
-    ostream& out()
-    {
-        static ostream x(std::cout);
-        return x;
-    }
-
-    namespace
-    {
-        inline ostream& error_stream()
-        {
-            static ostream x(std::clog);
-            return x;
-        }
-    }
-
-#endif
-
-    ostream& outerr()
-    {
-        return error_stream() << "Error: ";
-    }
-
-    ostream& outerr(fs::path const& file, int line)
-    {
-        if (line >= 0)
-        {
-            if (ms_errors)
-                return error_stream() << path_to_stream(file) << "(" << line << "): error: ";
-            else
-                return error_stream() << path_to_stream(file) << ":" << line << ": error: ";
-        }
-        else
-        {
-            return error_stream() << path_to_stream(file) << ": error: ";
-        }
-    }
-
-    ostream& outerr(file_ptr const& f, string_iterator pos)
-    {
-        return outerr(f->path, f->position_of(pos).line);
-    }
-
-    ostream& outwarn(fs::path const& file, int line)
-    {
-        if (line >= 0)
-        {
-            if (ms_errors)
-                return error_stream() << path_to_stream(file) << "(" << line << "): warning: ";
-            else
-                return error_stream() << path_to_stream(file) << ":" << line << ": warning: ";
-        }
-        else
-        {
-            return error_stream() << path_to_stream(file) << ": warning: ";
-        }
+        if (!WideCharToMultiByte(CP_UTF8, 0, x.c_str(), -1, buffer.get(), buffer_count, 0, 0))
+            throw conversion_error("Error converting wide string to utf-8.");
+        
+        return std::string(buffer.get());
     }
 
-    ostream& outwarn(file_ptr const& f, string_iterator pos)
+    std::wstring from_utf8(quickbook::string_view text)
     {
-        return outwarn(f->path, f->position_of(pos).line);
-    }
-
-    ostream& ostream::operator<<(char c) {
-        assert(c > 0 && c <= 127);
-        base << c;
-        return *this;
-    }
-
-    inline bool check_ascii(char const* x) {
-        for(;*x;++x) if(*x <= 0 || *x > 127) return false;
-        return true;
-    }
-
-    ostream& ostream::operator<<(char const* x) {
-        assert(check_ascii(x));
-        base << x;
-        return *this;
-    }
-
-    ostream& ostream::operator<<(std::string const& x) {
-        write_utf8(base, x);
-        return *this;
-    }
-
-    ostream& ostream::operator<<(boost::string_ref x) {
-        write_utf8(base, x);
-        return *this;
-    }
-
-    ostream& ostream::operator<<(int x) {
-        base << x;
-        return *this;
-    }
-
-    ostream& ostream::operator<<(unsigned int x) {
-        base << x;
-        return *this;
-    }
+        std::string x(text.begin(), text.end());
+        int buffer_count = MultiByteToWideChar(CP_UTF8, 0, x.c_str(), -1, 0, 0);
+    
+        if (!buffer_count)
+            throw conversion_error("Error converting utf-8 to wide string.");
 
-    ostream& ostream::operator<<(long x) {
-        base << x;
-        return *this;
-    }
+        boost::scoped_ptr<wchar_t> buffer(new wchar_t[buffer_count]);
 
-    ostream& ostream::operator<<(unsigned long x) {
-        base << x;
-        return *this;
-    }
+        if (!MultiByteToWideChar(CP_UTF8, 0, x.c_str(), -1, buffer.get(), buffer_count))
+            throw conversion_error("Error converting utf-8 to wide string.");
 
-#if !defined(BOOST_NO_LONG_LONG)
-    ostream& ostream::operator<<(long long x) {
-        base << x;
-        return *this;
-    }
-
-    ostream& ostream::operator<<(unsigned long long x) {
-        base << x;
-        return *this;
+        return std::wstring(buffer.get());
     }
 #endif
-
-    ostream& ostream::operator<<(fs::path const& x) {
-        base << path_to_stream(x);
-        return *this;
-    }
-
-    ostream& ostream::operator<<(base_ostream& (*x)(base_ostream&)) {
-        base << x;
-        return *this;
-    }
-
-    ostream& ostream::operator<<(base_ios& (*x)(base_ios&)) {
-        base << x;
-        return *this;
-    }
 }}