Parser - This implements a parser for the C family of languages. More...

#include <Parser.h>

Inheritance diagram for clang::Parser:

Collaboration diagram for clang::Parser:

Classes
class	DeclaratorScopeObj
	DeclaratorScopeObj - RAII object used in Parser::ParseDirectDeclarator to enter a new C++ declarator scope and exit it when the function is finished.
struct	ForRangeInit
	Information on a C++0x for-range-initializer found while parsing a declaration which turns out to be a for-range-declaration.
struct	IfExistsCondition
	Describes the condition of a Microsoft __if_exists or __if_not_exists block.
struct	LateParsedAttribute
	Contains the lexed tokens of an attribute with arguments that may reference member variables and so need to be parsed at the end of the class declaration after parsing all other member member declarations.
class	LateParsedAttrList
class	LateParsedClass
	Inner node of the LateParsedDeclaration tree that parses all its members recursively.
class	LateParsedDeclaration
	[class.mem]p1: "...
struct	LateParsedDefaultArgument
	LateParsedDefaultArgument - Keeps track of a parameter that may have a default argument that cannot be parsed yet because it occurs within a member function declaration inside the class (C++ [class.mem]p2).
struct	LateParsedMemberInitializer
	LateParsedMemberInitializer - An initializer for a non-static class data member whose parsing must to be delayed until the class is completely defined (C++11 [class.mem]p2).
struct	LateParsedMethodDeclaration
	LateParsedMethodDeclaration - A method declaration inside a class that contains at least one entity whose parsing needs to be delayed until the class itself is completely-defined, such as a default argument (C++ [class.mem]p2).
struct	LexedMethod
	Contains the lexed tokens of a member function definition which needs to be parsed at the end of the class declaration after parsing all other member declarations.
class	ObjCDeclContextSwitch
	ObjCDeclContextSwitch - An object used to switch context from an objective-c decl context to its enclosing decl context and back.
struct	ObjCImplParsingDataRAII
class	ObjCTypeParamListScope
	Class to handle popping type parameters when leaving the scope. More...
struct	ParsedAttributesWithRange
struct	ParsedTemplateInfo
	Contains information about any template-specific information that has been parsed prior to parsing declaration specifiers.
class	ParseScope
	ParseScope - Introduces a new scope for parsing. More...
class	ParseScopeFlags
	RAII object used to modify the scope flags for the current scope.
struct	ParsingClass
	Representation of a class that has been parsed, including any member function declarations or definitions that need to be parsed after the corresponding top-level class is complete.
class	ParsingClassDefinition
	RAII object used to manage the parsing of a class definition.
class	TemplateParameterDepthRAII
	RAII class that manages the template parameter depth.
class	TentativeParsingAction
	TentativeParsingAction - An object that is used as a kind of "tentative parsing transaction".
class	UnannotatedTentativeParsingAction
	A tentative parsing action that can also revert token annotations. More...
Public Types
enum	SkipUntilFlags { StopAtSemi = 1 << 0, StopBeforeMatch = 1 << 1, StopAtCodeCompletion = 1 << 2 }
	Control flags for SkipUntil functions. More...
enum	TypeCastState { NotTypeCast = 0, MaybeTypeCast, IsTypeCast }
	TypeCastState - State whether an expression is or may be a type cast. More...
typedef OpaquePtr< DeclGroupRef >	DeclGroupPtrTy
typedef OpaquePtr< TemplateName >	TemplateTy
typedef SmallVector < TemplateParameterList *, 4 >	TemplateParameterLists
typedef Sema::FullExprArg	FullExprArg
Public Member Functions
	Parser (Preprocessor &PP, Sema &Actions, bool SkipFunctionBodies)
	~Parser () override
const LangOptions &	getLangOpts () const
const TargetInfo &	getTargetInfo () const
Preprocessor &	getPreprocessor () const
Sema &	getActions () const
AttributeFactory &	getAttrFactory ()
const Token &	getCurToken () const
Scope *	getCurScope () const
void	incrementMSManglingNumber () const
Decl *	getObjCDeclContext () const
void	Initialize ()
	Initialize - Warm up the parser.
bool	ParseTopLevelDecl (DeclGroupPtrTy &Result)
	ParseTopLevelDecl - Parse one top-level declaration.
bool	ParseTopLevelDecl ()
SourceLocation	ConsumeToken ()
	ConsumeToken - Consume the current 'peek token' and lex the next one.
bool	TryConsumeToken (tok::TokenKind Expected)
bool	TryConsumeToken (tok::TokenKind Expected, SourceLocation &Loc)
IdentifierInfo *	getNullabilityKeyword (NullabilityKind nullability)
	Retrieve the underscored keyword (_Nonnull, _Nullable) that corresponds to the given nullability kind.
const Token &	NextToken ()
	NextToken - This peeks ahead one token and returns it without consuming it.
bool	TryAnnotateTypeOrScopeToken (bool EnteringContext=false, bool NeedType=false)
	TryAnnotateTypeOrScopeToken - If the current token position is on a typename (possibly qualified in C++) or a C++ scope specifier not followed by a typename, TryAnnotateTypeOrScopeToken will replace one or more tokens with a single annotation token representing the typename or C++ scope respectively.
bool	TryAnnotateTypeOrScopeTokenAfterScopeSpec (bool EnteringContext, bool NeedType, CXXScopeSpec &SS, bool IsNewScope)
	Try to annotate a type or scope token, having already parsed an optional scope specifier.
bool	TryAnnotateCXXScopeToken (bool EnteringContext=false)
	TryAnnotateScopeToken - Like TryAnnotateTypeOrScopeToken but only annotates C++ scope specifiers and template-ids.
void	EnterScope (unsigned ScopeFlags)
	EnterScope - Start a new scope.
void	ExitScope ()
	ExitScope - Pop a scope off the scope stack.
DiagnosticBuilder	Diag (SourceLocation Loc, unsigned DiagID)
DiagnosticBuilder	Diag (const Token &Tok, unsigned DiagID)
DiagnosticBuilder	Diag (unsigned DiagID)
bool	SkipUntil (tok::TokenKind T, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
	SkipUntil - Read tokens until we get to the specified token, then consume it (unless StopBeforeMatch is specified).
bool	SkipUntil (tok::TokenKind T1, tok::TokenKind T2, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
bool	SkipUntil (tok::TokenKind T1, tok::TokenKind T2, tok::TokenKind T3, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
bool	SkipUntil (ArrayRef< tok::TokenKind > Toks, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))
	SkipUntil - Read tokens until we get to the specified token, then consume it (unless no flag StopBeforeMatch).
void	SkipMalformedDecl ()
	SkipMalformedDecl - Read tokens until we get to some likely good stopping point for skipping past a simple-declaration.
ExprResult	ParseExpression (TypeCastState isTypeCast=NotTypeCast)
	Simple precedence-based parser for binary/ternary operators.
ExprResult	ParseConstantExpression (TypeCastState isTypeCast=NotTypeCast)
ExprResult	ParseConstraintExpression ()
	Parse a constraint-expression.
ExprResult	ParseAssignmentExpression (TypeCastState isTypeCast=NotTypeCast)
	Parse an expr that doesn't include (top-level) commas.
ExprResult	ParseMSAsmIdentifier (llvm::SmallVectorImpl< Token > &LineToks, unsigned &NumLineToksConsumed, void *Info, bool IsUnevaluated)
	Parse an identifier in an MS-style inline assembly block.
TypeResult	ParseTypeName (SourceRange Range=nullptr, Declarator::TheContext Context=Declarator::TypeNameContext, AccessSpecifier AS=AS_none, Decl OwnedType=nullptr, ParsedAttributes Attrs=nullptr)
	ParseTypeName type-name: [C99 6.7.6] specifier-qualifier-list abstract-declarator[opt].
bool	ParseUnqualifiedId (CXXScopeSpec &SS, bool EnteringContext, bool AllowDestructorName, bool AllowConstructorName, ParsedType ObjectType, SourceLocation &TemplateKWLoc, UnqualifiedId &Result)
	Parse a C++ unqualified-id (or a C identifier), which describes the name of an entity.
Static Public Member Functions
static ParsedType	getTypeAnnotation (Token &Tok)
	getTypeAnnotation - Read a parsed type out of an annotation token.
Friends
class	ColonProtectionRAIIObject
class	InMessageExpressionRAIIObject
class	PoisonSEHIdentifiersRAIIObject
class	ObjCDeclContextSwitch
class	ParenBraceBracketBalancer
class	BalancedDelimiterTracker
LLVM_CONSTEXPR SkipUntilFlags	operator\| (SkipUntilFlags L, SkipUntilFlags R)

Detailed Description

Parser - This implements a parser for the C family of languages.

After parsing units of the grammar, productions are invoked to handle whatever has been read.

Definition at line 56 of file Parse/Parser.h.

Member Typedef Documentation

typedef OpaquePtr<DeclGroupRef> clang::Parser::DeclGroupPtrTy

Definition at line 260 of file Parse/Parser.h.

typedef Sema::FullExprArg clang::Parser::FullExprArg

Definition at line 265 of file Parse/Parser.h.

typedef SmallVector<TemplateParameterList *, 4> clang::Parser::TemplateParameterLists

Definition at line 263 of file Parse/Parser.h.

typedef OpaquePtr<TemplateName> clang::Parser::TemplateTy

Definition at line 261 of file Parse/Parser.h.

Member Enumeration Documentation

enum clang::Parser::SkipUntilFlags

Control flags for SkipUntil functions.

Enumerator:

StopAtSemi	Stop skipping at semicolon.
StopBeforeMatch	Stop skipping at specified token, but don't skip the token itself.
StopAtCodeCompletion	Stop at code completion.

Definition at line 841 of file Parse/Parser.h.

enum clang::Parser::TypeCastState

TypeCastState - State whether an expression is or may be a type cast.

Enumerator:

NotTypeCast
MaybeTypeCast
IsTypeCast

Definition at line 1380 of file Parse/Parser.h.

Constructor & Destructor Documentation

Parser::Parser	(	Preprocessor &	PP,
		Sema &	Actions,
		bool	SkipFunctionBodies
	)

Definition at line 71 of file Parse/Parser.cpp.

References clang::Preprocessor::addCommentHandler(), clang::comments::tok::eof, clang::Preprocessor::isCodeCompletionEnabled(), clang::Preprocessor::setCodeCompletionHandler(), clang::Token::setKind(), and clang::Token::startToken().

Parser::~Parser ( ) [override]

Definition at line 423 of file Parse/Parser.cpp.

References clang::Preprocessor::clearCodeCompletionHandler(), getCurScope(), getLangOpts(), clang::Preprocessor::isIncrementalProcessingEnabled(), and clang::Preprocessor::removeCommentHandler().

Member Function Documentation

SourceLocation clang::Parser::ConsumeToken ( ) [inline]

ConsumeToken - Consume the current 'peek token' and lex the next one.

This does not work with special tokens: string literals, code completion and balanced tokens must be handled using the specific consume methods. Returns the location of the consumed token.

Definition at line 285 of file Parse/Parser.h.

References clang::Token::getLocation(), and clang::Preprocessor::Lex().

Referenced by clang::BalancedDelimiterTracker::consumeClose(), Initialize(), ParseMSAsmIdentifier(), ParseOpenMPDirectiveKind(), ParseReductionId(), ParseTopLevelDecl(), ParseUnqualifiedId(), SkipMalformedDecl(), SkipUntil(), TryAnnotateTypeOrScopeToken(), and TryAnnotateTypeOrScopeTokenAfterScopeSpec().

DiagnosticBuilder Parser::Diag	(	SourceLocation	Loc,
		unsigned	DiagID
	)

Definition at line 94 of file Parse/Parser.cpp.

References clang::DiagnosticsEngine::Report().

Referenced by CheckArrayDesignatorSyntax(), clang::BalancedDelimiterTracker::consumeClose(), Diag(), diagnoseDynamicExceptionSpecification(), FixDigraph(), clang::ParseAST(), ParseUnqualifiedId(), and TryAnnotateTypeOrScopeToken().

DiagnosticBuilder Parser::Diag	(	const Token &	Tok,
		unsigned	DiagID
	)

Definition at line 98 of file Parse/Parser.cpp.

References Diag(), and clang::Token::getLocation().

DiagnosticBuilder clang::Parser::Diag ( unsigned DiagID ) [inline]

Definition at line 829 of file Parse/Parser.h.

References Diag().

void Parser::EnterScope ( unsigned ScopeFlags )

EnterScope - Start a new scope.

Definition at line 373 of file Parse/Parser.cpp.

References getCurScope(), and clang::Scope::Init().

Referenced by Initialize(), and clang::Parser::ParseScope::ParseScope().

void Parser::ExitScope ( )

ExitScope - Pop a scope off the scope stack.

Definition at line 384 of file Parse/Parser.cpp.

References clang::Sema::ActOnPopScope(), getCurScope(), clang::Token::getLocation(), and clang::Scope::getParent().

Referenced by clang::Parser::ParseScope::Exit().

Sema& clang::Parser::getActions ( ) const [inline]

Definition at line 247 of file Parse/Parser.h.

Referenced by clang::ParseAST().

AttributeFactory& clang::Parser::getAttrFactory ( ) [inline]

Definition at line 248 of file Parse/Parser.h.

Scope* clang::Parser::getCurScope ( ) const [inline]

Definition at line 251 of file Parse/Parser.h.

References clang::Sema::getCurScope().

Referenced by EnterScope(), ExitScope(), Initialize(), ParseAssignmentExpression(), ParseTypeName(), ParseUnqualifiedId(), TryAnnotateTypeOrScopeToken(), TryAnnotateTypeOrScopeTokenAfterScopeSpec(), and ~Parser().

const Token& clang::Parser::getCurToken ( ) const [inline]

Definition at line 250 of file Parse/Parser.h.

Referenced by ParseOpenMPDirectiveKind(), and ParseReductionId().

const LangOptions& clang::Parser::getLangOpts ( ) const [inline]

Definition at line 244 of file Parse/Parser.h.

References clang::Preprocessor::getLangOpts().

Referenced by clang::BalancedDelimiterTracker::consumeOpen(), diagnoseDynamicExceptionSpecification(), Initialize(), ParseMSAsmIdentifier(), ParseTopLevelDecl(), ParseUnqualifiedId(), TryAnnotateCXXScopeToken(), TryAnnotateTypeOrScopeToken(), TryAnnotateTypeOrScopeTokenAfterScopeSpec(), and ~Parser().

IdentifierInfo* clang::Parser::getNullabilityKeyword ( NullabilityKind nullability ) [inline]

Retrieve the underscored keyword (_Nonnull, _Nullable) that corresponds to the given nullability kind.

Definition at line 312 of file Parse/Parser.h.

References clang::Sema::getNullabilityKeyword().

Referenced by addContextSensitiveTypeNullability().

Decl* clang::Parser::getObjCDeclContext ( ) const [inline]

Definition at line 256 of file Parse/Parser.h.

References clang::Sema::getObjCDeclContext().

Preprocessor& clang::Parser::getPreprocessor ( ) const [inline]

Definition at line 246 of file Parse/Parser.h.

Referenced by ParseOpenMPDirectiveKind().

const TargetInfo& clang::Parser::getTargetInfo ( ) const [inline]

Definition at line 245 of file Parse/Parser.h.

References clang::Preprocessor::getTargetInfo().

static ParsedType clang::Parser::getTypeAnnotation ( Token & Tok ) [inline, static]

getTypeAnnotation - Read a parsed type out of an annotation token.

Definition at line 552 of file Parse/Parser.h.

References clang::Token::getAnnotationValue(), and clang::OpaquePtr< QualType >::getFromOpaquePtr().

void clang::Parser::incrementMSManglingNumber ( ) const [inline]

Definition at line 252 of file Parse/Parser.h.

References clang::Sema::incrementMSManglingNumber().

Referenced by clang::Parser::ParseScope::ParseScope().

void Parser::Initialize ( )

Initialize - Warm up the parser.

Definition at line 452 of file Parse/Parser.cpp.

References clang::Sema::ActOnTranslationUnitScope(), ConsumeToken(), clang::Scope::DeclScope, EnterScope(), clang::IdentifierTable::get(), getCurScope(), clang::Preprocessor::getIdentifierInfo(), clang::Preprocessor::getIdentifierTable(), getLangOpts(), clang::Sema::Initialize(), and clang::Preprocessor::SetPoisonReason().

Referenced by clang::ParseAST().

const Token& clang::Parser::NextToken ( ) [inline]

NextToken - This peeks ahead one token and returns it without consuming it.

Definition at line 547 of file Parse/Parser.h.

References clang::Preprocessor::LookAhead().

Referenced by clang::BalancedDelimiterTracker::consumeClose(), ParseUnqualifiedId(), SkipMalformedDecl(), TryAnnotateCXXScopeToken(), TryAnnotateTypeOrScopeToken(), and TryAnnotateTypeOrScopeTokenAfterScopeSpec().

ExprResult Parser::ParseAssignmentExpression ( TypeCastState isTypeCast = NotTypeCast )

Parse an expr that doesn't include (top-level) commas.

Definition at line 157 of file ParseExpr.cpp.

References clang::prec::Assignment, clang::Sema::CodeCompleteOrdinaryName(), clang::ExprError(), getCurScope(), clang::Token::is(), and clang::Sema::PCC_Expression.

Referenced by ParseExpression().

ExprResult Parser::ParseConstantExpression ( TypeCastState isTypeCast = NotTypeCast )

Definition at line 197 of file ParseExpr.cpp.

References clang::Sema::ActOnConstantExpression(), clang::prec::Conditional, and clang::Sema::ConstantEvaluated.

ExprResult Parser::ParseConstraintExpression ( )

Parse a constraint-expression.

///       constraint-expression: [Concepts TS temp.constr.decl p1]
///         logical-or-expression
///

Definition at line 216 of file ParseExpr.cpp.

References clang::prec::LogicalOr.

ExprResult Parser::ParseExpression ( TypeCastState isTypeCast = NotTypeCast )

Simple precedence-based parser for binary/ternary operators.

Note: we diverge from the C99 grammar when parsing the assignment-expression production. C99 specifies that the LHS of an assignment operator should be parsed as a unary-expression, but consistency dictates that it be a conditional-expession. In practice, the important thing here is that the LHS of an assignment has to be an l-value, which productions between unary-expression and conditional-expression don't produce. Because we want consistency, we parse the LHS as a conditional-expression, then check for l-value-ness in semantic analysis stages.

///       pm-expression: [C++ 5.5]
///         cast-expression
///         pm-expression '.*' cast-expression
///         pm-expression '->*' cast-expression
///
///       multiplicative-expression: [C99 6.5.5]
///     Note: in C++, apply pm-expression instead of cast-expression
///         cast-expression
///         multiplicative-expression '*' cast-expression
///         multiplicative-expression '/' cast-expression
///         multiplicative-expression '%' cast-expression
///
///       additive-expression: [C99 6.5.6]
///         multiplicative-expression
///         additive-expression '+' multiplicative-expression
///         additive-expression '-' multiplicative-expression
///
///       shift-expression: [C99 6.5.7]
///         additive-expression
///         shift-expression '<<' additive-expression
///         shift-expression '>>' additive-expression
///
///       relational-expression: [C99 6.5.8]
///         shift-expression
///         relational-expression '<' shift-expression
///         relational-expression '>' shift-expression
///         relational-expression '<=' shift-expression
///         relational-expression '>=' shift-expression
///
///       equality-expression: [C99 6.5.9]
///         relational-expression
///         equality-expression '==' relational-expression
///         equality-expression '!=' relational-expression
///
///       AND-expression: [C99 6.5.10]
///         equality-expression
///         AND-expression '&' equality-expression
///
///       exclusive-OR-expression: [C99 6.5.11]
///         AND-expression
///         exclusive-OR-expression '^' AND-expression
///
///       inclusive-OR-expression: [C99 6.5.12]
///         exclusive-OR-expression
///         inclusive-OR-expression '|' exclusive-OR-expression
///
///       logical-AND-expression: [C99 6.5.13]
///         inclusive-OR-expression
///         logical-AND-expression '&&' inclusive-OR-expression
///
///       logical-OR-expression: [C99 6.5.14]
///         logical-AND-expression
///         logical-OR-expression '||' logical-AND-expression
///
///       conditional-expression: [C99 6.5.15]
///         logical-OR-expression
///         logical-OR-expression '?' expression ':' conditional-expression
/// [GNU]   logical-OR-expression '?' ':' conditional-expression
/// [C++] the third operand is an assignment-expression
///
///       assignment-expression: [C99 6.5.16]
///         conditional-expression
///         unary-expression assignment-operator assignment-expression
/// [C++]   throw-expression [C++ 15]
///
///       assignment-operator: one of
///         = *= /= %= += -= <<= >>= &= ^= |=
///
///       expression: [C99 6.5.17]
///         assignment-expression ...[opt]
///         expression ',' assignment-expression ...[opt]
///

Definition at line 120 of file ParseExpr.cpp.

References clang::prec::Comma, and ParseAssignmentExpression().

ExprResult Parser::ParseMSAsmIdentifier	(	llvm::SmallVectorImpl< Token > &	LineToks,
		unsigned &	NumLineToksConsumed,
		void *	CastInfo,
		bool	IsUnevaluatedContext
	)

Parse an identifier in an MS-style inline assembly block.

Parameters:

CastInfo - a void* so that we don't have to teach Parser.h about the actual type.

Definition at line 183 of file ParseStmtAsm.cpp.

References ConsumeToken(), clang::frontend::CPlusPlus, clang::Preprocessor::EnterTokenStream(), clang::ActionResult< PtrTy, CompressInvalid >::get(), clang::Token::getIdentifierInfo(), getLangOpts(), clang::Token::getLocation(), clang::IdentifierInfo::getName(), clang::driver::tools::mips::Invalid, clang::Token::is(), clang::Token::isNot(), clang::ActionResult< PtrTy, CompressInvalid >::isUsable(), clang::Preprocessor::LookAhead(), clang::Sema::LookupInlineAsmIdentifier(), clang::Sema::LookupInlineAsmVarDeclField(), ParseUnqualifiedId(), clang::Result, clang::Token::setKind(), and clang::Token::startToken().

bool Parser::ParseTopLevelDecl ( DeclGroupPtrTy & Result )

ParseTopLevelDecl - Parse one top-level declaration.

ParseTopLevelDecl - Parse one top-level declaration, return whatever the action tells us to.

Returns true if the EOF was encountered.

This returns true if the EOF was encountered.

Definition at line 540 of file Parse/Parser.cpp.

References clang::Sema::ActOnEndOfTranslationUnit(), clang::Sema::ActOnModuleBegin(), clang::Sema::ActOnModuleEnd(), clang::Sema::ActOnModuleInclude(), ConsumeToken(), clang::comments::tok::eof, clang::Token::getAnnotationValue(), clang::Token::getKind(), getLangOpts(), clang::Token::getLocation(), clang::Token::is(), clang::Preprocessor::isIncrementalProcessingEnabled(), and clang::Sema::SetLateTemplateParser().

Referenced by clang::ParseAST().

bool clang::Parser::ParseTopLevelDecl ( ) [inline]

Definition at line 276 of file Parse/Parser.h.

References clang::Result.

TypeResult Parser::ParseTypeName	(	SourceRange *	Range = `nullptr`,
		Declarator::TheContext	Context = `Declarator::TypeNameContext`,
		AccessSpecifier	AS = `AS_none`,
		Decl **	OwnedType = `nullptr`,
		ParsedAttributes *	Attrs = `nullptr`
	)

ParseTypeName type-name: [C99 6.7.6] specifier-qualifier-list abstract-declarator[opt].

Called type-id in C++.

Definition at line 42 of file ParseDecl.cpp.

References clang::Sema::ActOnTypeName(), clang::DeclSpec::addAttributes(), getCurScope(), clang::ParsedAttributes::getList(), clang::DeclSpec::getRepAsDecl(), clang::Declarator::getSourceRange(), clang::Declarator::isInvalidType(), and clang::DeclSpec::isTypeSpecOwned().

bool Parser::ParseUnqualifiedId	(	CXXScopeSpec &	SS,
		bool	EnteringContext,
		bool	AllowDestructorName,
		bool	AllowConstructorName,
		ParsedType	ObjectType,
		SourceLocation &	TemplateKWLoc,
		UnqualifiedId &	Result
	)

Parse a C++ unqualified-id (or a C identifier), which describes the name of an entity.

       unqualified-id: [C++ expr.prim.general]
         identifier
         operator-function-id
         conversion-function-id
 [C++0x] literal-operator-id [TODO]
         ~ class-name
         template-id

Parameters:

SS	The nested-name-specifier that preceded this unqualified-id. If non-empty, then we are parsing the unqualified-id of a qualified-id.
EnteringContext	whether we are entering the scope of the nested-name-specifier.
AllowDestructorName	whether we allow parsing of a destructor name.
AllowConstructorName	whether we allow parsing a constructor name.
ObjectType	if this unqualified-id occurs within a member access expression, the type of the base object whose member is being accessed.
Result	on a successful parse, contains the parsed unqualified-id.

Returns:: true if parsing fails, false otherwise.

Definition at line 2379 of file ParseExprCXX.cpp.

References clang::CXXScopeSpec::clear(), ConsumeToken(), clang::frontend::CPlusPlus, clang::FixItHint::CreateInsertion(), clang::FixItHint::CreateRemoval(), Diag(), getCurScope(), clang::Sema::getDestructorName(), clang::Sema::getDestructorType(), clang::Token::getIdentifierInfo(), clang::UnqualifiedId::getKind(), getLangOpts(), clang::Token::getLocation(), clang::Sema::getTypeName(), clang::UnqualifiedId::IK_LiteralOperatorId, clang::UnqualifiedId::IK_OperatorFunctionId, clang::Token::is(), clang::Sema::isCurrentClassName(), clang::CXXScopeSpec::isEmpty(), clang::Token::isNot(), clang::CXXScopeSpec::isNotEmpty(), clang::CXXScopeSpec::isSet(), clang::TemplateIdAnnotation::LAngleLoc, clang::TemplateIdAnnotation::Name, NextToken(), clang::TemplateIdAnnotation::RAngleLoc, clang::UnqualifiedId::setConstructorName(), clang::UnqualifiedId::setConstructorTemplateId(), clang::UnqualifiedId::setDestructorName(), clang::UnqualifiedId::setIdentifier(), clang::UnqualifiedId::setTemplateId(), clang::Sema::ShouldEnterDeclaratorScope(), clang::TemplateIdAnnotation::TemplateKWLoc, and clang::TemplateIdAnnotation::TemplateNameLoc.

Referenced by ParseMSAsmIdentifier(), and ParseReductionId().

void Parser::SkipMalformedDecl ( )

SkipMalformedDecl - Read tokens until we get to some likely good stopping point for skipping past a simple-declaration.

Skip until we reach something which seems like a sensible place to pick up parsing after a malformed declaration.

This will sometimes stop sooner than SkipUntil(tok::r_brace) would, but will never stop later.

Definition at line 1613 of file ParseDecl.cpp.

References ConsumeToken(), clang::comments::tok::eof, clang::Token::getKind(), clang::Token::is(), clang::Token::isAtStartOfLine(), clang::Token::isObjCAtKeyword(), clang::Token::isOneOf(), NextToken(), SkipUntil(), and TryConsumeToken().

bool clang::Parser::SkipUntil	(	tok::TokenKind	T,
		SkipUntilFlags	Flags = `static_cast<SkipUntilFlags>(0)`
	)		`[inline]`

SkipUntil - Read tokens until we get to the specified token, then consume it (unless StopBeforeMatch is specified).

Because we cannot guarantee that the token will ever occur, this skips to the next token, or to some likely good stopping point. If Flags has StopAtSemi flag, skipping will stop at a ';' character.

If SkipUntil finds the specified token, it returns true, otherwise it returns false.

Definition at line 862 of file Parse/Parser.h.

Referenced by SkipMalformedDecl(), and SkipUntil().

bool clang::Parser::SkipUntil	(	tok::TokenKind	T1,
		tok::TokenKind	T2,
		SkipUntilFlags	Flags = `static_cast<SkipUntilFlags>(0)`
	)		`[inline]`

Definition at line 866 of file Parse/Parser.h.

References SkipUntil().

bool clang::Parser::SkipUntil	(	tok::TokenKind	T1,
		tok::TokenKind	T2,
		tok::TokenKind	T3,
		SkipUntilFlags	Flags = `static_cast<SkipUntilFlags>(0)`
	)		`[inline]`

Definition at line 871 of file Parse/Parser.h.

References SkipUntil().

bool Parser::SkipUntil	(	ArrayRef< tok::TokenKind >	Toks,
		SkipUntilFlags	Flags = `static_cast<SkipUntilFlags>(0)`
	)

SkipUntil - Read tokens until we get to the specified token, then consume it (unless no flag StopBeforeMatch).

Because we cannot guarantee that the token will ever occur, this skips to the next token, or to some likely good stopping point. If StopAtSemi is true, skipping will stop at a ';' character.

If SkipUntil finds the specified token, it returns true, otherwise it returns false.

Definition at line 252 of file Parse/Parser.cpp.

References ConsumeToken(), clang::comments::tok::eof, clang::Token::getKind(), HasFlagsSet(), clang::Token::is(), clang::Token::isNot(), SkipUntil(), StopAtCodeCompletion, StopAtSemi, and StopBeforeMatch.

bool Parser::TryAnnotateCXXScopeToken ( bool EnteringContext = false )

TryAnnotateScopeToken - Like TryAnnotateTypeOrScopeToken but only annotates C++ scope specifiers and template-ids.

This returns true if there was an error that could not be recovered from.

Note that this routine emits an error if you call it with ::new or ::delete as the current tokens, so only call it in contexts where these are invalid.

Definition at line 1782 of file Parse/Parser.cpp.

References clang::frontend::CPlusPlus, getLangOpts(), clang::Token::is(), clang::CXXScopeSpec::isEmpty(), and NextToken().

bool Parser::TryAnnotateTypeOrScopeToken	(	bool	EnteringContext = `false`,
		bool	NeedType = `false`
	)

TryAnnotateTypeOrScopeToken - If the current token position is on a typename (possibly qualified in C++) or a C++ scope specifier not followed by a typename, TryAnnotateTypeOrScopeToken will replace one or more tokens with a single annotation token representing the typename or C++ scope respectively.

This simplifies handling of C++ scope specifiers and allows efficient backtracking without the need to re-parse and resolve nested-names and typenames. It will mainly be called when we expect to treat identifiers as typenames (if they are typenames). For example, in C we do not expect identifiers inside expressions to be treated as typenames so it will not be called for expressions in C. The benefit for C/ObjC is that a typename will be annotated and Actions.getTypeName will not be needed to be called again (e.g. getTypeName will not be called twice, once to check whether we have a declaration specifier, and another one to get the actual type inside ParseDeclarationSpecifiers).

This returns true if an error occurred.

Note that this routine emits an error if you call it with ::new or ::delete as the current tokens, so only call it in contexts where these are invalid.

Definition at line 1553 of file Parse/Parser.cpp.