clang: clang::Parser Class Reference (original) (raw)

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

#include "[clang/Parse/Parser.h](Parse%5F2Parser%5F8h%5Fsource.html)"

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 171 of file Parser.h.

◆ DeclGroupPtrTy

◆ FullExprArg

◆ StmtVector

◆ TemplateParameterLists

◆ TemplateTy

◆ SkipUntilFlags

Control flags for SkipUntil functions.

Definition at line 473 of file Parser.h.

◆ ~Parser()

◆ ConsumeAnyToken()

◆ ConsumeToken()

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

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

Definition at line 262 of file Parser.h.

Referenced by ConsumeAnyToken(), fixSeparateAttrArgAndNumber(), Initialize(), ParseConstraintLogicalAndExpression(), ParseConstraintLogicalOrExpression(), parseContextScore(), parseDeclareSimdClauses(), parseMapperModifier(), parseMapType(), parseMapTypeModifiers(), ParseMSAsmIdentifier(), parseOpenMPAllocateClauseModifiers(), parseOpenMPDirectiveKind(), parseOpenMPReductionId(), ParseOpenMPReservedLocator(), parseOpenMPSimpleClause(), ParseOpenMPVarList(), ParseReductionId(), ParseUnqualifiedId(), SkipMalformedDecl(), SkipUntil(), TryAnnotateTypeOrScopeToken(), TryAnnotateTypeOrScopeTokenAfterScopeSpec(), and tryConsumeLambdaSpecifierToken().

◆ Diag() [1/3]

◆ Diag() [2/3]

Definition at line 85 of file Parser.cpp.

Referenced by addConstevalToLambdaDeclSpecifier(), addConstexprToLambdaDeclSpecifier(), addStaticToLambdaDeclSpecifier(), CheckArrayDesignatorSyntax(), CheckAvailabilitySpecList(), checkExtensionProperty(), checkOpenMPDirectiveName(), Diag(), DiagCompat(), DiagnoseCountAttributedTypeInUnnamedAnon(), diagnoseDynamicExceptionSpecification(), diagnoseExpectedAttributeSubjectSubRule(), DiagnoseLabelFollowedByDecl(), diagnoseRedundantPropertyNullability(), DiagnoseStaticSpecifierRestrictions(), diagnoseUnknownAttributeSubjectSubRule(), FixDigraph(), fixSeparateAttrArgAndNumber(), ParseConstraintLogicalAndExpression(), parseContextScore(), parseDeclareSimdClauses(), ParseFirstTopLevelDecl(), parseMapperModifier(), parseMapType(), parseMapTypeModifiers(), parseOpenMPAllocateClauseModifiers(), ParseOpenMPDeclareBeginVariantDirective(), parseOpenMPReductionId(), ParseOpenMPReservedLocator(), ParseOpenMPVarList(), parseStepSize(), ParseUnqualifiedId(), TryAnnotateTypeOrScopeToken(), TryAnnotateTypeOrScopeTokenAfterScopeSpec(), tryConsumeLambdaSpecifierToken(), and validateDeclsInsideHLSLBuffer().

◆ Diag() [3/3]

◆ DiagCompat() [1/3]

◆ DiagCompat() [2/3]

◆ DiagCompat() [3/3]

◆ EnterScope()

◆ ExitScope()

◆ getActions()

◆ getAttrFactory()

◆ getCurScope()

Definition at line 211 of file Parser.h.

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

◆ getCurToken()

Definition at line 210 of file Parser.h.

Referenced by isMapModifier(), isMapType(), parseContextScore(), parseDeclareSimdClauses(), parseMapType(), parseMapTypeModifiers(), parseOpenMPAllocateClauseModifiers(), parseOpenMPDirectiveKind(), parseOpenMPReductionId(), parseOpenMPSimpleClause(), ParseOpenMPVarList(), ParseReductionId(), parseStepSize(), and tryConsumeLambdaSpecifierToken().

◆ getEndOfPreviousToken()

◆ getLangOpts()

Definition at line 204 of file Parser.h.

Referenced by addConstexprToLambdaDeclSpecifier(), addStaticToLambdaDeclSpecifier(), checkOpenMPDirectiveName(), DiagCompat(), diagnoseDynamicExceptionSpecification(), DiagnoseLabelFollowedByDecl(), Initialize(), isMapModifier(), isMapType(), MightBeCXXScopeToken(), ParseFirstTopLevelDecl(), parseMapperModifier(), parseMapTypeModifiers(), ParseMSAsmIdentifier(), parseOpenMPAllocateClauseModifiers(), parseOpenMPSimpleClause(), ParseOpenMPVarList(), ParseTopLevelDecl(), ParseUnqualifiedId(), TryAnnotateCXXScopeToken(), TryAnnotateTypeOrScopeToken(), and TryAnnotateTypeOrScopeTokenAfterScopeSpec().

◆ GetLookAheadToken()

GetLookAheadToken - This peeks ahead N tokens and returns that token without consuming any tokens.

LookAhead(0) returns 'Tok', LookAhead(1) returns the token after Tok, etc.

Note that this differs from the Preprocessor's LookAhead method, because the Parser always has one token lexed that the preprocessor doesn't.

Definition at line 316 of file Parser.h.

Referenced by ParseTopLevelDecl().

◆ getNullabilityKeyword()

◆ getObjCDeclContext()

◆ getPreprocessor()

◆ getTargetInfo()

◆ getTypeAnnotation()

◆ incrementMSManglingNumber()

◆ Initialize()

Initialize - Warm up the parser.

Definition at line 483 of file Parser.cpp.

References clang::bycopy, clang::byref, ConsumeToken(), clang::Scope::DeclScope, EnterScope(), getCurScope(), getLangOpts(), clang::in, clang::inout, clang::nonnull, clang::null_unspecified, clang::nullable, clang::ObjC, clang::oneway, and clang::out.

Referenced by clang::ParseAST().

◆ MightBeCXXScopeToken()

◆ NextToken()

◆ ParseArrayBoundExpression()

◆ ParseAssignmentExpression()

◆ ParseCaseExpression()

◆ ParseConditionalExpression()

◆ ParseConstantExpression()

◆ ParseConstantExpressionInExprEvalContext()

◆ ParseConstraintExpression()

◆ ParseConstraintLogicalAndExpression()

Parse a constraint-logical-and-expression.

/// C++2a[temp.constr.decl]p1 /// constraint-logical-and-expression: /// primary-expression /// constraint-logical-and-expression '&&' primary-expression /// ///

Definition at line 197 of file ParseExpr.cpp.

References clang::AllowNonTypes, ConsumeToken(), clang::FixItHint::CreateInsertion(), Diag(), clang::ExprError(), clang::ActionResult< PtrTy, Compress >::get(), clang::Stmt::getBeginLoc(), clang::getBinOpPrecedence(), getCurScope(), clang::Stmt::getEndLoc(), clang::Expr::getExprLoc(), clang::Stmt::getSourceRange(), clang::prec::InclusiveOr, is(), clang::ActionResult< PtrTy, Compress >::isInvalid(), clang::ActionResult< PtrTy, Compress >::isUsable(), clang::prec::LogicalAnd, NextToken(), clang::Note, clang::PrimaryExprOnly, and clang::Sema::Unevaluated.

Referenced by ParseConstraintLogicalOrExpression().

◆ ParseConstraintLogicalOrExpression()

◆ ParseExpression()

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 /// /// compare-expression: [C++20 expr.spaceship] /// shift-expression /// compare-expression '<=>' shift-expression /// /// relational-expression: [C99 6.5.8] /// compare-expression /// relational-expression '<' compare-expression /// relational-expression '>' compare-expression /// relational-expression '<=' compare-expression /// relational-expression '>=' compare-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 47 of file ParseExpr.cpp.

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

◆ ParseFirstTopLevelDecl()

◆ parseMapperModifier()

Parses the mapper modifier in map, to, and from clauses.

Definition at line 4266 of file ParseOpenMP.cpp.

References BalancedDelimiterTracker, ConsumeToken(), clang::CPlusPlus, clang::Data, Diag(), getLangOpts(), SkipUntil(), StopBeforeMatch, and clang::T.

Referenced by parseMapTypeModifiers(), and ParseOpenMPVarList().

◆ parseMapTypeModifiers()

Parse map-type-modifiers in map clause.

map([ [map-type-modifier[,] [map-type-modifier[,] ...] [map-type] : ] list) where, map-type-modifier ::= always | close | mapper(mapper-identifier) | present where, map-type ::= alloc | delete | from | release | to | tofrom

Definition at line 4296 of file ParseOpenMP.cpp.

References ConsumeToken(), clang::Data, Diag(), getCurToken(), getLangOpts(), is(), isMapModifier(), isMapType(), isNot(), clang::OMPC_MAP_unknown, and parseMapperModifier().

Referenced by ParseOpenMPVarList().

◆ ParseMSAsmIdentifier()

◆ ParseOpenACCDirectiveDecl()

◆ ParseOpenACCDirectiveStmt()

◆ ParseOpenMPDeclareBeginVariantDirective()

◆ ParseOpenMPParensExpr()

◆ ParseOpenMPReservedLocator()

◆ ParseOpenMPVarList()

Parses clauses with list.

Definition at line 4657 of file ParseOpenMP.cpp.

References BalancedDelimiterTracker, ColonProtectionRAIIObject, ConsumeAnyToken(), clang::BalancedDelimiterTracker::consumeClose(), clang::BalancedDelimiterTracker::consumeOpen(), ConsumeToken(), clang::CPlusPlus, clang::Data, clang::Scope::DeclScope, Diag(), EnterScope(), ExitScope(), clang::ActionResult< PtrTy, Compress >::get(), getCurToken(), getLangOpts(), clang::getOpenMPSimpleClauseType(), is(), clang::isOpenMPDistributeDirective(), clang::isOpenMPTaskLoopDirective(), clang::ActionResult< PtrTy, Compress >::isUsable(), NextToken(), clang::OMPC_ADJUST_ARGS_unknown, clang::OMPC_DEPEND_unknown, clang::OMPC_DOACROSS_unknown, clang::OMPC_LASTPRIVATE_unknown, clang::OMPC_MAP_unknown, clang::OMPC_MOTION_MODIFIER_unknown, clang::OMPC_REDUCTION_unknown, clang::Scope::OpenMPDirectiveScope, ParseAssignmentExpression(), parseMapperModifier(), parseMapType(), parseMapTypeModifiers(), parseOpenMPAllocateClauseModifiers(), ParseOpenMPReservedLocator(), ParseReductionId(), parseStepSize(), SkipUntil(), StopBeforeMatch, and clang::T.

Referenced by parseDeclareSimdClauses().

◆ ParseStringLiteralExpression()

◆ ParseTopLevelDecl() [1/2]

◆ ParseTopLevelDecl() [2/2]

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

This returns true if the EOF was encountered.

/// top-level-declaration: /// declaration /// [C++20] module-import-declaration ///

Definition at line 614 of file Parser.cpp.

References clang::Sema::FirstDecl, clang::Token::getIdentifierInfo(), getKind(), getLangOpts(), GetLookAheadToken(), clang::Sema::ImportAllowed, clang::Sema::ImportFinished, clang::Module::isHeaderUnit(), isNot(), clang::SourceLocation::isValid(), NextToken(), clang::Sema::NotACXX20Module, clang::nullptr, clang::Sema::PrivateFragmentImportAllowed, clang::Sema::PrivateFragmentImportFinished, and clang::Result.

Referenced by clang::ParseAST().

◆ ParseTypeName()

◆ ParseUnevaluatedStringLiteralExpression()

◆ ParseUnqualifiedId()

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

Returns

true if parsing fails, false otherwise.

Definition at line 2578 of file ParseExprCXX.cpp.

References clang::CXXScopeSpec::clear(), ColonProtectionRAIIObject, ConsumeToken(), clang::CPlusPlus, clang::CPlusPlus17, clang::FixItHint::CreateInsertion(), clang::FixItHint::CreateRemoval(), Diag(), getCurScope(), getLangOpts(), clang::IK_LiteralOperatorId, clang::IK_OperatorFunctionId, is(), clang::CXXScopeSpec::isEmpty(), clang::TemplateIdAnnotation::isInvalid(), clang::CXXScopeSpec::isNotEmpty(), clang::CXXScopeSpec::isSet(), clang::SourceLocation::isValid(), clang::TemplateIdAnnotation::LAngleLoc, clang::TemplateIdAnnotation::Name, NextToken(), clang::TemplateIdAnnotation::RAngleLoc, clang::Result, clang::Template, clang::TemplateIdAnnotation::TemplateKWLoc, clang::TemplateIdAnnotation::TemplateNameLoc, clang::TNK_Dependent_template_name, clang::TNK_Function_template, clang::TNK_Non_template, and clang::TNK_Var_template.

Referenced by ParseMSAsmIdentifier(), and ParseReductionId().

◆ ReenterTemplateScopes()

◆ 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 2045 of file ParseDecl.cpp.

References ConsumeAnyToken(), ConsumeToken(), is(), NextToken(), SkipUntil(), and TryConsumeToken().

◆ SkipUntil() [1/4]

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 287 of file Parser.cpp.

References ConsumeAnyToken(), ConsumeToken(), HasFlagsSet(), SkipUntil(), StopAtCodeCompletion, StopAtSemi, and StopBeforeMatch.

◆ SkipUntil() [2/4]

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. Balances (), [], and {} delimiter tokens while skipping.

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

Definition at line 495 of file Parser.h.

References SkipUntil(), and clang::T.

Referenced by parseMapperModifier(), ParseOpenMPDeclareBeginVariantDirective(), parseOpenMPReductionId(), ParseOpenMPVarList(), SkipMalformedDecl(), SkipUntil(), SkipUntil(), SkipUntil(), and SkipUntil().

◆ SkipUntil() [3/4]

◆ SkipUntil() [4/4]

◆ TryAnnotateCXXScopeToken()

◆ TryAnnotateOptionalCXXScopeToken()

◆ TryAnnotateTypeOrScopeToken()

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 1887 of file Parser.cpp.

References ConsumeToken(), clang::CPlusPlus, Diag(), getCurScope(), getLangOpts(), clang::CXXScopeSpec::getRange(), clang::TemplateIdAnnotation::getTemplateArgs(), is(), clang::CXXScopeSpec::isEmpty(), clang::TemplateIdAnnotation::isInvalid(), isNot(), clang::TemplateIdAnnotation::LAngleLoc, clang::TemplateIdAnnotation::mightBeType(), clang::TemplateIdAnnotation::Name, NextToken(), clang::TemplateIdAnnotation::NumArgs, clang::TemplateIdAnnotation::RAngleLoc, clang::Result, clang::TemplateIdAnnotation::Template, clang::TemplateIdAnnotation::TemplateKWLoc, clang::TemplateIdAnnotation::TemplateNameLoc, TryAnnotateTypeOrScopeToken(), TryAnnotateTypeOrScopeTokenAfterScopeSpec(), and clang::TypeError().

Referenced by TryAnnotateTypeOrScopeToken().

◆ TryAnnotateTypeOrScopeTokenAfterScopeSpec()

Try to annotate a type or scope token, having already parsed an optional scope specifier.

IsNewScope should be true unless the scope specifier was extracted from an existing tok::annot_cxxscope annotation.

An Objective-C object type followed by '<' is a specialization of a parameterized class type or a protocol-qualified type.

Definition at line 2013 of file Parser.cpp.

References ConsumeToken(), clang::CPlusPlus, Diag(), clang::ActionResult< PtrTy, Compress >::get(), clang::CXXScopeSpec::getBeginLoc(), getCurScope(), getLangOpts(), is(), clang::CXXScopeSpec::isEmpty(), clang::CXXScopeSpec::isNotEmpty(), clang::ActionResult< PtrTy, Compress >::isUsable(), clang::TemplateIdAnnotation::Kind, NextToken(), clang::ObjC, clang::T, clang::Template, clang::TNK_Type_template, and clang::TNK_Undeclared_template.

Referenced by TryAnnotateTypeOrScopeToken().

◆ TryConsumeToken() [1/2]

◆ TryConsumeToken() [2/2]

◆ BalancedDelimiterTracker

◆ ColonProtectionRAIIObject

◆ InMessageExpressionRAIIObject

◆ ObjCDeclContextSwitch

◆ OffsetOfStateRAIIObject

◆ operator|

◆ ParenBraceBracketBalancer

◆ ParsingOpenACCDirectiveRAII

◆ ParsingOpenMPDirectiveRAII

◆ PoisonSEHIdentifiersRAIIObject

◆ MisleadingIndentationElseLoc

The location of the first statement inside an else that might have a missleading indentation.

If there is no MisleadingIndentationChecker on an else active, this location is invalid.

Definition at line 7184 of file Parser.h.

The documentation for this class was generated from the following files:

• include/clang/Parse/Parser.h
• lib/Parse/ParseCXXInlineMethods.cpp
• lib/Parse/ParseDecl.cpp
• lib/Parse/ParseDeclCXX.cpp
• lib/Parse/ParseExpr.cpp
• lib/Parse/ParseExprCXX.cpp
• lib/Parse/ParseHLSL.cpp
• lib/Parse/ParseInit.cpp
• lib/Parse/ParseObjc.cpp
• lib/Parse/ParseOpenACC.cpp
• lib/Parse/ParseOpenMP.cpp
• lib/Parse/ParsePragma.cpp
• lib/Parse/Parser.cpp
• lib/Parse/ParseStmt.cpp
• lib/Parse/ParseStmtAsm.cpp
• lib/Parse/ParseTemplate.cpp
• lib/Parse/ParseTentative.cpp