zcov: / include/clang/AST/FullExpr.h

	Files: 1 Branches Taken: 0.0% 0 / 0 Generated: 2010-02-10 01:31 Branches Executed: 0.0% 0 / 0 Line Coverage: 0.0% 0 / 5

	Programs: 2 Runs 3018

       1                 : //===--- FullExpr.h - C++ full expression class -----------------*- C++ -*-===//
       2                 : //
       3                 : //                     The LLVM Compiler Infrastructure
       4                 : //
       5                 : // This file is distributed under the University of Illinois Open Source
       6                 : // License. See LICENSE.TXT for details.
       7                 : //
       8                 : //===----------------------------------------------------------------------===//
       9                 : //
      10                 : //  This file defines the FullExpr interface, to be used for type safe handling
      11                 : //  of full expressions.
      12                 : //
      13                 : //  Full expressions are described in C++ [intro.execution]p12.
      14                 : //
      15                 : //===----------------------------------------------------------------------===//
      16                 : #ifndef LLVM_CLANG_AST_FULLEXPR_H
      17                 : #define LLVM_CLANG_AST_FULLEXPR_H
      18                 : 
      19                 : #include "llvm/ADT/PointerUnion.h"
      20                 : 
      21                 : namespace clang {
      22                 :   class ASTContext;
      23                 :   class CXXTemporary;
      24                 :   class Expr;
      25                 : 
      26                 : class FullExpr {
      27                 :   struct ExprAndTemporaries {
      28                 :     Expr *SubExpr;
      29                 :     
      30                 :     unsigned NumTemps;
      31                 :     
      32                 :     typedef CXXTemporary** temps_iterator;
      33                 :     
      34                0:     temps_iterator temps_begin() { 
      35                0:       return reinterpret_cast<CXXTemporary **>(this + 1); 
      36                 :     }
      37                0:     temps_iterator temps_end() { 
      38                0:       return temps_begin() + NumTemps;
      39                 :     }
      40                 :   };
      41                 : 
      42                 :   typedef llvm::PointerUnion<Expr *, ExprAndTemporaries *> SubExprTy;
      43                 :   SubExprTy SubExpr;
      44                 :   
      45                0:   FullExpr() { }
      46                 : 
      47                 : public:
      48                 :   static FullExpr Create(ASTContext &Context, Expr *SubExpr, 
      49                 :                          CXXTemporary **Temps, unsigned NumTemps);
      50                 :   void Destroy(ASTContext &Context);
      51                 :   
      52                 :   Expr *getExpr() {
      53                 :     if (Expr *E = SubExpr.dyn_cast<Expr *>())
      54                 :       return E;
      55                 :     
      56                 :     return SubExpr.get<ExprAndTemporaries *>()->SubExpr;
      57                 :   }
      58                 :   
      59                 :   const Expr *getExpr() const { 
      60                 :     return const_cast<FullExpr*>(this)->getExpr();
      61                 :   }
      62                 :   
      63                 :   typedef CXXTemporary** temps_iterator;
      64                 : 
      65                 :   temps_iterator temps_begin() {
      66                 :     if (ExprAndTemporaries *ET = SubExpr.dyn_cast<ExprAndTemporaries *>())
      67                 :       return ET->temps_begin();
      68                 :     
      69                 :     return 0;
      70                 :   }
      71                 :   temps_iterator temps_end() {
      72                 :     if (ExprAndTemporaries *ET = SubExpr.dyn_cast<ExprAndTemporaries *>())
      73                 :       return ET->temps_end();
      74                 :     
      75                 :     return 0;
      76                 :   }
      77                 :     
      78                 :   void *getAsOpaquePtr() const { return SubExpr.getOpaqueValue(); }
      79                 : 
      80                 :   static FullExpr getFromOpaquePtr(void *Ptr) {
      81                 :     FullExpr E;
      82                 :     E.SubExpr = SubExprTy::getFromOpaqueValue(Ptr);
      83                 :     return E;
      84                 :   }
      85                 : };
      86                 : 
      87                 : }  // end namespace clang
      88                 : 
      89                 : #endif