lib/Frontend/StmtXML.cpp

//===--- 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 VisitObjCKVCRefExpr(ObjCKVCRefExpr *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::VisitObjCKVCRefExpr(ObjCKVCRefExpr *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));
}