CbC/CbC_llvm: clang/lib/Parse/Parser.cpp comparison

comparison clang/lib/Parse/Parser.cpp @ 207:2e18cbf3894f

LLVM12

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 08 Jun 2021 06:07:14 +0900
parents	0572611fdcc8
children	dd44ba33042e 5f17cb93ff66

comparison

equal deleted inserted replaced

-:0572611fdcc8
+:2e18cbf3894f
 return Ident__except;
 }
 Parser::Parser(Preprocessor &pp, Sema &actions, bool skipFunctionBodies)
-: PP(pp), Actions(actions), Diags(PP.getDiagnostics()),
+: PP(pp), PreferredType(pp.isCodeCompletionEnabled()), Actions(actions),
-GreaterThanIsOperator(true), ColonIsSacred(false),
+Diags(PP.getDiagnostics()), GreaterThanIsOperator(true),
-InMessageExpression(false), TemplateParameterDepth(0),
+ColonIsSacred(false), InMessageExpression(false),
-ParsingInObjCContainer(false) {
+TemplateParameterDepth(0), ParsingInObjCContainer(false) {
 SkipFunctionBodies = pp.isCodeCompletionEnabled() || skipFunctionBodies;
 Tok.startToken();
 Tok.setKind(tok::eof);
 Actions.CurScope = nullptr;
 NumCachedScopes = 0;
 return false;
 }
 }
 Diag(Tok, diag::err_expected) << tok::identifier;
 return true;
+}
+void Parser::checkCompoundToken(SourceLocation FirstTokLoc,
+tok::TokenKind FirstTokKind, CompoundToken Op) {
+if (FirstTokLoc.isInvalid())
+return;
+SourceLocation SecondTokLoc = Tok.getLocation();
+// If either token is in a macro, we expect both tokens to come from the same
+// macro expansion.
+if ((FirstTokLoc.isMacroID() || SecondTokLoc.isMacroID()) &&
+PP.getSourceManager().getFileID(FirstTokLoc) !=
+PP.getSourceManager().getFileID(SecondTokLoc)) {
+Diag(FirstTokLoc, diag::warn_compound_token_split_by_macro)
+<< (FirstTokKind == Tok.getKind()) << FirstTokKind << Tok.getKind()
+<< static_cast<int>(Op) << SourceRange(FirstTokLoc);
+Diag(SecondTokLoc, diag::note_compound_token_split_second_token_here)
+<< (FirstTokKind == Tok.getKind()) << Tok.getKind()
+<< SourceRange(SecondTokLoc);
+return;
+}
+// We expect the tokens to abut.
+if (Tok.hasLeadingSpace() || Tok.isAtStartOfLine()) {
+SourceLocation SpaceLoc = PP.getLocForEndOfToken(FirstTokLoc);
+if (SpaceLoc.isInvalid())
+SpaceLoc = FirstTokLoc;
+Diag(SpaceLoc, diag::warn_compound_token_split_by_whitespace)
+<< (FirstTokKind == Tok.getKind()) << FirstTokKind << Tok.getKind()
+<< static_cast<int>(Op) << SourceRange(FirstTokLoc, SecondTokLoc);
+return;
+}
 }
 //===----------------------------------------------------------------------===//
 // Error recovery.
 //===----------------------------------------------------------------------===//
 }
 Ident_instancetype = nullptr;
 Ident_final = nullptr;
 Ident_sealed = nullptr;
+Ident_abstract = nullptr;
 Ident_override = nullptr;
 Ident_GNU_final = nullptr;
 Ident_import = nullptr;
 Ident_module = nullptr;
 Ident_super = &PP.getIdentifierTable().get("super");
 Ident_vector = nullptr;
 Ident_bool = nullptr;
+Ident_Bool = nullptr;
 Ident_pixel = nullptr;
 if (getLangOpts().AltiVec || getLangOpts().ZVector) {
 Ident_vector = &PP.getIdentifierTable().get("vector");
 Ident_bool = &PP.getIdentifierTable().get("bool");
+Ident_Bool = &PP.getIdentifierTable().get("_Bool");
 }
 if (getLangOpts().AltiVec)
 Ident_pixel = &PP.getIdentifierTable().get("pixel");
 Ident_introduced = nullptr;
 // C11 6.9p1 says translation units must have at least one top-level
 // declaration. C++ doesn't have this restriction. We also don't want to
 // complain if we have a precompiled header, although technically if the PCH
 // is empty we should still emit the (pedantic) diagnostic.
+// If the main file is a header, we're only pretending it's a TU; don't warn.
 bool NoTopLevelDecls = ParseTopLevelDecl(Result, true);
 if (NoTopLevelDecls && !Actions.getASTContext().getExternalSource() &&
-!getLangOpts().CPlusPlus)
+!getLangOpts().CPlusPlus && !getLangOpts().IsHeaderFile)
 Diag(diag::ext_empty_translation_unit);
 return NoTopLevelDecls;
 }
 PP.Diag(OverrideLoc, diag::note_max_tokens_total_override);
 }
 }
 // Late template parsing can begin.
-if (getLangOpts().DelayedTemplateParsing)
+Actions.SetLateTemplateParser(LateTemplateParserCallback, nullptr, this);
-Actions.SetLateTemplateParser(LateTemplateParserCallback, nullptr,
-this);
 if (!PP.isIncrementalProcessingEnabled())
 Actions.ActOnEndOfTranslationUnit();
 //else don't tell Sema that we ended parsing: more input might come.
 return true;
 HandlePragmaFPContract();
 return nullptr;
 case tok::annot_pragma_fenv_access:
 HandlePragmaFEnvAccess();
 return nullptr;
+case tok::annot_pragma_fenv_round:
+HandlePragmaFEnvRound();
+return nullptr;
 case tok::annot_pragma_float_control:
 HandlePragmaFloatControl();
 return nullptr;
 case tok::annot_pragma_fp:
 HandlePragmaFP();
 return nullptr;
 }
 SingleDecl = ParseObjCMethodDefinition();
 break;
 case tok::code_completion:
+cutOffParsing();
 if (CurParsedObjCImpl) {
 // Code-complete Objective-C methods even without leading '-'/'+' prefix.
 Actions.CodeCompleteObjCMethodDecl(getCurScope(),
 /*IsInstanceMethod=*/None,
 /*ReturnType=*/nullptr);
 }
 Actions.CodeCompleteOrdinaryName(
 getCurScope(),
 CurParsedObjCImpl ? Sema::PCC_ObjCImplementation : Sema::PCC_Namespace);
-cutOffParsing();
 return nullptr;
 case tok::kw_import:
 SingleDecl = ParseModuleImport(SourceLocation());
 break;
 case tok::kw_export:
 case tok::kw_static_assert:
 case tok::kw__Static_assert:
 // A function definition cannot start with any of these keywords.
 {
 SourceLocation DeclEnd;
-return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs);
+return ParseDeclaration(DeclaratorContext::File, DeclEnd, attrs);
 }
 case tok::kw_static:
 // Parse (then ignore) 'static' prior to a template instantiation. This is
 // a GCC extension that we intentionally do not support.
 if (getLangOpts().CPlusPlus && NextToken().is(tok::kw_template)) {
 Diag(ConsumeToken(), diag::warn_static_inline_explicit_inst_ignored)
 << 0;
 SourceLocation DeclEnd;
-return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs);
+return ParseDeclaration(DeclaratorContext::File, DeclEnd, attrs);
 }
 goto dont_know;
 case tok::kw_inline:
 if (getLangOpts().CPlusPlus) {
 tok::TokenKind NextKind = NextToken().getKind();
 // Inline namespaces. Allowed as an extension even in C++03.
 if (NextKind == tok::kw_namespace) {
 SourceLocation DeclEnd;
-return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs);
+return ParseDeclaration(DeclaratorContext::File, DeclEnd, attrs);
 }
 // Parse (then ignore) 'inline' prior to a template instantiation. This is
 // a GCC extension that we intentionally do not support.
 if (NextKind == tok::kw_template) {
 Diag(ConsumeToken(), diag::warn_static_inline_explicit_inst_ignored)
 << 1;
 SourceLocation DeclEnd;
-return ParseDeclaration(DeclaratorContext::FileContext, DeclEnd, attrs);
+return ParseDeclaration(DeclaratorContext::File, DeclEnd, attrs);
 }
 }
 goto dont_know;
 case tok::kw_extern:
 SourceLocation TemplateLoc = ConsumeToken();
 Diag(ExternLoc, getLangOpts().CPlusPlus11 ?
 diag::warn_cxx98_compat_extern_template :
 diag::ext_extern_template) << SourceRange(ExternLoc, TemplateLoc);
 SourceLocation DeclEnd;
-return Actions.ConvertDeclToDeclGroup(
+return Actions.ConvertDeclToDeclGroup(ParseExplicitInstantiation(
-ParseExplicitInstantiation(DeclaratorContext::FileContext, ExternLoc,
+DeclaratorContext::File, ExternLoc, TemplateLoc, DeclEnd, attrs));
-TemplateLoc, DeclEnd, attrs));
 }
 goto dont_know;
 case tok::kw___if_exists:
 case tok::kw___if_not_exists:
 ConsumeToken();
 RecordDecl *AnonRecord = nullptr;
 Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none,
 DS, AnonRecord);
 DS.complete(TheDecl);
-if (getLangOpts().OpenCL)
-Actions.setCurrentOpenCLExtensionForDecl(TheDecl);
 if (AnonRecord) {
 Decl* decls[] = {AnonRecord, TheDecl};
 return Actions.BuildDeclaratorGroup(decls);
 }
 return Actions.ConvertDeclToDeclGroup(TheDecl);
 // literal following it, this must be a C++ linkage specifier like
 // 'extern "C"'.
 if (getLangOpts().CPlusPlus && isTokenStringLiteral() &&
 DS.getStorageClassSpec() == DeclSpec::SCS_extern &&
 DS.getParsedSpecifiers() == DeclSpec::PQ_StorageClassSpecifier) {
-Decl *TheDecl = ParseLinkage(DS, DeclaratorContext::FileContext);
+Decl *TheDecl = ParseLinkage(DS, DeclaratorContext::File);
 return Actions.ConvertDeclToDeclGroup(TheDecl);
 }
-return ParseDeclGroup(DS, DeclaratorContext::FileContext);
+return ParseDeclGroup(DS, DeclaratorContext::File);
 }
 Parser::DeclGroupPtrTy
 Parser::ParseDeclarationOrFunctionDefinition(ParsedAttributesWithRange &attrs,
 ParsingDeclSpec *DS,
 ParseScope BodyScope(this, Scope::FnScope | Scope::DeclScope |
 Scope::CompoundStmtScope);
 Scope *ParentScope = getCurScope()->getParent();
-D.setFunctionDefinitionKind(FDK_Definition);
+D.setFunctionDefinitionKind(FunctionDefinitionKind::Definition);
 Decl *DP = Actions.HandleDeclarator(ParentScope, D,
 TemplateParameterLists);
 D.complete(DP);
 D.getMutableDeclSpec().abort();
 Actions.CurContext->isTranslationUnit()) {
 ParseScope BodyScope(this, Scope::FnScope | Scope::DeclScope |
 Scope::CompoundStmtScope);
 Scope *ParentScope = getCurScope()->getParent();
-D.setFunctionDefinitionKind(FDK_Definition);
+D.setFunctionDefinitionKind(FunctionDefinitionKind::Definition);
 Decl *FuncDecl = Actions.HandleDeclarator(ParentScope, D,
 MultiTemplateParamsArg());
 D.complete(FuncDecl);
 D.getMutableDeclSpec().abort();
 if (FuncDecl) {
 diag::err_invalid_storage_class_in_func_decl);
 DS.ClearStorageClassSpecs();
 }
 // Parse the first declarator attached to this declspec.
-Declarator ParmDeclarator(DS, DeclaratorContext::KNRTypeListContext);
+Declarator ParmDeclarator(DS, DeclaratorContext::KNRTypeList);
 ParseDeclarator(ParmDeclarator);
 // Handle the full declarator list.
 while (1) {
 // If attributes are present, parse them.
 case Sema::NC_Unknown:
 // It's not something we know about. Leave it unannotated.
 break;
 case Sema::NC_Type: {
+if (TryAltiVecVectorToken())
+// vector has been found as a type id when altivec is enabled but
+// this is followed by a declaration specifier so this is really the
+// altivec vector token.  Leave it unannotated.
+break;
 SourceLocation BeginLoc = NameLoc;
 if (SS.isNotEmpty())
 BeginLoc = SS.getBeginLoc();
 /// An Objective-C object type followed by '<' is a specialization of
 Tok.setLocation(BeginLoc);
 PP.AnnotateCachedTokens(Tok);
 return ANK_Success;
 }
-case Sema::NC_ContextIndependentExpr:
+case Sema::NC_OverloadSet:
-Tok.setKind(tok::annot_primary_expr);
+Tok.setKind(tok::annot_overload_set);
 setExprAnnotation(Tok, Classification.getExpression());
 Tok.setAnnotationEndLoc(NameLoc);
 if (SS.isNotEmpty())
 Tok.setLocation(SS.getBeginLoc());
 PP.AnnotateCachedTokens(Tok);
 return ANK_Success;
 case Sema::NC_NonType:
+if (TryAltiVecVectorToken())
+// vector has been found as a non-type id when altivec is enabled but
+// this is followed by a declaration specifier so this is really the
+// altivec vector token.  Leave it unannotated.
+break;
 Tok.setKind(tok::annot_non_type);
 setNonTypeAnnotation(Tok, Classification.getNonTypeDecl());
 Tok.setLocation(NameLoc);
 Tok.setAnnotationEndLoc(NameLoc);
 PP.AnnotateCachedTokens(Tok);
 assert(Tok.is(tok::code_completion));
 PrevTokLocation = Tok.getLocation();
 for (Scope *S = getCurScope(); S; S = S->getParent()) {
 if (S->getFlags() & Scope::FnScope) {
+cutOffParsing();
 Actions.CodeCompleteOrdinaryName(getCurScope(),
 Sema::PCC_RecoveryInFunction);
+return PrevTokLocation;
+}
+if (S->getFlags() & Scope::ClassScope) {
 cutOffParsing();
+Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Class);
 return PrevTokLocation;
 }
+}
-if (S->getFlags() & Scope::ClassScope) {
-Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Class);
+cutOffParsing();
-cutOffParsing();
-return PrevTokLocation;
-}
-}
 Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Namespace);
-cutOffParsing();
 return PrevTokLocation;
 }
 // Code-completion pass-through functions
 bool IsImport) {
 // Parse the module path.
 while (true) {
 if (!Tok.is(tok::identifier)) {
 if (Tok.is(tok::code_completion)) {
+cutOffParsing();
 Actions.CodeCompleteModuleImport(UseLoc, Path);
-cutOffParsing();
 return true;
 }
 Diag(Tok, diag::err_module_expected_ident) << IsImport;
 SkipUntil(tok::semi);

Mercurial > hg > CbC > CbC_llvm

comparison clang/lib/Parse/Parser.cpp @ 207:2e18cbf3894f