#include "llvm/Bitcode/ReaderWriter.h"
#include "llvm/Support/Streams.h"
#include "llvm/Support/Timer.h"
+#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/OwningPtr.h"
#include <fstream>
namespace {
class DeclPrinter {
public:
- std::ostream& Out;
+ llvm::raw_ostream& Out;
- DeclPrinter(std::ostream* out) : Out(out ? *out : *llvm::cerr.stream()) {}
- DeclPrinter() : Out(*llvm::cerr.stream()) {}
+ DeclPrinter(llvm::raw_ostream* out) : Out(out ? *out : llvm::errs()) {}
+ DeclPrinter() : Out(llvm::errs()) {}
+ virtual ~DeclPrinter();
void PrintDecl(Decl *D);
void PrintFunctionDeclStart(FunctionDecl *FD);
};
} // end anonymous namespace
+DeclPrinter::~DeclPrinter() {
+ Out.flush();
+}
+
void DeclPrinter:: PrintDecl(Decl *D) {
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
PrintFunctionDeclStart(FD);
namespace {
class ASTPrinter : public ASTConsumer, public DeclPrinter {
public:
- ASTPrinter(std::ostream* o = NULL) : DeclPrinter(o) {}
+ ASTPrinter(llvm::raw_ostream* o = NULL) : DeclPrinter(o) {}
virtual void HandleTopLevelDecl(Decl *D) {
PrintDecl(D);
};
}
-ASTConsumer *clang::CreateASTPrinter(std::ostream* out) {
+ASTConsumer *clang::CreateASTPrinter(llvm::raw_ostream* out) {
return new ASTPrinter(out);
}
#ifndef DRIVER_ASTCONSUMERS_H
#define DRIVER_ASTCONSUMERS_H
+#include "llvm/Support/raw_ostream.h"
#include <string>
#include <iosfwd>
class Preprocessor;
class PreprocessorFactory;
-ASTConsumer *CreateASTPrinter(std::ostream* OS = NULL);
+ASTConsumer *CreateASTPrinter(llvm::raw_ostream* OS = NULL);
ASTConsumer *CreateASTDumper();
#include "clang/Lex/Preprocessor.h"
#include "clang/Basic/SourceManager.h"
#include "llvm/Support/Streams.h"
+#include "llvm/Support/raw_ostream.h"
#include "llvm/System/Path.h"
-#include <fstream>
+#include "llvm/ADT/OwningPtr.h"
using namespace clang;
/// isSameToken - Return true if the two specified tokens start have the same
}
// Create the output file.
- std::ostream *OutFile;
+ llvm::OwningPtr<llvm::raw_ostream> OwnedStream;
+ llvm::raw_ostream *OutFile;
if (OutFileName == "-") {
- OutFile = llvm::cout.stream();
+ OutFile = &llvm::outs();
} else if (!OutFileName.empty()) {
- OutFile = new std::ofstream(OutFileName.c_str(),
- std::ios_base::binary|std::ios_base::out);
+ std::string Err;
+ OutFile = new llvm::raw_fd_ostream(OutFileName.c_str(), Err);
+ OwnedStream.reset(OutFile);
} else if (InFileName == "-") {
- OutFile = llvm::cout.stream();
+ OutFile = &llvm::outs();
} else {
llvm::sys::Path Path(InFileName);
Path.eraseSuffix();
Path.appendSuffix("cpp");
- OutFile = new std::ofstream(Path.toString().c_str(),
- std::ios_base::binary|std::ios_base::out);
+ std::string Err;
+ OutFile = new llvm::raw_fd_ostream(Path.toString().c_str(), Err);
+ OwnedStream.reset(OutFile);
}
// Get the buffer corresponding to MainFileID. If we haven't changed it, then
} else {
fprintf(stderr, "No changes\n");
}
+ OutFile->flush();
}
#include "clang/Lex/Lexer.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/OwningPtr.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Streams.h"
+#include "llvm/Support/raw_ostream.h"
#include "llvm/System/Path.h"
-#include <sstream>
-#include <fstream>
using namespace clang;
using llvm::utostr;
// Create the output file.
- std::ostream *OutFile;
+ llvm::OwningPtr<llvm::raw_ostream> OwnedStream;
+ llvm::raw_ostream *OutFile;
if (OutFileName == "-") {
- OutFile = llvm::cout.stream();
+ OutFile = &llvm::outs();
} else if (!OutFileName.empty()) {
- OutFile = new std::ofstream(OutFileName.c_str(),
- std::ios_base::binary|std::ios_base::out);
+ std::string Err;
+ OutFile = new llvm::raw_fd_ostream(OutFileName.c_str(), Err);
+ OwnedStream.reset(OutFile);
} else if (InFileName == "-") {
- OutFile = llvm::cout.stream();
+ OutFile = &llvm::outs();
} else {
llvm::sys::Path Path(InFileName);
Path.eraseSuffix();
Path.appendSuffix("cpp");
- OutFile = new std::ofstream(Path.toString().c_str(),
- std::ios_base::binary|std::ios_base::out);
+ std::string Err;
+ OutFile = new llvm::raw_fd_ostream(Path.toString().c_str(), Err);
+ OwnedStream.reset(OutFile);
}
RewriteInclude();
}
// Emit metadata.
*OutFile << ResultStr;
+ OutFile->flush();
}
//===----------------------------------------------------------------------===//
if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(S)) {
CastExpr *Replacement = new CastExpr(ICE->getType(), ICE->getSubExpr(), SourceLocation());
// Get the new text.
- std::ostringstream Buf;
+ std::string SStr;
+ llvm::raw_string_ostream Buf(SStr);
Replacement->printPretty(Buf);
const std::string &Str = Buf.str();
buf += " objc_sync_exit(";
Expr *syncExpr = new ExplicitCastExpr(Context->getObjCIdType(),
S->getSynchExpr(), SourceLocation());
- std::ostringstream syncExprBuf;
+ std::string syncExprBufS;
+ llvm::raw_string_ostream syncExprBuf(syncExprBufS);
syncExpr->printPretty(syncExprBuf);
buf += syncExprBuf.str();
buf += ");\n";
Preamble += " __attribute__ ((section (\"__DATA, __cfstring\"))) = {__CFConstantStringClassReference,";
Preamble += "0x000007c8,"; // utf8_str
// The pretty printer for StringLiteral handles escape characters properly.
- std::ostringstream prettyBuf;
+ std::string prettyBufS;
+ llvm::raw_string_ostream prettyBuf(prettyBufS);
Exp->getString()->printPretty(prettyBuf);
Preamble += prettyBuf.str();
Preamble += ",";
TranslationUnit& TU) {
{
// Pretty-print the decls to a temp file.
- std::ofstream DeclPP(FNameDeclPrint.c_str());
- assert (DeclPP && "Could not open file for printing out decls.");
+ std::string Err;
+ llvm::raw_fd_ostream DeclPP(FNameDeclPrint.c_str(), Err);
+ assert (Err.empty() && "Could not open file for printing out decls.");
llvm::OwningPtr<ASTConsumer> FilePrinter(CreateASTPrinter(&DeclPP));
for (TranslationUnit::iterator I=TU.begin(), E=TU.end(); I!=E; ++I)
{
// Pretty-print the deserialized decls to a temp file.
- std::ofstream DeclPP(FNameDeclPrint.c_str());
- assert (DeclPP && "Could not open file for printing out decls.");
+ std::string Err;
+ llvm::raw_fd_ostream DeclPP(FNameDeclPrint.c_str(), Err);
+ assert (Err.empty() && "Could not open file for printing out decls.");
llvm::OwningPtr<ASTConsumer> FilePrinter(CreateASTPrinter(&DeclPP));
for (TranslationUnit::iterator I=NewTU->begin(), E=NewTU->end(); I!=E; ++I)
#include "llvm/ADT/GraphTraits.h"
#include "llvm/Support/Allocator.h"
+#include "llvm/Support/raw_ostream.h"
#include <list>
#include <vector>
-#include <iosfwd>
#include <cassert>
namespace clang {
unsigned getBlockID() const { return BlockID; }
void dump(const CFG* cfg) const;
- void print(std::ostream& OS, const CFG* cfg) const;
- void printTerminator(std::ostream& OS) const;
+ void print(llvm::raw_ostream& OS, const CFG* cfg) const;
+ void printTerminator(llvm::raw_ostream& OS) const;
};
//===--------------------------------------------------------------------===//
void viewCFG() const;
- void print(std::ostream& OS) const;
+ void print(llvm::raw_ostream& OS) const;
void dump() const;
//===--------------------------------------------------------------------===//
#ifndef LLVM_CLANG_AST_PRETTY_PRINTER_H
#define LLVM_CLANG_AST_PRETTY_PRINTER_H
-#include <iosfwd>
+#include "llvm/Support/raw_ostream.h"
namespace clang {
class PrinterHelper {
public:
virtual ~PrinterHelper();
- virtual bool handledStmt(Stmt* E, std::ostream& OS) = 0;
+ virtual bool handledStmt(Stmt* E, llvm::raw_ostream& OS) = 0;
};
} // end namespace clang
#define LLVM_CLANG_AST_STMT_H
#include "llvm/Support/Casting.h"
+#include "llvm/Support/raw_ostream.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/AST/StmtIterator.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/iterator.h"
#include "llvm/Bitcode/SerializationFwd.h"
-#include <iosfwd>
#include <string>
using llvm::dyn_cast_or_null;
/// dumpPretty/printPretty - These two methods do a "pretty print" of the AST
/// back to its original source language syntax.
void dumpPretty() const;
- void printPretty(std::ostream &OS, PrinterHelper* = NULL) const;
+ void printPretty(llvm::raw_ostream &OS, PrinterHelper* = NULL) const;
/// viewAST - Visualize an AST rooted at this Stmt* using GraphViz. Only
/// works on systems with GraphViz (Mac OS X) or dot+gv installed.
#include "llvm/Support/Streams.h"
#include "llvm/Support/Compiler.h"
#include <llvm/Support/Allocator.h>
+#include <llvm/Support/Format.h>
#include <iomanip>
#include <algorithm>
#include <sstream>
void setBlockID(signed i) { CurrentBlock = i; }
void setStmtID(unsigned i) { CurrentStmt = i; }
- virtual bool handledStmt(Stmt* Terminator, std::ostream& OS) {
+ virtual bool handledStmt(Stmt* Terminator, llvm::raw_ostream& OS) {
StmtMapTy::iterator I = StmtMap.find(Terminator);
class VISIBILITY_HIDDEN CFGBlockTerminatorPrint
: public StmtVisitor<CFGBlockTerminatorPrint,void> {
- std::ostream& OS;
+ llvm::raw_ostream& OS;
StmtPrinterHelper* Helper;
public:
- CFGBlockTerminatorPrint(std::ostream& os, StmtPrinterHelper* helper)
+ CFGBlockTerminatorPrint(llvm::raw_ostream& os, StmtPrinterHelper* helper)
: OS(os), Helper(helper) {}
void VisitIfStmt(IfStmt* I) {
};
-void print_stmt(std::ostream&OS, StmtPrinterHelper* Helper, Stmt* Terminator) {
+void print_stmt(llvm::raw_ostream&OS, StmtPrinterHelper* Helper, Stmt* Terminator) {
if (Helper) {
// special printing for statement-expressions.
if (StmtExpr* SE = dyn_cast<StmtExpr>(Terminator)) {
if (isa<Expr>(Terminator)) OS << '\n';
}
-void print_block(std::ostream& OS, const CFG* cfg, const CFGBlock& B,
+void print_block(llvm::raw_ostream& OS, const CFG* cfg, const CFGBlock& B,
StmtPrinterHelper* Helper, bool print_edges) {
if (Helper) Helper->setBlockID(B.getBlockID());
if (print_edges)
OS << " ";
- OS << std::setw(3) << j << ": ";
+ OS << llvm::format("%3d", j) << ": ";
if (Helper)
Helper->setStmtID(j);
} // end anonymous namespace
/// dump - A simple pretty printer of a CFG that outputs to stderr.
-void CFG::dump() const { print(*llvm::cerr.stream()); }
+void CFG::dump() const { print(llvm::errs()); }
/// print - A simple pretty printer of a CFG that outputs to an ostream.
-void CFG::print(std::ostream& OS) const {
+void CFG::print(llvm::raw_ostream& OS) const {
StmtPrinterHelper Helper(this);
}
/// dump - A simply pretty printer of a CFGBlock that outputs to stderr.
-void CFGBlock::dump(const CFG* cfg) const { print(*llvm::cerr.stream(), cfg); }
+void CFGBlock::dump(const CFG* cfg) const { print(llvm::errs(), cfg); }
/// print - A simple pretty printer of a CFGBlock that outputs to an ostream.
/// Generally this will only be called from CFG::print.
-void CFGBlock::print(std::ostream& OS, const CFG* cfg) const {
+void CFGBlock::print(llvm::raw_ostream& OS, const CFG* cfg) const {
StmtPrinterHelper Helper(cfg);
print_block(OS, cfg, *this, &Helper, true);
}
/// printTerminator - A simple pretty printer of the terminator of a CFGBlock.
-void CFGBlock::printTerminator(std::ostream& OS) const {
+void CFGBlock::printTerminator(llvm::raw_ostream& OS) const {
CFGBlockTerminatorPrint TPrinter(OS,NULL);
TPrinter.Visit(const_cast<Stmt*>(getTerminator()));
}
static std::string getNodeLabel(const CFGBlock* Node, const CFG* Graph) {
#ifndef NDEBUG
- std::ostringstream Out;
+ std::string OutSStr;
+ llvm::raw_string_ostream Out(OutSStr);
print_block(Out,Graph, *Node, GraphHelper, false);
- std::string OutStr = Out.str();
+ std::string& OutStr = Out.str();
if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
#include "clang/AST/PrettyPrinter.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Streams.h"
+#include "llvm/Support/Format.h"
using namespace clang;
//===----------------------------------------------------------------------===//
namespace {
class VISIBILITY_HIDDEN StmtPrinter : public StmtVisitor<StmtPrinter> {
- std::ostream &OS;
+ llvm::raw_ostream &OS;
unsigned IndentLevel;
clang::PrinterHelper* Helper;
public:
- StmtPrinter(std::ostream &os, PrinterHelper* helper) :
+ StmtPrinter(llvm::raw_ostream &os, PrinterHelper* helper) :
OS(os), IndentLevel(0), Helper(helper) {}
void PrintStmt(Stmt *S, int SubIndent = 1) {
OS << "<null expr>";
}
- std::ostream &Indent(int Delta = 0) const {
+ llvm::raw_ostream &Indent(int Delta = 0) const {
for (int i = 0, e = IndentLevel+Delta; i < e; ++i)
OS << " ";
return OS;
if (value < 256 && isprint(value)) {
OS << "'" << (char)value << "'";
} else if (value < 256) {
- OS << "'\\x" << std::hex << value << std::dec << "'";
+ OS << "'\\x" << llvm::format("%x", value) << "'";
} else {
// FIXME what to really do here?
OS << value;
//===----------------------------------------------------------------------===//
void Stmt::dumpPretty() const {
- printPretty(*llvm::cerr.stream());
+ printPretty(llvm::errs());
}
-void Stmt::printPretty(std::ostream &OS, PrinterHelper* Helper) const {
+void Stmt::printPretty(llvm::raw_ostream &OS, PrinterHelper* Helper) const {
if (this == 0) {
OS << "<NULL>";
return;
static std::string getNodeLabel(const Stmt* Node, const Stmt* Graph) {
#ifndef NDEBUG
- std::ostringstream Out;
+ std::string OutSStr;
+ llvm::raw_string_ostream Out(OutSStr);
if (Node)
Out << Node->getStmtClassName();
S += '*';
if (getSizeExpr()) {
- std::ostringstream s;
+ std::string SStr;
+ llvm::raw_string_ostream s(SStr);
getSizeExpr()->printPretty(s);
S += s.str();
}
void TypeOfExpr::getAsStringInternal(std::string &InnerString) const {
if (!InnerString.empty()) // Prefix the basic type, e.g. 'typeof(e) X'.
InnerString = ' ' + InnerString;
- std::ostringstream s;
+ std::string Str;
+ llvm::raw_string_ostream s(Str);
getUnderlyingExpr()->printPretty(s);
InnerString = "typeof(" + s.str() + ")" + InnerString;
}
#include "llvm/Support/Streams.h"
#include "llvm/ADT/ImmutableList.h"
#include "llvm/Support/Compiler.h"
+#include "llvm/Support/raw_ostream.h"
#ifndef NDEBUG
#include "llvm/Support/GraphWriter.h"
SourceLocation SLoc = S->getLocStart();
Out << S->getStmtClassName() << ' ' << (void*) S << ' ';
- S->printPretty(Out);
+ llvm::raw_os_ostream OutS(Out);
+ S->printPretty(OutS);
+ OutS.flush();
if (SLoc.isFileID()) {
Out << "\\lline="
Out << "\\|Terminator: ";
- E.getSrc()->printTerminator(Out);
+ llvm::raw_os_ostream OutS(Out);
+ E.getSrc()->printTerminator(OutS);
+ OutS.flush();
if (SLoc.isFileID()) {
Out << "\\lline="
if (Label) {
if (CaseStmt* C = dyn_cast<CaseStmt>(Label)) {
Out << "\\lcase ";
- C->getLHS()->printPretty(Out);
-
+ llvm::raw_os_ostream OutS(Out);
+ C->getLHS()->printPretty(OutS);
+ OutS.flush();
+
if (Stmt* RHS = C->getRHS()) {
Out << " .. ";
- RHS->printPretty(Out);
+ RHS->printPretty(OutS);
+ OutS.flush();
}
Out << ":";
else { Out << nl; }
Out << " (" << (void*) I.getKey() << ") ";
- I.getKey()->printPretty(Out);
+ llvm::raw_os_ostream OutS(Out);
+ I.getKey()->printPretty(OutS);
+ OutS.flush();
Out << " : ";
I.getData().print(Out);
}
else { Out << nl; }
Out << " (" << (void*) I.getKey() << ") ";
- I.getKey()->printPretty(Out);
+ llvm::raw_os_ostream OutS(Out);
+ I.getKey()->printPretty(OutS);
+ OutS.flush();
Out << " : ";
I.getData().print(Out);
}
#include "llvm/Support/Compiler.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Streams.h"
+#include "llvm/Support/raw_ostream.h"
#include "llvm/System/Path.h"
#include <fstream>
-#include <sstream>
using namespace clang;
// Add the name of the file as an <h1> tag.
{
- std::ostringstream os;
+ std::string s;
+ llvm::raw_string_ostream os(s);
os << "<h3>Bug Summary</h3>\n<table class=\"simpletable\">\n"
"<tr><td class=\"rowname\">File:</td><td>"
const std::string& BugDesc = D.getDescription();
if (!BugDesc.empty()) {
- std::ostringstream os;
+ std::string s;
+ llvm::raw_string_ostream os(s);
os << "\n<!-- BUGDESC " << BugDesc << " -->\n";
R.InsertStrBefore(SourceLocation::getFileLoc(FileID, 0), os.str());
}
{
- std::ostringstream os;
+ std::string s;
+ llvm::raw_string_ostream os(s);
os << "\n<!-- BUGFILE " << DirName << Entry->getName() << " -->\n";
R.InsertStrBefore(SourceLocation::getFileLoc(FileID, 0), os.str());
}
{
- std::ostringstream os;
+ std::string s;
+ llvm::raw_string_ostream os(s);
os << "\n<!-- BUGLINE " << D.back()->getLocation().getLogicalLineNumber()
<< " -->\n";
R.InsertStrBefore(SourceLocation::getFileLoc(FileID, 0), os.str());
}
{
- std::ostringstream os;
+ std::string s;
+ llvm::raw_string_ostream os(s);
os << "\n<!-- BUGPATHLENGTH " << D.size() << " -->\n";
R.InsertStrBefore(SourceLocation::getFileLoc(FileID, 0), os.str());
}
// Create the html for the message.
- std::ostringstream os;
+ std::string s;
+ llvm::raw_string_ostream os(s);
os << "\n<tr><td class=\"num\"></td><td class=\"line\">"
<< "<div id=\"";
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/OwningPtr.h"
#include "llvm/Support/MemoryBuffer.h"
-#include <sstream>
+#include "llvm/Support/raw_ostream.h"
using namespace clang;
bool ReplaceTabs) {
unsigned len = s.size();
- std::ostringstream os;
+ std::string Str;
+ llvm::raw_string_ostream os(Str);
for (unsigned i = 0 ; i < len; ++i) {
SourceLocation StartLoc = SourceLocation::getFileLoc(FileID, 0);
SourceLocation EndLoc = SourceLocation::getFileLoc(FileID, FileEnd-FileStart);
- std::ostringstream os;
+ std::string s;
+ llvm::raw_string_ostream os(s);
os << "<!doctype html>\n" // Use HTML 5 doctype
"<html>\n<head>\n";
#include "clang/AST/Stmt.h"
#include "clang/Lex/Lexer.h"
#include "clang/Basic/SourceManager.h"
-#include <sstream>
+#include "llvm/Support/raw_ostream.h"
using namespace clang;
void RewriteBuffer::RemoveText(unsigned OrigOffset, unsigned Size) {
return true;
// Get the new text.
- std::ostringstream S;
+ std::string SStr;
+ llvm::raw_string_ostream S(SStr);
To->printPretty(S);
const std::string &Str = S.str();
projects / clang / commitdiff