Expr.h revision 1049436d4b53d928b555f7381bc1639dd302bbc7
1324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver//===--- Expr.h - Classes for representing expressions ----------*- C++ -*-===// 2324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 3324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// The LLVM Compiler Infrastructure 4324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 5324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// This file was developed by Chris Lattner and is distributed under 6324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// the University of Illinois Open Source License. See LICENSE.TXT for details. 7324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 8324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver//===----------------------------------------------------------------------===// 9324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 10324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// This file defines the Expr interface and subclasses. 11324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 12324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver//===----------------------------------------------------------------------===// 13324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 14324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#ifndef LLVM_CLANG_AST_EXPR_H 15324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#define LLVM_CLANG_AST_EXPR_H 16324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 17324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#include "clang/AST/Stmt.h" 18324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#include "clang/AST/Type.h" 19324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#include "clang/AST/Decl.h" 20324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#include "clang/Basic/IdentifierTable.h" 21324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#include "llvm/ADT/APSInt.h" 22324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#include "llvm/ADT/APFloat.h" 23324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 24324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruvernamespace clang { 25324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver class IdentifierInfo; 26324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver class Selector; 27324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver class Decl; 28324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver class ASTContext; 29324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 30324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Expr - This represents one expression. Note that Expr's are subclasses of 31324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Stmt. This allows an expression to be transparently used any place a Stmt 32324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// is required. 33324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 34324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass Expr : public Stmt { 35324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver QualType TR; 36324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverprotected: 37324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr(StmtClass SC, QualType T) : Stmt(SC), TR(T) {} 38324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 39324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver QualType getType() const { return TR; } 40324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver void setType(QualType t) { TR = t; } 41324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 42324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// SourceLocation tokens are not useful in isolation - they are low level 43324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// value objects created/interpreted by SourceManager. We assume AST 44324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// clients will have a pointer to the respective SourceManager. 45324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual SourceRange getSourceRange() const = 0; 46324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 47324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// getExprLoc - Return the preferred location for the arrow when diagnosing 48324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// a problem with a generic expression. 49324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual SourceLocation getExprLoc() const { return getLocStart(); } 50324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 51324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// hasLocalSideEffect - Return true if this immediate expression has side 52324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// effects, not counting any sub-expressions. 53324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool hasLocalSideEffect() const; 54324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 55324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or 56324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// incomplete type other than void. Nonarray expressions that can be lvalues: 57324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// - name, where name must be a variable 58324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// - e[i] 59324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// - (e), where e must be an lvalue 60324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// - e.name, where e must be an lvalue 61324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// - e->name 62324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// - *e, the type of e cannot be a function type 63324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// - string-constant 64324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// - reference type [C++ [expr]] 65324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// 66324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver enum isLvalueResult { 67324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver LV_Valid, 68324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver LV_NotObjectType, 69324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver LV_IncompleteVoidType, 70324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver LV_DuplicateVectorComponents, 71324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver LV_InvalidExpression 72324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver }; 73324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver isLvalueResult isLvalue() const; 74324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 75324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, 76324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// does not have an incomplete type, does not have a const-qualified type, 77324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// and if it is a structure or union, does not have any member (including, 78324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// recursively, any member or element of all contained aggregates or unions) 79324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// with a const-qualified type. 80324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver enum isModifiableLvalueResult { 81324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver MLV_Valid, 82324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver MLV_NotObjectType, 83324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver MLV_IncompleteVoidType, 84324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver MLV_DuplicateVectorComponents, 85324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver MLV_InvalidExpression, 86324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver MLV_IncompleteType, 87324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver MLV_ConstQualified, 88324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver MLV_ArrayType 89324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver }; 90324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver isModifiableLvalueResult isModifiableLvalue() const; 91324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 92324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool isNullPointerConstant(ASTContext &Ctx) const; 93324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 94324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// isIntegerConstantExpr - Return true if this expression is a valid integer 95324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// constant expression, and, if so, return its value in Result. If not a 96324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// valid i-c-e, return false and fill in Loc (if specified) with the location 97324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// of the invalid expression. 98324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, 99324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation *Loc = 0, 100324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool isEvaluated = true) const; 101324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool isIntegerConstantExpr(ASTContext &Ctx, SourceLocation *Loc = 0) const { 102324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver llvm::APSInt X(32); 103324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return isIntegerConstantExpr(X, Ctx, Loc); 104324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 105324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// isConstantExpr - Return true if this expression is a valid constant expr. 106324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool isConstantExpr(ASTContext &Ctx, SourceLocation *Loc) const; 107324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 108324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Stmt *T) { 109324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return T->getStmtClass() >= firstExprConstant && 110324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver T->getStmtClass() <= lastExprConstant; 111324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 112324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Expr *) { return true; } 113324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 114324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static inline Expr* Materialize(llvm::Deserializer& D) { 115324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return cast<Expr>(Stmt::Materialize(D)); 116324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 117324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver}; 118324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 119324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver//===----------------------------------------------------------------------===// 120324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// Primary Expressions. 121324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver//===----------------------------------------------------------------------===// 122324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 123324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// DeclRefExpr - [C99 6.5.1p2] - A reference to a declared variable, function, 124324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// enum, etc. 125324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass DeclRefExpr : public Expr { 126324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ValueDecl *D; 127324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation Loc; 128324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 129324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver DeclRefExpr(ValueDecl *d, QualType t, SourceLocation l) : 130324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr(DeclRefExprClass, t), D(d), Loc(l) {} 131324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 132324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ValueDecl *getDecl() { return D; } 133324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver const ValueDecl *getDecl() const { return D; } 134324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual SourceRange getSourceRange() const { return SourceRange(Loc); } 135324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 136324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 137324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Stmt *T) { 138324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return T->getStmtClass() == DeclRefExprClass; 139324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 140324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const DeclRefExpr *) { return true; } 141324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 142324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Iterators 143324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_begin(); 144324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_end(); 145324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 146324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual void directEmit(llvm::Serializer& S) const; 147324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static DeclRefExpr* directMaterialize(llvm::Deserializer& D); 148324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver}; 149324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 150324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// PreDefinedExpr - [C99 6.4.2.2] - A pre-defined identifier such as __func__. 151324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass PreDefinedExpr : public Expr { 152324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 153324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver enum IdentType { 154324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Func, 155324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Function, 156324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver PrettyFunction 157324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver }; 158324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 159324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverprivate: 160324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation Loc; 161324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IdentType Type; 162324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 163324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver PreDefinedExpr(SourceLocation l, QualType type, IdentType IT) 164324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver : Expr(PreDefinedExprClass, type), Loc(l), Type(IT) {} 165324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 166324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IdentType getIdentType() const { return Type; } 167324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 168324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual SourceRange getSourceRange() const { return SourceRange(Loc); } 169324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 170324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Stmt *T) { 171324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return T->getStmtClass() == PreDefinedExprClass; 172324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 173324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const PreDefinedExpr *) { return true; } 174324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 175324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Iterators 176324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_begin(); 177324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_end(); 178324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 179324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual void directEmit(llvm::Serializer& S) const; 180324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static PreDefinedExpr* directMaterialize(llvm::Deserializer& D); 181324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver}; 182324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 183324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass IntegerLiteral : public Expr { 184324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver llvm::APInt Value; 185324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation Loc; 186324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 187324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // type should be IntTy, LongTy, LongLongTy, UnsignedIntTy, UnsignedLongTy, 188324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // or UnsignedLongLongTy 189324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IntegerLiteral(const llvm::APInt &V, QualType type, SourceLocation l) 190324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver : Expr(IntegerLiteralClass, type), Value(V), Loc(l) { 191324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver assert(type->isIntegerType() && "Illegal type in IntegerLiteral"); 192324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 193324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver const llvm::APInt &getValue() const { return Value; } 194324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual SourceRange getSourceRange() const { return SourceRange(Loc); } 195324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 196324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Stmt *T) { 197324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return T->getStmtClass() == IntegerLiteralClass; 198324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 199324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const IntegerLiteral *) { return true; } 200324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 201324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Iterators 202324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_begin(); 203324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_end(); 204324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 205324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual void directEmit(llvm::Serializer& S) const; 206324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static IntegerLiteral* directMaterialize(llvm::Deserializer& D); 207324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver}; 208324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 209324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass CharacterLiteral : public Expr { 210324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver unsigned Value; 211324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation Loc; 212324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 213324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // type should be IntTy 214324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver CharacterLiteral(unsigned value, QualType type, SourceLocation l) 215324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver : Expr(CharacterLiteralClass, type), Value(value), Loc(l) { 216324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 217324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation getLoc() const { return Loc; } 218324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 219324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual SourceRange getSourceRange() const { return SourceRange(Loc); } 220324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 221324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver unsigned getValue() const { return Value; } 222324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 223324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Stmt *T) { 224324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return T->getStmtClass() == CharacterLiteralClass; 225324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 226324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const CharacterLiteral *) { return true; } 227324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 228324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Iterators 229324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_begin(); 230324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_end(); 231324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 232324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual void directEmit(llvm::Serializer& S) const; 233324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static CharacterLiteral* directMaterialize(llvm::Deserializer& D); 234324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver}; 235324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 236324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass FloatingLiteral : public Expr { 237324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver llvm::APFloat Value; 238324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation Loc; 239324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 240324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver FloatingLiteral(const llvm::APFloat &V, QualType Type, SourceLocation L) 241324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver : Expr(FloatingLiteralClass, Type), Value(V), Loc(L) {} 242324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 243324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver const llvm::APFloat &getValue() const { return Value; } 244324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 245324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// getValueAsDouble - This returns the value as an inaccurate double. Note 246324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// that this may cause loss of precision, but is useful for debugging dumps 247324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// etc. 248324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver double getValueAsDouble() const { 249324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // FIXME: We need something for long double here. 250324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (cast<BuiltinType>(getType())->getKind() == BuiltinType::Float) 251324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return Value.convertToFloat(); 252324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver else 253324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return Value.convertToDouble(); 254324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 255324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 256324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual SourceRange getSourceRange() const { return SourceRange(Loc); } 257324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 258324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Stmt *T) { 259324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return T->getStmtClass() == FloatingLiteralClass; 260324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 261324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const FloatingLiteral *) { return true; } 262324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 263324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Iterators 264324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_begin(); 265324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_end(); 266324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 267324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual void directEmit(llvm::Serializer& S) const; 268324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static FloatingLiteral* directMaterialize(llvm::Deserializer& D); 269324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver}; 270324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 271324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// ImaginaryLiteral - We support imaginary integer and floating point literals, 272324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// like "1.0i". We represent these as a wrapper around FloatingLiteral and 273324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// IntegerLiteral classes. Instances of this class always have a Complex type 274324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// whose element type matches the subexpression. 275324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 276324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass ImaginaryLiteral : public Expr { 277324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *Val; 278324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 279324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ImaginaryLiteral(Expr *val, QualType Ty) 280324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver : Expr(ImaginaryLiteralClass, Ty), Val(val) {} 281324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 282324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver const Expr *getSubExpr() const { return Val; } 283324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *getSubExpr() { return Val; } 284324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 285324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual SourceRange getSourceRange() const { return Val->getSourceRange(); } 286324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Stmt *T) { 287324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return T->getStmtClass() == ImaginaryLiteralClass; 288324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 289324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const ImaginaryLiteral *) { return true; } 290324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 291324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Iterators 292324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_begin(); 293324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_end(); 294324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 295324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual void directEmit(llvm::Serializer& S) const; 296324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static ImaginaryLiteral* directMaterialize(llvm::Deserializer& D); 297324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver}; 298324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 299324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// StringLiteral - This represents a string literal expression, e.g. "foo" 300324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// or L"bar" (wide strings). The actual string is returned by getStrData() 301324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// is NOT null-terminated, and the length of the string is determined by 302324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// calling getByteLength(). 303324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass StringLiteral : public Expr { 304324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver const char *StrData; 305324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver unsigned ByteLength; 306324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool IsWide; 307324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // if the StringLiteral was composed using token pasting, both locations 308324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // are needed. If not (the common case), firstTokLoc == lastTokLoc. 309324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // FIXME: if space becomes an issue, we should create a sub-class. 310324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation firstTokLoc, lastTokLoc; 311324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 312324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver StringLiteral(const char *strData, unsigned byteLength, bool Wide, 313324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver QualType t, SourceLocation b, SourceLocation e); 314324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual ~StringLiteral(); 315324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 316324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver const char *getStrData() const { return StrData; } 317324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver unsigned getByteLength() const { return ByteLength; } 318324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool isWide() const { return IsWide; } 319324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 320324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual SourceRange getSourceRange() const { 321324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return SourceRange(firstTokLoc,lastTokLoc); 322324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 323324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Stmt *T) { 324324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return T->getStmtClass() == StringLiteralClass; 325324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 326324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const StringLiteral *) { return true; } 327324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 328324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Iterators 329324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_begin(); 330324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_end(); 331324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 332324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual void directEmit(llvm::Serializer& S) const; 333324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static StringLiteral* directMaterialize(llvm::Deserializer& D); 334324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver}; 335324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 336324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// ParenExpr - This represents a parethesized expression, e.g. "(1)". This 337324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// AST node is only formed if full location information is requested. 338324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass ParenExpr : public Expr { 339324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation L, R; 340324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *Val; 341324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 342324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ParenExpr(SourceLocation l, SourceLocation r, Expr *val) 343324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver : Expr(ParenExprClass, val->getType()), L(l), R(r), Val(val) {} 344324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 345324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver const Expr *getSubExpr() const { return Val; } 346324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *getSubExpr() { return Val; } 347324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceRange getSourceRange() const { return SourceRange(L, R); } 348324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 349324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Stmt *T) { 350324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return T->getStmtClass() == ParenExprClass; 351324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 352324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const ParenExpr *) { return true; } 353324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 354324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Iterators 355324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_begin(); 356324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_end(); 357324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 358324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual void directEmit(llvm::Serializer& S) const; 359324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static ParenExpr* directMaterialize(llvm::Deserializer& D); 360324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver}; 361324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 362324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 363324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// UnaryOperator - This represents the unary-expression's (except sizeof of 364324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// types), the postinc/postdec operators from postfix-expression, and various 365324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// extensions. 366324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 367324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Notes on various nodes: 368324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 369324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Real/Imag - These return the real/imag part of a complex operand. If 370324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// applied to a non-complex value, the former returns its operand and the 371324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// later returns zero in the type of the operand. 372324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 373324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// __builtin_offsetof(type, a.b[10]) is represented as a unary operator whose 374324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// subexpression is a compound literal with the various MemberExpr and 375324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// ArraySubscriptExpr's applied to it. 376324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 377324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass UnaryOperator : public Expr { 378324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 379324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Note that additions to this should also update the StmtVisitor class. 380324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver enum Opcode { 381324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver PostInc, PostDec, // [C99 6.5.2.4] Postfix increment and decrement operators 382324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver PreInc, PreDec, // [C99 6.5.3.1] Prefix increment and decrement operators. 383324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver AddrOf, Deref, // [C99 6.5.3.2] Address and indirection operators. 384324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Plus, Minus, // [C99 6.5.3.3] Unary arithmetic operators. 385324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Not, LNot, // [C99 6.5.3.3] Unary arithmetic operators. 386324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SizeOf, AlignOf, // [C99 6.5.3.4] Sizeof (expr, not type) operator. 387324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Real, Imag, // "__real expr"/"__imag expr" Extension. 388324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Extension, // __extension__ marker. 389324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver OffsetOf // __builtin_offsetof 390324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver }; 391324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverprivate: 392324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *Val; 393324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Opcode Opc; 394324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation Loc; 395324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 396324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 397324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver UnaryOperator(Expr *input, Opcode opc, QualType type, SourceLocation l) 398324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver : Expr(UnaryOperatorClass, type), Val(input), Opc(opc), Loc(l) {} 399324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 400324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Opcode getOpcode() const { return Opc; } 401324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *getSubExpr() const { return Val; } 402324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 403324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// getOperatorLoc - Return the location of the operator. 404324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation getOperatorLoc() const { return Loc; } 405324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 406324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// isPostfix - Return true if this is a postfix operation, like x++. 407324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool isPostfix(Opcode Op); 408324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 409324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool isPostfix() const { return isPostfix(Opc); } 410324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool isIncrementDecrementOp() const { return Opc>=PostInc && Opc<=PreDec; } 411324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool isSizeOfAlignOfOp() const { return Opc == SizeOf || Opc == AlignOf; } 412324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool isArithmeticOp(Opcode Op) { return Op >= Plus && Op <= LNot; } 413324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 414324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 415324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// corresponds to, e.g. "sizeof" or "[pre]++" 416324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static const char *getOpcodeStr(Opcode Op); 417324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 418324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual SourceRange getSourceRange() const { 419324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (isPostfix()) 420324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return SourceRange(Val->getLocStart(), Loc); 421324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver else 422324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return SourceRange(Loc, Val->getLocEnd()); 423324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 424324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual SourceLocation getExprLoc() const { return Loc; } 425324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 426324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Stmt *T) { 427324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return T->getStmtClass() == UnaryOperatorClass; 428324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 429324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const UnaryOperator *) { return true; } 430324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 431324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Iterators 432324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_begin(); 433324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_end(); 434324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 435324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual void directEmit(llvm::Serializer& S) const; 436324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static UnaryOperator* directMaterialize(llvm::Deserializer& D); 437324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver}; 438324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 439324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// SizeOfAlignOfTypeExpr - [C99 6.5.3.4] - This is only for sizeof/alignof of 440324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// *types*. sizeof(expr) is handled by UnaryOperator. 441324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass SizeOfAlignOfTypeExpr : public Expr { 442324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool isSizeof; // true if sizeof, false if alignof. 443324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver QualType Ty; 444324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation OpLoc, RParenLoc; 445324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 446324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SizeOfAlignOfTypeExpr(bool issizeof, QualType argType, QualType resultType, 447324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation op, SourceLocation rp) : 448324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr(SizeOfAlignOfTypeExprClass, resultType), 449324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver isSizeof(issizeof), Ty(argType), OpLoc(op), RParenLoc(rp) {} 450324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 451324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool isSizeOf() const { return isSizeof; } 452324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver QualType getArgumentType() const { return Ty; } 453324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 454324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation getOperatorLoc() const { return OpLoc; } 455324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceRange getSourceRange() const { return SourceRange(OpLoc, RParenLoc); } 456324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 457324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Stmt *T) { 458324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return T->getStmtClass() == SizeOfAlignOfTypeExprClass; 459324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 460324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const SizeOfAlignOfTypeExpr *) { return true; } 461324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 462324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Iterators 463324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_begin(); 464324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_end(); 465324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver}; 466324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 467324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver//===----------------------------------------------------------------------===// 468324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// Postfix Operators. 469324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver//===----------------------------------------------------------------------===// 470324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 471324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting. 472324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass ArraySubscriptExpr : public Expr { 473324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver enum { LHS, RHS, END_EXPR=2 }; 474324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr* SubExprs[END_EXPR]; 475324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation RBracketLoc; 476324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 477324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ArraySubscriptExpr(Expr *lhs, Expr *rhs, QualType t, 478324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation rbracketloc) 479324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver : Expr(ArraySubscriptExprClass, t), RBracketLoc(rbracketloc) { 480324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SubExprs[LHS] = lhs; 481324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SubExprs[RHS] = rhs; 482324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 483324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 484324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// An array access can be written A[4] or 4[A] (both are equivalent). 485324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// - getBase() and getIdx() always present the normalized view: A[4]. 486324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// In this case getBase() returns "A" and getIdx() returns "4". 487324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// - getLHS() and getRHS() present the syntactic view. e.g. for 488324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// 4[A] getLHS() returns "4". 489324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 490324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *getLHS() { return SubExprs[LHS]; } 491324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver const Expr *getLHS() const { return SubExprs[LHS]; } 492324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 493324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *getRHS() { return SubExprs[RHS]; } 494324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver const Expr *getRHS() const { return SubExprs[RHS]; } 495324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 496324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *getBase() { 497324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return (getLHS()->getType()->isIntegerType()) ? getRHS() : getLHS(); 498324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 499324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 500324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver const Expr *getBase() const { 501324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return (getLHS()->getType()->isIntegerType()) ? getRHS() : getLHS(); 502324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 503324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 504324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *getIdx() { 505324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return (getLHS()->getType()->isIntegerType()) ? getLHS() : getRHS(); 506324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 507324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 508324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver const Expr *getIdx() const { 509324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return (getLHS()->getType()->isIntegerType()) ? getLHS() : getRHS(); 510324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 511324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 512324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 513324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceRange getSourceRange() const { 514324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return SourceRange(getLHS()->getLocStart(), RBracketLoc); 515324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 516324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual SourceLocation getExprLoc() const { return RBracketLoc; } 517324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 518324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Stmt *T) { 519324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return T->getStmtClass() == ArraySubscriptExprClass; 520324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 521324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const ArraySubscriptExpr *) { return true; } 522324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 523324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Iterators 524324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_begin(); 525324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_end(); 526324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 527324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual void directEmit(llvm::Serializer& S) const; 528324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static ArraySubscriptExpr* directMaterialize(llvm::Deserializer& D); 529324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver}; 530324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 531324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 532324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// CallExpr - [C99 6.5.2.2] Function Calls. 533324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 534324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass CallExpr : public Expr { 535324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver enum { FN=0, ARGS_START=1 }; 536324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr **SubExprs; 537324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver unsigned NumArgs; 538324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation RParenLoc; 539324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 540324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // This version of the ctor is for deserialization. 541324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver CallExpr(Expr** subexprs, unsigned numargs, QualType t, 542324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation rparenloc) 543324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver : Expr(CallExprClass,t), SubExprs(subexprs), 544324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver NumArgs(numargs), RParenLoc(rparenloc) {} 545324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 546324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 547324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver CallExpr(Expr *fn, Expr **args, unsigned numargs, QualType t, 548324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation rparenloc); 549324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ~CallExpr() { 550324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver delete [] SubExprs; 551324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 552324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 553324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver const Expr *getCallee() const { return SubExprs[FN]; } 554324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *getCallee() { return SubExprs[FN]; } 555324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 556324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// getNumArgs - Return the number of actual arguments to this call. 557324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// 558324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver unsigned getNumArgs() const { return NumArgs; } 559324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 560324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// getArg - Return the specified argument. 561324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *getArg(unsigned Arg) { 562324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver assert(Arg < NumArgs && "Arg access out of range!"); 563324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return SubExprs[Arg+ARGS_START]; 564324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 565324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver const Expr *getArg(unsigned Arg) const { 566324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver assert(Arg < NumArgs && "Arg access out of range!"); 567324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return SubExprs[Arg+ARGS_START]; 568324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 569324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// setArg - Set the specified argument. 570324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver void setArg(unsigned Arg, Expr *ArgExpr) { 571324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver assert(Arg < NumArgs && "Arg access out of range!"); 572324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SubExprs[Arg+ARGS_START] = ArgExpr; 573324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 574324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// getNumCommas - Return the number of commas that must have been present in 575324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// this function call. 576324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver unsigned getNumCommas() const { return NumArgs ? NumArgs - 1 : 0; } 577324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 578324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool isBuiltinClassifyType(llvm::APSInt &Result) const; 579324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 580324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceRange getSourceRange() const { 581324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return SourceRange(getCallee()->getLocStart(), RParenLoc); 582324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 583324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 584324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Stmt *T) { 585324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return T->getStmtClass() == CallExprClass; 586324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 587324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const CallExpr *) { return true; } 588324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 589324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Iterators 590324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_begin(); 591324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_end(); 592324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 593324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual void directEmit(llvm::Serializer& S) const; 594324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static CallExpr* directMaterialize(llvm::Deserializer& D); 595324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver}; 596324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 597324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// MemberExpr - [C99 6.5.2.3] Structure and Union Members. 598324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 599324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass MemberExpr : public Expr { 600324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *Base; 601324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver FieldDecl *MemberDecl; 602324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation MemberLoc; 603324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool IsArrow; // True if this is "X->F", false if this is "X.F". 604324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 605324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver MemberExpr(Expr *base, bool isarrow, FieldDecl *memberdecl, SourceLocation l) 606324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver : Expr(MemberExprClass, memberdecl->getType()), 607324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Base(base), MemberDecl(memberdecl), MemberLoc(l), IsArrow(isarrow) {} 608324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 609324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *getBase() const { return Base; } 610324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver FieldDecl *getMemberDecl() const { return MemberDecl; } 611324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool isArrow() const { return IsArrow; } 612324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 613324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual SourceRange getSourceRange() const { 614324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return SourceRange(getBase()->getLocStart(), MemberLoc); 615324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 616324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual SourceLocation getExprLoc() const { return MemberLoc; } 617324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 618324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Stmt *T) { 619324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return T->getStmtClass() == MemberExprClass; 620324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 621324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const MemberExpr *) { return true; } 622324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 623324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Iterators 624324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_begin(); 625324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_end(); 626324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver}; 627324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 628324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// OCUVectorElementExpr - This represents access to specific elements of a 629324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// vector, and may occur on the left hand side or right hand side. For example 630324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// the following is legal: "V.xy = V.zw" if V is a 4 element ocu vector. 631324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 632324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass OCUVectorElementExpr : public Expr { 633324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *Base; 634324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IdentifierInfo &Accessor; 635324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation AccessorLoc; 636324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 637324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver enum ElementType { 638324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Point, // xywz 639324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Color, // rgba 640324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Texture // stpq 641324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver }; 642324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver OCUVectorElementExpr(QualType ty, Expr *base, IdentifierInfo &accessor, 643324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver SourceLocation loc) 644324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver : Expr(OCUVectorElementExprClass, ty), 645324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Base(base), Accessor(accessor), AccessorLoc(loc) {} 646324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 647324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver const Expr *getBase() const { return Base; } 648324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *getBase() { return Base; } 649324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 650324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IdentifierInfo &getAccessor() const { return Accessor; } 651324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 652324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// getNumElements - Get the number of components being selected. 653324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver unsigned getNumElements() const; 654324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 655324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// getElementType - Determine whether the components of this access are 656324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// "point" "color" or "texture" elements. 657324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ElementType getElementType() const; 658324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 659324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// containsDuplicateElements - Return true if any element access is 660324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// repeated. 661324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver bool containsDuplicateElements() const; 662324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 663324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// getEncodedElementAccess - Encode the elements accessed into a bit vector. 664324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// The encoding currently uses 2-bit bitfields, but clients should use the 665324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// accessors below to access them. 666324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// 667324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver unsigned getEncodedElementAccess() const; 668324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 669324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// getAccessedFieldNo - Given an encoded value and a result number, return 670324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// the input field number being accessed. 671324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static unsigned getAccessedFieldNo(unsigned Idx, unsigned EncodedVal) { 672324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return (EncodedVal >> (Idx*2)) & 3; 673324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 674324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 675324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual SourceRange getSourceRange() const { 676324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return SourceRange(getBase()->getLocStart(), AccessorLoc); 677324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 678324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const Stmt *T) { 679324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return T->getStmtClass() == OCUVectorElementExprClass; 680324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 681324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver static bool classof(const OCUVectorElementExpr *) { return true; } 682324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 683324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Iterators 684324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_begin(); 685324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver virtual child_iterator child_end(); 686324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver}; 687324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 688324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// CompoundLiteralExpr - [C99 6.5.2.5] 689324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 690324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverclass CompoundLiteralExpr : public Expr { 691324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Expr *Init; 692324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverpublic: 693 CompoundLiteralExpr(QualType ty, Expr *init) : 694 Expr(CompoundLiteralExprClass, ty), Init(init) {} 695 696 const Expr *getInitializer() const { return Init; } 697 Expr *getInitializer() { return Init; } 698 699 virtual SourceRange getSourceRange() const { 700 if (Init) 701 return Init->getSourceRange(); 702 return SourceRange(); 703 } 704 705 static bool classof(const Stmt *T) { 706 return T->getStmtClass() == CompoundLiteralExprClass; 707 } 708 static bool classof(const CompoundLiteralExpr *) { return true; } 709 710 // Iterators 711 virtual child_iterator child_begin(); 712 virtual child_iterator child_end(); 713}; 714 715/// ImplicitCastExpr - Allows us to explicitly represent implicit type 716/// conversions. For example: converting T[]->T*, void f()->void (*f)(), 717/// float->double, short->int, etc. 718/// 719class ImplicitCastExpr : public Expr { 720 Expr *Op; 721public: 722 ImplicitCastExpr(QualType ty, Expr *op) : 723 Expr(ImplicitCastExprClass, ty), Op(op) {} 724 725 Expr *getSubExpr() { return Op; } 726 const Expr *getSubExpr() const { return Op; } 727 728 virtual SourceRange getSourceRange() const { return Op->getSourceRange(); } 729 730 static bool classof(const Stmt *T) { 731 return T->getStmtClass() == ImplicitCastExprClass; 732 } 733 static bool classof(const ImplicitCastExpr *) { return true; } 734 735 // Iterators 736 virtual child_iterator child_begin(); 737 virtual child_iterator child_end(); 738 739 virtual void directEmit(llvm::Serializer& S) const; 740 static ImplicitCastExpr* directMaterialize(llvm::Deserializer& D); 741}; 742 743/// CastExpr - [C99 6.5.4] Cast Operators. 744/// 745class CastExpr : public Expr { 746 Expr *Op; 747 SourceLocation Loc; // the location of the left paren 748public: 749 CastExpr(QualType ty, Expr *op, SourceLocation l) : 750 Expr(CastExprClass, ty), Op(op), Loc(l) {} 751 752 SourceLocation getLParenLoc() const { return Loc; } 753 754 Expr *getSubExpr() const { return Op; } 755 756 virtual SourceRange getSourceRange() const { 757 return SourceRange(Loc, getSubExpr()->getSourceRange().getEnd()); 758 } 759 static bool classof(const Stmt *T) { 760 return T->getStmtClass() == CastExprClass; 761 } 762 static bool classof(const CastExpr *) { return true; } 763 764 // Iterators 765 virtual child_iterator child_begin(); 766 virtual child_iterator child_end(); 767 768 virtual void directEmit(llvm::Serializer& S) const; 769 static CastExpr* directMaterialize(llvm::Deserializer& D); 770}; 771 772class BinaryOperator : public Expr { 773public: 774 enum Opcode { 775 // Operators listed in order of precedence. 776 // Note that additions to this should also update the StmtVisitor class. 777 Mul, Div, Rem, // [C99 6.5.5] Multiplicative operators. 778 Add, Sub, // [C99 6.5.6] Additive operators. 779 Shl, Shr, // [C99 6.5.7] Bitwise shift operators. 780 LT, GT, LE, GE, // [C99 6.5.8] Relational operators. 781 EQ, NE, // [C99 6.5.9] Equality operators. 782 And, // [C99 6.5.10] Bitwise AND operator. 783 Xor, // [C99 6.5.11] Bitwise XOR operator. 784 Or, // [C99 6.5.12] Bitwise OR operator. 785 LAnd, // [C99 6.5.13] Logical AND operator. 786 LOr, // [C99 6.5.14] Logical OR operator. 787 Assign, MulAssign,// [C99 6.5.16] Assignment operators. 788 DivAssign, RemAssign, 789 AddAssign, SubAssign, 790 ShlAssign, ShrAssign, 791 AndAssign, XorAssign, 792 OrAssign, 793 Comma // [C99 6.5.17] Comma operator. 794 }; 795private: 796 enum { LHS, RHS, END_EXPR }; 797 Expr* SubExprs[END_EXPR]; 798 Opcode Opc; 799 SourceLocation OpLoc; 800public: 801 802 BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, 803 SourceLocation opLoc) 804 : Expr(BinaryOperatorClass, ResTy), Opc(opc), OpLoc(opLoc) { 805 SubExprs[LHS] = lhs; 806 SubExprs[RHS] = rhs; 807 assert(!isCompoundAssignmentOp() && 808 "Use ArithAssignBinaryOperator for compound assignments"); 809 } 810 811 SourceLocation getOperatorLoc() const { return OpLoc; } 812 Opcode getOpcode() const { return Opc; } 813 Expr *getLHS() const { return SubExprs[LHS]; } 814 Expr *getRHS() const { return SubExprs[RHS]; } 815 virtual SourceRange getSourceRange() const { 816 return SourceRange(getLHS()->getLocStart(), getRHS()->getLocEnd()); 817 } 818 819 /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 820 /// corresponds to, e.g. "<<=". 821 static const char *getOpcodeStr(Opcode Op); 822 823 /// predicates to categorize the respective opcodes. 824 bool isMultiplicativeOp() const { return Opc >= Mul && Opc <= Rem; } 825 bool isAdditiveOp() const { return Opc == Add || Opc == Sub; } 826 bool isShiftOp() const { return Opc == Shl || Opc == Shr; } 827 bool isBitwiseOp() const { return Opc >= And && Opc <= Or; } 828 bool isRelationalOp() const { return Opc >= LT && Opc <= GE; } 829 bool isEqualityOp() const { return Opc == EQ || Opc == NE; } 830 bool isLogicalOp() const { return Opc == LAnd || Opc == LOr; } 831 bool isAssignmentOp() const { return Opc >= Assign && Opc <= OrAssign; } 832 bool isCompoundAssignmentOp() const { return Opc > Assign && Opc <= OrAssign;} 833 bool isShiftAssignOp() const { return Opc == ShlAssign || Opc == ShrAssign; } 834 835 static bool classof(const Stmt *S) { 836 return S->getStmtClass() == BinaryOperatorClass || 837 S->getStmtClass() == CompoundAssignOperatorClass; 838 } 839 static bool classof(const BinaryOperator *) { return true; } 840 841 // Iterators 842 virtual child_iterator child_begin(); 843 virtual child_iterator child_end(); 844 845 virtual void directEmit(llvm::Serializer& S) const; 846 static BinaryOperator* directMaterialize(llvm::Deserializer& D); 847 848protected: 849 BinaryOperator(Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, 850 SourceLocation oploc, bool dead) 851 : Expr(CompoundAssignOperatorClass, ResTy), Opc(opc), OpLoc(oploc) { 852 SubExprs[LHS] = lhs; 853 SubExprs[RHS] = rhs; 854 } 855}; 856 857/// CompoundAssignOperator - For compound assignments (e.g. +=), we keep 858/// track of the type the operation is performed in. Due to the semantics of 859/// these operators, the operands are promoted, the aritmetic performed, an 860/// implicit conversion back to the result type done, then the assignment takes 861/// place. This captures the intermediate type which the computation is done 862/// in. 863class CompoundAssignOperator : public BinaryOperator { 864 QualType ComputationType; 865public: 866 CompoundAssignOperator(Expr *lhs, Expr *rhs, Opcode opc, 867 QualType ResType, QualType CompType, 868 SourceLocation OpLoc) 869 : BinaryOperator(lhs, rhs, opc, ResType, OpLoc, true), 870 ComputationType(CompType) { 871 assert(isCompoundAssignmentOp() && 872 "Only should be used for compound assignments"); 873 } 874 875 QualType getComputationType() const { return ComputationType; } 876 877 static bool classof(const CompoundAssignOperator *) { return true; } 878 static bool classof(const Stmt *S) { 879 return S->getStmtClass() == CompoundAssignOperatorClass; 880 } 881}; 882 883/// ConditionalOperator - The ?: operator. Note that LHS may be null when the 884/// GNU "missing LHS" extension is in use. 885/// 886class ConditionalOperator : public Expr { 887 enum { COND, LHS, RHS, END_EXPR }; 888 Expr* SubExprs[END_EXPR]; // Left/Middle/Right hand sides. 889public: 890 ConditionalOperator(Expr *cond, Expr *lhs, Expr *rhs, QualType t) 891 : Expr(ConditionalOperatorClass, t) { 892 SubExprs[COND] = cond; 893 SubExprs[LHS] = lhs; 894 SubExprs[RHS] = rhs; 895 } 896 897 Expr *getCond() const { return SubExprs[COND]; } 898 Expr *getLHS() const { return SubExprs[LHS]; } 899 Expr *getRHS() const { return SubExprs[RHS]; } 900 901 virtual SourceRange getSourceRange() const { 902 return SourceRange(getCond()->getLocStart(), getRHS()->getLocEnd()); 903 } 904 static bool classof(const Stmt *T) { 905 return T->getStmtClass() == ConditionalOperatorClass; 906 } 907 static bool classof(const ConditionalOperator *) { return true; } 908 909 // Iterators 910 virtual child_iterator child_begin(); 911 virtual child_iterator child_end(); 912}; 913 914/// AddrLabelExpr - The GNU address of label extension, representing &&label. 915class AddrLabelExpr : public Expr { 916 SourceLocation AmpAmpLoc, LabelLoc; 917 LabelStmt *Label; 918public: 919 AddrLabelExpr(SourceLocation AALoc, SourceLocation LLoc, LabelStmt *L, 920 QualType t) 921 : Expr(AddrLabelExprClass, t), AmpAmpLoc(AALoc), LabelLoc(LLoc), Label(L) {} 922 923 virtual SourceRange getSourceRange() const { 924 return SourceRange(AmpAmpLoc, LabelLoc); 925 } 926 927 LabelStmt *getLabel() const { return Label; } 928 929 static bool classof(const Stmt *T) { 930 return T->getStmtClass() == AddrLabelExprClass; 931 } 932 static bool classof(const AddrLabelExpr *) { return true; } 933 934 // Iterators 935 virtual child_iterator child_begin(); 936 virtual child_iterator child_end(); 937}; 938 939/// StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}). 940/// The StmtExpr contains a single CompoundStmt node, which it evaluates and 941/// takes the value of the last subexpression. 942class StmtExpr : public Expr { 943 CompoundStmt *SubStmt; 944 SourceLocation LParenLoc, RParenLoc; 945public: 946 StmtExpr(CompoundStmt *substmt, QualType T, 947 SourceLocation lp, SourceLocation rp) : 948 Expr(StmtExprClass, T), SubStmt(substmt), LParenLoc(lp), RParenLoc(rp) { } 949 950 CompoundStmt *getSubStmt() { return SubStmt; } 951 const CompoundStmt *getSubStmt() const { return SubStmt; } 952 953 virtual SourceRange getSourceRange() const { 954 return SourceRange(LParenLoc, RParenLoc); 955 } 956 957 static bool classof(const Stmt *T) { 958 return T->getStmtClass() == StmtExprClass; 959 } 960 static bool classof(const StmtExpr *) { return true; } 961 962 // Iterators 963 virtual child_iterator child_begin(); 964 virtual child_iterator child_end(); 965}; 966 967/// TypesCompatibleExpr - GNU builtin-in function __builtin_type_compatible_p. 968/// This AST node represents a function that returns 1 if two *types* (not 969/// expressions) are compatible. The result of this built-in function can be 970/// used in integer constant expressions. 971class TypesCompatibleExpr : public Expr { 972 QualType Type1; 973 QualType Type2; 974 SourceLocation BuiltinLoc, RParenLoc; 975public: 976 TypesCompatibleExpr(QualType ReturnType, SourceLocation BLoc, 977 QualType t1, QualType t2, SourceLocation RP) : 978 Expr(TypesCompatibleExprClass, ReturnType), Type1(t1), Type2(t2), 979 BuiltinLoc(BLoc), RParenLoc(RP) {} 980 981 QualType getArgType1() const { return Type1; } 982 QualType getArgType2() const { return Type2; } 983 984 virtual SourceRange getSourceRange() const { 985 return SourceRange(BuiltinLoc, RParenLoc); 986 } 987 static bool classof(const Stmt *T) { 988 return T->getStmtClass() == TypesCompatibleExprClass; 989 } 990 static bool classof(const TypesCompatibleExpr *) { return true; } 991 992 // Iterators 993 virtual child_iterator child_begin(); 994 virtual child_iterator child_end(); 995}; 996 997/// ChooseExpr - GNU builtin-in function __builtin_choose_expr. 998/// This AST node is similar to the conditional operator (?:) in C, with 999/// the following exceptions: 1000/// - the test expression much be a constant expression. 1001/// - the expression returned has it's type unaltered by promotion rules. 1002/// - does not evaluate the expression that was not chosen. 1003class ChooseExpr : public Expr { 1004 enum { COND, LHS, RHS, END_EXPR }; 1005 Expr* SubExprs[END_EXPR]; // Left/Middle/Right hand sides. 1006 SourceLocation BuiltinLoc, RParenLoc; 1007public: 1008 ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs, QualType t, 1009 SourceLocation RP) 1010 : Expr(ChooseExprClass, t), 1011 BuiltinLoc(BLoc), RParenLoc(RP) { 1012 SubExprs[COND] = cond; 1013 SubExprs[LHS] = lhs; 1014 SubExprs[RHS] = rhs; 1015 } 1016 1017 /// isConditionTrue - Return true if the condition is true. This is always 1018 /// statically knowable for a well-formed choosexpr. 1019 bool isConditionTrue(ASTContext &C) const; 1020 1021 Expr *getCond() const { return SubExprs[COND]; } 1022 Expr *getLHS() const { return SubExprs[LHS]; } 1023 Expr *getRHS() const { return SubExprs[RHS]; } 1024 1025 virtual SourceRange getSourceRange() const { 1026 return SourceRange(BuiltinLoc, RParenLoc); 1027 } 1028 static bool classof(const Stmt *T) { 1029 return T->getStmtClass() == ChooseExprClass; 1030 } 1031 static bool classof(const ChooseExpr *) { return true; } 1032 1033 // Iterators 1034 virtual child_iterator child_begin(); 1035 virtual child_iterator child_end(); 1036}; 1037 1038/// VAArgExpr, used for the builtin function __builtin_va_start. 1039class VAArgExpr : public Expr { 1040 Expr *Val; 1041 SourceLocation BuiltinLoc, RParenLoc; 1042public: 1043 VAArgExpr(SourceLocation BLoc, Expr* e, QualType t, SourceLocation RPLoc) 1044 : Expr(VAArgExprClass, t), 1045 Val(e), 1046 BuiltinLoc(BLoc), 1047 RParenLoc(RPLoc) { } 1048 1049 const Expr *getSubExpr() const { return Val; } 1050 Expr *getSubExpr() { return Val; } 1051 virtual SourceRange getSourceRange() const { 1052 return SourceRange(BuiltinLoc, RParenLoc); 1053 } 1054 static bool classof(const Stmt *T) { 1055 return T->getStmtClass() == VAArgExprClass; 1056 } 1057 static bool classof(const VAArgExpr *) { return true; } 1058 1059 // Iterators 1060 virtual child_iterator child_begin(); 1061 virtual child_iterator child_end(); 1062}; 1063 1064/// InitListExpr, used for struct and array initializers. 1065class InitListExpr : public Expr { 1066 Expr **InitExprs; 1067 unsigned NumInits; 1068 SourceLocation LBraceLoc, RBraceLoc; 1069public: 1070 InitListExpr(SourceLocation lbraceloc, Expr **initexprs, unsigned numinits, 1071 SourceLocation rbraceloc); 1072 ~InitListExpr() { 1073 delete [] InitExprs; 1074 } 1075 1076 unsigned getNumInits() const { return NumInits; } 1077 1078 const Expr* getInit(unsigned Init) const { 1079 assert(Init < NumInits && "Initializer access out of range!"); 1080 return InitExprs[Init]; 1081 } 1082 1083 Expr* getInit(unsigned Init) { 1084 assert(Init < NumInits && "Initializer access out of range!"); 1085 return InitExprs[Init]; 1086 } 1087 1088 void setInit(unsigned Init, Expr *expr) { 1089 assert(Init < NumInits && "Initializer access out of range!"); 1090 InitExprs[Init] = expr; 1091 } 1092 1093 virtual SourceRange getSourceRange() const { 1094 return SourceRange(LBraceLoc, RBraceLoc); 1095 } 1096 static bool classof(const Stmt *T) { 1097 return T->getStmtClass() == InitListExprClass; 1098 } 1099 static bool classof(const InitListExpr *) { return true; } 1100 1101 // Iterators 1102 virtual child_iterator child_begin(); 1103 virtual child_iterator child_end(); 1104}; 1105 1106/// ObjCStringLiteral, used for Objective-C string literals 1107/// i.e. @"foo". 1108class ObjCStringLiteral : public Expr { 1109 StringLiteral *String; 1110 SourceLocation AtLoc; 1111public: 1112 ObjCStringLiteral(StringLiteral *SL, QualType T, SourceLocation L) 1113 : Expr(ObjCStringLiteralClass, T), String(SL), AtLoc(L) {} 1114 1115 StringLiteral* getString() { return String; } 1116 1117 const StringLiteral* getString() const { return String; } 1118 1119 virtual SourceRange getSourceRange() const { 1120 return SourceRange(AtLoc, String->getLocEnd()); 1121 } 1122 1123 static bool classof(const Stmt *T) { 1124 return T->getStmtClass() == ObjCStringLiteralClass; 1125 } 1126 static bool classof(const ObjCStringLiteral *) { return true; } 1127 1128 // Iterators 1129 virtual child_iterator child_begin(); 1130 virtual child_iterator child_end(); 1131}; 1132 1133/// ObjCEncodeExpr, used for @encode in Objective-C. 1134class ObjCEncodeExpr : public Expr { 1135 QualType EncType; 1136 SourceLocation AtLoc, RParenLoc; 1137public: 1138 ObjCEncodeExpr(QualType T, QualType ET, 1139 SourceLocation at, SourceLocation rp) 1140 : Expr(ObjCEncodeExprClass, T), EncType(ET), AtLoc(at), RParenLoc(rp) {} 1141 1142 SourceLocation getAtLoc() const { return AtLoc; } 1143 SourceLocation getRParenLoc() const { return RParenLoc; } 1144 1145 SourceRange getSourceRange() const { return SourceRange(AtLoc, RParenLoc); } 1146 1147 QualType getEncodedType() const { return EncType; } 1148 1149 static bool classof(const Stmt *T) { 1150 return T->getStmtClass() == ObjCEncodeExprClass; 1151 } 1152 static bool classof(const ObjCEncodeExpr *) { return true; } 1153 1154 // Iterators 1155 virtual child_iterator child_begin(); 1156 virtual child_iterator child_end(); 1157}; 1158 1159/// ObjCSelectorExpr used for @selector in Objective-C. 1160class ObjCSelectorExpr : public Expr { 1161 1162 Selector SelName; 1163 1164 SourceLocation AtLoc, RParenLoc; 1165public: 1166 ObjCSelectorExpr(QualType T, Selector selInfo, 1167 SourceLocation at, SourceLocation rp) 1168 : Expr(ObjCSelectorExprClass, T), SelName(selInfo), 1169 AtLoc(at), RParenLoc(rp) {} 1170 1171 const Selector &getSelector() const { return SelName; } 1172 Selector &getSelector() { return SelName; } 1173 1174 SourceLocation getAtLoc() const { return AtLoc; } 1175 SourceLocation getRParenLoc() const { return RParenLoc; } 1176 SourceRange getSourceRange() const { return SourceRange(AtLoc, RParenLoc); } 1177 1178 /// getNumArgs - Return the number of actual arguments to this call. 1179 unsigned getNumArgs() const { return SelName.getNumArgs(); } 1180 1181 static bool classof(const Stmt *T) { 1182 return T->getStmtClass() == ObjCSelectorExprClass; 1183 } 1184 static bool classof(const ObjCSelectorExpr *) { return true; } 1185 1186 // Iterators 1187 virtual child_iterator child_begin(); 1188 virtual child_iterator child_end(); 1189 1190}; 1191 1192/// ObjCProtocolExpr used for protocol in Objective-C. 1193class ObjCProtocolExpr : public Expr { 1194 1195 ObjcProtocolDecl *Protocol; 1196 1197 SourceLocation AtLoc, RParenLoc; 1198 public: 1199 ObjCProtocolExpr(QualType T, ObjcProtocolDecl *protocol, 1200 SourceLocation at, SourceLocation rp) 1201 : Expr(ObjCProtocolExprClass, T), Protocol(protocol), 1202 AtLoc(at), RParenLoc(rp) {} 1203 1204 ObjcProtocolDecl *getProtocol() const { return Protocol; } 1205 1206 SourceLocation getAtLoc() const { return AtLoc; } 1207 SourceLocation getRParenLoc() const { return RParenLoc; } 1208 SourceRange getSourceRange() const { return SourceRange(AtLoc, RParenLoc); } 1209 1210 static bool classof(const Stmt *T) { 1211 return T->getStmtClass() == ObjCProtocolExprClass; 1212 } 1213 static bool classof(const ObjCProtocolExpr *) { return true; } 1214 1215 // Iterators 1216 virtual child_iterator child_begin(); 1217 virtual child_iterator child_end(); 1218 1219}; 1220 1221class ObjCMessageExpr : public Expr { 1222 enum { RECEIVER=0, ARGS_START=1 }; 1223 1224 Expr **SubExprs; 1225 1226 // A unigue name for this message. 1227 Selector SelName; 1228 1229 // A method prototype for this message (optional). 1230 // FIXME: Since method decls contain the selector, and most messages have a 1231 // prototype, consider devising a scheme for unifying SelName/MethodProto. 1232 ObjcMethodDecl *MethodProto; 1233 1234 IdentifierInfo *ClassName; // optional - 0 for instance messages. 1235 1236 SourceLocation LBracloc, RBracloc; 1237public: 1238 // constructor for class messages. 1239 // FIXME: clsName should be typed to ObjCInterfaceType 1240 ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo, 1241 QualType retType, ObjcMethodDecl *methDecl, 1242 SourceLocation LBrac, SourceLocation RBrac, 1243 Expr **ArgExprs); 1244 // constructor for instance messages. 1245 ObjCMessageExpr(Expr *receiver, Selector selInfo, 1246 QualType retType, ObjcMethodDecl *methDecl, 1247 SourceLocation LBrac, SourceLocation RBrac, 1248 Expr **ArgExprs); 1249 ~ObjCMessageExpr() { 1250 delete [] SubExprs; 1251 } 1252 1253 const Expr *getReceiver() const { return SubExprs[RECEIVER]; } 1254 Expr *getReceiver() { return SubExprs[RECEIVER]; } 1255 1256 const Selector &getSelector() const { return SelName; } 1257 Selector &getSelector() { return SelName; } 1258 1259 const ObjcMethodDecl *getMethodDecl() const { return MethodProto; } 1260 ObjcMethodDecl *getMethodDecl() { return MethodProto; } 1261 1262 const IdentifierInfo *getClassName() const { return ClassName; } 1263 IdentifierInfo *getClassName() { return ClassName; } 1264 1265 /// getNumArgs - Return the number of actual arguments to this call. 1266 unsigned getNumArgs() const { return SelName.getNumArgs(); } 1267 1268/// getArg - Return the specified argument. 1269 Expr *getArg(unsigned Arg) { 1270 assert(Arg < SelName.getNumArgs() && "Arg access out of range!"); 1271 return SubExprs[Arg+ARGS_START]; 1272 } 1273 const Expr *getArg(unsigned Arg) const { 1274 assert(Arg < SelName.getNumArgs() && "Arg access out of range!"); 1275 return SubExprs[Arg+ARGS_START]; 1276 } 1277 /// setArg - Set the specified argument. 1278 void setArg(unsigned Arg, Expr *ArgExpr) { 1279 assert(Arg < SelName.getNumArgs() && "Arg access out of range!"); 1280 SubExprs[Arg+ARGS_START] = ArgExpr; 1281 } 1282 SourceRange getSourceRange() const { return SourceRange(LBracloc, RBracloc); } 1283 1284 static bool classof(const Stmt *T) { 1285 return T->getStmtClass() == ObjCMessageExprClass; 1286 } 1287 static bool classof(const ObjCMessageExpr *) { return true; } 1288 1289 // Iterators 1290 virtual child_iterator child_begin(); 1291 virtual child_iterator child_end(); 1292}; 1293 1294} // end namespace clang 1295 1296#endif 1297