зеркало из https://github.com/microsoft/clang-1.git
839 строки
35 KiB
C++
839 строки
35 KiB
C++
//===--- PrintParserActions.cpp - Implement -parse-print-callbacks mode ---===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This code simply runs the preprocessor on the input file and prints out the
|
|
// result. This is the traditional behavior of the -E option.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/Frontend/Utils.h"
|
|
#include "clang/Parse/Action.h"
|
|
#include "clang/Parse/DeclSpec.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
using namespace clang;
|
|
|
|
namespace {
|
|
class ParserPrintActions : public MinimalAction {
|
|
llvm::raw_ostream& Out;
|
|
|
|
public:
|
|
ParserPrintActions(Preprocessor &PP, llvm::raw_ostream& OS)
|
|
: MinimalAction(PP), Out(OS) {}
|
|
|
|
// Printing Functions which also must call MinimalAction
|
|
|
|
/// ActOnDeclarator - This callback is invoked when a declarator is parsed
|
|
/// and 'Init' specifies the initializer if any. This is for things like:
|
|
/// "int X = 4" or "typedef int foo".
|
|
virtual DeclPtrTy ActOnDeclarator(Scope *S, Declarator &D) {
|
|
Out << __FUNCTION__ << " ";
|
|
if (IdentifierInfo *II = D.getIdentifier()) {
|
|
Out << "'" << II->getName() << "'";
|
|
} else {
|
|
Out << "<anon>";
|
|
}
|
|
Out << "\n";
|
|
|
|
// Pass up to EmptyActions so that the symbol table is maintained right.
|
|
return MinimalAction::ActOnDeclarator(S, D);
|
|
}
|
|
/// ActOnPopScope - This callback is called immediately before the specified
|
|
/// scope is popped and deleted.
|
|
virtual void ActOnPopScope(SourceLocation Loc, Scope *S) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return MinimalAction::ActOnPopScope(Loc, S);
|
|
}
|
|
|
|
/// ActOnTranslationUnitScope - This callback is called once, immediately
|
|
/// after creating the translation unit scope (in Parser::Initialize).
|
|
virtual void ActOnTranslationUnitScope(SourceLocation Loc, Scope *S) {
|
|
Out << __FUNCTION__ << "\n";
|
|
MinimalAction::ActOnTranslationUnitScope(Loc, S);
|
|
}
|
|
|
|
|
|
Action::DeclPtrTy ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
|
|
IdentifierInfo *ClassName,
|
|
SourceLocation ClassLoc,
|
|
IdentifierInfo *SuperName,
|
|
SourceLocation SuperLoc,
|
|
const DeclPtrTy *ProtoRefs,
|
|
unsigned NumProtocols,
|
|
SourceLocation EndProtoLoc,
|
|
AttributeList *AttrList) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return MinimalAction::ActOnStartClassInterface(AtInterfaceLoc,
|
|
ClassName, ClassLoc,
|
|
SuperName, SuperLoc,
|
|
ProtoRefs, NumProtocols,
|
|
EndProtoLoc, AttrList);
|
|
}
|
|
|
|
/// ActOnForwardClassDeclaration -
|
|
/// Scope will always be top level file scope.
|
|
Action::DeclPtrTy ActOnForwardClassDeclaration(SourceLocation AtClassLoc,
|
|
IdentifierInfo **IdentList,
|
|
unsigned NumElts) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return MinimalAction::ActOnForwardClassDeclaration(AtClassLoc, IdentList,
|
|
NumElts);
|
|
}
|
|
|
|
// Pure Printing
|
|
|
|
/// ActOnParamDeclarator - This callback is invoked when a parameter
|
|
/// declarator is parsed. This callback only occurs for functions
|
|
/// with prototypes. S is the function prototype scope for the
|
|
/// parameters (C++ [basic.scope.proto]).
|
|
virtual DeclPtrTy ActOnParamDeclarator(Scope *S, Declarator &D) {
|
|
Out << __FUNCTION__ << " ";
|
|
if (IdentifierInfo *II = D.getIdentifier()) {
|
|
Out << "'" << II->getName() << "'";
|
|
} else {
|
|
Out << "<anon>";
|
|
}
|
|
Out << "\n";
|
|
return DeclPtrTy();
|
|
}
|
|
|
|
/// AddInitializerToDecl - This action is called immediately after
|
|
/// ParseDeclarator (when an initializer is present). The code is factored
|
|
/// this way to make sure we are able to handle the following:
|
|
/// void func() { int xx = xx; }
|
|
/// This allows ActOnDeclarator to register "xx" prior to parsing the
|
|
/// initializer. The declaration above should still result in a warning,
|
|
/// since the reference to "xx" is uninitialized.
|
|
virtual void AddInitializerToDecl(DeclPtrTy Dcl, ExprArg Init) {
|
|
Out << __FUNCTION__ << "\n";
|
|
}
|
|
|
|
/// FinalizeDeclaratorGroup - After a sequence of declarators are parsed,
|
|
/// this gives the actions implementation a chance to process the group as
|
|
/// a whole.
|
|
virtual DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec& DS,
|
|
DeclPtrTy *Group,
|
|
unsigned NumDecls) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return DeclGroupPtrTy();
|
|
}
|
|
|
|
/// ActOnStartOfFunctionDef - This is called at the start of a function
|
|
/// definition, instead of calling ActOnDeclarator. The Declarator includes
|
|
/// information about formal arguments that are part of this function.
|
|
virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *FnBodyScope,
|
|
Declarator &D){
|
|
Out << __FUNCTION__ << "\n";
|
|
return DeclPtrTy();
|
|
}
|
|
|
|
/// ActOnStartOfFunctionDef - This is called at the start of a function
|
|
/// definition, after the FunctionDecl has already been created.
|
|
virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclPtrTy D) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return DeclPtrTy();
|
|
}
|
|
|
|
virtual void ActOnStartOfObjCMethodDef(Scope *FnBodyScope, DeclPtrTy D) {
|
|
Out << __FUNCTION__ << "\n";
|
|
}
|
|
|
|
/// ActOnFunctionDefBody - This is called when a function body has completed
|
|
/// parsing. Decl is the DeclTy returned by ParseStartOfFunctionDef.
|
|
virtual DeclPtrTy ActOnFinishFunctionBody(DeclPtrTy Decl, StmtArg Body) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return DeclPtrTy();
|
|
}
|
|
|
|
virtual DeclPtrTy ActOnFileScopeAsmDecl(SourceLocation Loc,
|
|
ExprArg AsmString) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return DeclPtrTy();
|
|
}
|
|
|
|
/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
|
|
/// no declarator (e.g. "struct foo;") is parsed.
|
|
virtual DeclPtrTy ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return DeclPtrTy();
|
|
}
|
|
|
|
/// ActOnLinkageSpec - Parsed a C++ linkage-specification that
|
|
/// contained braces. Lang/StrSize contains the language string that
|
|
/// was parsed at location Loc. Decls/NumDecls provides the
|
|
/// declarations parsed inside the linkage specification.
|
|
virtual DeclPtrTy ActOnLinkageSpec(SourceLocation Loc,
|
|
SourceLocation LBrace,
|
|
SourceLocation RBrace, const char *Lang,
|
|
unsigned StrSize,
|
|
DeclPtrTy *Decls, unsigned NumDecls) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return DeclPtrTy();
|
|
}
|
|
|
|
/// ActOnLinkageSpec - Parsed a C++ linkage-specification without
|
|
/// braces. Lang/StrSize contains the language string that was
|
|
/// parsed at location Loc. D is the declaration parsed.
|
|
virtual DeclPtrTy ActOnLinkageSpec(SourceLocation Loc, const char *Lang,
|
|
unsigned StrSize, DeclPtrTy D) {
|
|
return DeclPtrTy();
|
|
}
|
|
|
|
//===------------------------------------------------------------------===//
|
|
// Type Parsing Callbacks.
|
|
//===------------------------------------------------------------------===//
|
|
|
|
virtual TypeResult ActOnTypeName(Scope *S, Declarator &D) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return TypeResult();
|
|
}
|
|
|
|
virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagType, TagUseKind TUK,
|
|
SourceLocation KWLoc, const CXXScopeSpec &SS,
|
|
IdentifierInfo *Name, SourceLocation NameLoc,
|
|
AttributeList *Attr, AccessSpecifier AS,
|
|
MultiTemplateParamsArg TemplateParamLists,
|
|
bool &Owned) {
|
|
// TagType is an instance of DeclSpec::TST, indicating what kind of tag this
|
|
// is (struct/union/enum/class).
|
|
Out << __FUNCTION__ << "\n";
|
|
return DeclPtrTy();
|
|
}
|
|
|
|
/// Act on @defs() element found when parsing a structure. ClassName is the
|
|
/// name of the referenced class.
|
|
virtual void ActOnDefs(Scope *S, DeclPtrTy TagD, SourceLocation DeclStart,
|
|
IdentifierInfo *ClassName,
|
|
llvm::SmallVectorImpl<DeclPtrTy> &Decls) {
|
|
Out << __FUNCTION__ << "\n";
|
|
}
|
|
|
|
virtual DeclPtrTy ActOnField(Scope *S, DeclPtrTy TagD,
|
|
SourceLocation DeclStart,
|
|
Declarator &D, ExprTy *BitfieldWidth) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return DeclPtrTy();
|
|
}
|
|
|
|
virtual DeclPtrTy ActOnIvar(Scope *S, SourceLocation DeclStart,
|
|
DeclPtrTy IntfDecl,
|
|
Declarator &D, ExprTy *BitfieldWidth,
|
|
tok::ObjCKeywordKind visibility) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return DeclPtrTy();
|
|
}
|
|
|
|
virtual void ActOnFields(Scope* S, SourceLocation RecLoc, DeclPtrTy TagDecl,
|
|
DeclPtrTy *Fields, unsigned NumFields,
|
|
SourceLocation LBrac, SourceLocation RBrac,
|
|
AttributeList *AttrList) {
|
|
Out << __FUNCTION__ << "\n";
|
|
}
|
|
|
|
virtual DeclPtrTy ActOnEnumConstant(Scope *S, DeclPtrTy EnumDecl,
|
|
DeclPtrTy LastEnumConstant,
|
|
SourceLocation IdLoc,IdentifierInfo *Id,
|
|
SourceLocation EqualLoc, ExprTy *Val) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return DeclPtrTy();
|
|
}
|
|
|
|
virtual void ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
|
|
SourceLocation RBraceLoc, DeclPtrTy EnumDecl,
|
|
DeclPtrTy *Elements, unsigned NumElements,
|
|
Scope *S, AttributeList *AttrList) {
|
|
Out << __FUNCTION__ << "\n";
|
|
}
|
|
|
|
//===------------------------------------------------------------------===//
|
|
// Statement Parsing Callbacks.
|
|
//===------------------------------------------------------------------===//
|
|
|
|
virtual OwningStmtResult ActOnNullStmt(SourceLocation SemiLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
|
|
virtual OwningStmtResult ActOnCompoundStmt(SourceLocation L,
|
|
SourceLocation R,
|
|
MultiStmtArg Elts,
|
|
bool isStmtExpr) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
virtual OwningStmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
|
|
SourceLocation StartLoc,
|
|
SourceLocation EndLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
|
|
virtual OwningStmtResult ActOnExprStmt(FullExprArg Expr) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return OwningStmtResult(*this, Expr->release());
|
|
}
|
|
|
|
/// ActOnCaseStmt - Note that this handles the GNU 'case 1 ... 4' extension,
|
|
/// which can specify an RHS value.
|
|
virtual OwningStmtResult ActOnCaseStmt(SourceLocation CaseLoc,
|
|
ExprArg LHSVal,
|
|
SourceLocation DotDotDotLoc,
|
|
ExprArg RHSVal,
|
|
SourceLocation ColonLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
virtual OwningStmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
|
|
SourceLocation ColonLoc,
|
|
StmtArg SubStmt, Scope *CurScope){
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
|
|
virtual OwningStmtResult ActOnLabelStmt(SourceLocation IdentLoc,
|
|
IdentifierInfo *II,
|
|
SourceLocation ColonLoc,
|
|
StmtArg SubStmt) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
|
|
virtual OwningStmtResult ActOnIfStmt(SourceLocation IfLoc,
|
|
FullExprArg CondVal, StmtArg ThenVal,
|
|
SourceLocation ElseLoc,
|
|
StmtArg ElseVal) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
|
|
virtual OwningStmtResult ActOnStartOfSwitchStmt(ExprArg Cond) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
|
|
virtual OwningStmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
|
|
StmtArg Switch,
|
|
StmtArg Body) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
|
|
virtual OwningStmtResult ActOnWhileStmt(SourceLocation WhileLoc,
|
|
FullExprArg Cond, StmtArg Body) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
virtual OwningStmtResult ActOnDoStmt(SourceLocation DoLoc, StmtArg Body,
|
|
SourceLocation WhileLoc,
|
|
SourceLocation LPLoc, ExprArg Cond,
|
|
SourceLocation RPLoc){
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
virtual OwningStmtResult ActOnForStmt(SourceLocation ForLoc,
|
|
SourceLocation LParenLoc,
|
|
StmtArg First, ExprArg Second,
|
|
ExprArg Third, SourceLocation RParenLoc,
|
|
StmtArg Body) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
virtual OwningStmtResult ActOnObjCForCollectionStmt(
|
|
SourceLocation ForColLoc,
|
|
SourceLocation LParenLoc,
|
|
StmtArg First, ExprArg Second,
|
|
SourceLocation RParenLoc, StmtArg Body) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
virtual OwningStmtResult ActOnGotoStmt(SourceLocation GotoLoc,
|
|
SourceLocation LabelLoc,
|
|
IdentifierInfo *LabelII) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
virtual OwningStmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
|
|
SourceLocation StarLoc,
|
|
ExprArg DestExp) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
virtual OwningStmtResult ActOnContinueStmt(SourceLocation ContinueLoc,
|
|
Scope *CurScope) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
virtual OwningStmtResult ActOnBreakStmt(SourceLocation GotoLoc,
|
|
Scope *CurScope) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
virtual OwningStmtResult ActOnReturnStmt(SourceLocation ReturnLoc,
|
|
ExprArg RetValExp) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
virtual OwningStmtResult ActOnAsmStmt(SourceLocation AsmLoc,
|
|
bool IsSimple,
|
|
bool IsVolatile,
|
|
unsigned NumOutputs,
|
|
unsigned NumInputs,
|
|
std::string *Names,
|
|
MultiExprArg Constraints,
|
|
MultiExprArg Exprs,
|
|
ExprArg AsmString,
|
|
MultiExprArg Clobbers,
|
|
SourceLocation RParenLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
|
|
// Objective-c statements
|
|
virtual OwningStmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc,
|
|
SourceLocation RParen,
|
|
DeclPtrTy Parm, StmtArg Body,
|
|
StmtArg CatchList) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
|
|
virtual OwningStmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc,
|
|
StmtArg Body) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
|
|
virtual OwningStmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc,
|
|
StmtArg Try, StmtArg Catch,
|
|
StmtArg Finally) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
|
|
virtual OwningStmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc,
|
|
ExprArg Throw,
|
|
Scope *CurScope) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
|
|
virtual OwningStmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
|
|
ExprArg SynchExpr,
|
|
StmtArg SynchBody) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
|
|
// C++ Statements
|
|
virtual DeclPtrTy ActOnExceptionDeclarator(Scope *S, Declarator &D) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return DeclPtrTy();
|
|
}
|
|
|
|
virtual OwningStmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
|
|
DeclPtrTy ExceptionDecl,
|
|
StmtArg HandlerBlock) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
|
|
virtual OwningStmtResult ActOnCXXTryBlock(SourceLocation TryLoc,
|
|
StmtArg TryBlock,
|
|
MultiStmtArg Handlers) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return StmtEmpty();
|
|
}
|
|
|
|
//===------------------------------------------------------------------===//
|
|
// Expression Parsing Callbacks.
|
|
//===------------------------------------------------------------------===//
|
|
|
|
// Primary Expressions.
|
|
|
|
/// ActOnIdentifierExpr - Parse an identifier in expression context.
|
|
/// 'HasTrailingLParen' indicates whether or not the identifier has a '('
|
|
/// token immediately after it.
|
|
virtual OwningExprResult ActOnIdentifierExpr(Scope *S, SourceLocation Loc,
|
|
IdentifierInfo &II,
|
|
bool HasTrailingLParen,
|
|
const CXXScopeSpec *SS,
|
|
bool isAddressOfOperand) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnCXXOperatorFunctionIdExpr(
|
|
Scope *S, SourceLocation OperatorLoc,
|
|
OverloadedOperatorKind Op,
|
|
bool HasTrailingLParen, const CXXScopeSpec &SS,
|
|
bool isAddressOfOperand) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnCXXConversionFunctionExpr(
|
|
Scope *S, SourceLocation OperatorLoc,
|
|
TypeTy *Type, bool HasTrailingLParen,
|
|
const CXXScopeSpec &SS,bool isAddressOfOperand) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnPredefinedExpr(SourceLocation Loc,
|
|
tok::TokenKind Kind) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnCharacterConstant(const Token &) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnNumericConstant(const Token &) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
/// ActOnStringLiteral - The specified tokens were lexed as pasted string
|
|
/// fragments (e.g. "foo" "bar" L"baz").
|
|
virtual OwningExprResult ActOnStringLiteral(const Token *Toks,
|
|
unsigned NumToks) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnParenExpr(SourceLocation L, SourceLocation R,
|
|
ExprArg Val) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return move(Val); // Default impl returns operand.
|
|
}
|
|
|
|
// Postfix Expressions.
|
|
virtual OwningExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
|
|
tok::TokenKind Kind,
|
|
ExprArg Input) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
virtual OwningExprResult ActOnArraySubscriptExpr(Scope *S, ExprArg Base,
|
|
SourceLocation LLoc,
|
|
ExprArg Idx,
|
|
SourceLocation RLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
virtual OwningExprResult ActOnMemberReferenceExpr(Scope *S, ExprArg Base,
|
|
SourceLocation OpLoc,
|
|
tok::TokenKind OpKind,
|
|
SourceLocation MemberLoc,
|
|
IdentifierInfo &Member,
|
|
DeclPtrTy ImplDecl,
|
|
const CXXScopeSpec *SS=0) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnCallExpr(Scope *S, ExprArg Fn,
|
|
SourceLocation LParenLoc,
|
|
MultiExprArg Args,
|
|
SourceLocation *CommaLocs,
|
|
SourceLocation RParenLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
// Unary Operators. 'Tok' is the token for the operator.
|
|
virtual OwningExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
|
|
tok::TokenKind Op, ExprArg Input) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
virtual OwningExprResult
|
|
ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType,
|
|
void *TyOrEx, const SourceRange &ArgRange) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnCompoundLiteral(SourceLocation LParen,
|
|
TypeTy *Ty,
|
|
SourceLocation RParen,
|
|
ExprArg Op) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
virtual OwningExprResult ActOnInitList(SourceLocation LParenLoc,
|
|
MultiExprArg InitList,
|
|
SourceLocation RParenLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
virtual OwningExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
|
|
TypeTy *Ty, SourceLocation RParenLoc,
|
|
ExprArg Op) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
|
|
tok::TokenKind Kind,
|
|
ExprArg LHS, ExprArg RHS) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
/// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
|
|
/// in the case of a the GNU conditional expr extension.
|
|
virtual OwningExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
|
|
SourceLocation ColonLoc,
|
|
ExprArg Cond, ExprArg LHS,
|
|
ExprArg RHS) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
//===--------------------- GNU Extension Expressions ------------------===//
|
|
|
|
virtual OwningExprResult ActOnAddrLabel(SourceLocation OpLoc,
|
|
SourceLocation LabLoc,
|
|
IdentifierInfo *LabelII) {// "&&foo"
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnStmtExpr(SourceLocation LPLoc,
|
|
StmtArg SubStmt,
|
|
SourceLocation RPLoc) { // "({..})"
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnBuiltinOffsetOf(Scope *S,
|
|
SourceLocation BuiltinLoc,
|
|
SourceLocation TypeLoc,
|
|
TypeTy *Arg1,
|
|
OffsetOfComponent *CompPtr,
|
|
unsigned NumComponents,
|
|
SourceLocation RParenLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
// __builtin_types_compatible_p(type1, type2)
|
|
virtual OwningExprResult ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
|
|
TypeTy *arg1,TypeTy *arg2,
|
|
SourceLocation RPLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
// __builtin_choose_expr(constExpr, expr1, expr2)
|
|
virtual OwningExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
|
|
ExprArg cond, ExprArg expr1,
|
|
ExprArg expr2,
|
|
SourceLocation RPLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
// __builtin_va_arg(expr, type)
|
|
virtual OwningExprResult ActOnVAArg(SourceLocation BuiltinLoc,
|
|
ExprArg expr, TypeTy *type,
|
|
SourceLocation RPLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnGNUNullExpr(SourceLocation TokenLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope) {
|
|
Out << __FUNCTION__ << "\n";
|
|
}
|
|
|
|
virtual void ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope) {
|
|
Out << __FUNCTION__ << "\n";
|
|
}
|
|
|
|
virtual void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {
|
|
Out << __FUNCTION__ << "\n";
|
|
}
|
|
|
|
virtual OwningExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc,
|
|
StmtArg Body,
|
|
Scope *CurScope) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual DeclPtrTy ActOnStartNamespaceDef(Scope *S, SourceLocation IdentLoc,
|
|
IdentifierInfo *Ident,
|
|
SourceLocation LBrace) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return DeclPtrTy();
|
|
}
|
|
|
|
virtual void ActOnFinishNamespaceDef(DeclPtrTy Dcl, SourceLocation RBrace) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return;
|
|
}
|
|
|
|
#if 0
|
|
// FIXME: AttrList should be deleted by this function, but the definition
|
|
// would have to be available.
|
|
virtual DeclPtrTy ActOnUsingDirective(Scope *CurScope,
|
|
SourceLocation UsingLoc,
|
|
SourceLocation NamespcLoc,
|
|
const CXXScopeSpec &SS,
|
|
SourceLocation IdentLoc,
|
|
IdentifierInfo *NamespcName,
|
|
AttributeList *AttrList) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return DeclPtrTy();
|
|
}
|
|
#endif
|
|
|
|
virtual void ActOnParamDefaultArgument(DeclPtrTy param,
|
|
SourceLocation EqualLoc,
|
|
ExprArg defarg) {
|
|
Out << __FUNCTION__ << "\n";
|
|
}
|
|
|
|
virtual void ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
|
|
SourceLocation EqualLoc,
|
|
SourceLocation ArgLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
}
|
|
|
|
virtual void ActOnParamDefaultArgumentError(DeclPtrTy param) {
|
|
Out << __FUNCTION__ << "\n";
|
|
}
|
|
|
|
virtual void AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
|
|
SourceLocation LParenLoc,
|
|
MultiExprArg Exprs,
|
|
SourceLocation *CommaLocs,
|
|
SourceLocation RParenLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return;
|
|
}
|
|
|
|
virtual void ActOnStartDelayedCXXMethodDeclaration(Scope *S,
|
|
DeclPtrTy Method) {
|
|
Out << __FUNCTION__ << "\n";
|
|
}
|
|
|
|
virtual void ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy Param) {
|
|
Out << __FUNCTION__ << "\n";
|
|
}
|
|
|
|
virtual void ActOnFinishDelayedCXXMethodDeclaration(Scope *S,
|
|
DeclPtrTy Method) {
|
|
Out << __FUNCTION__ << "\n";
|
|
}
|
|
|
|
virtual DeclPtrTy ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
|
|
ExprArg AssertExpr,
|
|
ExprArg AssertMessageExpr) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return DeclPtrTy();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
|
|
tok::TokenKind Kind,
|
|
SourceLocation LAngleBracketLoc,
|
|
TypeTy *Ty,
|
|
SourceLocation RAngleBracketLoc,
|
|
SourceLocation LParenLoc,
|
|
ExprArg Op,
|
|
SourceLocation RParenLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnCXXTypeid(SourceLocation OpLoc,
|
|
SourceLocation LParenLoc,
|
|
bool isType, void *TyOrExpr,
|
|
SourceLocation RParenLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnCXXThis(SourceLocation ThisLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc,
|
|
tok::TokenKind Kind) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnCXXThrow(SourceLocation OpLoc, ExprArg Op) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnCXXTypeConstructExpr(SourceRange TypeRange,
|
|
TypeTy *TypeRep,
|
|
SourceLocation LParenLoc,
|
|
MultiExprArg Exprs,
|
|
SourceLocation *CommaLocs,
|
|
SourceLocation RParenLoc) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnCXXConditionDeclarationExpr(Scope *S,
|
|
SourceLocation StartLoc,
|
|
Declarator &D,
|
|
SourceLocation EqualLoc,
|
|
ExprArg AssignExprVal) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnCXXNew(SourceLocation StartLoc,
|
|
bool UseGlobal,
|
|
SourceLocation PlacementLParen,
|
|
MultiExprArg PlacementArgs,
|
|
SourceLocation PlacementRParen,
|
|
bool ParenTypeId, Declarator &D,
|
|
SourceLocation ConstructorLParen,
|
|
MultiExprArg ConstructorArgs,
|
|
SourceLocation ConstructorRParen) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnCXXDelete(SourceLocation StartLoc,
|
|
bool UseGlobal, bool ArrayForm,
|
|
ExprArg Operand) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
|
|
virtual OwningExprResult ActOnUnaryTypeTrait(UnaryTypeTrait OTT,
|
|
SourceLocation KWLoc,
|
|
SourceLocation LParen,
|
|
TypeTy *Ty,
|
|
SourceLocation RParen) {
|
|
Out << __FUNCTION__ << "\n";
|
|
return ExprEmpty();
|
|
}
|
|
};
|
|
}
|
|
|
|
MinimalAction *clang::CreatePrintParserActionsAction(Preprocessor &PP,
|
|
llvm::raw_ostream* OS) {
|
|
return new ParserPrintActions(PP, *OS);
|
|
}
|