lib/Frontend/StmtXML.cpp - platform/external/clang - Gitiles

 //===--- StmtXML.cpp - XML implementation for Stmt ASTs ------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Stmt::dumpXML methods, which dump out the
 // AST to an XML document.
 //
 //===----------------------------------------------------------------------===//

 #include "clang/Frontend/DocumentXML.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/Basic/SourceManager.h"
 #include "llvm/Support/Compiler.h"
 using namespace clang;

 //===----------------------------------------------------------------------===//
 // StmtXML Visitor
 //===----------------------------------------------------------------------===//

 namespace  {
   class VISIBILITY_HIDDEN StmtXML : public StmtVisitor<StmtXML> {
     DocumentXML&  Doc;

     //static const char *getOpcodeStr(UnaryOperator::Opcode Op);
     //static const char *getOpcodeStr(BinaryOperator::Opcode Op);


   void addSpecialAttribute(const char* pName, StringLiteral* Str) {
     Doc.addAttribute(pName, Doc.escapeString(Str->getStrData(), Str->getByteLength()));
   }

   void addSpecialAttribute(const char* pName, SizeOfAlignOfExpr* S) {
     if (S->isArgumentType())
       Doc.addAttribute(pName, S->getArgumentType());
   }

   void addSpecialAttribute(const char* pName, CXXTypeidExpr* S) {
     if (S->isTypeOperand())
       Doc.addAttribute(pName, S->getTypeOperand());
   }


   public:
     StmtXML(DocumentXML& doc)
       : Doc(doc) {
     }

     void DumpSubTree(Stmt *S) {
       if (S) {
         Visit(S);
         if (DeclStmt* DS = dyn_cast<DeclStmt>(S)) {
           for (DeclStmt::decl_iterator DI = DS->decl_begin(),
                  DE = DS->decl_end(); DI != DE; ++DI) {
             Doc.PrintDecl(*DI);
           }
         } else {
           if (CXXConditionDeclExpr* CCDE = dyn_cast<CXXConditionDeclExpr>(S))
             Doc.PrintDecl(CCDE->getVarDecl());
           for (Stmt::child_iterator i = S->child_begin(), e = S->child_end();
                i != e; ++i)
             DumpSubTree(*i);
         }
         Doc.toParent();
       } else {
         Doc.addSubNode("NULL").toParent();
       }
     }


 #define NODE_XML( CLASS, NAME )          \
   void Visit##CLASS(CLASS* S)            \
   {                                      \
     typedef CLASS tStmtType;             \
     Doc.addSubNode(NAME);

 #define ATTRIBUTE_XML( FN, NAME )         Doc.addAttribute(NAME, S->FN);
 #define TYPE_ATTRIBUTE_XML( FN )          ATTRIBUTE_XML(FN, "type")
 #define ATTRIBUTE_OPT_XML( FN, NAME )     Doc.addAttributeOptional(NAME, S->FN);
 #define ATTRIBUTE_SPECIAL_XML( FN, NAME ) addSpecialAttribute(NAME, S);
 #define ATTRIBUTE_FILE_LOCATION_XML       Doc.addLocationRange(S->getSourceRange());


 #define ATTRIBUTE_ENUM_XML( FN, NAME )  \
   {                                     \
     const char* pAttributeName = NAME;  \
     const bool optional = false;        \
     switch (S->FN) {                    \
       default: assert(0 && "unknown enum value");

 #define ATTRIBUTE_ENUM_OPT_XML( FN, NAME )  \
   {                                         \
     const char* pAttributeName = NAME;      \
     const bool optional = true;             \
     switch (S->FN) {                        \
       default: assert(0 && "unknown enum value");

 #define ENUM_XML( VALUE, NAME )         case VALUE: if ((!optional) || NAME[0]) Doc.addAttribute(pAttributeName, NAME); break;
 #define END_ENUM_XML                    } }
 #define END_NODE_XML                    }

 #define ID_ATTRIBUTE_XML                Doc.addAttribute("id", S);
 #define SUB_NODE_XML( CLASS )
 #define SUB_NODE_SEQUENCE_XML( CLASS )
 #define SUB_NODE_OPT_XML( CLASS )

 #include "clang/Frontend/StmtXML.def"

 #if (0)
     // Stmts.
     void VisitStmt(Stmt *Node);
     void VisitDeclStmt(DeclStmt *Node);
     void VisitLabelStmt(LabelStmt *Node);
     void VisitGotoStmt(GotoStmt *Node);

     // Exprs
     void VisitExpr(Expr *Node);
     void VisitDeclRefExpr(DeclRefExpr *Node);
     void VisitPredefinedExpr(PredefinedExpr *Node);
     void VisitCharacterLiteral(CharacterLiteral *Node);
     void VisitIntegerLiteral(IntegerLiteral *Node);
     void VisitFloatingLiteral(FloatingLiteral *Node);
     void VisitStringLiteral(StringLiteral *Str);
     void VisitUnaryOperator(UnaryOperator *Node);
     void VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *Node);
     void VisitMemberExpr(MemberExpr *Node);
     void VisitExtVectorElementExpr(ExtVectorElementExpr *Node);
     void VisitBinaryOperator(BinaryOperator *Node);
     void VisitCompoundAssignOperator(CompoundAssignOperator *Node);
     void VisitAddrLabelExpr(AddrLabelExpr *Node);
     void VisitTypesCompatibleExpr(TypesCompatibleExpr *Node);

     // C++
     void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node);
     void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node);
     void VisitCXXThisExpr(CXXThisExpr *Node);
     void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node);

     // ObjC
     void VisitObjCEncodeExpr(ObjCEncodeExpr *Node);
     void VisitObjCMessageExpr(ObjCMessageExpr* Node);
     void VisitObjCSelectorExpr(ObjCSelectorExpr *Node);
     void VisitObjCProtocolExpr(ObjCProtocolExpr *Node);
     void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node);
     void VisitObjCImplicitSetterGetterRefExpr(
                         ObjCImplicitSetterGetterRefExpr *Node);
     void VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node);
     void VisitObjCSuperExpr(ObjCSuperExpr *Node);
 #endif
   };
 }

 //===----------------------------------------------------------------------===//
 //  Stmt printing methods.
 //===----------------------------------------------------------------------===//
 #if (0)
 void StmtXML::VisitStmt(Stmt *Node) {
   // nothing special to do
 }

 void StmtXML::VisitDeclStmt(DeclStmt *Node) {
   for (DeclStmt::decl_iterator DI = Node->decl_begin(), DE = Node->decl_end();
        DI != DE; ++DI) {
     Doc.PrintDecl(*DI);
   }
 }

 void StmtXML::VisitLabelStmt(LabelStmt *Node) {
   Doc.addAttribute("name", Node->getName());
 }

 void StmtXML::VisitGotoStmt(GotoStmt *Node) {
   Doc.addAttribute("name", Node->getLabel()->getName());
 }

 //===----------------------------------------------------------------------===//
 //  Expr printing methods.
 //===----------------------------------------------------------------------===//

 void StmtXML::VisitExpr(Expr *Node) {
   DumpExpr(Node);
 }

 void StmtXML::VisitDeclRefExpr(DeclRefExpr *Node) {
   DumpExpr(Node);

   const char* pKind;
   switch (Node->getDecl()->getKind()) {
     case Decl::Function: pKind = "FunctionDecl"; break;
     case Decl::Var: pKind = "Var"; break;
     case Decl::ParmVar: pKind = "ParmVar"; break;
     case Decl::EnumConstant: pKind = "EnumConstant"; break;
     case Decl::Typedef: pKind = "Typedef"; break;
     case Decl::Record: pKind = "Record"; break;
     case Decl::Enum: pKind = "Enum"; break;
     case Decl::CXXRecord: pKind = "CXXRecord"; break;
     case Decl::ObjCInterface: pKind = "ObjCInterface"; break;
     case Decl::ObjCClass: pKind = "ObjCClass"; break;
     default: pKind = "Decl"; break;
   }

   Doc.addAttribute("kind", pKind);
   Doc.addAttribute("name", Node->getDecl()->getNameAsString());
   Doc.addRefAttribute(Node->getDecl());
 }

 void StmtXML::VisitPredefinedExpr(PredefinedExpr *Node) {
   DumpExpr(Node);
   switch (Node->getIdentType()) {
     default: assert(0 && "unknown case");
     case PredefinedExpr::Func:           Doc.addAttribute("predefined", " __func__"); break;
     case PredefinedExpr::Function:       Doc.addAttribute("predefined", " __FUNCTION__"); break;
     case PredefinedExpr::PrettyFunction: Doc.addAttribute("predefined", " __PRETTY_FUNCTION__");break;
   }
 }

 void StmtXML::VisitCharacterLiteral(CharacterLiteral *Node) {
   DumpExpr(Node);
   Doc.addAttribute("value", Node->getValue());
 }

 void StmtXML::VisitIntegerLiteral(IntegerLiteral *Node) {
   DumpExpr(Node);
   bool isSigned = Node->getType()->isSignedIntegerType();
   Doc.addAttribute("value", Node->getValue().toString(10, isSigned));
 }

 void StmtXML::VisitFloatingLiteral(FloatingLiteral *Node) {
   DumpExpr(Node);
   // FIXME: output float as written in source (no approximation or the like)
   //Doc.addAttribute("value", Node->getValueAsApproximateDouble()));
   Doc.addAttribute("value", "FIXME");
 }

 void StmtXML::VisitStringLiteral(StringLiteral *Str) {
   DumpExpr(Str);
   if (Str->isWide())
     Doc.addAttribute("is_wide", "1");

   Doc.addAttribute("value", Doc.escapeString(Str->getStrData(), Str->getByteLength()));
 }


 const char *StmtXML::getOpcodeStr(UnaryOperator::Opcode Op) {
   switch (Op) {
   default: assert(0 && "Unknown unary operator");
   case UnaryOperator::PostInc: return "postinc";
   case UnaryOperator::PostDec: return "postdec";
   case UnaryOperator::PreInc:  return "preinc";
   case UnaryOperator::PreDec:  return "predec";
   case UnaryOperator::AddrOf:  return "addrof";
   case UnaryOperator::Deref:   return "deref";
   case UnaryOperator::Plus:    return "plus";
   case UnaryOperator::Minus:   return "minus";
   case UnaryOperator::Not:     return "not";
   case UnaryOperator::LNot:    return "lnot";
   case UnaryOperator::Real:    return "__real";
   case UnaryOperator::Imag:    return "__imag";
   case UnaryOperator::Extension: return "__extension__";
   case UnaryOperator::OffsetOf: return "__builtin_offsetof";
   }
 }


 const char *StmtXML::getOpcodeStr(BinaryOperator::Opcode Op) {
   switch (Op) {
   default: assert(0 && "Unknown binary operator");
   case BinaryOperator::PtrMemD:   return "ptrmemd";
   case BinaryOperator::PtrMemI:   return "ptrmemi";
   case BinaryOperator::Mul:       return "mul";
   case BinaryOperator::Div:       return "div";
   case BinaryOperator::Rem:       return "rem";
   case BinaryOperator::Add:       return "add";
   case BinaryOperator::Sub:       return "sub";
   case BinaryOperator::Shl:       return "shl";
   case BinaryOperator::Shr:       return "shr";
   case BinaryOperator::LT:        return "lt";
   case BinaryOperator::GT:        return "gt";
   case BinaryOperator::LE:        return "le";
   case BinaryOperator::GE:        return "ge";
   case BinaryOperator::EQ:        return "eq";
   case BinaryOperator::NE:        return "ne";
   case BinaryOperator::And:       return "and";
   case BinaryOperator::Xor:       return "xor";
   case BinaryOperator::Or:        return "or";
   case BinaryOperator::LAnd:      return "land";
   case BinaryOperator::LOr:       return "lor";
   case BinaryOperator::Assign:    return "assign";
   case BinaryOperator::MulAssign: return "mulassign";
   case BinaryOperator::DivAssign: return "divassign";
   case BinaryOperator::RemAssign: return "remassign";
   case BinaryOperator::AddAssign: return "addassign";
   case BinaryOperator::SubAssign: return "subassign";
   case BinaryOperator::ShlAssign: return "shlassign";
   case BinaryOperator::ShrAssign: return "shrassign";
   case BinaryOperator::AndAssign: return "andassign";
   case BinaryOperator::XorAssign: return "xorassign";
   case BinaryOperator::OrAssign:  return "orassign";
   case BinaryOperator::Comma:     return "comma";
   }
 }

 void StmtXML::VisitUnaryOperator(UnaryOperator *Node) {
   DumpExpr(Node);
   Doc.addAttribute("op_code", getOpcodeStr(Node->getOpcode()));
 }

 void StmtXML::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *Node) {
   DumpExpr(Node);
   Doc.addAttribute("is_sizeof", Node->isSizeOf() ? "sizeof" : "alignof");
   Doc.addAttribute("is_type", Node->isArgumentType() ? "1" : "0");
   if (Node->isArgumentType())
     DumpTypeExpr(Node->getArgumentType());
 }

 void StmtXML::VisitMemberExpr(MemberExpr *Node) {
   DumpExpr(Node);
   Doc.addAttribute("is_deref", Node->isArrow() ? "1" : "0");
   Doc.addAttribute("name", Node->getMemberDecl()->getNameAsString());
   Doc.addRefAttribute(Node->getMemberDecl());
 }

 void StmtXML::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
   DumpExpr(Node);
   Doc.addAttribute("name", Node->getAccessor().getName());
 }

 void StmtXML::VisitBinaryOperator(BinaryOperator *Node) {
   DumpExpr(Node);
   Doc.addAttribute("op_code", getOpcodeStr(Node->getOpcode()));
 }

 void StmtXML::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
   VisitBinaryOperator(Node);
 /* FIXME: is this needed in the AST?
   DumpExpr(Node);
   CurrentNode = CurrentNode->addSubNode("ComputeLHSTy");
   DumpType(Node->getComputationLHSType());
   CurrentNode = CurrentNode->Parent->addSubNode("ComputeResultTy");
   DumpType(Node->getComputationResultType());
   Doc.toParent();
 */
 }

 // GNU extensions.

 void StmtXML::VisitAddrLabelExpr(AddrLabelExpr *Node) {
   DumpExpr(Node);
   Doc.addAttribute("name", Node->getLabel()->getName());
 }

 void StmtXML::VisitTypesCompatibleExpr(TypesCompatibleExpr *Node) {
   DumpExpr(Node);
   DumpTypeExpr(Node->getArgType1());
   DumpTypeExpr(Node->getArgType2());
 }

 //===----------------------------------------------------------------------===//
 // C++ Expressions
 //===----------------------------------------------------------------------===//

 void StmtXML::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
   DumpExpr(Node);
   Doc.addAttribute("kind", Node->getCastName());
   DumpTypeExpr(Node->getTypeAsWritten());
 }

 void StmtXML::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
   DumpExpr(Node);
   Doc.addAttribute("value", Node->getValue() ? "true" : "false");
 }

 void StmtXML::VisitCXXThisExpr(CXXThisExpr *Node) {
   DumpExpr(Node);
 }

 void StmtXML::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
   DumpExpr(Node);
   DumpTypeExpr(Node->getTypeAsWritten());
 }

 //===----------------------------------------------------------------------===//
 // Obj-C Expressions
 //===----------------------------------------------------------------------===//

 void StmtXML::VisitObjCMessageExpr(ObjCMessageExpr* Node) {
   DumpExpr(Node);
   Doc.addAttribute("selector", Node->getSelector().getAsString());
   IdentifierInfo* clsName = Node->getClassName();
   if (clsName)
     Doc.addAttribute("class", clsName->getName());
 }

 void StmtXML::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
   DumpExpr(Node);
   DumpTypeExpr(Node->getEncodedType());
 }

 void StmtXML::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
   DumpExpr(Node);
   Doc.addAttribute("selector", Node->getSelector().getAsString());
 }

 void StmtXML::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
   DumpExpr(Node);
   Doc.addAttribute("protocol", Node->getProtocol()->getNameAsString());
 }

 void StmtXML::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) {
   DumpExpr(Node);
   Doc.addAttribute("property", Node->getProperty()->getNameAsString());
 }

 void StmtXML::VisitObjCImplicitSetterGetterRefExpr(
                              ObjCImplicitSetterGetterRefExpr *Node) {
   DumpExpr(Node);
   ObjCMethodDecl *Getter = Node->getGetterMethod();
   ObjCMethodDecl *Setter = Node->getSetterMethod();
   Doc.addAttribute("Getter", Getter->getSelector().getAsString());
   Doc.addAttribute("Setter", Setter ? Setter->getSelector().getAsString().c_str() : "(null)");
 }

 void StmtXML::VisitObjCSuperExpr(ObjCSuperExpr *Node) {
   DumpExpr(Node);
   Doc.addAttribute("super", "1");
 }

 void StmtXML::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) {
   DumpExpr(Node);
   Doc.addAttribute("kind", Node->getDecl()->getDeclKindName());
   Doc.addAttribute("decl", Node->getDecl()->getNameAsString());
   if (Node->isFreeIvar())
     Doc.addAttribute("isFreeIvar", "1");
 }
 #endif
 //===----------------------------------------------------------------------===//
 // Stmt method implementations
 //===----------------------------------------------------------------------===//

 /// dumpAll - This does a dump of the specified AST fragment and all subtrees.
 void DocumentXML::PrintStmt(const Stmt *S) {
   StmtXML P(*this);
   P.DumpSubTree(const_cast<Stmt*>(S));
 }
	//===--- StmtXML.cpp - XML implementation for Stmt ASTs ------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//
	//
	// This file implements the Stmt::dumpXML methods, which dump out the
	// AST to an XML document.
	//
	//===----------------------------------------------------------------------===//

	#include "clang/Frontend/DocumentXML.h"
	#include "clang/AST/StmtVisitor.h"
	#include "clang/AST/DeclObjC.h"
	#include "clang/AST/DeclCXX.h"
	#include "clang/Basic/SourceManager.h"
	#include "llvm/Support/Compiler.h"
	using namespace clang;

	//===----------------------------------------------------------------------===//
	// StmtXML Visitor
	//===----------------------------------------------------------------------===//

	namespace {
	class VISIBILITY_HIDDEN StmtXML : public StmtVisitor<StmtXML> {
	DocumentXML& Doc;

	//static const char *getOpcodeStr(UnaryOperator::Opcode Op);
	//static const char *getOpcodeStr(BinaryOperator::Opcode Op);


	void addSpecialAttribute(const char* pName, StringLiteral* Str) {
	Doc.addAttribute(pName, Doc.escapeString(Str->getStrData(), Str->getByteLength()));
	}

	void addSpecialAttribute(const char* pName, SizeOfAlignOfExpr* S) {
	if (S->isArgumentType())
	Doc.addAttribute(pName, S->getArgumentType());
	}

	void addSpecialAttribute(const char* pName, CXXTypeidExpr* S) {
	if (S->isTypeOperand())
	Doc.addAttribute(pName, S->getTypeOperand());
	}


	public:
	StmtXML(DocumentXML& doc)
	: Doc(doc) {
	}

	void DumpSubTree(Stmt *S) {
	if (S) {
	Visit(S);
	if (DeclStmt* DS = dyn_cast<DeclStmt>(S)) {
	for (DeclStmt::decl_iterator DI = DS->decl_begin(),
	DE = DS->decl_end(); DI != DE; ++DI) {
	Doc.PrintDecl(*DI);
	}
	} else {
	if (CXXConditionDeclExpr* CCDE = dyn_cast<CXXConditionDeclExpr>(S))
	Doc.PrintDecl(CCDE->getVarDecl());
	for (Stmt::child_iterator i = S->child_begin(), e = S->child_end();
	i != e; ++i)
	DumpSubTree(*i);
	}
	Doc.toParent();
	} else {
	Doc.addSubNode("NULL").toParent();
	}
	}


	#define NODE_XML( CLASS, NAME ) \
	void Visit##CLASS(CLASS* S) \
	{ \
	typedef CLASS tStmtType; \
	Doc.addSubNode(NAME);

	#define ATTRIBUTE_XML( FN, NAME ) Doc.addAttribute(NAME, S->FN);
	#define TYPE_ATTRIBUTE_XML( FN ) ATTRIBUTE_XML(FN, "type")
	#define ATTRIBUTE_OPT_XML( FN, NAME ) Doc.addAttributeOptional(NAME, S->FN);
	#define ATTRIBUTE_SPECIAL_XML( FN, NAME ) addSpecialAttribute(NAME, S);
	#define ATTRIBUTE_FILE_LOCATION_XML Doc.addLocationRange(S->getSourceRange());


	#define ATTRIBUTE_ENUM_XML( FN, NAME ) \
	{ \
	const char* pAttributeName = NAME; \
	const bool optional = false; \
	switch (S->FN) { \
	default: assert(0 && "unknown enum value");

	#define ATTRIBUTE_ENUM_OPT_XML( FN, NAME ) \
	{ \
	const char* pAttributeName = NAME; \
	const bool optional = true; \
	switch (S->FN) { \
	default: assert(0 && "unknown enum value");

	#define ENUM_XML( VALUE, NAME ) case VALUE: if ((!optional) \|\| NAME[0]) Doc.addAttribute(pAttributeName, NAME); break;
	#define END_ENUM_XML } }
	#define END_NODE_XML }

	#define ID_ATTRIBUTE_XML Doc.addAttribute("id", S);
	#define SUB_NODE_XML( CLASS )
	#define SUB_NODE_SEQUENCE_XML( CLASS )
	#define SUB_NODE_OPT_XML( CLASS )

	#include "clang/Frontend/StmtXML.def"

	#if (0)
	// Stmts.
	void VisitStmt(Stmt *Node);
	void VisitDeclStmt(DeclStmt *Node);
	void VisitLabelStmt(LabelStmt *Node);
	void VisitGotoStmt(GotoStmt *Node);

	// Exprs
	void VisitExpr(Expr *Node);
	void VisitDeclRefExpr(DeclRefExpr *Node);
	void VisitPredefinedExpr(PredefinedExpr *Node);
	void VisitCharacterLiteral(CharacterLiteral *Node);
	void VisitIntegerLiteral(IntegerLiteral *Node);
	void VisitFloatingLiteral(FloatingLiteral *Node);
	void VisitStringLiteral(StringLiteral *Str);
	void VisitUnaryOperator(UnaryOperator *Node);
	void VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *Node);
	void VisitMemberExpr(MemberExpr *Node);
	void VisitExtVectorElementExpr(ExtVectorElementExpr *Node);
	void VisitBinaryOperator(BinaryOperator *Node);
	void VisitCompoundAssignOperator(CompoundAssignOperator *Node);
	void VisitAddrLabelExpr(AddrLabelExpr *Node);
	void VisitTypesCompatibleExpr(TypesCompatibleExpr *Node);

	// C++
	void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node);
	void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node);
	void VisitCXXThisExpr(CXXThisExpr *Node);
	void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node);

	// ObjC
	void VisitObjCEncodeExpr(ObjCEncodeExpr *Node);
	void VisitObjCMessageExpr(ObjCMessageExpr* Node);
	void VisitObjCSelectorExpr(ObjCSelectorExpr *Node);
	void VisitObjCProtocolExpr(ObjCProtocolExpr *Node);
	void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node);
	void VisitObjCImplicitSetterGetterRefExpr(
	ObjCImplicitSetterGetterRefExpr *Node);
	void VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node);
	void VisitObjCSuperExpr(ObjCSuperExpr *Node);
	#endif
	};
	}

	//===----------------------------------------------------------------------===//
	// Stmt printing methods.
	//===----------------------------------------------------------------------===//
	#if (0)
	void StmtXML::VisitStmt(Stmt *Node) {
	// nothing special to do
	}

	void StmtXML::VisitDeclStmt(DeclStmt *Node) {
	for (DeclStmt::decl_iterator DI = Node->decl_begin(), DE = Node->decl_end();
	DI != DE; ++DI) {
	Doc.PrintDecl(*DI);
	}
	}

	void StmtXML::VisitLabelStmt(LabelStmt *Node) {
	Doc.addAttribute("name", Node->getName());
	}

	void StmtXML::VisitGotoStmt(GotoStmt *Node) {
	Doc.addAttribute("name", Node->getLabel()->getName());
	}

	//===----------------------------------------------------------------------===//
	// Expr printing methods.
	//===----------------------------------------------------------------------===//

	void StmtXML::VisitExpr(Expr *Node) {
	DumpExpr(Node);
	}

	void StmtXML::VisitDeclRefExpr(DeclRefExpr *Node) {
	DumpExpr(Node);

	const char* pKind;
	switch (Node->getDecl()->getKind()) {
	case Decl::Function: pKind = "FunctionDecl"; break;
	case Decl::Var: pKind = "Var"; break;
	case Decl::ParmVar: pKind = "ParmVar"; break;
	case Decl::EnumConstant: pKind = "EnumConstant"; break;
	case Decl::Typedef: pKind = "Typedef"; break;
	case Decl::Record: pKind = "Record"; break;
	case Decl::Enum: pKind = "Enum"; break;
	case Decl::CXXRecord: pKind = "CXXRecord"; break;
	case Decl::ObjCInterface: pKind = "ObjCInterface"; break;
	case Decl::ObjCClass: pKind = "ObjCClass"; break;
	default: pKind = "Decl"; break;
	}

	Doc.addAttribute("kind", pKind);
	Doc.addAttribute("name", Node->getDecl()->getNameAsString());
	Doc.addRefAttribute(Node->getDecl());
	}

	void StmtXML::VisitPredefinedExpr(PredefinedExpr *Node) {
	DumpExpr(Node);
	switch (Node->getIdentType()) {
	default: assert(0 && "unknown case");
	case PredefinedExpr::Func: Doc.addAttribute("predefined", " __func__"); break;
	case PredefinedExpr::Function: Doc.addAttribute("predefined", " __FUNCTION__"); break;
	case PredefinedExpr::PrettyFunction: Doc.addAttribute("predefined", " __PRETTY_FUNCTION__");break;
	}
	}

	void StmtXML::VisitCharacterLiteral(CharacterLiteral *Node) {
	DumpExpr(Node);
	Doc.addAttribute("value", Node->getValue());
	}

	void StmtXML::VisitIntegerLiteral(IntegerLiteral *Node) {
	DumpExpr(Node);
	bool isSigned = Node->getType()->isSignedIntegerType();
	Doc.addAttribute("value", Node->getValue().toString(10, isSigned));
	}

	void StmtXML::VisitFloatingLiteral(FloatingLiteral *Node) {
	DumpExpr(Node);
	// FIXME: output float as written in source (no approximation or the like)
	//Doc.addAttribute("value", Node->getValueAsApproximateDouble()));
	Doc.addAttribute("value", "FIXME");
	}

	void StmtXML::VisitStringLiteral(StringLiteral *Str) {
	DumpExpr(Str);
	if (Str->isWide())
	Doc.addAttribute("is_wide", "1");

	Doc.addAttribute("value", Doc.escapeString(Str->getStrData(), Str->getByteLength()));
	}


	const char *StmtXML::getOpcodeStr(UnaryOperator::Opcode Op) {
	switch (Op) {
	default: assert(0 && "Unknown unary operator");
	case UnaryOperator::PostInc: return "postinc";
	case UnaryOperator::PostDec: return "postdec";
	case UnaryOperator::PreInc: return "preinc";
	case UnaryOperator::PreDec: return "predec";
	case UnaryOperator::AddrOf: return "addrof";
	case UnaryOperator::Deref: return "deref";
	case UnaryOperator::Plus: return "plus";
	case UnaryOperator::Minus: return "minus";
	case UnaryOperator::Not: return "not";
	case UnaryOperator::LNot: return "lnot";
	case UnaryOperator::Real: return "__real";
	case UnaryOperator::Imag: return "__imag";
	case UnaryOperator::Extension: return "__extension__";
	case UnaryOperator::OffsetOf: return "__builtin_offsetof";
	}
	}


	const char *StmtXML::getOpcodeStr(BinaryOperator::Opcode Op) {
	switch (Op) {
	default: assert(0 && "Unknown binary operator");
	case BinaryOperator::PtrMemD: return "ptrmemd";
	case BinaryOperator::PtrMemI: return "ptrmemi";
	case BinaryOperator::Mul: return "mul";
	case BinaryOperator::Div: return "div";
	case BinaryOperator::Rem: return "rem";
	case BinaryOperator::Add: return "add";
	case BinaryOperator::Sub: return "sub";
	case BinaryOperator::Shl: return "shl";
	case BinaryOperator::Shr: return "shr";
	case BinaryOperator::LT: return "lt";
	case BinaryOperator::GT: return "gt";
	case BinaryOperator::LE: return "le";
	case BinaryOperator::GE: return "ge";
	case BinaryOperator::EQ: return "eq";
	case BinaryOperator::NE: return "ne";
	case BinaryOperator::And: return "and";
	case BinaryOperator::Xor: return "xor";
	case BinaryOperator::Or: return "or";
	case BinaryOperator::LAnd: return "land";
	case BinaryOperator::LOr: return "lor";
	case BinaryOperator::Assign: return "assign";
	case BinaryOperator::MulAssign: return "mulassign";
	case BinaryOperator::DivAssign: return "divassign";
	case BinaryOperator::RemAssign: return "remassign";
	case BinaryOperator::AddAssign: return "addassign";
	case BinaryOperator::SubAssign: return "subassign";
	case BinaryOperator::ShlAssign: return "shlassign";
	case BinaryOperator::ShrAssign: return "shrassign";
	case BinaryOperator::AndAssign: return "andassign";
	case BinaryOperator::XorAssign: return "xorassign";
	case BinaryOperator::OrAssign: return "orassign";
	case BinaryOperator::Comma: return "comma";
	}
	}

	void StmtXML::VisitUnaryOperator(UnaryOperator *Node) {
	DumpExpr(Node);
	Doc.addAttribute("op_code", getOpcodeStr(Node->getOpcode()));
	}

	void StmtXML::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *Node) {
	DumpExpr(Node);
	Doc.addAttribute("is_sizeof", Node->isSizeOf() ? "sizeof" : "alignof");
	Doc.addAttribute("is_type", Node->isArgumentType() ? "1" : "0");
	if (Node->isArgumentType())
	DumpTypeExpr(Node->getArgumentType());
	}

	void StmtXML::VisitMemberExpr(MemberExpr *Node) {
	DumpExpr(Node);
	Doc.addAttribute("is_deref", Node->isArrow() ? "1" : "0");
	Doc.addAttribute("name", Node->getMemberDecl()->getNameAsString());
	Doc.addRefAttribute(Node->getMemberDecl());
	}

	void StmtXML::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
	DumpExpr(Node);
	Doc.addAttribute("name", Node->getAccessor().getName());
	}

	void StmtXML::VisitBinaryOperator(BinaryOperator *Node) {
	DumpExpr(Node);
	Doc.addAttribute("op_code", getOpcodeStr(Node->getOpcode()));
	}

	void StmtXML::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
	VisitBinaryOperator(Node);
	/* FIXME: is this needed in the AST?
	DumpExpr(Node);
	CurrentNode = CurrentNode->addSubNode("ComputeLHSTy");
	DumpType(Node->getComputationLHSType());
	CurrentNode = CurrentNode->Parent->addSubNode("ComputeResultTy");
	DumpType(Node->getComputationResultType());
	Doc.toParent();
	*/
	}

	// GNU extensions.

	void StmtXML::VisitAddrLabelExpr(AddrLabelExpr *Node) {
	DumpExpr(Node);
	Doc.addAttribute("name", Node->getLabel()->getName());
	}

	void StmtXML::VisitTypesCompatibleExpr(TypesCompatibleExpr *Node) {
	DumpExpr(Node);
	DumpTypeExpr(Node->getArgType1());
	DumpTypeExpr(Node->getArgType2());
	}

	//===----------------------------------------------------------------------===//
	// C++ Expressions
	//===----------------------------------------------------------------------===//

	void StmtXML::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
	DumpExpr(Node);
	Doc.addAttribute("kind", Node->getCastName());
	DumpTypeExpr(Node->getTypeAsWritten());
	}

	void StmtXML::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
	DumpExpr(Node);
	Doc.addAttribute("value", Node->getValue() ? "true" : "false");
	}

	void StmtXML::VisitCXXThisExpr(CXXThisExpr *Node) {
	DumpExpr(Node);
	}

	void StmtXML::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
	DumpExpr(Node);
	DumpTypeExpr(Node->getTypeAsWritten());
	}

	//===----------------------------------------------------------------------===//
	// Obj-C Expressions
	//===----------------------------------------------------------------------===//

	void StmtXML::VisitObjCMessageExpr(ObjCMessageExpr* Node) {
	DumpExpr(Node);
	Doc.addAttribute("selector", Node->getSelector().getAsString());
	IdentifierInfo* clsName = Node->getClassName();
	if (clsName)
	Doc.addAttribute("class", clsName->getName());
	}

	void StmtXML::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
	DumpExpr(Node);
	DumpTypeExpr(Node->getEncodedType());
	}

	void StmtXML::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
	DumpExpr(Node);
	Doc.addAttribute("selector", Node->getSelector().getAsString());
	}

	void StmtXML::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
	DumpExpr(Node);
	Doc.addAttribute("protocol", Node->getProtocol()->getNameAsString());
	}

	void StmtXML::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) {
	DumpExpr(Node);
	Doc.addAttribute("property", Node->getProperty()->getNameAsString());
	}

	void StmtXML::VisitObjCImplicitSetterGetterRefExpr(
	ObjCImplicitSetterGetterRefExpr *Node) {
	DumpExpr(Node);
	ObjCMethodDecl *Getter = Node->getGetterMethod();
	ObjCMethodDecl *Setter = Node->getSetterMethod();
	Doc.addAttribute("Getter", Getter->getSelector().getAsString());
	Doc.addAttribute("Setter", Setter ? Setter->getSelector().getAsString().c_str() : "(null)");
	}

	void StmtXML::VisitObjCSuperExpr(ObjCSuperExpr *Node) {
	DumpExpr(Node);
	Doc.addAttribute("super", "1");
	}

	void StmtXML::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) {
	DumpExpr(Node);
	Doc.addAttribute("kind", Node->getDecl()->getDeclKindName());
	Doc.addAttribute("decl", Node->getDecl()->getNameAsString());
	if (Node->isFreeIvar())
	Doc.addAttribute("isFreeIvar", "1");
	}
	#endif
	//===----------------------------------------------------------------------===//
	// Stmt method implementations
	//===----------------------------------------------------------------------===//

	/// dumpAll - This does a dump of the specified AST fragment and all subtrees.
	void DocumentXML::PrintStmt(const Stmt *S) {
	StmtXML P(*this);
	P.DumpSubTree(const_cast<Stmt*>(S));
	}