This is an archive of the discontinued LLVM Phabricator instance.

Differential D27538

[libcxx] [test] Fix MSVC warning C4244 "conversion from 'X' to 'Y', possible loss of data", part 1/7.
ClosedPublic

Authored by STL_MSFT on Dec 7 2016, 1:59 PM.

Details

Reviewers
mclow.lists
EricWF
Summary

[libcxx] [test] Fix MSVC warning C4244 "conversion from 'X' to 'Y', possible loss of data", part 1/7.

Given std::basic_streambuf<CharT>::int_type __c, std::basic_string<CharT> str_,
and having checked __c != std::basic_streambuf<CharT>::traits_type::eof() (substituting typedefs
for clarity), the line str_.push_back(__c); is safe according to humans, but truncates according
to compilers. str_.push_back(static_cast<CharT>(__c)); avoids that problem.

Diff Detail

Event Timeline

STL_MSFT updated this revision to Diff 80652.Dec 7 2016, 1:59 PM
STL_MSFT retitled this revision from to [libcxx] [test] Fix MSVC warning C4244 "conversion from 'X' to 'Y', possible loss of data", part 1/7..
STL_MSFT updated this object.
STL_MSFT added reviewers: EricWF, mclow.lists.
STL_MSFT added a subscriber: cfe-commits.
Herald edited edge metadata. · View Herald TranscriptDec 7 2016, 1:59 PM
EricWF accepted this revision.Dec 7 2016, 10:58 PM
EricWF edited edge metadata.
This revision is now accepted and ready to land.Dec 7 2016, 10:58 PM
STL_MSFT mentioned this in rL289105: [libcxx] [test] Fix MSVC warning C4244 "conversion from 'X' to 'Y', possible….Dec 8 2016, 1:48 PM
STL_MSFT closed this revision.Dec 8 2016, 1:57 PM

Revision Contents

PathSize
test/
std/
input.output/
iostream.format/
ext.manip/
2 lines
input.streams/
istream.unformatted/
2 lines
2 lines
output.streams/
ostream.formatted/
ostream.inserters.arithmetic/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ostream.inserters.character/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
ostream.inserters/
2 lines
2 lines
2 lines
2 lines
ostream.manip/
2 lines
2 lines
ostream.rvalue/
2 lines
ostream.unformatted/
2 lines
2 lines

Diff 80652

test/std/input.output/iostream.format/ext.manip/put_time.pass.cpp

Show All 34 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 35 Lines

test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.pass.cpp

Show All 37 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 34 Lines

test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf_chart.pass.cpp

Show All 38 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 34 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/double.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 33 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/float.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 33 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/int.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 33 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 33 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_double.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 33 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/long_long.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 33 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/short.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 33 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_int.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 33 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 33 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_long_long.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 33 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/unsigned_short.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 33 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.pass.cpp

Show All 34 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 37 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_pointer.pass.cpp

Show All 34 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 37 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.pass.cpp

Show All 34 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 37 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_pointer.pass.cpp

Show All 34 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 37 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.pass.cpp

Show All 34 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 37 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_pointer.pass.cpp

Show All 34 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 37 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.pass.cpp

Show All 34 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 19 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ios_base.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 11 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/ostream.pass.cpp

Show All 34 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 18 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/streambuf.pass.cpp

Show All 40 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 12 Lines

test/std/input.output/iostream.format/output.streams/ostream.manip/endl.pass.cpp

Show All 36 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
Show All 27 Lines

test/std/input.output/iostream.format/output.streams/ostream.manip/ends.pass.cpp

Show All 34 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 20 Lines

test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.pass.cpp

Show All 37 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 18 Lines

test/std/input.output/iostream.format/output.streams/ostream.unformatted/put.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 26 Lines

test/std/input.output/iostream.format/output.streams/ostream.unformatted/write.pass.cpp

Show All 33 Lines
protected: protected:
virtual typename base::int_type virtual typename base::int_type
overflow(typename base::int_type __c = base::traits_type::eof()) overflow(typename base::int_type __c = base::traits_type::eof())
{ {
if (__c != base::traits_type::eof()) if (__c != base::traits_type::eof())
{ {
int n = static_cast<int>(str_.size()); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(static_cast<CharT>(__c));
str_.resize(str_.capacity()); str_.resize(str_.capacity());
base::setp(const_cast<CharT*>(str_.data()), base::setp(const_cast<CharT*>(str_.data()),
const_cast<CharT*>(str_.data() + str_.size())); const_cast<CharT*>(str_.data() + str_.size()));
base::pbump(n+1); base::pbump(n+1);
} }
return __c; return __c;
} }
}; };
Show All 26 Lines