/// ParseMainProgram - Parse the main program.
///
/// [R1101]:
/// main-program :=
/// [program-stmt]
/// [specification-part]
/// [execution-part]
/// [internal-subprogram-part]
/// end-program-stmt
bool Parser::ParseMainProgram(std::vector<StmtResult> &Body) {
// If the PROGRAM statement didn't have an identifier, pretend like it did for
// the time being.
StmtResult ProgStmt;
if (Tok.is(tok::kw_PROGRAM)) {
ProgStmt = ParsePROGRAMStmt();
Body.push_back(ProgStmt);
}
// If the PROGRAM statement has an identifier, pass it on to the main program
// action.
const IdentifierInfo *IDInfo = 0;
SMLoc NameLoc;
if (ProgStmt.isUsable()) {
ProgramStmt *PS = ProgStmt.takeAs<ProgramStmt>();
IDInfo = PS->getProgramName();
NameLoc = PS->getNameLocation();
// FIXME: Debugging
dump(PS);
}
Actions.ActOnMainProgram(IDInfo, NameLoc);
// FIXME: Check for the specific keywords and not just absence of END or
// ENDPROGRAM.
ParseStatementLabel();
if (Tok.isNot(tok::kw_END) && Tok.isNot(tok::kw_ENDPROGRAM))
ParseSpecificationPart(Body);
// FIXME: Check for the specific keywords and not just absence of END or
// ENDPROGRAM.
ParseStatementLabel();
if (Tok.isNot(tok::kw_END) && Tok.isNot(tok::kw_ENDPROGRAM))
ParseExecutionPart(Body);
// FIXME: Debugging support.
dump(Body);
ParseStatementLabel();
StmtResult EndProgStmt = ParseEND_PROGRAMStmt();
Body.push_back(EndProgStmt);
IDInfo = 0;
NameLoc = SMLoc();
if (EndProgStmt.isUsable()) {
EndProgramStmt *EPS = EndProgStmt.takeAs<EndProgramStmt>();
IDInfo = EPS->getProgramName();
NameLoc = EPS->getNameLocation();
}
Actions.ActOnEndMainProgram(IDInfo, NameLoc);
return EndProgStmt.isInvalid();
}
void Parser::CheckStmtOrder(SourceLocation Loc, StmtResult SR) {
auto S = SR.get();
if(SR.isUsable()) {
if(Actions.InsideWhereConstruct(S))
Actions.CheckValidWhereStmtPart(S);
}
if(PrevStmtWasSelectCase) {
PrevStmtWasSelectCase = false;
if(SR.isUsable() && (isa<SelectionCase>(S) ||
(isa<ConstructPartStmt>(S) &&
cast<ConstructPartStmt>(S)->getConstructStmtClass() == ConstructPartStmt::EndSelectStmtClass)))
return;
Diag.Report(SR.isUsable()? S->getLocation() : Loc,
diag::err_expected_case_or_end_select);
}
if(SR.isUsable() && isa<SelectCaseStmt>(S))
PrevStmtWasSelectCase = true;
}
/// ParseSpecificationPart - Parse the specification part.
///
/// [R204]:
/// specification-part :=
/// [use-stmt] ...
/// [import-stmt] ...
/// [implicit-part] ...
/// [declaration-construct] ...
bool Parser::ParseSpecificationPart(std::vector<StmtResult> &Body) {
bool HasErrors = false;
while (Tok.is(tok::kw_USE)) {
StmtResult S = ParseUSEStmt();
if (S.isUsable()) {
Body.push_back(S);
} else if (S.isInvalid()) {
LexToEndOfStatement();
HasErrors = true;
} else {
break;
}
ParseStatementLabel();
}
while (Tok.is(tok::kw_IMPORT)) {
StmtResult S = ParseIMPORTStmt();
if (S.isUsable()) {
Body.push_back(S);
} else if (S.isInvalid()) {
LexToEndOfStatement();
HasErrors = true;
} else {
break;
}
ParseStatementLabel();
}
if (ParseImplicitPartList(Body))
HasErrors = true;
if (ParseDeclarationConstructList()) {
LexToEndOfStatement();
HasErrors = true;
}
return HasErrors;
}
/// ParseExecutableConstruct - Parse the executable construct.
///
/// [R213]:
/// executable-construct :=
/// action-stmt
/// or associate-construct
/// or block-construct
/// or case-construct
/// or critical-construct
/// or do-construct
/// or forall-construct
/// or if-construct
/// or select-type-construct
/// or where-construct
StmtResult Parser::ParseExecutableConstruct() {
ParseStatementLabel();
ParseConstructNameLabel();
LookForExecutableStmtKeyword(StmtLabel || StmtConstructName.isUsable()?
false : true);
auto Loc = Tok.getLocation();
StmtResult SR = ParseActionStmt();
CheckStmtOrder(Loc, SR);
if (SR.isInvalid()) return StmtError();
if (!SR.isUsable()) return StmtResult();
return SR;
}
/// ParseExecutionPart - Parse the execution part.
///
/// [R208]:
/// execution-part :=
/// executable-construct
/// [ execution-part-construct ] ...
bool Parser::ParseExecutionPart(std::vector<StmtResult> &Body) {
bool HadError = false;
while (true) {
StmtResult SR = ParseExecutableConstruct();
if (SR.isInvalid()) {
LexToEndOfStatement();
HadError = true;
} else if (!SR.isUsable()) {
break;
}
Body.push_back(SR);
}
return HadError;
}
/// ParseImplicitPartList - Parse a (possibly empty) list of implicit part
/// statements.
bool Parser::ParseImplicitPartList(std::vector<StmtResult> &Body) {
bool HasErrors = false;
while (true) {
StmtResult S = ParseImplicitPart();
if (S.isUsable()) {
Body.push_back(S);
} else if (S.isInvalid()) {
LexToEndOfStatement();
HasErrors = true;
} else {
break;
}
}
return HasErrors;
}
/// \brief Parsing of declarative or executable OpenMP directives.
///
/// threadprivate-directive:
/// annot_pragma_openmp 'threadprivate' simple-variable-list
/// annot_pragma_openmp_end
///
/// executable-directive:
/// annot_pragma_openmp 'parallel' | 'simd' | 'for' | 'sections' |
/// 'section' | 'single' | 'master' | 'critical' [ '(' <name> ')' ] |
/// 'parallel for' | 'parallel sections' | 'task' | 'taskyield' |
/// 'barrier' | 'taskwait' | 'flush' {clause} annot_pragma_openmp_end
///
StmtResult
Parser::ParseOpenMPDeclarativeOrExecutableDirective(bool StandAloneAllowed) {
assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
ParenBraceBracketBalancer BalancerRAIIObj(*this);
SmallVector<Expr *, 5> Identifiers;
SmallVector<OMPClause *, 5> Clauses;
SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>, OMPC_unknown + 1>
FirstClauses(OMPC_unknown + 1);
unsigned ScopeFlags =
Scope::FnScope | Scope::DeclScope | Scope::OpenMPDirectiveScope;
SourceLocation Loc = ConsumeToken(), EndLoc;
auto DKind = ParseOpenMPDirectiveKind(*this);
// Name of critical directive.
DeclarationNameInfo DirName;
StmtResult Directive = StmtError();
bool HasAssociatedStatement = true;
bool FlushHasClause = false;
switch (DKind) {
case OMPD_threadprivate:
ConsumeToken();
if (!ParseOpenMPSimpleVarList(OMPD_threadprivate, Identifiers, false)) {
// The last seen token is annot_pragma_openmp_end - need to check for
// extra tokens.
if (Tok.isNot(tok::annot_pragma_openmp_end)) {
Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
<< getOpenMPDirectiveName(OMPD_threadprivate);
SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
}
DeclGroupPtrTy Res =
Actions.ActOnOpenMPThreadprivateDirective(Loc, Identifiers);
Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
}
SkipUntil(tok::annot_pragma_openmp_end);
break;
case OMPD_flush:
if (PP.LookAhead(0).is(tok::l_paren)) {
FlushHasClause = true;
// Push copy of the current token back to stream to properly parse
// pseudo-clause OMPFlushClause.
PP.EnterToken(Tok);
}
case OMPD_taskyield:
case OMPD_barrier:
case OMPD_taskwait:
if (!StandAloneAllowed) {
Diag(Tok, diag::err_omp_immediate_directive)
<< getOpenMPDirectiveName(DKind);
}
HasAssociatedStatement = false;
// Fall through for further analysis.
case OMPD_parallel:
case OMPD_simd:
case OMPD_for:
case OMPD_sections:
case OMPD_single:
case OMPD_section:
case OMPD_master:
case OMPD_critical:
case OMPD_parallel_for:
case OMPD_parallel_sections:
case OMPD_task: {
ConsumeToken();
// Parse directive name of the 'critical' directive if any.
if (DKind == OMPD_critical) {
BalancedDelimiterTracker T(*this, tok::l_paren,
tok::annot_pragma_openmp_end);
if (!T.consumeOpen()) {
if (Tok.isAnyIdentifier()) {
DirName =
DeclarationNameInfo(Tok.getIdentifierInfo(), Tok.getLocation());
ConsumeAnyToken();
} else {
Diag(Tok, diag::err_omp_expected_identifier_for_critical);
}
T.consumeClose();
}
}
if (isOpenMPLoopDirective(DKind))
ScopeFlags |= Scope::OpenMPLoopDirectiveScope;
if (isOpenMPSimdDirective(DKind))
ScopeFlags |= Scope::OpenMPSimdDirectiveScope;
ParseScope OMPDirectiveScope(this, ScopeFlags);
Actions.StartOpenMPDSABlock(DKind, DirName, Actions.getCurScope(), Loc);
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
OpenMPClauseKind CKind =
Tok.isAnnotation()
? OMPC_unknown
: FlushHasClause ? OMPC_flush
: getOpenMPClauseKind(PP.getSpelling(Tok));
FlushHasClause = false;
OMPClause *Clause =
ParseOpenMPClause(DKind, CKind, !FirstClauses[CKind].getInt());
FirstClauses[CKind].setInt(true);
if (Clause) {
FirstClauses[CKind].setPointer(Clause);
Clauses.push_back(Clause);
}
// Skip ',' if any.
if (Tok.is(tok::comma))
ConsumeToken();
}
// End location of the directive.
EndLoc = Tok.getLocation();
// Consume final annot_pragma_openmp_end.
ConsumeToken();
StmtResult AssociatedStmt;
bool CreateDirective = true;
if (HasAssociatedStatement) {
// The body is a block scope like in Lambdas and Blocks.
Sema::CompoundScopeRAII CompoundScope(Actions);
Actions.ActOnOpenMPRegionStart(DKind, getCurScope());
Actions.ActOnStartOfCompoundStmt();
// Parse statement
AssociatedStmt = ParseStatement();
Actions.ActOnFinishOfCompoundStmt();
if (!AssociatedStmt.isUsable()) {
Actions.ActOnCapturedRegionError();
CreateDirective = false;
} else {
AssociatedStmt = Actions.ActOnCapturedRegionEnd(AssociatedStmt.get());
CreateDirective = AssociatedStmt.isUsable();
}
}
if (CreateDirective)
Directive = Actions.ActOnOpenMPExecutableDirective(
DKind, DirName, Clauses, AssociatedStmt.get(), Loc, EndLoc);
// Exit scope.
Actions.EndOpenMPDSABlock(Directive.get());
OMPDirectiveScope.Exit();
break;
}
case OMPD_unknown:
Diag(Tok, diag::err_omp_unknown_directive);
SkipUntil(tok::annot_pragma_openmp_end);
break;
}
return Directive;
}
/// \brief Parsing of declarative or executable OpenMP directives.
///
/// threadprivate-directive:
/// annot_pragma_openmp 'threadprivate' simple-variable-list
/// annot_pragma_openmp_end
///
/// parallel-directive:
/// annot_pragma_openmp 'parallel' {clause} annot_pragma_openmp_end
///
StmtResult Parser::ParseOpenMPDeclarativeOrExecutableDirective() {
assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
ParenBraceBracketBalancer BalancerRAIIObj(*this);
SmallVector<Expr *, 5> Identifiers;
SmallVector<OMPClause *, 5> Clauses;
SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>, NUM_OPENMP_CLAUSES>
FirstClauses(NUM_OPENMP_CLAUSES);
const unsigned ScopeFlags = Scope::FnScope | Scope::DeclScope |
Scope::OpenMPDirectiveScope;
SourceLocation Loc = ConsumeToken(), EndLoc;
OpenMPDirectiveKind DKind = Tok.isAnnotation() ?
OMPD_unknown :
getOpenMPDirectiveKind(PP.getSpelling(Tok));
// Name of critical directive.
DeclarationNameInfo DirName;
StmtResult Directive = StmtError();
switch (DKind) {
case OMPD_threadprivate:
ConsumeToken();
if (!ParseOpenMPSimpleVarList(OMPD_threadprivate, Identifiers, false)) {
// The last seen token is annot_pragma_openmp_end - need to check for
// extra tokens.
if (Tok.isNot(tok::annot_pragma_openmp_end)) {
Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
<< getOpenMPDirectiveName(OMPD_threadprivate);
SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
}
DeclGroupPtrTy Res =
Actions.ActOnOpenMPThreadprivateDirective(Loc,
Identifiers);
Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
}
SkipUntil(tok::annot_pragma_openmp_end);
break;
case OMPD_parallel: {
ConsumeToken();
Actions.StartOpenMPDSABlock(DKind, DirName, Actions.getCurScope());
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
OpenMPClauseKind CKind = Tok.isAnnotation() ?
OMPC_unknown :
getOpenMPClauseKind(PP.getSpelling(Tok));
OMPClause *Clause = ParseOpenMPClause(DKind, CKind,
!FirstClauses[CKind].getInt());
FirstClauses[CKind].setInt(true);
if (Clause) {
FirstClauses[CKind].setPointer(Clause);
Clauses.push_back(Clause);
}
// Skip ',' if any.
if (Tok.is(tok::comma))
ConsumeToken();
}
// End location of the directive.
EndLoc = Tok.getLocation();
// Consume final annot_pragma_openmp_end.
ConsumeToken();
StmtResult AssociatedStmt;
bool CreateDirective = true;
ParseScope OMPDirectiveScope(this, ScopeFlags);
{
// The body is a block scope like in Lambdas and Blocks.
Sema::CompoundScopeRAII CompoundScope(Actions);
Actions.ActOnCapturedRegionStart(Loc, getCurScope(), CR_OpenMP, 1);
Actions.ActOnStartOfCompoundStmt();
// Parse statement
AssociatedStmt = ParseStatement();
Actions.ActOnFinishOfCompoundStmt();
if (!AssociatedStmt.isUsable()) {
Actions.ActOnCapturedRegionError();
CreateDirective = false;
} else {
AssociatedStmt = Actions.ActOnCapturedRegionEnd(AssociatedStmt.take());
CreateDirective = AssociatedStmt.isUsable();
}
}
if (CreateDirective)
Directive = Actions.ActOnOpenMPExecutableDirective(DKind, Clauses,
AssociatedStmt.take(),
Loc, EndLoc);
// Exit scope.
Actions.EndOpenMPDSABlock(Directive.get());
OMPDirectiveScope.Exit();
}
break;
case OMPD_unknown:
Diag(Tok, diag::err_omp_unknown_directive);
SkipUntil(tok::annot_pragma_openmp_end);
break;
case OMPD_task:
case NUM_OPENMP_DIRECTIVES:
Diag(Tok, diag::err_omp_unexpected_directive)
<< getOpenMPDirectiveName(DKind);
SkipUntil(tok::annot_pragma_openmp_end);
break;
}
return Directive;
}
/// ParseSAVEStmt - Parse the SAVE statement.
///
/// [R543]:
/// save-stmt :=
/// SAVE [ [::] saved-entity-list ]
Parser::StmtResult Parser::ParseSAVEStmt() {
// Check if this is an assignment.
if (IsNextToken(tok::equal))
return StmtResult();
auto Loc = ConsumeToken();
if(Tok.isAtStartOfStatement())
return Actions.ActOnSAVE(Context, Loc, StmtLabel);
bool IsSaveStmt = ConsumeIfPresent(tok::coloncolon);
SmallVector<Stmt *,8> StmtList;
bool ListParsedOk = true;
auto IDLoc = Tok.getLocation();
auto II = Tok.getIdentifierInfo();
StmtResult Stmt;
if(ConsumeIfPresent(tok::slash)) {
IDLoc = Tok.getLocation();
II = Tok.getIdentifierInfo();
if(ExpectAndConsume(tok::identifier)) {
if(!ExpectAndConsume(tok::slash))
ListParsedOk = false;
Stmt = Actions.ActOnSAVECommonBlock(Context, Loc, IDLoc, II);
}
else ListParsedOk = false;
}
else if(ExpectAndConsume(tok::identifier)) {
if(!IsSaveStmt && Features.FixedForm && (IsPresent(tok::equal) || IsPresent(tok::l_paren)))
return ReparseAmbiguousAssignmentStatement();
Stmt = Actions.ActOnSAVE(Context, Loc, IDLoc, II, nullptr);
} else ListParsedOk = false;
if(Stmt.isUsable())
StmtList.push_back(Stmt.get());
if(ListParsedOk) {
while(ConsumeIfPresent(tok::comma)) {
IDLoc = Tok.getLocation();
II = Tok.getIdentifierInfo();
if(ConsumeIfPresent(tok::slash)) {
IDLoc = Tok.getLocation();
II = Tok.getIdentifierInfo();
if(!ExpectAndConsume(tok::identifier)) {
ListParsedOk = false;
break;
}
if(!ExpectAndConsume(tok::slash)) {
ListParsedOk = false;
break;
}
Stmt = Actions.ActOnSAVECommonBlock(Context, Loc, IDLoc, II);
}
else if(ExpectAndConsume(tok::identifier))
Stmt = Actions.ActOnSAVE(Context, Loc, IDLoc, II, nullptr);
else {
ListParsedOk = false;
break;
}
if(Stmt.isUsable())
StmtList.push_back(Stmt.get());
}
}
if(ListParsedOk) ExpectStatementEnd();
else SkipUntilNextStatement();
return Actions.ActOnCompoundStmt(Context, Loc, StmtList, StmtLabel);
}