/**
* \brief Print RTL to a stream.
*
* Prints this object to a stream in text form.
*
* \param os Stream to output to (often cout or cerr).
*/
void
RTL::print(std::ostream &os /*= cout*/, bool html /*=false*/) const
{
if (html)
os << "<tr><td>";
// print out the instruction address of this RTL
auto fill = os.fill('0');
os << std::hex << std::setw(8) << nativeAddr << std::dec;
os.fill(fill);
if (html)
os << "</td>";
// Print the statements
// First line has 8 extra chars as above
bool bFirst = true;
for (const auto &stmt : stmtList) {
if (html) {
if (!bFirst) os << "<tr><td></td>";
} else {
if (bFirst) os << " ";
else os << std::setw(9) << " ";
}
if (stmt) stmt->print(os, html);
// Note: we only put newlines where needed. So none at the end of
// Statement::print; one here to separate from other statements
if (html)
os << "</tr>";
os << "\n";
bFirst = false;
}
if (stmtList.empty()) os << std::endl; // New line for NOP
}
static inline void formatGdbmiChar(std::ostream &str, wchar_t c)
{
switch (c) {
case L'\n':
str << "\\n";
break;
case L'\t':
str << "\\t";
break;
case L'\r':
str << "\\r";
break;
case L'\\':
case L'"':
str << '\\' << char(c);
break;
default:
if (c < 128) {
str << char(c);
} else {
// Always pad up to 3 digits in case a digit follows
const char oldFill = str.fill('0');
str << '\\' << std::oct;
str.width(3);
str << unsigned(c) << std::dec;
str.fill(oldFill);
}
break;
}
}
void Date::print(std::ostream& out) const {
auto ch = out.fill('0');
out << std::setw(2) << day << '.';
out << std::setw(2) << month << '.';
out << std::setw(4) << year;
out.fill(ch);
}
BOOL LLPermissions::exportStream(std::ostream& output_stream) const
{
if (!output_stream.good()) return FALSE;
output_stream << "\tpermissions 0\n";
output_stream << "\t{\n";
char prev_fill = output_stream.fill('0');
output_stream << std::hex;
output_stream << "\t\tbase_mask\t" << std::setw(8) << mMaskBase << "\n";
output_stream << "\t\towner_mask\t" << std::setw(8) << mMaskOwner << "\n";
output_stream << "\t\tgroup_mask\t" << std::setw(8) << mMaskGroup << "\n";
output_stream << "\t\teveryone_mask\t" << std::setw(8) << mMaskEveryone << "\n";
output_stream << "\t\tnext_owner_mask\t" << std::setw(8) << mMaskNextOwner << "\n";
output_stream << std::dec;
output_stream.fill(prev_fill);
output_stream << "\t\tcreator_id\t" << mCreator << "\n";
output_stream << "\t\towner_id\t" << mOwner << "\n";
output_stream << "\t\tlast_owner_id\t" << mLastOwner << "\n";
output_stream << "\t\tgroup_id\t" << mGroup << "\n";
if(mIsGroupOwned)
{
output_stream << "\t\tgroup_owned\t1\n";
}
output_stream << "\t}\n";
return TRUE;
}
void print128(std::ostream& out, uint8* data)
{
out.fill('0');
out << std::hex;
for(int i = 15; i >= 0; --i) {
out.width(2);
out << int(data[i]);
}
out.fill(' ');
out << std::dec;
}
// Format a 128bit vector register by adding digits in reverse order
void formatVectorRegister(std::ostream &str, const unsigned char *array, int size)
{
const char oldFill = str.fill('0');
str << "0x" << std::hex;
for (int i = size - 1; i >= 0; i--) {
str.width(2);
str << unsigned(array[i]);
}
str << std::dec;
str.fill(oldFill);
}
void ILogger::WriteTag(std::ostream& theOstream, SeverityType theSeverity,
const char* theSourceFile, int theSourceLine)
{
const struct std::tm* anTm; // Pointer to Time structure
std::time_t anNow;
// Get current time in seconds since Jan 1, 1970
anNow = std::time(NULL);
// Convert current time value into local time (with help from OS)
anTm = std::localtime(&anNow);
// Output time in timestamp format
theOstream << anTm->tm_year + 1900 << "-";
theOstream.fill('0');
theOstream.width(2);
theOstream << anTm->tm_mon + 1 << "-";
theOstream.fill('0');
theOstream.width(2);
theOstream << anTm->tm_mday << " ";
theOstream.fill('0');
theOstream.width(2);
theOstream << anTm->tm_hour + 1 << ":";
theOstream.fill('0');
theOstream.width(2);
theOstream << anTm->tm_min << ":";
theOstream.fill('0');
theOstream.width(2);
theOstream << anTm->tm_sec << " ";
// Now print the log level as a single character
switch(theSeverity)
{
case SeverityInfo:
theOstream << "I";
break;
case SeverityWarning:
theOstream << "W";
break;
case SeverityError:
theOstream << "E";
break;
case SeverityFatal:
theOstream << "F";
break;
default:
theOstream << "U";
break;
}
theOstream << " " << theSourceFile << ":" << theSourceLine << " ";
}
void PrintRealDateTime(std::ostream& os, int64_t tm,
bool ignore_microseconds) {
char buf[32];
const time_t tm_s = tm / 1000000L;
struct tm lt;
strftime(buf, sizeof(buf), "%Y/%m/%d-%H:%M:%S", localtime_r(&tm_s, <));
if (ignore_microseconds) {
os << buf;
} else {
const char old_fill = os.fill('0');
os << buf << '.' << std::setw(6) << tm % 1000000L;
os.fill(old_fill);
}
}
void
FormattedTable::printNoDataRow(char intersect_char, char fill_char,
std::ostream & out, std::map<std::string, unsigned short> & col_widths,
std::set<std::string>::iterator & col_begin, std::set<std::string>::iterator & col_end) const
{
out.fill(fill_char);
out << std::right << intersect_char << std::setw(_column_width+2) << intersect_char;
for (std::set<std::string>::iterator header = col_begin; header != col_end; ++header)
out << std::setw(col_widths[*header]+2) << intersect_char;
out << "\n";
// Clear the fill character
out.fill(' ');
}
void StackFrame::Print(std::ostream &stream) const {
char old_fill = stream.fill('0');
stream << std::hex << std::setw(8)
<< reinterpret_cast<long>(return_address_)
<< std::dec;
stream.fill(old_fill);
if (!callee_name_.empty()) {
stream << " in " << callee_name_ << " ()";
} else {
stream << " in ?? ()";
}
}
// printAlignedFP - Simulate the printf "%A.Bf" format, where A is the
// TotalWidth size, and B is the AfterDec size.
//
static void printAlignedFP(double Val, unsigned AfterDec, unsigned TotalWidth,
std::ostream &OS) {
assert(TotalWidth >= AfterDec+1 && "Bad FP Format!");
OS.width(TotalWidth-AfterDec-1);
char OldFill = OS.fill();
OS.fill(' ');
OS << (int)Val; // Integer part;
OS << ".";
OS.width(AfterDec);
OS.fill('0');
unsigned ResultFieldSize = 1;
while (AfterDec--) ResultFieldSize *= 10;
OS << (int)(Val*ResultFieldSize) % ResultFieldSize;
OS.fill(OldFill);
}
void hexDump(std::ostream &o,void const *v,uint cb,uint cbDone)
{
boost::io::ios_all_saver streamStateSaver(o);
PConstBuffer b = (PConstBuffer) v;
uint cbLine = 16, cbThis;
o.fill('0');
for (; cb; cb -= cbThis, cbDone += cbThis) {
cbThis = std::min(cbLine, cb);
o << std::hex;
o.width(4);
o << cbDone << ": ";
uint i;
for (i = 0; i < cbThis; i++, b++) {
o.width(2);
o << (uint) *b << " ";
}
for (i = cbThis; i < cbLine; i++) {
o << " ";
}
o << "| ";
for (i = 0, b -= cbThis; i < cbThis; i++, b++) {
if (isprint(*b)) {
o << *b;
} else {
o << " ";
}
}
o << std::endl;
}
}
void print_in_readelf_style(std::ostream& s, const core::Cie& cie)
{
// first line is section-offset, length-not-including-length-field, zeroes, "CIE"
s.width(8);
s.fill('0');
s << setw(8) << setfill('0') << std::hex << cie.get_offset()
<< ' '
<< setw(16) << setfill('0') << std::hex << cie.get_bytes_in_cie()
<< ' '
<< setw(8) << setfill('0') << 0 << std::dec
<< " CIE"
<< endl;
// cie fields come next
s << " Version: " << (int) cie.get_version() << endl
<< " Augmentation: \"" << cie.get_augmenter() << "\"" << endl
<< " Code alignment factor: " << cie.get_code_alignment_factor() << endl
<< " Data alignment factor: " << cie.get_data_alignment_factor() << endl
<< " Return address column: " << cie.get_return_address_register_rule() << endl
<< " Augmentation data: ";
auto augbytes = cie.get_augmentation_bytes();
for (auto i_byte = augbytes.begin(); i_byte != augbytes.end(); ++i_byte)
{
if (i_byte != augbytes.begin()) s << ' ';
s << std::hex << setw(2) << setfill('0') << (unsigned) *i_byte;
}
s << std::dec << endl;
s << endl;
/* Now we need to print the "initial instructions". */
encap::frame_instrlist initial_instrs(cie, /* FIXME */ 8, cie.initial_instructions_seq());
print_in_readelf_style(s, initial_instrs, -1);
}
void generate_source_font_data(std::ostream& os, const txtvc::bfgfont& font,
const std::string& font_data_identifier)
{
const int bytes_per_line = 8;
const boost::io::ios_fill_saver fill_saver(os);
const boost::io::ios_width_saver width_saver(os);
const boost::io::ios_flags_saver flags_saver(os);
// Dump font data
os << "static const uint8_t " << font_data_identifier << "[] =" << std::endl;
os << "{" << std::endl;
os << std::hex;
os.fill('0');
int count = 0;
for (auto byte : font.data())
{
if (count % bytes_per_line == 0)
{
os << indent;
}
os << "0x" << std::setw(2) << int(byte) << ", ";
if (count % bytes_per_line == bytes_per_line - 1)
{
os << std::endl;
}
++count;
}
os << "};" << std::endl << std::endl;
}
size_t basic_fmt::check_command(std::ostream& formatter)
{
fmt_command cmd;
ostream_string_output output(formatter);
size_t cmd_pos = process_fmt(this->fmt_, this->pos_, cmd, output);
if( cmd_pos == (size_t)-1 )
throw format_exception("basic_fmt: too many actual arguments");
if( cmd.fill )
formatter.fill(cmd.fill);
if( cmd.width )
formatter.width(cmd.width);
if( cmd.precision )
formatter.precision(cmd.precision);
switch( cmd.command ) {
case 's':
case 'i':
case 'd':
std::dec(formatter);
break;
case 'x':
std::hex(formatter);
break;
default:
throw format_exception(fmt("basic_fmt: bad format command %s") % cmd.command);
}
return cmd_pos;
}
void Utils::DisplayTime( const timespec& disp, std::ostream& Cout)
{
Cout << disp.tv_sec << ".";
Cout.width(9);
Cout.fill('0');
Cout << disp.tv_nsec << " second(s)";
}
void print_in_readelf_style(std::ostream& s, const Cie& cie)
{
// first line is section-offset, length-not-including-length-field, zeroes, "CIE"
s.width(8);
s.fill('0');
s << setw(8) << setfill('0') << std::hex << cie.get_offset()
<< ' '
<< setw(16) << setfill('0') << std::hex << cie.get_bytes_in_cie()
<< ' '
<< setw(8) << setfill('0') << 0 << std::dec
<< " CIE "
<< "\"" << cie.get_augmenter() << "\" cf=" << cie.get_code_alignment_factor()
<< " df=" << cie.get_data_alignment_factor()
<< " ra=" << cie.get_return_address_register_rule() << endl;
/* Now we need to print the "initial instructions" in decoded form. */
auto result = cie.get_owner().interpret_instructions(
cie,
0,
cie.get_initial_instructions(),
cie.get_initial_instructions_length()
);
// encap::frame_instrlist initial_instrs(cie, /* FIXME */ 8, cie.initial_instructions_seq());
/* Add the unfinished row as if it were a real row. */
result.add_unfinished_row(/* HACK */ result.unfinished_row_addr + 1);
print_in_readelf_style(s, result, cie);
}
void print_in_readelf_style(std::ostream& s, const Fde& fde)
{
// auto decoded = decode_fde(dbg, fde);
// don't decode -- that's for -wF
// first line is section-offset, length-not-including-length-field, id, "FDE"
s.width(8);
s.fill('0');
s << setw(8) << setfill('0') << std::hex << fde.get_fde_offset()
<< ' '
<< setw(16) << setfill('0') << std::hex << fde.get_fde_byte_length()
<< ' '
<< setw(8) << setfill('0') << fde.get_id() << std::dec
<< " FDE cie="
<< setw(8) << setfill('0') << std::hex << fde.find_cie()->get_cie_offset()
<< " pc="
<< setw(16) << setfill('0') << std::hex << fde.get_low_pc()
<< ".."
<< setw(16) << setfill('0') << std::hex << (fde.get_low_pc() + fde.get_func_length())
<< endl;
/* Now we need to print the "initial instructions" in decoded form. */
auto result = fde.decode();
result.add_unfinished_row(fde.get_low_pc() + fde.get_func_length());
print_in_readelf_style(s, result, *fde.find_cie());
}
inline
arma_ostream_state::arma_ostream_state(const std::ostream& o)
: orig_flags (o.flags())
, orig_precision(o.precision())
, orig_width (o.width())
, orig_fill (o.fill())
{
}
void MatrixArchive::writeName(std::ostream & fout, std::string const & name) const
{
// fixed size character name
validateName(name, SM_SOURCE_FILE_POS);
fout.fill(' ');
fout.width(s_fixedNameSize);
fout << name;
}
void FileLogger::writeTag(std::ostream& outStream, SeverityType severity, const char* sourceFile, int sourceLine)
{
const struct std::tm* timeStruct;
std::time_t now;
now = std::time(nullptr);
timeStruct = std::localtime(&now);
outStream << timeStruct->tm_year + 1900 << "-";
outStream.fill('0');
outStream.width(2);
outStream << timeStruct->tm_mon + 1 << "-";
outStream.fill('0');
outStream.width(2);
outStream << timeStruct->tm_mday << " ";
outStream.fill('0');
outStream.width(2);
outStream << timeStruct->tm_hour + 1 << ":";
outStream.fill('0');
outStream.width(2);
outStream << timeStruct->tm_min << ":";
outStream.fill('0');
outStream.width(2);
outStream << timeStruct->tm_sec << " ";
switch(severity)
{
case SeverityInfo:
outStream << "Information :";
break;
case SeverityWarning:
outStream << "Warning :";
break;
case SeverityError:
outStream << "Error :";
break;
case SeverityFatal:
outStream << "Fatal error :";
break;
default:
outStream << "Unknown :";
break;
}
outStream << " " << sourceFile << " : line " << sourceLine << " ";
}
inline
void
arma_ostream_state::restore(std::ostream& o) const
{
o.flags (orig_flags);
o.precision(orig_precision);
o.width (orig_width);
o.fill (orig_fill);
}
void
printHex(std::ostream& os, const uint8_t* buffer, size_t length, bool isUpperCase/* = true*/)
{
if (buffer == nullptr || length == 0)
return;
auto newFlags = std::ios::hex;
if (isUpperCase) {
newFlags |= std::ios::uppercase;
}
auto oldFlags = os.flags(newFlags);
auto oldFill = os.fill('0');
for (size_t i = 0; i < length; ++i) {
os << std::setw(2) << static_cast<unsigned int>(buffer[i]);
}
os.fill(oldFill);
os.flags(oldFlags);
}
static void setPos(std::ostream& _os, const std::streamsize& _x, const std::streamsize& _y)
{
char tmp = _os.fill();
if (_y > 0)
{
_os.fill('\n');
_os.width(_y);
_os << '\n';
}
if (_x > 0)
{
_os.fill(' ');
_os.width(_x);
_os << ' ';
}
_os.flush();
_os.fill(tmp);
}
void printHeading( std::ostream& outs, std::string title, int width, char border_char )
{
printHorizontalLine( outs, border_char, width );
printCenteredTitle( outs, title, width);
printHorizontalLine( outs, border_char, width );
//reset outs
outs.clear();
outs.fill(' ');
}
void init_iosflags(std::ostream& ss, const PrintfSpec& spec) {
if (spec.width != -1)
ss.width(spec.width);
if (spec.precision != -1)
ss.precision(spec.precision);
if (spec.flags & PrintfSpec::AlignLeft)
ss.setf(std::ios::left, std::ios::adjustfield);
else {
if (spec.flags & PrintfSpec::PadZero)
ss.setf(std::ios::internal, std::ios::adjustfield);
else
ss.setf(std::ios::right, std::ios::adjustfield);
}
if (spec.flags & PrintfSpec::PadZero) ss.fill('0');
if (spec.flags & PrintfSpec::ForceSign) ss.setf(std::ios::showpos);
if (spec.flags & PrintfSpec::ShowType) {
ss.setf(std::ios::showpoint);
ss.setf(std::ios::showbase);
}
}
inline void print_byte(std::ostream& out, uint8_t x)
{
switch (x)
{
case 9: out << "\\t"; return;
case 10: out << "\\n"; return;
case 13: out << "\\r"; return;
case 92: out << "\\\\"; return;
}
if ((x >= 32) && (x <= 126))
{
out << char(x);
}
else
{
out << "\\x";
out.width(2);
out.fill('0');
out << std::hex << unsigned(x);
}
}
void print_in_readelf_style(std::ostream& s, const core::Fde& fde)
{
// auto decoded = decode_fde(dbg, fde);
// don't decode -- that's for -wF
// first line is section-offset, length-not-including-length-field, id, "FDE"
s.width(8);
s.fill('0');
s << setw(8) << setfill('0') << std::hex << fde.get_fde_offset()
<< ' '
<< setw(16) << setfill('0') << std::hex << fde.get_fde_byte_length()
<< ' '
<< setw(8) << setfill('0') << fde.get_id() << std::dec
<< " FDE cie="
<< setw(8) << setfill('0') << std::hex << fde.find_cie()->get_cie_offset()
<< " pc="
<< setw(16) << setfill('0') << std::hex << fde.get_low_pc()
<< ".."
<< setw(16) << setfill('0') << std::hex << (fde.get_low_pc() + fde.get_func_length())
<< endl;
auto augbytes = fde.get_augmentation_bytes();
if (augbytes.size() > 0)
{
s << " Augmentation data: ";
for (auto i_byte = augbytes.begin(); i_byte != augbytes.end(); ++i_byte)
{
if (i_byte != augbytes.begin()) s << ' ';
s << std::hex << setw(2) << setfill('0') << (unsigned) *i_byte;
}
s << endl << endl;
}
s << std::dec;
/* Now we need to print the instructions. */
// TODO: eliminate this once the assertion below assures me that it's the same as
// instrbytes etc..
auto instr_seq = fde.instr_bytes_seq();
encap::frame_instrlist instrs(*fde.find_cie(), /* FIXME */ 8, instr_seq);
print_in_readelf_style(s, instrs, fde.get_low_pc());
}
inline
std::streamsize
arma_ostream::modify_stream(std::ostream& o, const std::complex<T>* data, const uword n_elem)
{
arma_ignore(data);
arma_ignore(n_elem);
o.unsetf(ios::showbase);
o.unsetf(ios::uppercase);
o.fill(' ');
o.setf(ios::scientific);
o.setf(ios::showpos);
o.setf(ios::right);
o.unsetf(ios::fixed);
std::streamsize cell_width;
o.precision(3);
cell_width = 2 + 2*(1 + 3 + o.precision() + 5) + 1;
return cell_width;
}
inline
std::streamsize
arma_ostream::modify_stream(std::ostream& o, typename SpMat<T>::const_iterator begin, const uword n_elem, const typename arma_cx_only<T>::result* junk)
{
arma_ignore(begin);
arma_ignore(n_elem);
arma_ignore(junk);
o.unsetf(ios::showbase);
o.unsetf(ios::uppercase);
o.fill(' ');
o.setf(ios::scientific);
o.setf(ios::showpos);
o.setf(ios::right);
o.unsetf(ios::fixed);
std::streamsize cell_width;
o.precision(3);
cell_width = 2 + 2*(1 + 3 + o.precision() + 5) + 1;
return cell_width;
}