1 files changed, 19 insertions, 19 deletions

diff --git a/include/llvm/Assembly/Writer.h b/include/llvm/Assembly/Writer.h
index 02c9fd0cc1..6ef33ad1b6 100644
--- a/include/llvm/Assembly/Writer.h
+++ b/include/llvm/Assembly/Writer.h
@@ -30,26 +30,26 @@ class SlotCalculator;
 // representation of an object into an ascii bytestream that the parser can 
 // understand later... (the parser only understands whole classes though)
 //
-void WriteToAssembly(const Module  *Module, ostream &o);
-void WriteToAssembly(const GlobalVariable *G, ostream &o);
-void WriteToAssembly(const Method  *Method, ostream &o);
-void WriteToAssembly(const BasicBlock  *BB, ostream &o);
-void WriteToAssembly(const Instruction *In, ostream &o);
-void WriteToAssembly(const Constant     *V, ostream &o);
+void WriteToAssembly(const Module  *Module, std::ostream &o);
+void WriteToAssembly(const GlobalVariable *G, std::ostream &o);
+void WriteToAssembly(const Method  *Method, std::ostream &o);
+void WriteToAssembly(const BasicBlock  *BB, std::ostream &o);
+void WriteToAssembly(const Instruction *In, std::ostream &o);
+void WriteToAssembly(const Constant     *V, std::ostream &o);
 
 // WriteTypeSymbolic - This attempts to write the specified type as a symbolic
 // type, iff there is an entry in the modules symbol table for the specified
 // type or one of it's component types.  This is slower than a simple x << Type;
 //
-ostream &WriteTypeSymbolic(ostream &o, const Type *Ty, const Module *Module);
+std::ostream &WriteTypeSymbolic(std::ostream &, const Type *, const Module *M);
 
 
 // WriteAsOperand - Write the name of the specified value out to the specified
 // ostream.  This can be useful when you just want to print int %reg126, not the
 // whole instruction that generated it.
 //
-ostream &WriteAsOperand(ostream &o, const Value *V, bool PrintType = true,
-                       	bool PrintName = true, SlotCalculator *Table = 0);
+std::ostream &WriteAsOperand(std::ostream &, const Value *, bool PrintTy = true,
+                             bool PrintName = true, SlotCalculator *Table = 0);
 
 
 // WriteToVCG - Dump the specified structure to a VCG file.  If method is
@@ -57,8 +57,8 @@ ostream &WriteAsOperand(ostream &o, const Value *V, bool PrintType = true,
 // family of files with a common base name is created, with a method name
 // suffix.
 //
-void WriteToVCG(const Module *Module, const string &Filename);
-void WriteToVCG(const Method *Method, const string &Filename);
+void WriteToVCG(const Module *Module, const std::string &Filename);
+void WriteToVCG(const Method *Method, const std::string &Filename);
 
 
 
@@ -66,37 +66,37 @@ void WriteToVCG(const Method *Method, const string &Filename);
 // Define operator<< to work on the various classes that we can send to an 
 // ostream...
 //
-inline ostream &operator<<(ostream &o, const Module *C) {
+inline std::ostream &operator<<(std::ostream &o, const Module *C) {
   WriteToAssembly(C, o); return o;
 }
 
-inline ostream &operator<<(ostream &o, const GlobalVariable *G) {
+inline std::ostream &operator<<(std::ostream &o, const GlobalVariable *G) {
   WriteToAssembly(G, o); return o;
 }
 
-inline ostream &operator<<(ostream &o, const Method *M) {
+inline std::ostream &operator<<(std::ostream &o, const Method *M) {
   WriteToAssembly(M, o); return o;
 }
 
-inline ostream &operator<<(ostream &o, const BasicBlock *B) {
+inline std::ostream &operator<<(std::ostream &o, const BasicBlock *B) {
   WriteToAssembly(B, o); return o;
 }
 
-inline ostream &operator<<(ostream &o, const Instruction *I) {
+inline std::ostream &operator<<(std::ostream &o, const Instruction *I) {
   WriteToAssembly(I, o); return o;
 }
 
-inline ostream &operator<<(ostream &o, const Constant *I) {
+inline std::ostream &operator<<(std::ostream &o, const Constant *I) {
   WriteToAssembly(I, o); return o;
 }
 
 
-inline ostream &operator<<(ostream &o, const Type *T) {
+inline std::ostream &operator<<(std::ostream &o, const Type *T) {
   if (!T) return o << "<null Type>";
   return o << T->getDescription();
 }
 
-inline ostream &operator<<(ostream &o, const Value *I) {
+inline std::ostream &operator<<(std::ostream &o, const Value *I) {
   switch (I->getValueType()) {
   case Value::TypeVal:       return o << cast<const Type>(I);
   case Value::ConstantVal:   WriteToAssembly(cast<Constant>(I)      , o); break;