vendor/clang/clang-r73879

9 files changed, 1484 insertions, 19 deletions

diff --git a/include/clang/Frontend/ASTUnit.h b/include/clang/Frontend/ASTUnit.h
new file mode 100644
index 000000000000..68c06f5dcee6
--- /dev/null
+++ b/include/clang/Frontend/ASTUnit.h
@@ -0,0 +1,75 @@
+//===--- ASTUnit.h - ASTUnit utility ----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// ASTUnit utility class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_FRONTEND_ASTUNIT_H
+#define LLVM_CLANG_FRONTEND_ASTUNIT_H
+
+#include "llvm/ADT/OwningPtr.h"
+#include <string>
+
+namespace clang {
+  class FileManager;
+  class FileEntry;
+  class SourceManager;
+  class DiagnosticClient;
+  class Diagnostic;
+  class HeaderSearch;
+  class TargetInfo;
+  class Preprocessor;
+  class ASTContext;
+  class Decl;
+
+/// \brief Utility class for loading a ASTContext from a PCH file.
+///
+class ASTUnit {
+  llvm::OwningPtr<SourceManager>    SourceMgr;
+  llvm::OwningPtr<DiagnosticClient> DiagClient;
+  llvm::OwningPtr<Diagnostic>       Diags;
+  llvm::OwningPtr<HeaderSearch>     HeaderInfo;
+  llvm::OwningPtr<TargetInfo>       Target;
+  llvm::OwningPtr<Preprocessor>     PP;
+  llvm::OwningPtr<ASTContext>       Ctx;
+
+  ASTUnit(const ASTUnit&); // do not implement
+  ASTUnit &operator=(const ASTUnit &); // do not implement
+  ASTUnit();
+  
+public:
+  ~ASTUnit();
+
+  const SourceManager &getSourceManager() const { return *SourceMgr.get(); }
+        SourceManager &getSourceManager()       { return *SourceMgr.get(); }
+
+  const Preprocessor &getPreprocessor() const { return *PP.get(); }
+        Preprocessor &getPreprocessor()       { return *PP.get(); }
+              
+  const ASTContext &getASTContext() const { return *Ctx.get(); }
+        ASTContext &getASTContext()       { return *Ctx.get(); }
+
+  /// \brief Create a ASTUnit from a PCH file.
+  ///
+  /// \param Filename PCH filename
+  ///
+  /// \param FileMgr The FileManager to use
+  ///
+  /// \param ErrMsg Error message to report if the PCH file could not be loaded
+  ///
+  /// \returns the initialized ASTUnit or NULL if the PCH failed to load
+  static ASTUnit *LoadFromPCHFile(const std::string &Filename,
+                                  FileManager &FileMgr,
+                                  std::string *ErrMsg = 0);
+};
+
+} // namespace clang
+
+#endif
diff --git a/include/clang/Frontend/DeclContextXML.def b/include/clang/Frontend/DeclContextXML.def
new file mode 100644
index 000000000000..39ed5f9432b6
--- /dev/null
+++ b/include/clang/Frontend/DeclContextXML.def
@@ -0,0 +1,113 @@
+//===-- DeclContextXML.def - Metadata about Context XML nodes ---*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the XML context info database as written in the   
+//  <ReferenceSection>/<Contexts> sub-nodes of the XML document. Type nodes 
+//  are referred by "context" reference attributes throughout the document.
+//  A context node never contains sub-nodes. 
+//  The semantics of the attributes and enums are mostly self-documenting
+//  by looking at the appropriate internally used functions and values.
+//  The following macros are used:
+//
+//  NODE_XML( CLASS, NAME ) - A node of name NAME denotes a concrete 
+//  context of class CLASS where CLASS is a class name used internally by clang. 
+//  After a NODE_XML the definition of all (optional) attributes of that context 
+//  node and possible sub-nodes follows.
+//
+//  END_NODE_XML - Closes the attribute definition of the current node.
+//
+//  ID_ATTRIBUTE_XML - Context nodes have an "id" attribute containing a 
+//  string, which value uniquely identify that statement. Other nodes may refer 
+//  by "context" attributes to this value.
+//
+//  TYPE_ATTRIBUTE_XML( FN ) - Context nodes may refer to the ids of type 
+//  nodes by a "type" attribute, if they create a type during declaration. 
+//  For instance 'struct S;' creates both a context 'S::' and a type 'S'. 
+//  Contexts and types always have different ids, however declarations and 
+//  contexts may share the same ids. FN is internally used by clang.
+// 
+//  ATTRIBUTE_XML( FN, NAME ) - An attribute named NAME. FN is internally 
+//  used by clang. A boolean attribute have the values "0" or "1".
+//
+//  ATTRIBUTE_ENUM[_OPT]_XML( FN, NAME ) - An attribute named NAME. The value
+//  is an enumeration defined with ENUM_XML macros immediately following after 
+//  that macro. An optional attribute is ommited, if the particular enum is the 
+//  empty string. FN is internally used by clang.
+//  
+//  ENUM_XML( VALUE, NAME ) - An enumeration element named NAME. VALUE is 
+//  internally used by clang.
+//
+//  END_ENUM_XML - Closes the enumeration definition of the current attribute.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TYPE_ATTRIBUTE_XML
+#  define TYPE_ATTRIBUTE_XML( FN )     ATTRIBUTE_XML(FN, "type")
+#endif
+
+#ifndef CONTEXT_ATTRIBUTE_XML
+#  define CONTEXT_ATTRIBUTE_XML( FN )  ATTRIBUTE_XML(FN, "context")
+#endif
+
+NODE_XML(TranslationUnitDecl, "TranslationUnit")
+  ID_ATTRIBUTE_XML
+END_NODE_XML
+
+NODE_XML(FunctionDecl, "Function")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+  TYPE_ATTRIBUTE_XML(getType()->getAsFunctionType())
+END_NODE_XML
+
+NODE_XML(NamespaceDecl, "Namespace")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+END_NODE_XML
+
+NODE_XML(RecordDecl, "Record")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+  TYPE_ATTRIBUTE_XML(getTypeForDecl()) 
+END_NODE_XML
+
+NODE_XML(EnumDecl, "Enum")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+  TYPE_ATTRIBUTE_XML(getTypeForDecl()) 
+END_NODE_XML
+
+NODE_XML(LinkageSpecDecl, "LinkageSpec")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_ENUM_OPT_XML(getLanguage(), "lang")
+	  ENUM_XML(LinkageSpecDecl::lang_c, "C")
+	  ENUM_XML(LinkageSpecDecl::lang_cxx, "CXX")
+  END_ENUM_XML
+END_NODE_XML
+
+//===----------------------------------------------------------------------===//
+#undef NODE_XML
+#undef ID_ATTRIBUTE_XML                
+#undef TYPE_ATTRIBUTE_XML
+#undef ATTRIBUTE_XML
+#undef ATTRIBUTE_SPECIAL_XML
+#undef ATTRIBUTE_OPT_XML
+#undef ATTRIBUTE_ENUM_XML
+#undef ATTRIBUTE_ENUM_OPT_XML
+#undef ATTRIBUTE_FILE_LOCATION_XML
+#undef ENUM_XML
+#undef END_ENUM_XML                    
+#undef END_NODE_XML                    
+#undef SUB_NODE_XML
+#undef SUB_NODE_SEQUENCE_XML
+#undef SUB_NODE_OPT_XML
diff --git a/include/clang/Frontend/DeclXML.def b/include/clang/Frontend/DeclXML.def
new file mode 100644
index 000000000000..956d9719f9f4
--- /dev/null
+++ b/include/clang/Frontend/DeclXML.def
@@ -0,0 +1,250 @@
+//===-- DeclXML.def - Metadata about Decl XML nodes ------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the XML statement database structure as written in 
+//  <TranslationUnit> sub-nodes of the XML document. 
+//  The semantics of the attributes and enums are mostly self-documenting
+//  by looking at the appropriate internally used functions and values.
+//  The following macros are used:
+//
+//  NODE_XML( CLASS, NAME ) - A node of name NAME denotes a concrete 
+//  statement of class CLASS where CLASS is a class name used internally by clang. 
+//  After a NODE_XML the definition of all (optional) attributes of that statement 
+//  node and possible sub-nodes follows.
+//
+//  END_NODE_XML - Closes the attribute definition of the current node.
+//
+//  ID_ATTRIBUTE_XML - Some statement nodes have an "id" attribute containing a 
+//  string, which value uniquely identify that statement. Other nodes may refer 
+//  by reference attributes to this value (currently used only for Label).
+//
+//  TYPE_ATTRIBUTE_XML( FN ) - Type nodes refer to the result type id of an
+//  expression by a "type" attribute. FN is internally used by clang.
+// 
+//  ATTRIBUTE_XML( FN, NAME ) - An attribute named NAME. FN is internally 
+//  used by clang. A boolean attribute have the values "0" or "1".
+//
+//  ATTRIBUTE_SPECIAL_XML( FN, NAME ) - An attribute named NAME which deserves 
+//  a special handling. See the appropriate documentations. 
+//
+//  ATTRIBUTE_FILE_LOCATION_XML - A bunch of attributes denoting the location of
+//  a statement in the source file(s).
+//
+//  ATTRIBUTE_OPT_XML( FN, NAME ) - An optional attribute named NAME. 
+//  Optional attributes are omitted for boolean types, if the value is false, 
+//  for integral types, if the value is null and for strings, 
+//  if the value is the empty string. FN is internally used by clang.
+//
+//  ATTRIBUTE_ENUM[_OPT]_XML( FN, NAME ) - An attribute named NAME. The value
+//  is an enumeration defined with ENUM_XML macros immediately following after 
+//  that macro. An optional attribute is ommited, if the particular enum is the 
+//  empty string. FN is internally used by clang.
+//  
+//  ENUM_XML( VALUE, NAME ) - An enumeration element named NAME. VALUE is 
+//  internally used by clang.
+//
+//  END_ENUM_XML - Closes the enumeration definition of the current attribute.
+//
+//  SUB_NODE_XML( CLASS ) - A mandatory sub-node of class CLASS or its sub-classes.
+//
+//  SUB_NODE_OPT_XML( CLASS ) - An optional sub-node of class CLASS or its sub-classes.
+//
+//  SUB_NODE_SEQUENCE_XML( CLASS ) - Zero or more sub-nodes of class CLASS or 
+//  its sub-classes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ATTRIBUTE_FILE_LOCATION_XML
+#  define ATTRIBUTE_FILE_LOCATION_XML             \
+     ATTRIBUTE_XML(getFilename(), "file")         \
+     ATTRIBUTE_XML(getLine(), "line")             \
+     ATTRIBUTE_XML(getColumn(), "col")            \
+     ATTRIBUTE_OPT_XML(getFilename(), "endfile")  \
+     ATTRIBUTE_OPT_XML(getLine(), "endline")      \
+     ATTRIBUTE_OPT_XML(getColumn(), "endcol")
+#endif
+
+#ifndef TYPE_ATTRIBUTE_XML
+#  define TYPE_ATTRIBUTE_XML( FN )    ATTRIBUTE_XML(FN, "type")
+#endif
+
+#ifndef CONTEXT_ATTRIBUTE_XML
+#  define CONTEXT_ATTRIBUTE_XML( FN ) ATTRIBUTE_XML(FN, "context")
+#endif
+
+//NODE_XML(TranslationUnitDecl, "TranslationUnit")
+//  SUB_NODE_SEQUENCE_XML(Decl)
+//END_NODE_XML
+
+NODE_XML(Decl, "FIXME_Decl")
+  ATTRIBUTE_FILE_LOCATION_XML
+END_NODE_XML
+
+NODE_XML(FunctionDecl, "Function")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+  TYPE_ATTRIBUTE_XML(getType()->getAsFunctionType()->getResultType())
+  ATTRIBUTE_XML(getType()->getAsFunctionType(), "function_type")
+  ATTRIBUTE_ENUM_OPT_XML(getStorageClass(), "storage_class")
+	  ENUM_XML(FunctionDecl::None, "")
+	  ENUM_XML(FunctionDecl::Extern, "extern")
+	  ENUM_XML(FunctionDecl::Static, "static")
+	  ENUM_XML(FunctionDecl::PrivateExtern, "__private_extern__")
+  END_ENUM_XML
+  ATTRIBUTE_OPT_XML(isInline(), "inline")
+  //ATTRIBUTE_OPT_XML(isVariadic(), "variadic")       // in the type reference
+  ATTRIBUTE_XML(getNumParams(), "num_args")
+  SUB_NODE_SEQUENCE_XML(ParmVarDecl)
+  //SUB_NODE_OPT_XML("Body")
+END_NODE_XML
+
+NODE_XML(CXXMethodDecl, "CXXMethodDecl")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+  TYPE_ATTRIBUTE_XML(getType()->getAsFunctionType()->getResultType())
+  ATTRIBUTE_XML(getType()->getAsFunctionType(), "function_type")
+  ATTRIBUTE_OPT_XML(isInline(), "inline")
+  ATTRIBUTE_OPT_XML(isStatic(), "static")       
+  ATTRIBUTE_OPT_XML(isVirtual(), "virtual")       
+  ATTRIBUTE_XML(getNumParams(), "num_args")
+  SUB_NODE_SEQUENCE_XML(ParmVarDecl)
+  //SUB_NODE_OPT_XML("Body")
+END_NODE_XML
+
+//NODE_XML("Body")
+//  SUB_NODE_XML(Stmt)
+//END_NODE_XML
+  
+NODE_XML(NamespaceDecl, "Namespace")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+END_NODE_XML
+
+NODE_XML(UsingDirectiveDecl, "UsingDirective")
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+  ATTRIBUTE_XML(getNominatedNamespace(), "ref")
+END_NODE_XML
+
+NODE_XML(NamespaceAliasDecl, "NamespaceAlias")
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+  ATTRIBUTE_XML(getNamespace(), "ref")
+END_NODE_XML
+
+NODE_XML(RecordDecl, "Record")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+  ATTRIBUTE_OPT_XML(isDefinition() == false, "forward")
+  ATTRIBUTE_XML(getTypeForDecl(), "type")             // refers to the type this decl creates 
+  SUB_NODE_SEQUENCE_XML(FieldDecl)
+END_NODE_XML
+
+NODE_XML(EnumDecl, "Enum")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+  ATTRIBUTE_OPT_XML(isDefinition() == false, "forward")
+  ATTRIBUTE_SPECIAL_XML(getIntegerType(), "type")     // is NULL in pure declarations thus deserves special handling 
+  SUB_NODE_SEQUENCE_XML(EnumConstantDecl)             // only present in definition
+END_NODE_XML
+
+NODE_XML(EnumConstantDecl, "EnumConstant")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_XML(getInitVal().toString(10, true), "value")     // integer
+  SUB_NODE_OPT_XML(Expr)                                      // init expr of this constant
+END_NODE_XML
+
+NODE_XML(FieldDecl, "Field")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_OPT_XML(isMutable(), "mutable")
+  ATTRIBUTE_OPT_XML(isBitField(), "bitfield")
+  SUB_NODE_OPT_XML(Expr)                                      // init expr of a bit field
+END_NODE_XML
+
+NODE_XML(TypedefDecl, "Typedef")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+  TYPE_ATTRIBUTE_XML(getUnderlyingType())
+END_NODE_XML
+
+NODE_XML(VarDecl, "Var")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_ENUM_OPT_XML(getStorageClass(), "storage_class")
+	  ENUM_XML(VarDecl::None, "")
+	  ENUM_XML(VarDecl::Auto, "auto")
+	  ENUM_XML(VarDecl::Register, "register")
+	  ENUM_XML(VarDecl::Extern, "extern")
+	  ENUM_XML(VarDecl::Static, "static")
+	  ENUM_XML(VarDecl::PrivateExtern, "__private_extern__")
+  END_ENUM_XML
+  SUB_NODE_OPT_XML(Expr)                                      // init expr 
+END_NODE_XML
+
+NODE_XML(ParmVarDecl, "ParmVar")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_XML(getNameAsString(), "name")
+  TYPE_ATTRIBUTE_XML(getType())
+  SUB_NODE_OPT_XML(Expr)                                      // default argument expression 
+END_NODE_XML
+
+NODE_XML(LinkageSpecDecl, "LinkageSpec")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getDeclContext(), "context")
+  ATTRIBUTE_ENUM_OPT_XML(getLanguage(), "lang")
+	  ENUM_XML(LinkageSpecDecl::lang_c, "C")
+	  ENUM_XML(LinkageSpecDecl::lang_cxx, "CXX")
+  END_ENUM_XML
+END_NODE_XML
+
+
+//===----------------------------------------------------------------------===//
+#undef NODE_XML
+#undef ID_ATTRIBUTE_XML                
+#undef TYPE_ATTRIBUTE_XML
+#undef ATTRIBUTE_XML
+#undef ATTRIBUTE_SPECIAL_XML
+#undef ATTRIBUTE_OPT_XML
+#undef ATTRIBUTE_ENUM_XML
+#undef ATTRIBUTE_ENUM_OPT_XML
+#undef ATTRIBUTE_FILE_LOCATION_XML
+#undef ENUM_XML
+#undef END_ENUM_XML                    
+#undef END_NODE_XML                    
+#undef SUB_NODE_XML
+#undef SUB_NODE_SEQUENCE_XML
+#undef SUB_NODE_OPT_XML
diff --git a/include/clang/Frontend/DocumentXML.def b/include/clang/Frontend/DocumentXML.def
new file mode 100644
index 000000000000..4c52bd84422f
--- /dev/null
+++ b/include/clang/Frontend/DocumentXML.def
@@ -0,0 +1,75 @@
+//===-- DocumentXML.def - Metadata about Document XML nodes -----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the XML root database structure as written in 
+//  an AST XML document. 
+//  The following macros are used:
+//
+//  NODE_XML( CLASS, NAME ) - A node of name NAME denotes a concrete 
+//  statement of class CLASS where CLASS is a class name used internally by clang. 
+//  After a NODE_XML the definition of all (optional) attributes of that statement 
+//  node and possible sub-nodes follows.
+//
+//  END_NODE_XML - Closes the attribute definition of the current node.
+//
+//  ID_ATTRIBUTE_XML - Some nodes have an "id" attribute containing a 
+//  string, which value uniquely identify the entity represented by that node. 
+//  Other nodes may refer by reference attributes to this value.
+//
+//  ATTRIBUTE_SPECIAL_XML( FN, NAME ) - An attribute named NAME which deserves 
+//  a special handling. See the appropriate documentations. 
+//
+//  SUB_NODE_XML( CLASS ) - A mandatory sub-node of class CLASS or its sub-classes.
+//
+//  SUB_NODE_SEQUENCE_XML( CLASS ) - Zero or more sub-nodes of class CLASS or 
+//  its sub-classes.
+//
+//===----------------------------------------------------------------------===//
+
+ROOT_NODE_XML("CLANG_XML")
+  ATTRIBUTE_SPECIAL_XML(ignore, "version")     // special retrieving needed
+  SUB_NODE_XML("TranslationUnit")
+  SUB_NODE_XML("ReferenceSection")
+END_NODE_XML
+
+NODE_XML("TranslationUnit")
+  SUB_NODE_SEQUENCE_XML(Decl)
+END_NODE_XML
+
+NODE_XML("ReferenceSection")
+  SUB_NODE_XML("Types")
+  SUB_NODE_XML("Contexts")
+  SUB_NODE_XML("Files")
+END_NODE_XML
+
+NODE_XML("Types")
+  SUB_NODE_SEQUENCE_XML(Type)
+END_NODE_XML
+
+NODE_XML("Contexts")
+  SUB_NODE_SEQUENCE_XML(DeclContext)
+END_NODE_XML
+
+NODE_XML("Files")
+  SUB_NODE_SEQUENCE_XML("File")
+END_NODE_XML
+
+NODE_XML("File")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_SPECIAL_XML(ignore, "name")         // special retrieving needed, denotes the source file name
+END_NODE_XML
+
+
+//===----------------------------------------------------------------------===//
+#undef NODE_XML
+#undef ID_ATTRIBUTE_XML                
+#undef ATTRIBUTE_SPECIAL_XML
+#undef END_NODE_XML                    
+#undef SUB_NODE_XML
+#undef SUB_NODE_SEQUENCE_XML
diff --git a/include/clang/Frontend/DocumentXML.h b/include/clang/Frontend/DocumentXML.h
index 99db717190dd..4ed11e153ce3 100644
--- a/include/clang/Frontend/DocumentXML.h
+++ b/include/clang/Frontend/DocumentXML.h
@@ -17,6 +17,7 @@
 
 #include <string>
 #include <map>
+#include <stack>
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeOrdering.h"
 #include "llvm/Support/raw_ostream.h"
@@ -30,6 +31,7 @@ class Decl;
 class NamedDecl;
 class FunctionDecl;
 class ASTContext;
+class LabelStmt;
  
 //--------------------------------------------------------- 
 namespace XML
@@ -50,26 +52,37 @@ class DocumentXML
 {
 public:
   DocumentXML(const std::string& rootName, llvm::raw_ostream& out);
-  ~DocumentXML();
 
   void initialize(ASTContext &Context);
   void PrintDecl(Decl *D);
   void PrintStmt(const Stmt *S);    // defined in StmtXML.cpp
-
   void finalize();
 
 
   DocumentXML& addSubNode(const std::string& name);   // also enters the sub node, returns *this
   DocumentXML& toParent();                            // returns *this
 
+  void addAttribute(const char* pName, const QualType& pType);  
+  void addAttribute(const char* pName, bool value);
+
+  template<class T>
+  void addAttribute(const char* pName, const T* value)
+  {
+    addPtrAttribute(pName, value);
+  }
+
+  template<class T>
+  void addAttribute(const char* pName, T* value)
+  {
+    addPtrAttribute(pName, value);
+  }
+
   template<class T>
   void addAttribute(const char* pName, const T& value);
   
-  void addTypeAttribute(const QualType& pType);  
-  void addRefAttribute(const NamedDecl* D);
+  template<class T>
+  void addAttributeOptional(const char* pName, const T& value);
 
-  enum tContextUsage { CONTEXT_AS_CONTEXT, CONTEXT_AS_ID };
-  void addContextAttribute(const DeclContext *DC, tContextUsage usage = CONTEXT_AS_CONTEXT);
   void addSourceFileAttribute(const std::string& fileName);
 
   PresumedLoc addLocation(const SourceLocation& Loc);
@@ -81,13 +94,9 @@ private:
   DocumentXML(const DocumentXML&);              // not defined
   DocumentXML& operator=(const DocumentXML&);   // not defined
 
-  struct NodeXML;
-
-  NodeXML*  Root;
-  NodeXML*  CurrentNode;   // always after Root
+  std::stack<std::string> NodeStack;
   llvm::raw_ostream& Out;
   ASTContext *Ctx;
-  int       CurrentIndent;
   bool      HasCurrentNodeSubNodes;
 
 
@@ -96,15 +105,38 @@ private:
   XML::IdMap<const Type*>              BasicTypes;
   XML::IdMap<std::string>              SourceFiles;
   XML::IdMap<const NamedDecl*>         Decls;
+  XML::IdMap<const LabelStmt*>         Labels;
 
   void addContextsRecursively(const DeclContext *DC);
-  void addBasicTypeRecursively(const Type* pType);
+  void addTypeRecursively(const Type* pType);
   void addTypeRecursively(const QualType& pType);
 
-  void PrintFunctionDecl(FunctionDecl *FD);
-  void addDeclIdAttribute(const NamedDecl* D);
-  void addTypeIdAttribute(const Type* pType);  
   void Indent();
+
+  // forced pointer dispatch:
+  void addPtrAttribute(const char* pName, const Type* pType);  
+  void addPtrAttribute(const char* pName, const NamedDecl* D);
+  void addPtrAttribute(const char* pName, const DeclContext* D);
+  void addPtrAttribute(const char* pName, const NamespaceDecl* D);    // disambiguation
+  void addPtrAttribute(const char* pName, const LabelStmt* L);
+  void addPtrAttribute(const char* pName, const char* text);
+
+  // defined in TypeXML.cpp:
+  void addParentTypes(const Type* pType);
+  void writeTypeToXML(const Type* pType);
+  void writeTypeToXML(const QualType& pType);
+  class TypeAdder;
+  friend class TypeAdder;
+
+  // defined in DeclXML.cpp:
+  void writeDeclToXML(Decl *D);
+  class DeclPrinter;
+  friend class DeclPrinter;
+
+  // for addAttributeOptional:
+  static bool isDefault(unsigned value)           { return value == 0; }
+  static bool isDefault(bool value)               { return !value; }
+  static bool isDefault(const std::string& value) { return value.empty(); }
 };
 
 //--------------------------------------------------------- inlines
@@ -122,6 +154,28 @@ inline void DocumentXML::addAttribute(const char* pName, const T& value)
 }
 
 //--------------------------------------------------------- 
+inline void DocumentXML::addPtrAttribute(const char* pName, const char* text)
+{
+  Out << ' ' << pName << "=\"" << text << "\"";
+}
+
+//--------------------------------------------------------- 
+inline void DocumentXML::addAttribute(const char* pName, bool value)
+{
+  addPtrAttribute(pName, value ? "1" : "0");
+}
+
+//--------------------------------------------------------- 
+template<class T>
+inline void DocumentXML::addAttributeOptional(const char* pName, const T& value)
+{
+  if (!isDefault(value))
+  {
+    addAttribute(pName, value);
+  }
+}
+
+//--------------------------------------------------------- 
 
 } //namespace clang 
 
diff --git a/include/clang/Frontend/PCHBitCodes.h b/include/clang/Frontend/PCHBitCodes.h
index 0862cd6390f4..e546a12c49e9 100644
--- a/include/clang/Frontend/PCHBitCodes.h
+++ b/include/clang/Frontend/PCHBitCodes.h
@@ -386,8 +386,8 @@ namespace clang {
       TYPE_OBJC_INTERFACE           = 21,
       /// \brief An ObjCQualifiedInterfaceType record.
       TYPE_OBJC_QUALIFIED_INTERFACE = 22,
-      /// \brief An ObjCQualifiedIdType record.
-      TYPE_OBJC_QUALIFIED_ID        = 23
+      /// \brief An ObjCObjectPointerType record.
+      TYPE_OBJC_OBJECT_POINTER      = 23
     };
 
     /// \brief The type IDs for special types constructed by semantic
diff --git a/include/clang/Frontend/PCHReader.h b/include/clang/Frontend/PCHReader.h
index 1e00ae34137d..b3ed36434312 100644
--- a/include/clang/Frontend/PCHReader.h
+++ b/include/clang/Frontend/PCHReader.h
@@ -53,6 +53,82 @@ class NamedDecl;
 class Preprocessor;
 class Sema;
 class SwitchCase;
+class PCHReader;
+class HeaderFileInfo;
+
+/// \brief Abstract interface for callback invocations by the PCHReader.
+///
+/// While reading a PCH file, the PCHReader will call the methods of the
+/// listener to pass on specific information. Some of the listener methods can
+/// return true to indicate to the PCHReader that the information (and
+/// consequently the PCH file) is invalid.
+class PCHReaderListener {
+public:
+  virtual ~PCHReaderListener();
+  
+  /// \brief Receives the language options.
+  ///
+  /// \returns true to indicate the options are invalid or false otherwise.
+  virtual bool ReadLanguageOptions(const LangOptions &LangOpts) {
+    return false;
+  }
+  
+  /// \brief Receives the target triple.
+  ///
+  /// \returns true to indicate the target triple is invalid or false otherwise.
+  virtual bool ReadTargetTriple(const std::string &Triple) {
+    return false;
+  }
+  
+  /// \brief Receives the contents of the predefines buffer.
+  ///
+  /// \param PCHPredef The start of the predefines buffer in the PCH
+  /// file.
+  ///
+  /// \param PCHPredefLen The length of the predefines buffer in the PCH
+  /// file.
+  ///
+  /// \param PCHBufferID The FileID for the PCH predefines buffer.
+  ///
+  /// \param SuggestedPredefines If necessary, additional definitions are added
+  /// here.
+  ///
+  /// \returns true to indicate the predefines are invalid or false otherwise.
+  virtual bool ReadPredefinesBuffer(const char *PCHPredef, 
+                                    unsigned PCHPredefLen,
+                                    FileID PCHBufferID,
+                                    std::string &SuggestedPredefines) {
+    return false;
+  }
+  
+  /// \brief Receives a HeaderFileInfo entry.
+  virtual void ReadHeaderFileInfo(const HeaderFileInfo &HFI) {}
+  
+  /// \brief Receives __COUNTER__ value.
+  virtual void ReadCounter(unsigned Value) {}
+};
+
+/// \brief PCHReaderListener implementation to validate the information of
+/// the PCH file against an initialized Preprocessor.
+class PCHValidator : public PCHReaderListener {
+  Preprocessor &PP;
+  PCHReader &Reader;
+  
+  unsigned NumHeaderInfos;
+  
+public:
+  PCHValidator(Preprocessor &PP, PCHReader &Reader)
+    : PP(PP), Reader(Reader), NumHeaderInfos(0) {}
+  
+  virtual bool ReadLanguageOptions(const LangOptions &LangOpts);
+  virtual bool ReadTargetTriple(const std::string &Triple);
+  virtual bool ReadPredefinesBuffer(const char *PCHPredef, 
+                                    unsigned PCHPredefLen,
+                                    FileID PCHBufferID,
+                                    std::string &SuggestedPredefines);
+  virtual void ReadHeaderFileInfo(const HeaderFileInfo &HFI);
+  virtual void ReadCounter(unsigned Value);
+};
 
 /// \brief Reads a precompiled head containing the contents of a
 /// translation unit.
@@ -75,12 +151,19 @@ public:
   enum PCHReadResult { Success, Failure, IgnorePCH };
 
 private:
+  /// \ brief The receiver of some callbacks invoked by PCHReader.
+  llvm::OwningPtr<PCHReaderListener> Listener;
+  
+  SourceManager &SourceMgr;
+  FileManager &FileMgr;
+  Diagnostic &Diags;
+  
   /// \brief The semantic analysis object that will be processing the
   /// PCH file and the translation unit that uses it.
   Sema *SemaObj;
 
   /// \brief The preprocessor that will be loading the source file.
-  Preprocessor &PP;
+  Preprocessor *PP;
 
   /// \brief The AST context into which we'll read the PCH file.
   ASTContext *Context;
@@ -328,12 +411,33 @@ private:
 public:
   typedef llvm::SmallVector<uint64_t, 64> RecordData;
 
-  explicit PCHReader(Preprocessor &PP, ASTContext *Context);
+  /// \brief Load the PCH file and validate its contents against the given
+  /// Preprocessor.
+  PCHReader(Preprocessor &PP, ASTContext *Context);
+  
+  /// \brief Load the PCH file without using any pre-initialized Preprocessor.
+  ///
+  /// The necessary information to initialize a Preprocessor later can be
+  /// obtained by setting a PCHReaderListener.
+  PCHReader(SourceManager &SourceMgr, FileManager &FileMgr, Diagnostic &Diags);
   ~PCHReader();
 
   /// \brief Load the precompiled header designated by the given file
   /// name.
   PCHReadResult ReadPCH(const std::string &FileName);
+  
+  /// \brief Set the PCH callbacks listener.
+  void setListener(PCHReaderListener *listener) {
+    Listener.reset(listener);
+  }
+  
+  /// \brief Set the Preprocessor to use.
+  void setPreprocessor(Preprocessor &pp) {
+    PP = &pp;
+  }
+  
+  /// \brief Sets and initializes the given Context.
+  void InitializeContext(ASTContext &Context);
 
   /// \brief Retrieve the name of the original source file name 
   const std::string &getOriginalSourceFile() { return OriginalFileName; }
diff --git a/include/clang/Frontend/StmtXML.def b/include/clang/Frontend/StmtXML.def
new file mode 100644
index 000000000000..26430f740d91
--- /dev/null
+++ b/include/clang/Frontend/StmtXML.def
@@ -0,0 +1,517 @@
+//===-- StmtXML.def - Metadata about Stmt XML nodes ------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the XML statement database structure as written in 
+//  <TranslationUnit> sub-nodes of the XML document. 
+//  The semantics of the attributes and enums are mostly self-documenting
+//  by looking at the appropriate internally used functions and values.
+//  The following macros are used:
+//
+//  NODE_XML( CLASS, NAME ) - A node of name NAME denotes a concrete 
+//  statement of class CLASS where CLASS is a class name used internally by clang. 
+//  After a NODE_XML the definition of all (optional) attributes of that statement 
+//  node and possible sub-nodes follows.
+//
+//  END_NODE_XML - Closes the attribute definition of the current node.
+//
+//  ID_ATTRIBUTE_XML - Some statement nodes have an "id" attribute containing a 
+//  string, which value uniquely identify that statement. Other nodes may refer 
+//  by reference attributes to this value (currently used only for Label).
+//
+//  TYPE_ATTRIBUTE_XML( FN ) - Type nodes refer to the result type id of an
+//  expression by a "type" attribute. FN is internally used by clang.
+// 
+//  ATTRIBUTE_XML( FN, NAME ) - An attribute named NAME. FN is internally 
+//  used by clang. A boolean attribute have the values "0" or "1".
+//
+//  ATTRIBUTE_SPECIAL_XML( FN, NAME ) - An attribute named NAME which deserves 
+//  a special handling. See the appropriate documentations. 
+//
+//  ATTRIBUTE_FILE_LOCATION_XML - A bunch of attributes denoting the location of
+//  a statement in the source file(s).
+//
+//  ATTRIBUTE_OPT_XML( FN, NAME ) - An optional attribute named NAME. 
+//  Optional attributes are omitted for boolean types, if the value is false, 
+//  for integral types, if the value is null and for strings, 
+//  if the value is the empty string. FN is internally used by clang.
+//
+//  ATTRIBUTE_ENUM[_OPT]_XML( FN, NAME ) - An attribute named NAME. The value
+//  is an enumeration defined with ENUM_XML macros immediately following after 
+//  that macro. An optional attribute is ommited, if the particular enum is the 
+//  empty string. FN is internally used by clang.
+//  
+//  ENUM_XML( VALUE, NAME ) - An enumeration element named NAME. VALUE is 
+//  internally used by clang.
+//
+//  END_ENUM_XML - Closes the enumeration definition of the current attribute.
+//
+//  SUB_NODE_XML( CLASS ) - A mandatory sub-node of class CLASS or its sub-classes.
+//
+//  SUB_NODE_OPT_XML( CLASS ) - An optional sub-node of class CLASS or its sub-classes.
+//
+//  SUB_NODE_SEQUENCE_XML( CLASS ) - Zero or more sub-nodes of class CLASS or 
+//  its sub-classes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ATTRIBUTE_FILE_LOCATION_XML
+#  define ATTRIBUTE_FILE_LOCATION_XML             \
+     ATTRIBUTE_XML(getFilename(), "file")         \
+     ATTRIBUTE_XML(getLine(), "line")             \
+     ATTRIBUTE_XML(getColumn(), "col")            \
+     ATTRIBUTE_OPT_XML(getFilename(), "endfile")  \
+     ATTRIBUTE_OPT_XML(getLine(), "endline")      \
+     ATTRIBUTE_OPT_XML(getColumn(), "endcol")
+#endif
+
+#ifndef TYPE_ATTRIBUTE_XML
+#  define TYPE_ATTRIBUTE_XML( FN )     ATTRIBUTE_XML(FN, "type")
+#endif
+
+#ifndef CONTEXT_ATTRIBUTE_XML
+#  define CONTEXT_ATTRIBUTE_XML( FN )  ATTRIBUTE_XML(FN, "context")
+#endif
+
+
+NODE_XML(NullStmt, "NullStmt")
+  ATTRIBUTE_FILE_LOCATION_XML
+END_NODE_XML
+
+NODE_XML(CompoundStmt, "CompoundStmt")
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(size(), "num_stmts")
+  SUB_NODE_SEQUENCE_XML(Stmt)
+END_NODE_XML
+
+NODE_XML(CaseStmt, "CaseStmt")                        // case expr: body;
+  ATTRIBUTE_FILE_LOCATION_XML
+  SUB_NODE_XML(Stmt)                                  // body 
+  SUB_NODE_XML(Expr)                                  // expr
+  SUB_NODE_XML(Expr)                                  // rhs expr in gc extension: case expr .. expr: body;
+END_NODE_XML
+
+NODE_XML(DefaultStmt, "DefaultStmt")                  // default: body;
+  ATTRIBUTE_FILE_LOCATION_XML
+  SUB_NODE_XML(Stmt)                                  // body 
+END_NODE_XML
+
+NODE_XML(LabelStmt, "LabelStmt")                      // Label: body;
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getName(), "name")                    // string
+  SUB_NODE_XML(Stmt)                                  // body 
+END_NODE_XML
+
+NODE_XML(IfStmt, "IfStmt")                            // if (cond) stmt1; else stmt2;
+  ATTRIBUTE_FILE_LOCATION_XML
+  SUB_NODE_XML(Expr)                                  // cond
+  SUB_NODE_XML(Stmt)                                  // stmt1
+  SUB_NODE_XML(Stmt)                                  // stmt2
+END_NODE_XML
+
+NODE_XML(SwitchStmt, "SwitchStmt")                    // switch (cond) body;
+  ATTRIBUTE_FILE_LOCATION_XML
+  SUB_NODE_XML(Expr)                                  // cond
+  SUB_NODE_XML(Stmt)                                  // body
+END_NODE_XML
+
+NODE_XML(WhileStmt, "WhileStmt")                      // while (cond) body;
+  ATTRIBUTE_FILE_LOCATION_XML
+  SUB_NODE_XML(Expr)                                  // cond
+  SUB_NODE_XML(Stmt)                                  // body
+END_NODE_XML
+
+NODE_XML(DoStmt, "DoStmt")                            // do body while (cond);
+  ATTRIBUTE_FILE_LOCATION_XML
+  SUB_NODE_XML(Expr)                                  // cond
+  SUB_NODE_XML(Stmt)                                  // body
+END_NODE_XML
+
+NODE_XML(ForStmt, "ForStmt")                          // for (init; cond; inc) body;
+  ATTRIBUTE_FILE_LOCATION_XML
+  SUB_NODE_XML(Stmt)                                  // init
+  SUB_NODE_XML(Expr)                                  // cond
+  SUB_NODE_XML(Expr)                                  // inc
+  SUB_NODE_XML(Stmt)                                  // body
+END_NODE_XML
+
+NODE_XML(GotoStmt, "GotoStmt")                        // goto label;
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getLabel()->getName(), "name")        // informal string
+  ATTRIBUTE_XML(getLabel(), "ref")                    // id string
+END_NODE_XML
+
+NODE_XML(IndirectGotoStmt, "IndirectGotoStmt")        // goto expr;
+  ATTRIBUTE_FILE_LOCATION_XML
+  SUB_NODE_XML(Expr)                                  // expr
+END_NODE_XML
+
+NODE_XML(ContinueStmt, "ContinueStmt")                // continue
+  ATTRIBUTE_FILE_LOCATION_XML
+END_NODE_XML
+
+NODE_XML(BreakStmt, "BreakStmt")                      // break
+  ATTRIBUTE_FILE_LOCATION_XML
+END_NODE_XML
+
+NODE_XML(ReturnStmt, "ReturnStmt")                    // return expr;
+  ATTRIBUTE_FILE_LOCATION_XML
+  SUB_NODE_XML(Expr)                                  // expr
+END_NODE_XML
+
+NODE_XML(AsmStmt, "AsmStmt")                          // GNU inline-assembly statement extension
+  ATTRIBUTE_FILE_LOCATION_XML
+  // FIXME
+END_NODE_XML
+
+NODE_XML(DeclStmt, "DeclStmt")                        // a declaration statement   
+  ATTRIBUTE_FILE_LOCATION_XML
+  SUB_NODE_SEQUENCE_XML(Decl)                                  
+END_NODE_XML
+
+// C++ statements
+NODE_XML(CXXTryStmt, "CXXTryStmt")                    // try CompoundStmt CXXCatchStmt1 CXXCatchStmt2 ..
+  ATTRIBUTE_FILE_LOCATION_XML
+  ATTRIBUTE_XML(getNumHandlers(), "num_handlers")
+  SUB_NODE_XML(CompoundStmt) 
+  SUB_NODE_SEQUENCE_XML(CXXCatchStmt)                                  
+END_NODE_XML
+
+NODE_XML(CXXCatchStmt, "CXXCatchStmt")                // catch (decl) Stmt
+  ATTRIBUTE_FILE_LOCATION_XML
+  SUB_NODE_XML(VarDecl)
+  SUB_NODE_XML(Stmt) 
+END_NODE_XML
+
+// Expressions
+NODE_XML(PredefinedExpr, "PredefinedExpr")
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_ENUM_XML(getIdentType(), "kind")
+	  ENUM_XML(PredefinedExpr::Func, "__func__")
+	  ENUM_XML(PredefinedExpr::Function, "__FUNCTION__")
+	  ENUM_XML(PredefinedExpr::PrettyFunction, "__PRETTY_FUNCTION__")
+  END_ENUM_XML
+END_NODE_XML
+
+NODE_XML(DeclRefExpr, "DeclRefExpr")                  // an expression referring to a declared entity
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_XML(getDecl(), "ref")                     // id string of the declaration
+  ATTRIBUTE_XML(getDecl()->getNameAsString(), "name") // informal
+  //ATTRIBUTE_ENUM_XML(getDecl()->getKind(), "kind")  // really needed here?
+END_NODE_XML
+
+NODE_XML(IntegerLiteral, "IntegerLiteral")
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_XML(getValue(), "value")                  // (signed) integer
+END_NODE_XML
+
+NODE_XML(CharacterLiteral, "CharacterLiteral")
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_XML(getValue(), "value")                  // unsigned
+END_NODE_XML
+
+NODE_XML(FloatingLiteral, "FloatingLiteral")
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  // FIXME: output float as written in source (no approximation or the like)
+  //ATTRIBUTE_XML(getValueAsApproximateDouble(), "value")   // float
+END_NODE_XML
+
+NODE_XML(StringLiteral, "StringLiteral")
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_SPECIAL_XML(getStrData(), "value")          // string, special handling for escaping needed
+  ATTRIBUTE_OPT_XML(isWide(), "is_wide")                // boolean  
+END_NODE_XML
+
+NODE_XML(UnaryOperator, "UnaryOperator")                // op(expr) or (expr)op
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_ENUM_XML(getOpcode(), "kind")
+    ENUM_XML(UnaryOperator::PostInc, "postinc")
+    ENUM_XML(UnaryOperator::PostDec, "postdec")
+    ENUM_XML(UnaryOperator::PreInc,  "preinc")
+    ENUM_XML(UnaryOperator::PreDec,  "predec")
+    ENUM_XML(UnaryOperator::AddrOf,  "addrof")
+    ENUM_XML(UnaryOperator::Deref,   "deref")
+    ENUM_XML(UnaryOperator::Plus,    "plus")
+    ENUM_XML(UnaryOperator::Minus,   "minus")
+    ENUM_XML(UnaryOperator::Not,     "not")             // bitwise not
+    ENUM_XML(UnaryOperator::LNot,    "lnot")            // boolean not
+    ENUM_XML(UnaryOperator::Real,    "__real") 
+    ENUM_XML(UnaryOperator::Imag,    "__imag")
+    ENUM_XML(UnaryOperator::Extension, "__extension__")
+    ENUM_XML(UnaryOperator::OffsetOf,  "__builtin_offsetof")
+  END_ENUM_XML
+  SUB_NODE_XML(Expr)                                    // expr
+END_NODE_XML
+
+NODE_XML(BinaryOperator, "BinaryOperator")              // (expr1) op (expr2)
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_ENUM_XML(getOpcode(), "kind")
+    ENUM_XML(BinaryOperator::PtrMemD  , "ptrmemd")
+    ENUM_XML(BinaryOperator::PtrMemI  , "ptrmemi")
+    ENUM_XML(BinaryOperator::Mul      , "mul")
+    ENUM_XML(BinaryOperator::Div      , "div")
+    ENUM_XML(BinaryOperator::Rem      , "rem")
+    ENUM_XML(BinaryOperator::Add      , "add")
+    ENUM_XML(BinaryOperator::Sub      , "sub")
+    ENUM_XML(BinaryOperator::Shl      , "shl")
+    ENUM_XML(BinaryOperator::Shr      , "shr")
+    ENUM_XML(BinaryOperator::LT       , "lt")
+    ENUM_XML(BinaryOperator::GT       , "gt")
+    ENUM_XML(BinaryOperator::LE       , "le")
+    ENUM_XML(BinaryOperator::GE       , "ge")
+    ENUM_XML(BinaryOperator::EQ       , "eq")
+    ENUM_XML(BinaryOperator::NE       , "ne")
+    ENUM_XML(BinaryOperator::And      , "and")          // bitwise and
+    ENUM_XML(BinaryOperator::Xor      , "xor")
+    ENUM_XML(BinaryOperator::Or       , "or")           // bitwise or
+    ENUM_XML(BinaryOperator::LAnd     , "land")         // boolean and
+    ENUM_XML(BinaryOperator::LOr      , "lor")          // boolean or
+    ENUM_XML(BinaryOperator::Assign   , "assign")
+    ENUM_XML(BinaryOperator::MulAssign, "mulassign")
+    ENUM_XML(BinaryOperator::DivAssign, "divassign")
+    ENUM_XML(BinaryOperator::RemAssign, "remassign")
+    ENUM_XML(BinaryOperator::AddAssign, "addassign")
+    ENUM_XML(BinaryOperator::SubAssign, "subassign")
+    ENUM_XML(BinaryOperator::ShlAssign, "shlassign")
+    ENUM_XML(BinaryOperator::ShrAssign, "shrassign")
+    ENUM_XML(BinaryOperator::AndAssign, "andassign")
+    ENUM_XML(BinaryOperator::XorAssign, "xorassign")
+    ENUM_XML(BinaryOperator::OrAssign , "orassign")
+    ENUM_XML(BinaryOperator::Comma    , "comma")
+  END_ENUM_XML
+  SUB_NODE_XML(Expr)                                    // expr1
+  SUB_NODE_XML(Expr)                                    // expr2
+END_NODE_XML
+
+// FIXME: is there a special class needed or is BinaryOperator sufficient?
+//NODE_XML(CompoundAssignOperator, "CompoundAssignOperator")
+
+NODE_XML(ConditionalOperator, "ConditionalOperator")    // expr1 ? expr2 : expr3
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  SUB_NODE_XML(Expr)                                    // expr1
+  SUB_NODE_XML(Expr)                                    // expr2
+  SUB_NODE_XML(Expr)                                    // expr3
+END_NODE_XML
+
+NODE_XML(SizeOfAlignOfExpr, "SizeOfAlignOfExpr")        // sizeof(expr) or alignof(expr)
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_XML(isSizeOf(), "is_sizeof")  
+  ATTRIBUTE_XML(isArgumentType(), "is_type")            // "1" if expr denotes a type
+  ATTRIBUTE_SPECIAL_XML(getArgumentType(), "type_ref")  // optional, denotes the type of expr, if is_type=="1", special handling needed since getArgumentType() could assert
+  SUB_NODE_OPT_XML(Expr)                                // expr, if is_type=="0"
+END_NODE_XML
+
+NODE_XML(ArraySubscriptExpr, "ArraySubscriptExpr")      // expr1[expr2]
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  SUB_NODE_XML(Expr)                                    // expr1
+  SUB_NODE_XML(Expr)                                    // expr2
+END_NODE_XML
+
+NODE_XML(CallExpr, "CallExpr")                          // fnexpr(arg1, arg2, ...)
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_XML(getNumArgs(), "num_args")               // unsigned
+  SUB_NODE_XML(Expr)                                    // fnexpr
+  SUB_NODE_SEQUENCE_XML(Expr)                           // arg1..argN
+END_NODE_XML
+
+NODE_XML(MemberExpr, "MemberExpr")                      // expr->F or expr.F
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_XML(isArrow(), "is_deref")
+  ATTRIBUTE_XML(getMemberDecl(), "ref")                 // refers to F
+  ATTRIBUTE_XML(getMemberDecl()->getNameAsString(), "name") // informal
+  SUB_NODE_XML(Expr)                                    // expr
+END_NODE_XML
+
+NODE_XML(CStyleCastExpr, "CStyleCastExpr")              // (type)expr
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())                         
+  ATTRIBUTE_XML(getTypeAsWritten(), "type_ref")         // denotes the type as written in the source code
+  SUB_NODE_XML(Expr)                                    // expr
+END_NODE_XML
+
+NODE_XML(ImplicitCastExpr, "ImplicitCastExpr")
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())                         
+  SUB_NODE_XML(Expr)                                   
+END_NODE_XML
+
+NODE_XML(CompoundLiteralExpr, "CompoundLiteralExpr")    // [C99 6.5.2.5] 
+  SUB_NODE_XML(Expr)                                    // init
+END_NODE_XML
+
+NODE_XML(ExtVectorElementExpr, "ExtVectorElementExpr")
+  SUB_NODE_XML(Expr)                                    // base 
+END_NODE_XML
+
+NODE_XML(InitListExpr, "InitListExpr")                  // struct foo x = { expr1, { expr2, expr3 } };
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_OPT_XML(getInitializedFieldInUnion(), "field_ref")  // if a union is initialized, this refers to the initialized union field id 
+  ATTRIBUTE_XML(getNumInits(), "num_inits")             // unsigned
+  SUB_NODE_SEQUENCE_XML(Expr)                           // expr1..exprN
+END_NODE_XML
+
+NODE_XML(DesignatedInitExpr, "DesignatedInitExpr")
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+END_NODE_XML
+
+NODE_XML(ImplicitValueInitExpr, "ImplicitValueInitExpr")  //  Implicit value initializations occur within InitListExpr
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+END_NODE_XML
+
+NODE_XML(VAArgExpr, "VAArgExpr")                        // used for the builtin function __builtin_va_start(expr)
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  SUB_NODE_XML(Expr)                                    // expr
+END_NODE_XML
+
+NODE_XML(ParenExpr, "ParenExpr")                        // this represents a parethesized expression "(expr)". Only formed if full location information is requested.
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  SUB_NODE_XML(Expr)                                    // expr
+END_NODE_XML
+
+// GNU Extensions
+NODE_XML(AddrLabelExpr, "AddrLabelExpr")                // the GNU address of label extension, representing &&label.
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_XML(getLabel(), "ref")                      // id string
+  SUB_NODE_XML(LabelStmt)                               // expr
+END_NODE_XML
+
+NODE_XML(StmtExpr, "StmtExpr")                          // StmtExpr contains a single CompoundStmt node, which it evaluates and takes the value of the last subexpression.
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  SUB_NODE_XML(CompoundStmt)
+END_NODE_XML
+
+NODE_XML(TypesCompatibleExpr, "TypesCompatibleExpr")    // GNU builtin-in function __builtin_types_compatible_p
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_XML(getArgType1(), "type1_ref")             // id of type1 
+  ATTRIBUTE_XML(getArgType2(), "type2_ref")             // id of type2 
+END_NODE_XML
+
+NODE_XML(ChooseExpr, "ChooseExpr")                      // GNU builtin-in function __builtin_choose_expr(expr1, expr2, expr3)
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  SUB_NODE_XML(Expr)                                    // expr1
+  SUB_NODE_XML(Expr)                                    // expr2
+  SUB_NODE_XML(Expr)                                    // expr3
+END_NODE_XML
+
+NODE_XML(GNUNullExpr, "GNUNullExpr")                    // GNU __null extension
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+END_NODE_XML
+
+// C++ Expressions
+NODE_XML(CXXOperatorCallExpr, "CXXOperatorCallExpr")    // fnexpr(arg1, arg2, ...)
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_XML(getNumArgs(), "num_args")               // unsigned
+  SUB_NODE_XML(Expr)                                    // fnexpr
+  SUB_NODE_SEQUENCE_XML(Expr)                           // arg1..argN
+END_NODE_XML
+
+NODE_XML(CXXNamedCastExpr, "CXXNamedCastExpr")          // xxx_cast<type>(expr)
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_ENUM_XML(getStmtClass(), "kind")
+	  ENUM_XML(Stmt::CXXStaticCastExprClass, "static_cast")
+	  ENUM_XML(Stmt::CXXDynamicCastExprClass, "dynamic_cast")
+	  ENUM_XML(Stmt::CXXReinterpretCastExprClass, "reinterpret_cast")
+	  ENUM_XML(Stmt::CXXConstCastExprClass, "const_cast")
+  END_ENUM_XML
+  ATTRIBUTE_XML(getTypeAsWritten(), "type_ref")         // denotes the type as written in the source code
+  SUB_NODE_XML(Expr)                                    // expr
+END_NODE_XML
+
+NODE_XML(CXXMemberCallExpr, "CXXMemberCallExpr")        // fnexpr(arg1, arg2, ...)
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_XML(getNumArgs(), "num_args")               // unsigned
+  SUB_NODE_XML(Expr)                                    // fnexpr
+  SUB_NODE_SEQUENCE_XML(Expr)                           // arg1..argN
+END_NODE_XML
+
+NODE_XML(CXXBoolLiteralExpr, "CXXBoolLiteralExpr")
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_XML(getValue(), "value")                    // boolean
+END_NODE_XML
+
+NODE_XML(CXXNullPtrLiteralExpr, "CXXNullPtrLiteralExpr")  // [C++0x 2.14.7] C++ Pointer Literal
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+END_NODE_XML
+
+NODE_XML(CXXTypeidExpr, "CXXTypeidExpr")                // typeid(expr)
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_XML(isTypeOperand(), "is_type")             // "1" if expr denotes a type
+  ATTRIBUTE_SPECIAL_XML(getTypeOperand(), "type_ref")   // optional, denotes the type of expr, if is_type=="1", special handling needed since getTypeOperand() could assert
+  SUB_NODE_OPT_XML(Expr)                                // expr, if is_type=="0"
+END_NODE_XML
+
+NODE_XML(CXXThisExpr, "CXXThisExpr")                    // this
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+END_NODE_XML
+
+NODE_XML(CXXThrowExpr, "CXXThrowExpr")                  // throw (expr);
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  SUB_NODE_XML(Expr)                                    // NULL in case of "throw;"
+END_NODE_XML
+
+NODE_XML(CXXDefaultArgExpr, "CXXDefaultArgExpr")
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  ATTRIBUTE_XML(getParam(), "ref")                      // id of the parameter declaration (the expression is a subnode of the declaration)
+END_NODE_XML
+
+NODE_XML(CXXConditionDeclExpr, "CXXConditionDeclExpr")
+  ATTRIBUTE_FILE_LOCATION_XML
+  TYPE_ATTRIBUTE_XML(getType())
+  SUB_NODE_XML(VarDecl)                                 // a CXXConditionDeclExpr owns the declaration
+END_NODE_XML
+
+
+//===----------------------------------------------------------------------===//
+#undef NODE_XML
+#undef ID_ATTRIBUTE_XML                
+#undef TYPE_ATTRIBUTE_XML
+#undef ATTRIBUTE_XML
+#undef ATTRIBUTE_SPECIAL_XML
+#undef ATTRIBUTE_OPT_XML
+#undef ATTRIBUTE_ENUM_XML
+#undef ATTRIBUTE_ENUM_OPT_XML
+#undef ATTRIBUTE_FILE_LOCATION_XML
+#undef ENUM_XML
+#undef END_ENUM_XML                    
+#undef END_NODE_XML                    
+#undef SUB_NODE_XML
+#undef SUB_NODE_SEQUENCE_XML
+#undef SUB_NODE_OPT_XML
diff --git a/include/clang/Frontend/TypeXML.def b/include/clang/Frontend/TypeXML.def
new file mode 100644
index 000000000000..2a78fd9f75b1
--- /dev/null
+++ b/include/clang/Frontend/TypeXML.def
@@ -0,0 +1,277 @@
+//===-- TypeXML.def - Metadata about Type XML nodes ------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the XML type info database as written in the   
+//  <ReferenceSection>/<Types> sub-nodes of the XML document. Type nodes 
+//  are referred by "type" reference attributes throughout the document.
+//  A type node never contains sub-nodes. 
+//  The semantics of the attributes and enums are mostly self-documenting
+//  by looking at the appropriate internally used functions and values.
+//  The following macros are used:
+//
+//  NODE_XML( CLASS, NAME ) - A node of name NAME denotes a concrete 
+//  type of class CLASS where CLASS is a class name used internally by clang. 
+//  After a NODE_XML the definition of all (optional) attributes of that type 
+//  node follows.
+//
+//  END_NODE_XML - Closes the attribute definition of the current node.
+//
+//  ID_ATTRIBUTE_XML - Each type node has an "id" attribute containing a 
+//  string, which value uniquely identify the type. Other nodes may refer 
+//  by "type" reference attributes to this value.
+//
+//  TYPE_ATTRIBUTE_XML( FN ) - Type nodes may refer to the ids of other type 
+//  nodes by a "type" attribute. FN is internally used by clang.
+// 
+//  CONTEXT_ATTRIBUTE_XML( FN ) - Type nodes may refer to the ids of their 
+//  declaration contexts by a "context" attribute. FN is internally used by 
+//  clang.
+//
+//  ATTRIBUTE_XML( FN, NAME ) - An attribute named NAME. FN is internally 
+//  used by clang. A boolean attribute have the values "0" or "1".
+//
+//  ATTRIBUTE_OPT_XML( FN, NAME ) - An optional attribute named NAME. 
+//  Optional attributes are omitted for boolean types, if the value is false, 
+//  for integral types, if the value is null and for strings, 
+//  if the value is the empty string. FN is internally used by clang.
+//
+//  ATTRIBUTE_ENUM[_OPT]_XML( FN, NAME ) - An attribute named NAME. The value
+//  is an enumeration defined with ENUM_XML macros immediately following after 
+//  that macro. An optional attribute is ommited, if the particular enum is the 
+//  empty string. FN is internally used by clang.
+//  
+//  ENUM_XML( VALUE, NAME ) - An enumeration element named NAME. VALUE is 
+//  internally used by clang.
+//
+//  END_ENUM_XML - Closes the enumeration definition of the current attribute.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TYPE_ATTRIBUTE_XML
+#  define TYPE_ATTRIBUTE_XML( FN )     ATTRIBUTE_XML(FN, "type")
+#endif
+
+#ifndef CONTEXT_ATTRIBUTE_XML
+#  define CONTEXT_ATTRIBUTE_XML( FN )  ATTRIBUTE_XML(FN, "context")
+#endif
+
+
+NODE_XML(QualType, "CvQualifiedType")
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getTypePtr())                      // the qualified type, e.g. for 'T* const' it's 'T*'
+  ATTRIBUTE_OPT_XML(isConstQualified(), "const")        // boolean
+  ATTRIBUTE_OPT_XML(isVolatileQualified(), "volatile")  // boolean
+  ATTRIBUTE_OPT_XML(isRestrictQualified(), "restrict")  // boolean
+END_NODE_XML
+
+NODE_XML(ExtQualType, "ExtQualType")
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getBaseType())
+  ATTRIBUTE_OPT_XML(getAddressSpace(), "adress_space")  // unsigned: Address Space ID - The address space ID this type is qualified with.
+  ATTRIBUTE_ENUM_OPT_XML(getObjCGCAttr(), "objc_gc")    // GC __weak/__strong attributes
+	  ENUM_XML(QualType::GCNone, "")
+	  ENUM_XML(QualType::Weak, "weak")
+	  ENUM_XML(QualType::Strong, "strong")
+  END_ENUM_XML
+END_NODE_XML
+
+NODE_XML(BuiltinType, "FundamentalType")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_ENUM_XML(getKind(), "kind")
+	  ENUM_XML(BuiltinType::Void, "void")
+	  ENUM_XML(BuiltinType::Bool, "bool")
+	  ENUM_XML(BuiltinType::Char_U, "char")               // not explicitely qualified char, depends on target platform
+	  ENUM_XML(BuiltinType::Char_S, "char")               // not explicitely qualified char, depends on target platform
+	  ENUM_XML(BuiltinType::SChar, "signed char")
+	  ENUM_XML(BuiltinType::Short, "short");
+	  ENUM_XML(BuiltinType::Int, "int");
+	  ENUM_XML(BuiltinType::Long, "long");
+	  ENUM_XML(BuiltinType::LongLong, "long long");
+	  ENUM_XML(BuiltinType::Int128, "__int128_t");
+	  ENUM_XML(BuiltinType::UChar, "unsigned char");
+	  ENUM_XML(BuiltinType::UShort, "unsigned short");
+	  ENUM_XML(BuiltinType::UInt, "unsigned int");
+	  ENUM_XML(BuiltinType::ULong, "unsigned long");
+	  ENUM_XML(BuiltinType::ULongLong, "unsigned long long");
+	  ENUM_XML(BuiltinType::UInt128, "__uint128_t");
+	  ENUM_XML(BuiltinType::Float, "float");
+	  ENUM_XML(BuiltinType::Double, "double");
+	  ENUM_XML(BuiltinType::LongDouble, "long double");
+	  ENUM_XML(BuiltinType::WChar, "wchar_t");
+	  ENUM_XML(BuiltinType::NullPtr, "nullptr_t");        // This is the type of C++0x 'nullptr'.
+	  ENUM_XML(BuiltinType::Overload, "overloaded");
+	  ENUM_XML(BuiltinType::Dependent, "dependent");
+  END_ENUM_XML
+END_NODE_XML
+
+NODE_XML(FixedWidthIntType, "FixedWidthIntType")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_XML(getWidth(), "width")                    // unsigned
+  ATTRIBUTE_XML(isSigned(), "is_signed")                // boolean
+END_NODE_XML
+
+NODE_XML(PointerType, "PointerType")    
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getPointeeType())
+END_NODE_XML
+
+NODE_XML(LValueReferenceType, "ReferenceType")
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getPointeeType())
+END_NODE_XML
+
+NODE_XML(RValueReferenceType, "ReferenceType")
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getPointeeType())
+END_NODE_XML
+
+NODE_XML(FunctionNoProtoType, "FunctionNoProtoType")
+  ID_ATTRIBUTE_XML
+END_NODE_XML
+
+NODE_XML(FunctionProtoType, "FunctionType")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_XML(getResultType(), "result_type")
+  ATTRIBUTE_OPT_XML(isVariadic(), "variadic")
+END_NODE_XML
+
+NODE_XML(TypedefType, "Typedef")
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getDecl()->getUnderlyingType())
+  ATTRIBUTE_XML(getDecl()->getNameAsString(), "name")     // string
+  CONTEXT_ATTRIBUTE_XML(getDecl()->getDeclContext())
+END_NODE_XML
+
+NODE_XML(ComplexType, "ComplexType")                      // C99 complex types (_Complex float etc)
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getElementType())
+END_NODE_XML
+
+NODE_XML(BlockPointerType, "BlockPointerType")
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getPointeeType())                    // alway refers to a function type
+END_NODE_XML
+
+NODE_XML(MemberPointerType, "MemberPointerType")
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getPointeeType())
+  ATTRIBUTE_XML(getClass(), "class_type")                 // refers to the class type id of which the pointee is a member
+END_NODE_XML
+
+NODE_XML(ConstantArrayType, "ArrayType")
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getElementType())
+  ATTRIBUTE_XML(getSize(), "size")                        // unsigned                    
+  ATTRIBUTE_ENUM_OPT_XML(getSizeModifier(), "size_modifier")
+	  ENUM_XML(ArrayType::Normal, "")
+	  ENUM_XML(ArrayType::Static, "static")
+	  ENUM_XML(ArrayType::Star, "star")
+  END_ENUM_XML
+  ATTRIBUTE_OPT_XML(getIndexTypeQualifier(), "index_type_qualifier")   // unsigned
+END_NODE_XML
+
+NODE_XML(IncompleteArrayType, "IncompleteArrayType")
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getElementType())
+END_NODE_XML
+
+NODE_XML(VariableArrayType, "VariableArrayType")
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getElementType())
+  // note: the size expression is print at the point of declaration
+END_NODE_XML
+
+NODE_XML(DependentSizedArrayType, "DependentSizedArrayType")
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getElementType())
+  // FIXME: how to deal with size expression?
+END_NODE_XML
+
+NODE_XML(VectorType, "VectorType")
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getElementType())
+  ATTRIBUTE_XML(getNumElements(), "size")               // unsigned
+END_NODE_XML
+
+NODE_XML(ExtVectorType, "ExtVectorType")
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getElementType())
+  ATTRIBUTE_XML(getNumElements(), "size")               // unsigned
+END_NODE_XML
+
+NODE_XML(TypeOfExprType, "TypeOfExprType")
+  ID_ATTRIBUTE_XML
+  // note: the typeof expression is print at the point of use
+END_NODE_XML
+
+NODE_XML(TypeOfType, "TypeOfType")
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getUnderlyingType())
+END_NODE_XML
+
+
+NODE_XML(RecordType, "Record")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_XML(getDecl()->getNameAsString(), "name")   // string
+  ATTRIBUTE_ENUM_XML(getDecl()->getTagKind(), "kind")
+    ENUM_XML(TagDecl::TK_struct, "struct")
+    ENUM_XML(TagDecl::TK_union, "union")
+    ENUM_XML(TagDecl::TK_class, "class")
+  END_ENUM_XML
+  CONTEXT_ATTRIBUTE_XML(getDecl()->getDeclContext())
+END_NODE_XML
+
+NODE_XML(EnumType, "Enum")
+  ID_ATTRIBUTE_XML
+  ATTRIBUTE_XML(getDecl()->getNameAsString(), "name")   // string
+  CONTEXT_ATTRIBUTE_XML(getDecl()->getDeclContext())
+END_NODE_XML
+
+NODE_XML(TemplateTypeParmType, "TemplateTypeParmType")
+  ID_ATTRIBUTE_XML
+END_NODE_XML
+
+NODE_XML(TemplateSpecializationType, "TemplateSpecializationType")
+  ID_ATTRIBUTE_XML
+END_NODE_XML
+
+NODE_XML(QualifiedNameType, "QualifiedNameType")
+  ID_ATTRIBUTE_XML
+  TYPE_ATTRIBUTE_XML(getNamedType())
+END_NODE_XML
+
+NODE_XML(TypenameType, "TypenameType")
+  ID_ATTRIBUTE_XML
+END_NODE_XML
+
+NODE_XML(ObjCInterfaceType, "ObjCInterfaceType")
+  ID_ATTRIBUTE_XML
+END_NODE_XML
+
+NODE_XML(ObjCQualifiedInterfaceType, "ObjCQualifiedInterfaceType")
+  ID_ATTRIBUTE_XML
+END_NODE_XML
+
+NODE_XML(ObjCObjectPointerType, "ObjCObjectPointerType")
+  ID_ATTRIBUTE_XML
+END_NODE_XML
+
+
+//===----------------------------------------------------------------------===//
+#undef NODE_XML
+#undef ID_ATTRIBUTE_XML                
+#undef TYPE_ATTRIBUTE_XML
+#undef CONTEXT_ATTRIBUTE_XML
+#undef ATTRIBUTE_XML
+#undef ATTRIBUTE_OPT_XML
+#undef ATTRIBUTE_ENUM_XML
+#undef ATTRIBUTE_ENUM_OPT_XML
+#undef ENUM_XML
+#undef END_ENUM_XML                    
+#undef END_NODE_XML