ExprObjC.h revision 193326
1139743Simp//===--- ExprObjC.h - Classes for representing ObjC expressions -*- C++ -*-===// 239213Sgibbs// 3111206Sken// The LLVM Compiler Infrastructure 439213Sgibbs// 539213Sgibbs// This file is distributed under the University of Illinois Open Source 639213Sgibbs// License. See LICENSE.TXT for details. 739213Sgibbs// 839213Sgibbs//===----------------------------------------------------------------------===// 939213Sgibbs// 1039213Sgibbs// This file defines the ExprObjC interface and subclasses. 1139213Sgibbs// 1239213Sgibbs//===----------------------------------------------------------------------===// 1339213Sgibbs 1439213Sgibbs#ifndef LLVM_CLANG_AST_EXPROBJC_H 1539213Sgibbs#define LLVM_CLANG_AST_EXPROBJC_H 1639213Sgibbs 1739213Sgibbs#include "clang/AST/Expr.h" 1839213Sgibbs#include "clang/Basic/IdentifierTable.h" 1939213Sgibbs 2039213Sgibbsnamespace clang { 2139213Sgibbs class IdentifierInfo; 2239213Sgibbs class ASTContext; 2339213Sgibbs class ObjCMethodDecl; 2439213Sgibbs class ObjCPropertyDecl; 2539213Sgibbs 2639213Sgibbs/// ObjCStringLiteral, used for Objective-C string literals 27116162Sobrien/// i.e. @"foo". 28139743Simpclass ObjCStringLiteral : public Expr { 2939213Sgibbs Stmt *String; 3039213Sgibbs SourceLocation AtLoc; 3139213Sgibbspublic: 3239213Sgibbs ObjCStringLiteral(StringLiteral *SL, QualType T, SourceLocation L) 3339213Sgibbs : Expr(ObjCStringLiteralClass, T), String(SL), AtLoc(L) {} 3439213Sgibbs explicit ObjCStringLiteral(EmptyShell Empty) 3539213Sgibbs : Expr(ObjCStringLiteralClass, Empty) {} 3639213Sgibbs 3739213Sgibbs StringLiteral *getString() { return cast<StringLiteral>(String); } 3839213Sgibbs const StringLiteral *getString() const { return cast<StringLiteral>(String); } 3939213Sgibbs void setString(StringLiteral *S) { String = S; } 4039213Sgibbs 4139213Sgibbs SourceLocation getAtLoc() const { return AtLoc; } 4239213Sgibbs void setAtLoc(SourceLocation L) { AtLoc = L; } 4339213Sgibbs 4439213Sgibbs virtual SourceRange getSourceRange() const { 4539213Sgibbs return SourceRange(AtLoc, String->getLocEnd()); 4639213Sgibbs } 4739213Sgibbs 48116162Sobrien static bool classof(const Stmt *T) { 49116162Sobrien return T->getStmtClass() == ObjCStringLiteralClass; 50116162Sobrien } 5140020Sken static bool classof(const ObjCStringLiteral *) { return true; } 5239213Sgibbs 5339213Sgibbs // Iterators 5439213Sgibbs virtual child_iterator child_begin(); 5539213Sgibbs virtual child_iterator child_end(); 5660041Sphk}; 5751836Sphk 5851836Sphk/// ObjCEncodeExpr, used for @encode in Objective-C. @encode has the same type 5939213Sgibbs/// and behavior as StringLiteral except that the string initializer is obtained 6039213Sgibbs/// from ASTContext with the encoding type as an argument. 61105421Snjlclass ObjCEncodeExpr : public Expr { 6260422Sken QualType EncType; 6339213Sgibbs SourceLocation AtLoc, RParenLoc; 6439213Sgibbspublic: 65119708Sken ObjCEncodeExpr(QualType T, QualType ET, 66120599Sphk SourceLocation at, SourceLocation rp) 6739213Sgibbs : Expr(ObjCEncodeExprClass, T), EncType(ET), AtLoc(at), RParenLoc(rp) {} 6839213Sgibbs 6939213Sgibbs explicit ObjCEncodeExpr(EmptyShell Empty) : Expr(ObjCEncodeExprClass, Empty){} 7039213Sgibbs 7139213Sgibbs 7239213Sgibbs SourceLocation getAtLoc() const { return AtLoc; } 73168752Sscottl void setAtLoc(SourceLocation L) { AtLoc = L; } 7439213Sgibbs SourceLocation getRParenLoc() const { return RParenLoc; } 7539213Sgibbs void setRParenLoc(SourceLocation L) { RParenLoc = L; } 7639213Sgibbs 7739213Sgibbs QualType getEncodedType() const { return EncType; } 7839213Sgibbs void setEncodedType(QualType T) { EncType = T; } 7939213Sgibbs 8039213Sgibbs 8139213Sgibbs virtual SourceRange getSourceRange() const { 8239213Sgibbs return SourceRange(AtLoc, RParenLoc); 8339213Sgibbs } 8439213Sgibbs 8539213Sgibbs static bool classof(const Stmt *T) { 8639213Sgibbs return T->getStmtClass() == ObjCEncodeExprClass; 87111206Sken } 88111206Sken static bool classof(const ObjCEncodeExpr *) { return true; } 89111206Sken 90111206Sken // Iterators 91111206Sken virtual child_iterator child_begin(); 92111206Sken virtual child_iterator child_end(); 9339213Sgibbs}; 9439213Sgibbs 9539213Sgibbs/// ObjCSelectorExpr used for @selector in Objective-C. 96120884Sthomasclass ObjCSelectorExpr : public Expr { 97120884Sthomas Selector SelName; 98120884Sthomas SourceLocation AtLoc, RParenLoc; 99120884Sthomaspublic: 100120884Sthomas ObjCSelectorExpr(QualType T, Selector selInfo, 101120884Sthomas SourceLocation at, SourceLocation rp) 102120884Sthomas : Expr(ObjCSelectorExprClass, T), SelName(selInfo), AtLoc(at), RParenLoc(rp){} 103120884Sthomas explicit ObjCSelectorExpr(EmptyShell Empty) 104120884Sthomas : Expr(ObjCSelectorExprClass, Empty) {} 105120884Sthomas 106120884Sthomas Selector getSelector() const { return SelName; } 107168752Sscottl void setSelector(Selector S) { SelName = S; } 108168752Sscottl 10939213Sgibbs SourceLocation getAtLoc() const { return AtLoc; } 11039213Sgibbs SourceLocation getRParenLoc() const { return RParenLoc; } 11139213Sgibbs void setAtLoc(SourceLocation L) { AtLoc = L; } 11239213Sgibbs void setRParenLoc(SourceLocation L) { RParenLoc = L; } 11339213Sgibbs 11439213Sgibbs virtual SourceRange getSourceRange() const { 11539213Sgibbs return SourceRange(AtLoc, RParenLoc); 11639213Sgibbs } 11739213Sgibbs 11839213Sgibbs /// getNumArgs - Return the number of actual arguments to this call. 11939213Sgibbs unsigned getNumArgs() const { return SelName.getNumArgs(); } 12039213Sgibbs 12139213Sgibbs static bool classof(const Stmt *T) { 12239213Sgibbs return T->getStmtClass() == ObjCSelectorExprClass; 12339213Sgibbs } 12439213Sgibbs static bool classof(const ObjCSelectorExpr *) { return true; } 12539213Sgibbs 12639213Sgibbs // Iterators 12739213Sgibbs virtual child_iterator child_begin(); 12839213Sgibbs virtual child_iterator child_end(); 129111206Sken}; 130111206Sken 131111206Sken/// ObjCProtocolExpr used for protocol expression in Objective-C. This is used 132111206Sken/// as: @protocol(foo), as in: 133111206Sken/// obj conformsToProtocol:@protocol(foo)] 134111206Sken/// The return type is "Protocol*". 135111206Skenclass ObjCProtocolExpr : public Expr { 136111206Sken ObjCProtocolDecl *Protocol; 137111206Sken SourceLocation AtLoc, RParenLoc; 138111206Skenpublic: 13939213Sgibbs ObjCProtocolExpr(QualType T, ObjCProtocolDecl *protocol, 14039213Sgibbs SourceLocation at, SourceLocation rp) 14139213Sgibbs : Expr(ObjCProtocolExprClass, T), Protocol(protocol), 14239213Sgibbs AtLoc(at), RParenLoc(rp) {} 14339213Sgibbs explicit ObjCProtocolExpr(EmptyShell Empty) 14439213Sgibbs : Expr(ObjCProtocolExprClass, Empty) {} 14539213Sgibbs 14639213Sgibbs ObjCProtocolDecl *getProtocol() const { return Protocol; } 14746581Sken void setProtocol(ObjCProtocolDecl *P) { Protocol = P; } 14859249Sphk 14960938Sjake SourceLocation getAtLoc() const { return AtLoc; } 15039213Sgibbs SourceLocation getRParenLoc() const { return RParenLoc; } 15139213Sgibbs void setAtLoc(SourceLocation L) { AtLoc = L; } 15239213Sgibbs void setRParenLoc(SourceLocation L) { RParenLoc = L; } 15360938Sjake 15439213Sgibbs virtual SourceRange getSourceRange() const { 15539213Sgibbs return SourceRange(AtLoc, RParenLoc); 15639213Sgibbs } 157111206Sken 158112262Sphk static bool classof(const Stmt *T) { 159119708Sken return T->getStmtClass() == ObjCProtocolExprClass; 160111206Sken } 161111206Sken static bool classof(const ObjCProtocolExpr *) { return true; } 162111206Sken 163111206Sken // Iterators 164125975Sphk virtual child_iterator child_begin(); 16539213Sgibbs virtual child_iterator child_end(); 16639213Sgibbs}; 167111206Sken 168111206Sken/// ObjCIvarRefExpr - A reference to an ObjC instance variable. 169111206Skenclass ObjCIvarRefExpr : public Expr { 170111206Sken class ObjCIvarDecl *D; 171111206Sken SourceLocation Loc; 172111206Sken Stmt *Base; 173111206Sken bool IsArrow:1; // True if this is "X->F", false if this is "X.F". 174111206Sken bool IsFreeIvar:1; // True if ivar reference has no base (self assumed). 175111206Sken 176111206Skenpublic: 17739213Sgibbs ObjCIvarRefExpr(ObjCIvarDecl *d, 17839213Sgibbs QualType t, SourceLocation l, Expr *base=0, 17939213Sgibbs bool arrow = false, bool freeIvar = false) : 18039213Sgibbs Expr(ObjCIvarRefExprClass, t), D(d), 18139213Sgibbs Loc(l), Base(base), IsArrow(arrow), 18239213Sgibbs IsFreeIvar(freeIvar) {} 183111206Sken 184111206Sken explicit ObjCIvarRefExpr(EmptyShell Empty) 185111206Sken : Expr(ObjCIvarRefExprClass, Empty) {} 186111206Sken 187111206Sken ObjCIvarDecl *getDecl() { return D; } 18839213Sgibbs const ObjCIvarDecl *getDecl() const { return D; } 189111206Sken void setDecl(ObjCIvarDecl *d) { D = d; } 190111206Sken 191111206Sken const Expr *getBase() const { return cast<Expr>(Base); } 192111206Sken Expr *getBase() { return cast<Expr>(Base); } 193111206Sken void setBase(Expr * base) { Base = base; } 194111206Sken 195111206Sken bool isArrow() const { return IsArrow; } 196111206Sken bool isFreeIvar() const { return IsFreeIvar; } 197111206Sken void setIsArrow(bool A) { IsArrow = A; } 198111206Sken void setIsFreeIvar(bool A) { IsFreeIvar = A; } 19939213Sgibbs 20039213Sgibbs SourceLocation getLocation() const { return Loc; } 20139213Sgibbs void setLocation(SourceLocation L) { Loc = L; } 20239213Sgibbs 20339213Sgibbs virtual SourceRange getSourceRange() const { 20439213Sgibbs return isFreeIvar() ? SourceRange(Loc) 20539213Sgibbs : SourceRange(getBase()->getLocStart(), Loc); 20639213Sgibbs } 20754451Sken 20839213Sgibbs static bool classof(const Stmt *T) { 20940262Sken return T->getStmtClass() == ObjCIvarRefExprClass; 21040262Sken } 21167752Sken static bool classof(const ObjCIvarRefExpr *) { return true; } 21267752Sken 21367752Sken // Iterators 21467752Sken virtual child_iterator child_begin(); 21540262Sken virtual child_iterator child_end(); 21640262Sken}; 21739213Sgibbs 21839213Sgibbs/// ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC 21939213Sgibbs/// property. 220120599Sphk/// 221120599Sphkclass ObjCPropertyRefExpr : public Expr { 222120599Sphkprivate: 223120599Sphk ObjCPropertyDecl *AsProperty; 22439213Sgibbs SourceLocation IdLoc; 22539213Sgibbs Stmt *Base; 22639213Sgibbspublic: 22739213Sgibbs ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t, 22839213Sgibbs SourceLocation l, Expr *base) 22940603Sken : Expr(ObjCPropertyRefExprClass, t), AsProperty(PD), IdLoc(l), Base(base) { 23039213Sgibbs } 23139213Sgibbs 232111206Sken explicit ObjCPropertyRefExpr(EmptyShell Empty) 23339213Sgibbs : Expr(ObjCPropertyRefExprClass, Empty) {} 23439213Sgibbs 23539213Sgibbs ObjCPropertyDecl *getProperty() const { return AsProperty; } 23639213Sgibbs void setProperty(ObjCPropertyDecl *D) { AsProperty = D; } 23739213Sgibbs 23839213Sgibbs const Expr *getBase() const { return cast<Expr>(Base); } 23939213Sgibbs Expr *getBase() { return cast<Expr>(Base); } 24039213Sgibbs void setBase(Expr *base) { Base = base; } 24139213Sgibbs 242111206Sken SourceLocation getLocation() const { return IdLoc; } 24339213Sgibbs void setLocation(SourceLocation L) { IdLoc = L; } 24439213Sgibbs 24539213Sgibbs virtual SourceRange getSourceRange() const { 246111206Sken return SourceRange(getBase()->getLocStart(), IdLoc); 247111206Sken } 248111206Sken 249111206Sken static bool classof(const Stmt *T) { 250111206Sken return T->getStmtClass() == ObjCPropertyRefExprClass; 251111206Sken } 25239213Sgibbs static bool classof(const ObjCPropertyRefExpr *) { return true; } 25339213Sgibbs 25439213Sgibbs // Iterators 255111206Sken virtual child_iterator child_begin(); 256111206Sken virtual child_iterator child_end(); 25739213Sgibbs}; 258111206Sken 25939213Sgibbs/// ObjCKVCRefExpr - A dot-syntax expression to access "implicit" properties 260111206Sken/// (i.e. methods following the property naming convention). KVC stands for 26139213Sgibbs/// Key Value Encoding, a generic concept for accessing or setting a 'Key' 26239213Sgibbs/// value for an object. 26339213Sgibbs/// 26439213Sgibbsclass ObjCKVCRefExpr : public Expr { 26539213Sgibbs ObjCMethodDecl *Setter; 26639213Sgibbs ObjCMethodDecl *Getter; 26739213Sgibbs SourceLocation Loc; 26839213Sgibbs // FIXME: Swizzle these into a single pointer. 26939213Sgibbs Stmt *Base; 27039213Sgibbs ObjCInterfaceDecl *ClassProp; 27139213Sgibbs SourceLocation ClassLoc; 27239213Sgibbs 27339213Sgibbspublic: 27439213Sgibbs ObjCKVCRefExpr(ObjCMethodDecl *getter, 27539213Sgibbs QualType t, 27639213Sgibbs ObjCMethodDecl *setter, 277111206Sken SourceLocation l, Expr *base) 278105421Snjl : Expr(ObjCKVCRefExprClass, t), Setter(setter), 279105421Snjl Getter(getter), Loc(l), Base(base), ClassProp(0), 28060422Sken ClassLoc(SourceLocation()) { 28160422Sken } 28260422Sken ObjCKVCRefExpr(ObjCMethodDecl *getter, 28360422Sken QualType t, 28460422Sken ObjCMethodDecl *setter, 28560422Sken SourceLocation l, ObjCInterfaceDecl *C, SourceLocation CL) 28639213Sgibbs : Expr(ObjCKVCRefExprClass, t), Setter(setter), 28739213Sgibbs Getter(getter), Loc(l), Base(0), ClassProp(C), ClassLoc(CL) { 28839213Sgibbs } 28939213Sgibbs explicit ObjCKVCRefExpr(EmptyShell Empty) : Expr(ObjCKVCRefExprClass, Empty){} 29039213Sgibbs 29139213Sgibbs ObjCMethodDecl *getGetterMethod() const { return Getter; } 29239213Sgibbs ObjCMethodDecl *getSetterMethod() const { return Setter; } 29372119Speter ObjCInterfaceDecl *getClassProp() const { return ClassProp; } 29439213Sgibbs void setGetterMethod(ObjCMethodDecl *D) { Getter = D; } 295186882Simp void setSetterMethod(ObjCMethodDecl *D) { Setter = D; } 296186882Simp void setClassProp(ObjCInterfaceDecl *D) { ClassProp = D; } 297186882Simp 29839213Sgibbs virtual SourceRange getSourceRange() const { 29946747Sken if (Base) 30039213Sgibbs return SourceRange(getBase()->getLocStart(), Loc); 30139213Sgibbs return SourceRange(ClassLoc, Loc); 30246747Sken } 30339213Sgibbs const Expr *getBase() const { return cast_or_null<Expr>(Base); } 30439213Sgibbs Expr *getBase() { return cast_or_null<Expr>(Base); } 305186882Simp void setBase(Expr *base) { Base = base; } 30639213Sgibbs 30739213Sgibbs SourceLocation getLocation() const { return Loc; } 30839213Sgibbs void setLocation(SourceLocation L) { Loc = L; } 30939213Sgibbs SourceLocation getClassLoc() const { return ClassLoc; } 31039213Sgibbs void setClassLoc(SourceLocation L) { ClassLoc = L; } 311186882Simp 312186882Simp static bool classof(const Stmt *T) { 313186882Simp return T->getStmtClass() == ObjCKVCRefExprClass; 31439213Sgibbs } 31539213Sgibbs static bool classof(const ObjCKVCRefExpr *) { return true; } 316111206Sken 31739213Sgibbs // Iterators 31839213Sgibbs virtual child_iterator child_begin(); 319111206Sken virtual child_iterator child_end(); 32039213Sgibbs}; 32139213Sgibbs 32239213Sgibbsclass ObjCMessageExpr : public Expr { 32339213Sgibbs // SubExprs - The receiver and arguments of the message expression. 32439213Sgibbs Stmt **SubExprs; 32539213Sgibbs 32639213Sgibbs // NumArgs - The number of arguments (not including the receiver) to the 32739213Sgibbs // message expression. 328168752Sscottl unsigned NumArgs; 329168752Sscottl 33046581Sken // A unigue name for this message. 33160938Sjake Selector SelName; 33260938Sjake 33339213Sgibbs // A method prototype for this message (optional). 33439213Sgibbs // FIXME: Since method decls contain the selector, and most messages have a 335168752Sscottl // prototype, consider devising a scheme for unifying SelName/MethodProto. 33660938Sjake ObjCMethodDecl *MethodProto; 337168752Sscottl 33839213Sgibbs SourceLocation LBracloc, RBracloc; 339169562Sscottl 340169562Sscottl // Constants for indexing into SubExprs. 341104880Sphk enum { RECEIVER=0, ARGS_START=1 }; 34239213Sgibbs 34339213Sgibbs // Bit-swizzling flags. 34439213Sgibbs enum { IsInstMeth=0, IsClsMethDeclUnknown, IsClsMethDeclKnown, Flags=0x3 }; 34539213Sgibbs unsigned getFlag() const { return (uintptr_t) SubExprs[RECEIVER] & Flags; } 346168752Sscottl 347168752Sscottlpublic: 348168752Sscottl /// This constructor is used to represent class messages where the 34939213Sgibbs /// ObjCInterfaceDecl* of the receiver is not known. 35039213Sgibbs ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo, 35139213Sgibbs QualType retType, ObjCMethodDecl *methDecl, 35239213Sgibbs SourceLocation LBrac, SourceLocation RBrac, 353169605Sscottl Expr **ArgExprs, unsigned NumArgs); 35439213Sgibbs 35539213Sgibbs /// This constructor is used to represent class messages where the 35639213Sgibbs /// ObjCInterfaceDecl* of the receiver is known. 35739213Sgibbs // FIXME: clsName should be typed to ObjCInterfaceType 35839213Sgibbs ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo, 35939213Sgibbs QualType retType, ObjCMethodDecl *methDecl, 36039213Sgibbs SourceLocation LBrac, SourceLocation RBrac, 36139213Sgibbs Expr **ArgExprs, unsigned NumArgs); 36240603Sken 36340603Sken // constructor for instance messages. 36440603Sken ObjCMessageExpr(Expr *receiver, Selector selInfo, 36540603Sken QualType retType, ObjCMethodDecl *methDecl, 36640603Sken SourceLocation LBrac, SourceLocation RBrac, 36740603Sken Expr **ArgExprs, unsigned NumArgs); 36840603Sken 36940603Sken explicit ObjCMessageExpr(EmptyShell Empty) 37040603Sken : Expr(ObjCMessageExprClass, Empty), SubExprs(0), NumArgs(0) {} 371169605Sscottl 37240603Sken ~ObjCMessageExpr() { 37340603Sken delete [] SubExprs; 37440603Sken } 37540603Sken 37640603Sken /// getReceiver - Returns the receiver of the message expression. 37740603Sken /// This can be NULL if the message is for class methods. For 37840603Sken /// class methods, use getClassName. 37940603Sken /// FIXME: need to handle/detect 'super' usage within a class method. 380112946Sphk Expr *getReceiver() { 38140603Sken uintptr_t x = (uintptr_t) SubExprs[RECEIVER]; 38240603Sken return (x & Flags) == IsInstMeth ? (Expr*) x : 0; 38340603Sken } 38440603Sken const Expr *getReceiver() const { 38540603Sken return const_cast<ObjCMessageExpr*>(this)->getReceiver(); 38640603Sken } 38740603Sken // FIXME: need setters for different receiver types. 38840603Sken void setReceiver(Expr *rec) { SubExprs[RECEIVER] = rec; } 38940603Sken Selector getSelector() const { return SelName; } 39040603Sken void setSelector(Selector S) { SelName = S; } 391152565Sjdp 392164906Smjacob const ObjCMethodDecl *getMethodDecl() const { return MethodProto; } 39340603Sken ObjCMethodDecl *getMethodDecl() { return MethodProto; } 39440603Sken void setMethodDecl(ObjCMethodDecl *MD) { MethodProto = MD; } 39540603Sken 39639213Sgibbs typedef std::pair<ObjCInterfaceDecl*, IdentifierInfo*> ClassInfo; 39739213Sgibbs 39839213Sgibbs /// getClassInfo - For class methods, this returns both the ObjCInterfaceDecl* 39939213Sgibbs /// and IdentifierInfo* of the invoked class. Both can be NULL if this 40039213Sgibbs /// is an instance message, and the ObjCInterfaceDecl* can be NULL if none 40139213Sgibbs /// was available when this ObjCMessageExpr object was constructed. 402164906Smjacob ClassInfo getClassInfo() const; 40340603Sken void setClassInfo(const ClassInfo &C); 40439213Sgibbs 40539213Sgibbs /// getClassName - For class methods, this returns the invoked class, 40639213Sgibbs /// and returns NULL otherwise. For instance methods, use getReceiver. 40739213Sgibbs IdentifierInfo *getClassName() const { 40839213Sgibbs return getClassInfo().second; 40939213Sgibbs } 41039213Sgibbs 41139213Sgibbs /// getNumArgs - Return the number of actual arguments to this call. 41239213Sgibbs unsigned getNumArgs() const { return NumArgs; } 41339213Sgibbs void setNumArgs(unsigned nArgs) { 41439213Sgibbs NumArgs = nArgs; 41539213Sgibbs // FIXME: should always allocate SubExprs via the ASTContext's 41639213Sgibbs // allocator. 41739213Sgibbs if (!SubExprs) 41839213Sgibbs SubExprs = new Stmt* [NumArgs + 1]; 41939213Sgibbs } 42039213Sgibbs 42139213Sgibbs /// getArg - Return the specified argument. 42239213Sgibbs Expr *getArg(unsigned Arg) { 42339213Sgibbs assert(Arg < NumArgs && "Arg access out of range!"); 42439213Sgibbs return cast<Expr>(SubExprs[Arg+ARGS_START]); 42539213Sgibbs } 42639213Sgibbs const Expr *getArg(unsigned Arg) const { 42739213Sgibbs assert(Arg < NumArgs && "Arg access out of range!"); 42839213Sgibbs return cast<Expr>(SubExprs[Arg+ARGS_START]); 42939213Sgibbs } 43039213Sgibbs /// setArg - Set the specified argument. 43139213Sgibbs void setArg(unsigned Arg, Expr *ArgExpr) { 43239213Sgibbs assert(Arg < NumArgs && "Arg access out of range!"); 433168752Sscottl SubExprs[Arg+ARGS_START] = ArgExpr; 43439213Sgibbs } 43539213Sgibbs 436203108Smav SourceLocation getLeftLoc() const { return LBracloc; } 43739213Sgibbs SourceLocation getRightLoc() const { return RBracloc; } 43839213Sgibbs 43939213Sgibbs void setLeftLoc(SourceLocation L) { LBracloc = L; } 44039213Sgibbs void setRightLoc(SourceLocation L) { RBracloc = L; } 44139213Sgibbs 44239213Sgibbs void setSourceRange(SourceRange R) { 44339213Sgibbs LBracloc = R.getBegin(); 44439213Sgibbs RBracloc = R.getEnd(); 44539213Sgibbs } 44639213Sgibbs virtual SourceRange getSourceRange() const { 44739213Sgibbs return SourceRange(LBracloc, RBracloc); 44839213Sgibbs } 44939213Sgibbs 45039213Sgibbs static bool classof(const Stmt *T) { 45139213Sgibbs return T->getStmtClass() == ObjCMessageExprClass; 45239213Sgibbs } 45339213Sgibbs static bool classof(const ObjCMessageExpr *) { return true; } 454168752Sscottl 45539213Sgibbs // Iterators 45639213Sgibbs virtual child_iterator child_begin(); 45739213Sgibbs virtual child_iterator child_end(); 45839213Sgibbs 459168752Sscottl typedef ExprIterator arg_iterator; 46039213Sgibbs typedef ConstExprIterator const_arg_iterator; 46139213Sgibbs 46239213Sgibbs arg_iterator arg_begin() { return &SubExprs[ARGS_START]; } 463168752Sscottl arg_iterator arg_end() { return &SubExprs[ARGS_START] + NumArgs; } 46460938Sjake const_arg_iterator arg_begin() const { return &SubExprs[ARGS_START]; } 46539213Sgibbs const_arg_iterator arg_end() const { return &SubExprs[ARGS_START] + NumArgs; } 466168752Sscottl}; 467168752Sscottl 468164906Smjacob/// ObjCSuperExpr - Represents the "super" expression in Objective-C, 46939213Sgibbs/// which refers to the object on which the current method is executing. 47039213Sgibbsclass ObjCSuperExpr : public Expr { 471168786Sscottl SourceLocation Loc; 472188503Sjhbpublic: 473188503Sjhb ObjCSuperExpr(SourceLocation L, QualType Type) 474188503Sjhb : Expr(ObjCSuperExprClass, Type), Loc(L) { } 475188503Sjhb explicit ObjCSuperExpr(EmptyShell Empty) : Expr(ObjCSuperExprClass, Empty) {} 476188503Sjhb 477125975Sphk SourceLocation getLoc() const { return Loc; } 478188503Sjhb void setLoc(SourceLocation L) { Loc = L; } 479168786Sscottl 48039213Sgibbs virtual SourceRange getSourceRange() const { return SourceRange(Loc); } 48139213Sgibbs 48239213Sgibbs static bool classof(const Stmt *T) { 48339213Sgibbs return T->getStmtClass() == ObjCSuperExprClass; 48439213Sgibbs } 48539213Sgibbs static bool classof(const ObjCSuperExpr *) { return true; } 48639213Sgibbs 48739213Sgibbs // Iterators 48839213Sgibbs virtual child_iterator child_begin(); 48939213Sgibbs virtual child_iterator child_end(); 49039213Sgibbs}; 49139213Sgibbs 49239213Sgibbs} // end namespace clang 49339213Sgibbs 49439213Sgibbs#endif 49539213Sgibbs