1 // Input streams operating on strings-*- C++ -*- 2 3 // Copyright (C) 2004-2018 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 // 26 // ISO C++ 14882: 27.6.1 Input streams 27 // 28 29 #ifndef _GLIBCXX_USE_CXX11_ABI 30 // Instantiations in this file use the new SSO std::string ABI unless included 31 // by another file which defines _GLIBCXX_USE_CXX11_ABI=0. 32 # define _GLIBCXX_USE_CXX11_ABI 1 33 #endif 34 #include <istream> 35 #include <string> 36 37 namespace std _GLIBCXX_VISIBILITY(default) 38 { 39 _GLIBCXX_BEGIN_NAMESPACE_VERSION 40 41 template<> 42 basic_istream<char>& operator >>(basic_istream<char> & __in,basic_string<char> & __str)43 operator>>(basic_istream<char>& __in, basic_string<char>& __str) 44 { 45 typedef basic_istream<char> __istream_type; 46 typedef __istream_type::int_type __int_type; 47 typedef __istream_type::traits_type __traits_type; 48 typedef __istream_type::__streambuf_type __streambuf_type; 49 typedef __istream_type::__ctype_type __ctype_type; 50 typedef basic_string<char> __string_type; 51 typedef __string_type::size_type __size_type; 52 53 __size_type __extracted = 0; 54 ios_base::iostate __err = ios_base::goodbit; 55 __istream_type::sentry __cerb(__in, false); 56 if (__cerb) 57 { 58 __try 59 { 60 __str.erase(); 61 const streamsize __w = __in.width(); 62 const __size_type __n = __w > 0 ? static_cast<__size_type>(__w) 63 : __str.max_size(); 64 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); 65 const __int_type __eof = __traits_type::eof(); 66 __streambuf_type* __sb = __in.rdbuf(); 67 __int_type __c = __sb->sgetc(); 68 69 while (__extracted < __n 70 && !__traits_type::eq_int_type(__c, __eof) 71 && !__ct.is(ctype_base::space, 72 __traits_type::to_char_type(__c))) 73 { 74 streamsize __size = std::min(streamsize(__sb->egptr() 75 - __sb->gptr()), 76 streamsize(__n - __extracted)); 77 if (__size > 1) 78 { 79 __size = (__ct.scan_is(ctype_base::space, 80 __sb->gptr() + 1, 81 __sb->gptr() + __size) 82 - __sb->gptr()); 83 __str.append(__sb->gptr(), __size); 84 __sb->__safe_gbump(__size); 85 __extracted += __size; 86 __c = __sb->sgetc(); 87 } 88 else 89 { 90 __str += __traits_type::to_char_type(__c); 91 ++__extracted; 92 __c = __sb->snextc(); 93 } 94 } 95 96 if (__traits_type::eq_int_type(__c, __eof)) 97 __err |= ios_base::eofbit; 98 __in.width(0); 99 } 100 __catch(__cxxabiv1::__forced_unwind&) 101 { 102 __in._M_setstate(ios_base::badbit); 103 __throw_exception_again; 104 } 105 __catch(...) 106 { 107 // _GLIBCXX_RESOLVE_LIB_DEFECTS 108 // 91. Description of operator>> and getline() for string<> 109 // might cause endless loop 110 __in._M_setstate(ios_base::badbit); 111 } 112 } 113 if (!__extracted) 114 __err |= ios_base::failbit; 115 if (__err) 116 __in.setstate(__err); 117 return __in; 118 } 119 120 template<> 121 basic_istream<char>& getline(basic_istream<char> & __in,basic_string<char> & __str,char __delim)122 getline(basic_istream<char>& __in, basic_string<char>& __str, 123 char __delim) 124 { 125 typedef basic_istream<char> __istream_type; 126 typedef __istream_type::int_type __int_type; 127 typedef __istream_type::char_type __char_type; 128 typedef __istream_type::traits_type __traits_type; 129 typedef __istream_type::__streambuf_type __streambuf_type; 130 typedef basic_string<char> __string_type; 131 typedef __string_type::size_type __size_type; 132 133 __size_type __extracted = 0; 134 const __size_type __n = __str.max_size(); 135 ios_base::iostate __err = ios_base::goodbit; 136 __istream_type::sentry __cerb(__in, true); 137 if (__cerb) 138 { 139 __try 140 { 141 __str.erase(); 142 const __int_type __idelim = __traits_type::to_int_type(__delim); 143 const __int_type __eof = __traits_type::eof(); 144 __streambuf_type* __sb = __in.rdbuf(); 145 __int_type __c = __sb->sgetc(); 146 147 while (__extracted < __n 148 && !__traits_type::eq_int_type(__c, __eof) 149 && !__traits_type::eq_int_type(__c, __idelim)) 150 { 151 streamsize __size = std::min(streamsize(__sb->egptr() 152 - __sb->gptr()), 153 streamsize(__n - __extracted)); 154 if (__size > 1) 155 { 156 const __char_type* __p = __traits_type::find(__sb->gptr(), 157 __size, 158 __delim); 159 if (__p) 160 __size = __p - __sb->gptr(); 161 __str.append(__sb->gptr(), __size); 162 __sb->__safe_gbump(__size); 163 __extracted += __size; 164 __c = __sb->sgetc(); 165 } 166 else 167 { 168 __str += __traits_type::to_char_type(__c); 169 ++__extracted; 170 __c = __sb->snextc(); 171 } 172 } 173 174 if (__traits_type::eq_int_type(__c, __eof)) 175 __err |= ios_base::eofbit; 176 else if (__traits_type::eq_int_type(__c, __idelim)) 177 { 178 ++__extracted; 179 __sb->sbumpc(); 180 } 181 else 182 __err |= ios_base::failbit; 183 } 184 __catch(__cxxabiv1::__forced_unwind&) 185 { 186 __in._M_setstate(ios_base::badbit); 187 __throw_exception_again; 188 } 189 __catch(...) 190 { 191 // _GLIBCXX_RESOLVE_LIB_DEFECTS 192 // 91. Description of operator>> and getline() for string<> 193 // might cause endless loop 194 __in._M_setstate(ios_base::badbit); 195 } 196 } 197 if (!__extracted) 198 __err |= ios_base::failbit; 199 if (__err) 200 __in.setstate(__err); 201 return __in; 202 } 203 204 #ifdef _GLIBCXX_USE_WCHAR_T 205 template<> 206 basic_istream<wchar_t>& getline(basic_istream<wchar_t> & __in,basic_string<wchar_t> & __str,wchar_t __delim)207 getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str, 208 wchar_t __delim) 209 { 210 typedef basic_istream<wchar_t> __istream_type; 211 typedef __istream_type::int_type __int_type; 212 typedef __istream_type::char_type __char_type; 213 typedef __istream_type::traits_type __traits_type; 214 typedef __istream_type::__streambuf_type __streambuf_type; 215 typedef basic_string<wchar_t> __string_type; 216 typedef __string_type::size_type __size_type; 217 218 __size_type __extracted = 0; 219 const __size_type __n = __str.max_size(); 220 ios_base::iostate __err = ios_base::goodbit; 221 __istream_type::sentry __cerb(__in, true); 222 if (__cerb) 223 { 224 __try 225 { 226 __str.erase(); 227 const __int_type __idelim = __traits_type::to_int_type(__delim); 228 const __int_type __eof = __traits_type::eof(); 229 __streambuf_type* __sb = __in.rdbuf(); 230 __int_type __c = __sb->sgetc(); 231 232 while (__extracted < __n 233 && !__traits_type::eq_int_type(__c, __eof) 234 && !__traits_type::eq_int_type(__c, __idelim)) 235 { 236 streamsize __size = std::min(streamsize(__sb->egptr() 237 - __sb->gptr()), 238 streamsize(__n - __extracted)); 239 if (__size > 1) 240 { 241 const __char_type* __p = __traits_type::find(__sb->gptr(), 242 __size, 243 __delim); 244 if (__p) 245 __size = __p - __sb->gptr(); 246 __str.append(__sb->gptr(), __size); 247 __sb->__safe_gbump(__size); 248 __extracted += __size; 249 __c = __sb->sgetc(); 250 } 251 else 252 { 253 __str += __traits_type::to_char_type(__c); 254 ++__extracted; 255 __c = __sb->snextc(); 256 } 257 } 258 259 if (__traits_type::eq_int_type(__c, __eof)) 260 __err |= ios_base::eofbit; 261 else if (__traits_type::eq_int_type(__c, __idelim)) 262 { 263 ++__extracted; 264 __sb->sbumpc(); 265 } 266 else 267 __err |= ios_base::failbit; 268 } 269 __catch(__cxxabiv1::__forced_unwind&) 270 { 271 __in._M_setstate(ios_base::badbit); 272 __throw_exception_again; 273 } 274 __catch(...) 275 { 276 // _GLIBCXX_RESOLVE_LIB_DEFECTS 277 // 91. Description of operator>> and getline() for string<> 278 // might cause endless loop 279 __in._M_setstate(ios_base::badbit); 280 } 281 } 282 if (!__extracted) 283 __err |= ios_base::failbit; 284 if (__err) 285 __in.setstate(__err); 286 return __in; 287 } 288 #endif 289 290 _GLIBCXX_END_NAMESPACE_VERSION 291 } // namespace 292