9914f221bd
Original-commit: flang-compiler/f18@76121cda6c Reviewed-on: https://github.com/flang-compiler/f18/pull/96 Tree-same-pre-rewrite: false
356 lines
18 KiB
C++
356 lines
18 KiB
C++
// Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#ifndef OPENMP_PARSER_GRAMMAR_H_
|
|
#define OPENMP_PARSER_GRAMMAR_H_
|
|
|
|
// Top-level grammar specification for Fortran. These parsers drive
|
|
// the tokenization parsers in cooked-tokens.h to consume characters,
|
|
// recognize the productions of Fortran, and to construct a parse tree.
|
|
// See ParserCombinators.md for documentation on the parser combinator
|
|
// library used here to implement an LL recursive descent recognizer.
|
|
|
|
#include "basic-parsers.h"
|
|
#include "characters.h"
|
|
#include "debug-parser.h"
|
|
#include "grammar.h"
|
|
#include "parse-tree.h"
|
|
#include "stmt-parser.h"
|
|
#include "token-parsers.h"
|
|
#include "type-parsers.h"
|
|
#include "user-state.h"
|
|
#include <cinttypes>
|
|
#include <cstdio>
|
|
#include <functional>
|
|
#include <list>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <tuple>
|
|
#include <utility>
|
|
|
|
// OpenMP Directives and Clauses
|
|
namespace Fortran::parser {
|
|
|
|
constexpr auto beginOmpDirective = skipEmptyLines >> space >> "!$OMP "_sptok;
|
|
|
|
// OpenMP Clauses
|
|
|
|
// DEFAULT (PRIVATE | FIRSTPRIVATE | SHARED | NONE )
|
|
TYPE_PARSER(construct<OmpDefaultClause>(
|
|
"PRIVATE" >> pure(OmpDefaultClause::Type::Private) ||
|
|
"FIRSTPRIVATE" >> pure(OmpDefaultClause::Type::Firstprivate) ||
|
|
"SHARED" >> pure(OmpDefaultClause::Type::Shared) ||
|
|
"NONE" >> pure(OmpDefaultClause::Type::None)))
|
|
|
|
// PROC_BIND(CLOSE | MASTER | SPREAD)
|
|
TYPE_PARSER(construct<OmpProcBindClause>(
|
|
"CLOSE" >> pure(OmpProcBindClause::Type::Close) ||
|
|
"MASTER" >> pure(OmpProcBindClause::Type::Master) ||
|
|
"SPREAD" >> pure(OmpProcBindClause::Type::Spread)))
|
|
|
|
// MAP ([ [map-type-modifier[,]] map-type : ] list)
|
|
// map-type-modifier -> ALWAYS
|
|
// map-type -> TO | FROM | TOFROM | ALLOC | RELEASE | DELETE
|
|
TYPE_PARSER(construct<OmpMapClause>(
|
|
maybe(maybe("ALWAYS"_tok >> maybe(","_ch)) >>
|
|
("TO" >> pure(OmpMapClause::Type::To) / ":"_ch ||
|
|
"FROM" >> pure(OmpMapClause::Type::From) / ":"_ch ||
|
|
"TOFROM" >> pure(OmpMapClause::Type::Tofrom) / ":"_ch ||
|
|
"ALLOC" >> pure(OmpMapClause::Type::Alloc) / ":"_ch ||
|
|
"RELEASE" >> pure(OmpMapClause::Type::Release) / ":"_ch ||
|
|
"DELETE" >> pure(OmpMapClause::Type::Delete) / ":"_ch)),
|
|
nonemptyList(name)))
|
|
|
|
// SCHEDULE ([modifier [, modifier]:]kind[, chunk_size])
|
|
// Modifier -> MONITONIC | NONMONOTONIC | SIMD
|
|
// kind -> STATIC | DYNAMIC | GUIDED | AUTO | RUNTIME
|
|
// chunk_size -> ScalarIntExpr
|
|
TYPE_PARSER(construct<OmpScheduleModifierType>(
|
|
"MONOTONIC" >> pure(OmpScheduleModifierType::ModType::Monotonic) ||
|
|
"NONMONOTONIC" >> pure(OmpScheduleModifierType::ModType::Nonmonotonic) ||
|
|
"SIMD" >> pure(OmpScheduleModifierType::ModType::Simd)))
|
|
|
|
TYPE_PARSER(construct<OmpScheduleModifier>(Parser<OmpScheduleModifierType>{},
|
|
maybe(","_ch >> Parser<OmpScheduleModifierType>{})))
|
|
|
|
TYPE_PARSER(construct<OmpScheduleClause>(maybe(Parser<OmpScheduleModifier>{}),
|
|
"STATIC" >> pure(OmpScheduleClause::ScheduleType::Static) ||
|
|
"DYNAMIC" >> pure(OmpScheduleClause::ScheduleType::Dynamic) ||
|
|
"GUIDED" >> pure(OmpScheduleClause::ScheduleType::Guided) ||
|
|
"AUTO" >> pure(OmpScheduleClause::ScheduleType::Auto) ||
|
|
"RUNTIME" >> pure(OmpScheduleClause::ScheduleType::Runtime),
|
|
maybe(","_ch) >> scalarIntExpr))
|
|
|
|
// IF(directive-name-modifier: scalar-logical-expr)
|
|
TYPE_PARSER(construct<OmpIfClause>(
|
|
("PARALLEL"_tok >> pure(OmpIfClause::DirectiveNameModifier::Parallel) ||
|
|
"TARGET ENTER DATA"_tok >>
|
|
pure(OmpIfClause::DirectiveNameModifier::TargetEnterData) ||
|
|
"TARGET EXIT DATA"_tok >>
|
|
pure(OmpIfClause::DirectiveNameModifier::TargetExitData) ||
|
|
"TARGET DATA"_tok >>
|
|
pure(OmpIfClause::DirectiveNameModifier::TargetData) ||
|
|
"TARGET UPDATE"_tok >>
|
|
pure(OmpIfClause::DirectiveNameModifier::TargetUpdate) ||
|
|
"TARGET"_tok >> pure(OmpIfClause::DirectiveNameModifier::Target) ||
|
|
"TASKLOOP"_tok >> pure(OmpIfClause::DirectiveNameModifier::Taskloop) ||
|
|
"TASK"_tok >> pure(OmpIfClause::DirectiveNameModifier::Task)) /
|
|
maybe(":"_ch),
|
|
scalarLogicalExpr))
|
|
|
|
// REDUCTION(reduction-identifier: list)
|
|
constexpr auto reductionBinaryOperator = "+" >>
|
|
pure(OmpReductionOperator::BinaryOperator::Add) ||
|
|
"-" >> pure(OmpReductionOperator::BinaryOperator::Subtract) ||
|
|
"*" >> pure(OmpReductionOperator::BinaryOperator::Multiply) ||
|
|
".AND." >> pure(OmpReductionOperator::BinaryOperator::AND) ||
|
|
".OR." >> pure(OmpReductionOperator::BinaryOperator::OR) ||
|
|
".EQV." >> pure(OmpReductionOperator::BinaryOperator::EQV) ||
|
|
".NEQV." >> pure(OmpReductionOperator::BinaryOperator::NEQV);
|
|
|
|
constexpr auto reductionProcedureOperator = "MIN" >>
|
|
pure(OmpReductionOperator::ProcedureOperator::MIN) ||
|
|
"MAX" >> pure(OmpReductionOperator::ProcedureOperator::MAX) ||
|
|
"IAND" >> pure(OmpReductionOperator::ProcedureOperator::IAND) ||
|
|
"IOR" >> pure(OmpReductionOperator::ProcedureOperator::IOR) ||
|
|
"IEOR" >> pure(OmpReductionOperator::ProcedureOperator::IEOR);
|
|
|
|
TYPE_PARSER(construct<OmpReductionOperator>(reductionBinaryOperator) ||
|
|
construct<OmpReductionOperator>(reductionProcedureOperator))
|
|
|
|
TYPE_PARSER(construct<OmpReductionClause>(
|
|
Parser<OmpReductionOperator>{} / ":"_ch, nonemptyList(designator)))
|
|
|
|
// DEPEND(SOURCE | SINK : vec | (IN | OUT | INOUT) : list
|
|
TYPE_PARSER(construct<OmpDependSinkVecLength>(
|
|
indirect(Parser<DefinedOperator>{}), scalarIntConstantExpr))
|
|
|
|
TYPE_PARSER(
|
|
construct<OmpDependSinkVec>(name, maybe(Parser<OmpDependSinkVecLength>{})))
|
|
|
|
TYPE_PARSER(construct<OmpDependenceType>(
|
|
"IN"_tok >> pure(OmpDependenceType::Type::In) ||
|
|
"OUT"_tok >> pure(OmpDependenceType::Type::Out) ||
|
|
"INOUT"_tok >> pure(OmpDependenceType::Type::Inout)))
|
|
|
|
TYPE_CONTEXT_PARSER("Omp Depend clause"_en_US,
|
|
construct<OmpDependClause>(construct<OmpDependClause::Sink>(
|
|
"SINK"_tok >> ":"_ch >> nonemptyList(Parser<OmpDependSinkVec>{}))) ||
|
|
construct<OmpDependClause>(
|
|
construct<OmpDependClause::Source>("SOURCE"_tok)) ||
|
|
construct<OmpDependClause>(construct<OmpDependClause::InOut>(
|
|
Parser<OmpDependenceType>{}, ":"_ch >> nonemptyList(designator))))
|
|
|
|
// LINEAR(list: linear-step)
|
|
TYPE_PARSER(construct<OmpLinearModifier>(
|
|
"REF"_tok >> pure(OmpLinearModifier::Type::Ref) ||
|
|
"VAL"_tok >> pure(OmpLinearModifier::Type::Val) ||
|
|
"UVAL"_tok >> pure(OmpLinearModifier::Type::Uval)))
|
|
|
|
TYPE_CONTEXT_PARSER("Omp LINEAR clause"_en_US,
|
|
construct<OmpLinearClause>(
|
|
construct<OmpLinearClause>(construct<OmpLinearClause::WithModifier>(
|
|
Parser<OmpLinearModifier>{}, parenthesized(nonemptyList(name)),
|
|
maybe(":"_ch >> scalarIntConstantExpr))) ||
|
|
construct<OmpLinearClause>(construct<OmpLinearClause::WithoutModifier>(
|
|
nonemptyList(name), maybe(":"_ch >> scalarIntConstantExpr)))))
|
|
|
|
// ALIGNED(list: alignment)
|
|
TYPE_PARSER(construct<OmpAlignedClause>(
|
|
nonemptyList(name), maybe(":"_ch) >> scalarIntConstantExpr))
|
|
|
|
TYPE_PARSER(construct<OmpNameList>(pure(OmpNameList::Kind::Object), name) ||
|
|
construct<OmpNameList>("/" >> pure(OmpNameList::Kind::Common), name / "/"))
|
|
|
|
TYPE_PARSER(
|
|
construct<OmpClause>(construct<OmpClause::Defaultmap>("DEFAULTMAP"_tok >>
|
|
parenthesized("TOFROM"_tok >> ":"_ch >> "SCALAR"_tok))) ||
|
|
construct<OmpClause>(construct<OmpClause::Inbranch>("INBRANCH"_tok)) ||
|
|
construct<OmpClause>(construct<OmpClause::Mergeable>("MERGEABLE"_tok)) ||
|
|
construct<OmpClause>(construct<OmpClause::Nogroup>("NOGROUP"_tok)) ||
|
|
construct<OmpClause>(
|
|
construct<OmpClause::Notinbranch>("NOTINBRANCH"_tok)) ||
|
|
construct<OmpClause>(construct<OmpClause::Nowait>("NOWAIT"_tok)) ||
|
|
construct<OmpClause>(construct<OmpClause::Untied>("UNTIED"_tok)) ||
|
|
construct<OmpClause>(construct<OmpClause::Collapse>(
|
|
"COLLAPSE"_tok >> parenthesized(scalarIntConstantExpr))) ||
|
|
construct<OmpClause>(construct<OmpClause::Copyin>(
|
|
"COPYIN"_tok >> parenthesized(nonemptyList(Parser<OmpNameList>{})))) ||
|
|
construct<OmpClause>(construct<OmpClause::Copyprivate>("COPYPRIVATE"_tok >>
|
|
parenthesized(nonemptyList(Parser<OmpNameList>{})))) ||
|
|
construct<OmpClause>(construct<OmpClause::Device>(
|
|
"DEVICE"_tok >> parenthesized(scalarIntExpr))) ||
|
|
construct<OmpClause>(
|
|
construct<OmpClause::DistSchedule>("DIST_SCHEDULE"_tok >>
|
|
parenthesized("STATIC"_tok >> ","_ch >> scalarIntExpr))) ||
|
|
construct<OmpClause>(construct<OmpClause::Final>(
|
|
"FINAL"_tok >> parenthesized(scalarIntExpr))) ||
|
|
construct<OmpClause>(
|
|
construct<OmpClause::Firstprivate>("FIRSTPRIVATE"_tok >>
|
|
parenthesized(nonemptyList(Parser<OmpNameList>{})))) ||
|
|
construct<OmpClause>(construct<OmpClause::From>(
|
|
"FROM"_tok >> parenthesized(nonemptyList(designator)))) ||
|
|
construct<OmpClause>(construct<OmpClause::Grainsize>(
|
|
"GRAINSIZE"_tok >> parenthesized(scalarIntExpr))) ||
|
|
construct<OmpClause>(construct<OmpClause::Lastprivate>("LASTPRIVATE"_tok >>
|
|
parenthesized(nonemptyList(Parser<OmpNameList>{})))) ||
|
|
construct<OmpClause>(construct<OmpClause::Link>(
|
|
"LINK"_tok >> parenthesized(nonemptyList(name)))) ||
|
|
construct<OmpClause>(construct<OmpClause::NumTasks>(
|
|
"NUM_TASKS"_tok >> parenthesized(scalarIntExpr))) ||
|
|
construct<OmpClause>(construct<OmpClause::NumTeams>(
|
|
"NUM_TEAMS"_tok >> parenthesized(scalarIntExpr))) ||
|
|
construct<OmpClause>(construct<OmpClause::NumThreads>(
|
|
"NUM_THREADS"_tok >> parenthesized(scalarIntExpr))) ||
|
|
construct<OmpClause>(construct<OmpClause::Ordered>(
|
|
"ORDERED"_tok >> maybe(parenthesized(scalarIntConstantExpr)))) ||
|
|
construct<OmpClause>(construct<OmpClause::Priority>(
|
|
"PRIORITY"_tok >> parenthesized(scalarIntExpr))) ||
|
|
construct<OmpClause>(construct<OmpClause::Private>(
|
|
"PRIVATE"_tok >> parenthesized(nonemptyList(Parser<OmpNameList>{})))) ||
|
|
construct<OmpClause>(construct<OmpClause::Safelen>(
|
|
"SAFELEN"_tok >> parenthesized(scalarIntConstantExpr))) ||
|
|
construct<OmpClause>(construct<OmpClause::Shared>(
|
|
"SHARED"_tok >> parenthesized(nonemptyList(Parser<OmpNameList>{})))) ||
|
|
construct<OmpClause>(construct<OmpClause::Simdlen>(
|
|
"SIMDLEN"_tok >> parenthesized(scalarIntConstantExpr))) ||
|
|
construct<OmpClause>(construct<OmpClause::ThreadLimit>(
|
|
"THREAD_LIMIT"_tok >> parenthesized(scalarIntExpr))) ||
|
|
construct<OmpClause>(construct<OmpClause::To>(
|
|
"TO"_tok >> parenthesized(nonemptyList(designator)))) ||
|
|
construct<OmpClause>(construct<OmpClause::Uniform>(
|
|
"UNIFORM"_tok >> parenthesized(nonemptyList(name)))) ||
|
|
construct<OmpClause>(construct<OmpClause::UseDevicePtr>(
|
|
"USE_DEVICE_PTR"_tok >> parenthesized(nonemptyList(name)))) ||
|
|
construct<OmpClause>(
|
|
"ALIGNED"_tok >> parenthesized(Parser<OmpAlignedClause>{})) ||
|
|
construct<OmpClause>(
|
|
"DEFAULT"_tok >> parenthesized(Parser<OmpDefaultClause>{})) ||
|
|
construct<OmpClause>(
|
|
"DEPEND"_tok >> parenthesized(Parser<OmpDependClause>{})) ||
|
|
construct<OmpClause>("IF"_tok >> parenthesized(Parser<OmpIfClause>{})) ||
|
|
construct<OmpClause>(
|
|
"LINEAR"_tok >> parenthesized(Parser<OmpLinearClause>{})) ||
|
|
construct<OmpClause>("MAP"_tok >> parenthesized(Parser<OmpMapClause>{})) ||
|
|
construct<OmpClause>(
|
|
"PROC_BIND"_tok >> parenthesized(Parser<OmpProcBindClause>{})) ||
|
|
construct<OmpClause>(
|
|
"REDUCTION"_tok >> parenthesized(Parser<OmpReductionClause>{})) ||
|
|
construct<OmpClause>(
|
|
"SCHEDULE"_tok >> parenthesized(Parser<OmpScheduleClause>{})))
|
|
|
|
TYPE_PARSER(skipEmptyLines >> space >> "!$OMP END"_sptok >>
|
|
(construct<OmpEndDirective>(Parser<OmpLoopDirective>{})))
|
|
|
|
// Omp directives enclosing do loop
|
|
TYPE_PARSER(
|
|
construct<OmpLoopDirective>(
|
|
construct<OmpLoopDirective::DistributeParallelDoSimd>(
|
|
"DISTRIBUTE PARALLEL DO SIMD"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(
|
|
construct<OmpLoopDirective::DistributeParallelDo>(
|
|
"DISTRIBUTE PARALLEL DO"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(construct<OmpLoopDirective::DistributeSimd>(
|
|
"DISTRIBUTE SIMD"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(construct<OmpLoopDirective::Distribute>(
|
|
"DISTRIBUTE"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(construct<OmpLoopDirective::DoSimd>(
|
|
"DO SIMD"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(construct<OmpLoopDirective::Do>(
|
|
"DO"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(construct<OmpLoopDirective::ParallelDoSimd>(
|
|
"PARALLEL DO SIMD"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(construct<OmpLoopDirective::ParallelDo>(
|
|
"PARALLEL DO"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(construct<OmpLoopDirective::Simd>(
|
|
"SIMD"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(
|
|
construct<OmpLoopDirective::TargetParallelDoSimd>(
|
|
"TARGET PARALLEL DO SIMD"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(construct<OmpLoopDirective::TargetParallelDo>(
|
|
"TARGET PARALLEL DO"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(construct<OmpLoopDirective::TargetSimd>(
|
|
"TARGET SIMD"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(
|
|
construct<OmpLoopDirective::TargetTeamsDistributeParallelDoSimd>(
|
|
"TARGET TEAMS DISTRIBUTE PARALLEL DO SIMD"_tok >>
|
|
many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(
|
|
construct<OmpLoopDirective::TargetTeamsDistributeParallelDo>(
|
|
"TARGET TEAMS DISTRIBUTE PARALLEL DO"_tok >>
|
|
many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(
|
|
construct<OmpLoopDirective::TargetTeamsDistributeSimd>(
|
|
"TARGET TEAMS DISTRIBUTE SIMD"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(
|
|
construct<OmpLoopDirective::TargetTeamsDistribute>(
|
|
"TARGET TEAMS DISTRIBUTE"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(construct<OmpLoopDirective::TaskloopSimd>(
|
|
"TASKLOOP SIMD" >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(construct<OmpLoopDirective::Taskloop>(
|
|
"TASKLOOP" >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(
|
|
construct<OmpLoopDirective::TeamsDistributeParallelDoSimd>(
|
|
"TEAMS DISTRIBUTE PARALLEL DO SIMD"_tok >>
|
|
many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(
|
|
construct<OmpLoopDirective::TeamsDistributeParallelDo>(
|
|
"TEAMS DISTRIBUTE PARALLEL DO"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(
|
|
construct<OmpLoopDirective::TeamsDistributeSimd>(
|
|
"TEAMS DISTRIBUTE SIMD"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpLoopDirective>(construct<OmpLoopDirective::TeamsDistribute>(
|
|
"TEAMS DISTRIBUTE"_tok >> many(Parser<OmpClause>{}))))
|
|
|
|
TYPE_PARSER(construct<OmpStandaloneDirective>(
|
|
construct<OmpStandaloneDirective::Barrier>(
|
|
"BARRIER"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpStandaloneDirective>(
|
|
construct<OmpStandaloneDirective::CancellationPoint>(
|
|
"CANCELLATION POINT"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpStandaloneDirective>(construct<OmpStandaloneDirective::Cancel>(
|
|
"CANCEL"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpStandaloneDirective>(construct<OmpStandaloneDirective::Flush>(
|
|
"FLUSH"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpStandaloneDirective>(
|
|
construct<OmpStandaloneDirective::TargetEnterData>(
|
|
"TARGET ENTER DATA"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpStandaloneDirective>(
|
|
construct<OmpStandaloneDirective::TargetExitData>(
|
|
"TARGET EXIT DATA"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpStandaloneDirective>(
|
|
construct<OmpStandaloneDirective::TargetUpdate>(
|
|
"TARGET UPDATE"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpStandaloneDirective>(
|
|
construct<OmpStandaloneDirective::Taskwait>(
|
|
"TASKWAIT"_tok >> many(Parser<OmpClause>{}))) ||
|
|
construct<OmpStandaloneDirective>(
|
|
construct<OmpStandaloneDirective::Taskyield>(
|
|
"TASKYIELD"_tok >> many(Parser<OmpClause>{}))))
|
|
|
|
TYPE_PARSER(
|
|
construct<OpenMPLoopConstruct>(statement(Parser<OmpLoopDirective>{}),
|
|
Parser<DoConstruct>{}, maybe(Parser<OmpEndDirective>{})))
|
|
|
|
TYPE_PARSER(construct<OpenMPStandaloneConstruct>(
|
|
statement(Parser<OmpStandaloneDirective>{})))
|
|
|
|
TYPE_CONTEXT_PARSER("OpenMP construct"_en_US,
|
|
beginOmpDirective >> (construct<OpenMPConstruct>(
|
|
indirect(Parser<OpenMPStandaloneConstruct>{})) ||
|
|
construct<OpenMPConstruct>(
|
|
indirect(Parser<OpenMPLoopConstruct>{}))))
|
|
|
|
} // namespace Fortran::parser
|
|
#endif // OPENMP_PARSER_GRAMMAR_H_
|