This is an archive of the discontinued LLVM Phabricator instance.

Differential D27267

[libcxx] [test] Fix MSVC x64 warning C4267 "conversion from 'size_t' to 'int' [or 'unsigned int'], possible loss of data", part 1/4.
ClosedPublic

Authored by STL_MSFT on Nov 30 2016, 10:02 AM.

Details

Reviewers
mclow.lists
EricWF
Summary

[libcxx] [test] Fix MSVC x64 warning C4267 "conversion from 'size_t' to 'int' [or 'unsigned int'], possible loss of data", part 1/4.

Replace "int n = str_.size();" with "int n = static_cast<int>(str_.size());".

int is the correct type to use, because we're eventually calling
"base::pbump(n+1);" where base is std::basic_streambuf.
N4606 27.6.3.3.3 [streambuf.put.area]/4 declares: "void pbump(int n);"

Diff Detail

Event Timeline

STL_MSFT updated this revision to Diff 79772.Nov 30 2016, 10:02 AM
STL_MSFT retitled this revision from to [libcxx] [test] Fix MSVC x64 warning C4267 "conversion from 'size_t' to 'int' [or 'unsigned int'], possible loss of data", part 1/4..
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 TranscriptNov 30 2016, 10:02 AM
EricWF accepted this revision.Dec 2 2016, 11:42 PM
EricWF edited edge metadata.

LGTM.

Random thought: It would be nice for C++ to have a non_truncating_cast<T>(value) which generated an error when the conversion performs a truncation. This seems like the behavior we want for most of these changes, since the cast *shouldn't* truncate.

This revision is now accepted and ready to land.Dec 2 2016, 11:42 PM
STL_MSFT mentioned this in rL288751: [libcxx] [test] D27267: Fix MSVC x64 warning C4267 "conversion from 'size_t' to….Dec 5 2016, 5:24 PM
STL_MSFT closed this revision.Dec 5 2016, 5:28 PM

Thanks, r288751.

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
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 79772

test/std/input.output/iostream.format/ext.manip/put_time.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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 36 Lines

test/std/input.output/iostream.format/input.streams/istream.unformatted/get_streambuf.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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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_chart.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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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/output.streams/ostream.formatted/ostream.inserters.arithmetic/bool.pass.cpp

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 42 Lines • Show Last 20 Lines

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

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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/float.pass.cpp

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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/int.pass.cpp

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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/long.pass.cpp

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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/long_double.pass.cpp

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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/long_long.pass.cpp

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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/pointer.pass.cpp

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 42 Lines • Show Last 20 Lines

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

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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/unsigned_int.pass.cpp

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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/unsigned_long.pass.cpp

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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/unsigned_long_long.pass.cpp

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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/unsigned_short.pass.cpp

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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.character/CharT.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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 38 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/CharT_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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 38 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char.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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 38 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 38 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide.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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 38 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/char_to_wide_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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 38 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char.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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 38 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/signed_char_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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 38 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char.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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 38 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.character/unsigned_char_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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 38 Lines

test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters/basic_ios.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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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.formatted/ostream.inserters/ios_base.pass.cpp

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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.formatted/ostream.inserters/ostream.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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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/streambuf.pass.cpp

Show All 39 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 13 Lines

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

Show All 35 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 28 Lines

test/std/input.output/iostream.format/output.streams/ostream.manip/ends.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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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 21 Lines

test/std/input.output/iostream.format/output.streams/ostream.rvalue/CharT_pointer.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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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.unformatted/put.pass.cpp

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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.unformatted/write.pass.cpp

Show All 32 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 = str_.size(); int n = static_cast<int>(str_.size());
str_.push_back(__c); str_.push_back(__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