Blame view

3rdparty/boost_1_81_0/boost/leaf/common.hpp 2.86 KB
63e88f80   Hu Chunming   提交三方库
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
  #ifndef BOOST_LEAF_COMMON_HPP_INCLUDED
  #define BOOST_LEAF_COMMON_HPP_INCLUDED
  
  // Copyright 2018-2022 Emil Dotchevski and Reverge Studios, Inc.
  
  // Distributed under the Boost Software License, Version 1.0. (See accompanying
  // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  
  #include <boost/leaf/config.hpp>
  #include <boost/leaf/detail/demangle.hpp>
  
  #include <iosfwd>
  #if BOOST_LEAF_CFG_STD_STRING
  #   include <string>
  #endif
  #include <cerrno>
  #if BOOST_LEAF_CFG_WIN32
  #   include <windows.h>
  #   include <cstring>
  #   ifdef min
  #       undef min
  #   endif
  #   ifdef max
  #       undef max
  #   endif
  #endif
  
  namespace boost { namespace leaf {
  
  struct BOOST_LEAF_SYMBOL_VISIBLE e_api_function { char const * value; };
  
  #if BOOST_LEAF_CFG_STD_STRING
  
  struct BOOST_LEAF_SYMBOL_VISIBLE e_file_name
  {
      std::string value;
  };
  
  #else
  
  struct BOOST_LEAF_SYMBOL_VISIBLE e_file_name
  {
      constexpr static char const * const value = "<unavailable>";
      BOOST_LEAF_CONSTEXPR explicit e_file_name( char const * ) { }
  };
  
  #endif
  
  struct BOOST_LEAF_SYMBOL_VISIBLE e_errno
  {
      int value;
  
      explicit e_errno(int val=errno): value(val) { }
  
      template <class CharT, class Traits>
      friend std::basic_ostream<CharT, Traits> & operator<<(std::basic_ostream<CharT, Traits> & os, e_errno const & err)
      {
          return os << type<e_errno>() << ": " << err.value << ", \"" << std::strerror(err.value) << '"';
      }
  };
  
  struct BOOST_LEAF_SYMBOL_VISIBLE e_type_info_name { char const * value; };
  
  struct BOOST_LEAF_SYMBOL_VISIBLE e_at_line { int value; };
  
  namespace windows
  {
      struct e_LastError
      {
          unsigned value;
  
          explicit e_LastError(unsigned val): value(val) { }
  
  #if BOOST_LEAF_CFG_WIN32
          e_LastError(): value(GetLastError()) { }
  
          template <class CharT, class Traits>
          friend std::basic_ostream<CharT, Traits> & operator<<(std::basic_ostream<CharT, Traits> & os, e_LastError const & err)
          {
              struct msg_buf
              {
                  LPVOID * p;
                  msg_buf(): p(nullptr) { }
                  ~msg_buf() noexcept { if(p) LocalFree(p); }
              };
              msg_buf mb;
              if( FormatMessageA(
                  FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
                  nullptr,
                  err.value,
                  MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),
                  (LPSTR)&mb.p,
                  0,
                  nullptr) )
              {
                  BOOST_LEAF_ASSERT(mb.p != nullptr);
                  char * z = std::strchr((LPSTR)mb.p,0);
                  if( z[-1] == '\n' )
                      *--z = 0;
                  if( z[-1] == '\r' )
                      *--z = 0;
                  return os << type<e_LastError>() << ": " << err.value << ", \"" << (LPCSTR)mb.p << '"';
              }
              return os;
          }
  #endif
      };
  }
  
  } }
  
  #endif