* Trim #includes

* Remove WriteToAssembly functions from interface
* Move operator<< definition to only allow top level operator<< on Value*'s.
  Defined in Value.h

This header file is greatly deemphasized by these changes.  Now it is only
used if custom printing through WriteTypeSymbolic or WriteAsOperand is needed.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2171 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Assembly/Writer.h b/include/llvm/Assembly/Writer.h
index 4c6c9fd99231b374f965c06cdbacea5927ebe3a1..07671a18a50f15f9096762517aca9a3bdc410247 100644 (file)
--- a/include/llvm/Assembly/Writer.h
+++ b/include/llvm/Assembly/Writer.h
@@ -16,21 +16,12 @@
 #ifndef LLVM_ASSEMBLY_WRITER_H
 #define LLVM_ASSEMBLY_WRITER_H
 
-#include <iostream>
-#include "llvm/Type.h"
-
+#include <iosfwd>
+class Type;
+class Module;
+class Value;
 class SlotCalculator;
 
-// The only interface defined by this file... convert the internal 
-// 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, std::ostream &o);
-void WriteToAssembly(const GlobalVariable *G, std::ostream &o);
-void WriteToAssembly(const Function    *F , 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
@@ -46,55 +37,4 @@ std::ostream &WriteTypeSymbolic(std::ostream &, const Type *, const Module *M);
 std::ostream &WriteAsOperand(std::ostream &, const Value *, bool PrintTy = true,
                              bool PrintName = true, SlotCalculator *Table = 0);
 
-
-// Define operator<< to work on the various classes that we can send to an 
-// ostream...
-//
-inline std::ostream &operator<<(std::ostream &o, const Module *C) {
-  WriteToAssembly(C, o); return o;
-}
-
-inline std::ostream &operator<<(std::ostream &o, const GlobalVariable *G) {
-  WriteToAssembly(G, o); return o;
-}
-
-inline std::ostream &operator<<(std::ostream &o, const Function *F) {
-  WriteToAssembly(F, o); return o;
-}
-
-inline std::ostream &operator<<(std::ostream &o, const BasicBlock *B) {
-  WriteToAssembly(B, o); return o;
-}
-
-inline std::ostream &operator<<(std::ostream &o, const Instruction *I) {
-  WriteToAssembly(I, o); return o;
-}
-
-inline std::ostream &operator<<(std::ostream &o, const Constant *I) {
-  WriteToAssembly(I, o); return o;
-}
-
-
-inline std::ostream &operator<<(std::ostream &o, const Type *T) {
-  if (!T) return o << "<null Type>";
-  return o << T->getDescription();
-}
-
-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;
-  case Value::FunctionArgumentVal:
-    return o << I->getType() << " " << I->getName();
-  case Value::InstructionVal:WriteToAssembly(cast<Instruction>(I)   , o); break;
-  case Value::BasicBlockVal: WriteToAssembly(cast<BasicBlock>(I)    , o); break;
-  case Value::FunctionVal:   WriteToAssembly(cast<Function>(I)      , o); break;
-  case Value::GlobalVariableVal:
-                             WriteToAssembly(cast<GlobalVariable>(I), o); break;
-  case Value::ModuleVal:     WriteToAssembly(cast<Module>(I)        , o); break;
-  default: return o << "<unknown value type: " << I->getValueType() << ">";
-  }
-  return o;
-}
-
 #endif