Index: include/clang/Parse/Parser.h =================================================================== --- include/clang/Parse/Parser.h (revision 166768) +++ include/clang/Parse/Parser.h (working copy) @@ -43,6 +43,7 @@ class InMessageExpressionRAIIObject; class PoisonSEHIdentifiersRAIIObject; class VersionTuple; /// PrettyStackTraceParserEntry - If a crash happens while the parser is active, /// an entry is printed for it. @@ -180,6 +181,8 @@ OwningPtr OpenCLExtensionHandler; OwningPtr CommentSemaHandler; /// Whether the '>' token acts as an operator or not. This will be /// true except when we are parsing an expression within a C++ /// template argument list, where the '>' closes the template @@ -2207,6 +2210,53 @@ MacroInfo *MacroInfo, unsigned ArgumentIndex); virtual void CodeCompleteNaturalLanguage(); + +private: + //===--------------------------------------------------------------------===// + // OpenMP 3.1: OpenMP pragma constructs, directives, clauses, clause kinds, + // clause decl variable expressions list. + + // Parse OpenMP constructs. + StmtResult ParsePragmaOmpConstructs(SourceLocation *TrailingElseLoc); + StmtResult ParsePragmaOmpParallelConstruct(SourceLocation *TrailingElseLoc); + StmtResult ParsePragmaOmpForConstruct(SourceLocation *TrailingElseLoc); + StmtResult ParsePragmaOmpSectionsConstruct(SourceLocation *TrailingElseLoc); + StmtResult ParsePragmaOmpSingleConstruct(SourceLocation *TrailingElseLoc); + StmtResult ParsePragmaOmpTaskConstruct(SourceLocation *TrailingElseLoc); + StmtResult ParsePragmaOmpMasterConstruct(SourceLocation *TrailingElseLoc); + StmtResult ParsePragmaOmpCriticalConstruct(SourceLocation *TrailingElseLoc); + StmtResult ParsePragmaOmpAtomicConstruct(SourceLocation *TrailingElseLoc); + StmtResult ParsePragmaOmpOrderedConstruct(SourceLocation *TrailingElseLoc); + bool ParsePragmaOmpConstruct(SourceLocation &ConstrutLoc, + StmtResult &StructuredBlock, + SourceLocation *TrailingElseLoc, + StmtResult *Clauses = 0, + bool ParseClauses = false); + + // Parse OpenMP directives. + StmtResult ParsePragmaOmpDirectives(); + StmtResult ParsePragmaOmpBarrierDirective(); + StmtResult ParsePragmaOmpTaskwaitDirective(); + StmtResult ParsePragmaOmpTaskyieldDirective(); + StmtResult ParsePragmaOmpSectionDirective(); + StmtResult ParsePragmaOmpFlushDirective(); + StmtResult ParsePragmaOmpThreadPrivateDirective(); + bool ParsePragmaOmpNonListDirective(SourceLocation &DirectiveLoc); + bool ParsePragmaOmpListDirective(SourceLocation &DirectiveLoc, + SourceLocation &LParenLoc, + SourceLocation &RParenLoc, + ExprVector &DeclRefExprs, + bool OptVarList=false); + + // Parse OpenMP clauses. + bool ParsePragmaOmpClauses(StmtResult *Clauses); + + // Parse OpenMP clause decl variable expressions list. + bool ParsePragmaOmpClauseVariableExpressions(ExprVector &DeclRefExprs, + SourceLocation &LParenLoc, + SourceLocation &RParenLoc); + bool ParsePragmaOmpClauseVariableExpressions(ExprVector &DeclRefExprs, + SourceLocation &RParenLoc); }; } // end namespace clang Index: lib/Parse/CMakeLists.txt =================================================================== --- lib/Parse/CMakeLists.txt (revision 166768) +++ lib/Parse/CMakeLists.txt (working copy) @@ -7,6 +7,7 @@ ParseExprCXX.cpp ParseInit.cpp ParseObjc.cpp + ParseOpenMP.cpp ParsePragma.cpp ParseStmt.cpp ParseTemplate.cpp Index: lib/Parse/ParseOpenMP.cpp =================================================================== --- lib/Parse/ParseOpenMP.cpp (revision 0) +++ lib/Parse/ParseOpenMP.cpp (revision 0) @@ -0,0 +1,695 @@ +//===--------------ParseOpenMP.cpp - OpenMP Parser--------------------------===/ +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file implements the OpenMP pragma directive statements parsing portions +// of the Parser interface. +// +//===----------------------------------------------------------------------===// + +#include "clang/Parse/Parser.h" +#include "RAIIObjectsForParser.h" +#include "clang/Sema/DeclSpec.h" +#include "clang/Sema/PrettyDeclStackTrace.h" +#include "clang/Sema/Scope.h" +#include "clang/Sema/TypoCorrection.h" +#include "clang/Basic/Diagnostic.h" +#include "clang/Basic/PrettyStackTrace.h" +#include "clang/Basic/SourceManager.h" +#include "clang/Basic/OpenMP.h" +#include "llvm/ADT/SmallString.h" +using namespace clang; + +//===----------------------------------------------------------------------===// +// OpenMP 3.1: OpenMP pragma constructs, directives, clauses, clause kinds, +// clause decl variable expressions list. +//===----------------------------------------------------------------------===// + +/// ParsePragmaOmpConstructs - Read 'OpenMP pragma constructs'. +/// openmp-construct: +/// parallel-construct +/// for-construct +/// sections-construct +/// single-construct +/// parallel-for-construct +/// parallel-sections-construct +/// task-construct +/// master-construct +/// critical-construct +/// atomic-construct +/// ordered-construct +StmtResult +Parser::ParsePragmaOmpConstructs(SourceLocation *TrailingElseLoc) { + tok::TokenKind Kind = Tok.getKind(); + switch (Kind) { + case tok::annot_pragma_omp_parallel: + { + return ParsePragmaOmpParallelConstruct(TrailingElseLoc); + } + case tok::annot_pragma_omp_for: + { + return ParsePragmaOmpForConstruct(TrailingElseLoc); + } + case tok::annot_pragma_omp_sections: + { + return ParsePragmaOmpSectionsConstruct(TrailingElseLoc); + } + case tok::annot_pragma_omp_single: + { + return ParsePragmaOmpSingleConstruct(TrailingElseLoc); + } + case tok::annot_pragma_omp_task: + { + return ParsePragmaOmpTaskConstruct(TrailingElseLoc); + } + case tok::annot_pragma_omp_master: + { + return ParsePragmaOmpMasterConstruct(TrailingElseLoc); + } + case tok::annot_pragma_omp_critical: + { + return ParsePragmaOmpCriticalConstruct(TrailingElseLoc); + } + case tok::annot_pragma_omp_atomic: + { + return ParsePragmaOmpAtomicConstruct(TrailingElseLoc); + } + case tok::annot_pragma_omp_ordered: + { + return ParsePragmaOmpOrderedConstruct(TrailingElseLoc); + } + default: + { + assert (false && "Not a valid OpenMP pragma construct"); + } + } + + return StmtError(); +} + +/// ParsePragmaOmpParallelConstruct - Read 'OpenMP pragma parallel construct'. +/// parallel-construct: +/// parallel-directive structured-block +/// +/// parallel-directive: +/// # pragma omp parallel parallel-clause[opt] new-line +/// +StmtResult +Parser::ParsePragmaOmpParallelConstruct(SourceLocation *TrailingElseLoc) { + SourceLocation ParallelLoc; + StmtResult Clauses[omp::c_end]; + StmtResult StructuredBlock; + + if (!ParsePragmaOmpConstruct(ParallelLoc, StructuredBlock, TrailingElseLoc, + Clauses, true/*=ParseClauses*/)) + return StmtError(); + + return StmtEmpty(); +} + +/// ParsePragmaOmpForConstruct - Read 'OpenMP pragma for construct'. +/// for-construct: +/// for-directive iteration-statement +/// +/// for-directive: +/// # pragma omp for for-clauseseq[opt] new-line +StmtResult +Parser::ParsePragmaOmpForConstruct(SourceLocation *TrailingElseLoc) { + SourceLocation ForLoc; + StmtResult Clauses[omp::c_end]; + StmtResult StructuredBlock; + + if (!ParsePragmaOmpConstruct(ForLoc, StructuredBlock, TrailingElseLoc, + Clauses, true/*=ParseClauses*/)) + return StmtError(); + + return StmtEmpty(); +} + +/// ParsePragmaOmpSectionsConstruct - Read 'OpenMP pragma sections construct'. +/// sections-construct: +/// sections-directive section-scope +/// +/// sections-directive: +/// # pragma omp sections sections-clauseseq[opt] new-line + +/// section-scope +/// { section-sequence } +/// +/// section-sequence +/// section-directive[opt] structured-block +/// section-sequence section-directive structured-block +StmtResult +Parser::ParsePragmaOmpSectionsConstruct(SourceLocation *TrailingElseLoc) { + SourceLocation SectionsLoc; + StmtResult Clauses[omp::c_end]; + StmtResult StructuredBlock; + + if (!ParsePragmaOmpConstruct(SectionsLoc, StructuredBlock, TrailingElseLoc, + Clauses, true/*=ParseClauses*/)) + return StmtError(); + + return StmtEmpty(); +} + +/// ParsePragmaOmpSingleConstruct - Read 'OpenMP pragma single construct'. +/// single-construct: +/// single-directive structured-block +/// +/// single-directive: +/// # pragma omp single single-clauseseq[opt] new-line +StmtResult +Parser::ParsePragmaOmpSingleConstruct(SourceLocation *TrailingElseLoc) { + SourceLocation SingleLoc; + StmtResult Clauses[omp::c_end]; + StmtResult StructuredBlock; + + if (!ParsePragmaOmpConstruct(SingleLoc, StructuredBlock, TrailingElseLoc, + Clauses, true/*=ParseClauses*/)) + return StmtError(); + + return StmtEmpty(); +} + +/// ParsePragmaOmpTaskConstruct - Read 'OpenMP pragma task construct'. +/// task-construct: +/// task-directive structured-block +/// +/// task-directive: +/// # pragma omp task task-clauseseq[opt] new-line +StmtResult +Parser::ParsePragmaOmpTaskConstruct(SourceLocation *TrailingElseLoc) { + SourceLocation TaskLoc; + StmtResult Clauses[omp::c_end]; + StmtResult StructuredBlock; + + if (!ParsePragmaOmpConstruct(TaskLoc, StructuredBlock, TrailingElseLoc, + Clauses, true/*=ParseClauses*/)) + return StmtError(); + + return StmtEmpty(); +} + +/// ParsePragmaOmpMasterConstruct - Read 'OpenMP pragma master construct'. +/// master-construct: +/// master-directive structured-block +/// +/// master-directive: +/// # pragma omp master new-line +StmtResult +Parser::ParsePragmaOmpMasterConstruct(SourceLocation *TrailingElseLoc) { + SourceLocation MasterLoc; + StmtResult StructuredBlock; + + if (!ParsePragmaOmpConstruct(MasterLoc, StructuredBlock, TrailingElseLoc)) + return StmtError(); + + return StmtEmpty(); +} + +/// ParsePragmaOmpCriticalConstruct - Read 'OpenMP pragma critical construct'. +/// critical-construct: +/// critical-directive structured-block +/// +/// critical-directive: +/// # pragma omp critical region-phrase[opt] new-line +/// +/// region-phrase: +/// ( identifier ) +StmtResult +Parser::ParsePragmaOmpCriticalConstruct(SourceLocation *TrailingElseLoc) { + // FIXME: Not Implemented. + assert(false && "Not implemenetd yet"); + + return StmtEmpty(); +} + +/// ParsePragmaOmpAtomicConstruct - Read 'OpenMP pragma atomic construct'. +/// atomic-construct: +/// atomic-directive expression-statement +/// atomic-directive structured block +/// +/// atomic-directive: +/// # pragma omp atomic atomic-clause[opt] new-line +StmtResult +Parser::ParsePragmaOmpAtomicConstruct(SourceLocation *TrailingElseLoc) { + SourceLocation AtomicLoc; + StmtResult Clauses[omp::c_end]; + StmtResult StructuredBlock; + + if (!ParsePragmaOmpConstruct(AtomicLoc, StructuredBlock, TrailingElseLoc, + Clauses, true/*=ParseClauses*/)) + return StmtError(); + + return StmtEmpty(); +} + +/// ParsePragmaOmpOrderedConstruct - Read 'OpenMP pragma ordered construct'. +/// ordered-construct: +/// ordered-directive structured-block +/// +/// ordered-directive: +/// # pragma omp ordered new-line +StmtResult +Parser::ParsePragmaOmpOrderedConstruct(SourceLocation *TrailingElseLoc) { + SourceLocation OrderedLoc; + StmtResult StructuredBlock; + + if (!ParsePragmaOmpConstruct(OrderedLoc, StructuredBlock, TrailingElseLoc)) + return StmtError(); + + return StmtEmpty(); +} + +/// ParsePragmaOmpConstruct - Parse an OpenMP pragma construct. +bool Parser::ParsePragmaOmpConstruct(SourceLocation &ConstrutLoc, + StmtResult &StructuredBlock, + SourceLocation *TrailingElseLoc, + StmtResult *Clauses, + bool ParseClauses) { + // Record the source location information of the construct's name, and consume + // it. + ConstrutLoc = ConsumeToken(); + + if (ParseClauses) { + // Parse all the OpenMP clasues in the current OpenMP pragma directive line. + if (!ParsePragmaOmpClauses(Clauses)) + return false; + } else { + // Current token must be an end of pragma directive line token. Check for it. + if (Tok.isNot(tok::eod)) { + // FIXME: Report diagnostic message. + SkipUntil(tok::semi); + return false; + } + // Consume the "eod" token. + ConsumeToken(); + } + + // Parse the structured block. + StructuredBlock = ParseStatement(TrailingElseLoc); + if (StructuredBlock.isInvalid()) + return false; + + return true; +} + +/// ParsePragmaOmpClauses - Read OpenMP clause sequence. +/// parallel-clause: +/// unique-parallel-clause +/// data-default-clause +/// data-privatization-clause +/// data-privatization-in-clause +/// data-sharing-clause +/// data-reduction-clause +/// +/// for-clause +/// unique-for-clause +/// data-privatization-clause +/// data-privatization-in-clause +/// data-privatization-out-clause +/// data-reduction-clause +/// nowait +/// +/// sections-clause +/// data-privatization-clause +/// data-privatization-in-clause +/// data-privatization-out-clause +/// data-reduction-clause +/// nowait +/// +/// single-clause +/// unique-single-clause +/// data-privatization-clause +/// data-privatization-in-clause +/// nowait +/// +/// task-clause +/// unique-task-clause +/// data-default-clause +/// data-privatization-clause +/// data-privatization-in-clause +/// data-sharing-clause +/// +/// parallel-for-clause +/// unique-parallel-clause +/// unique-for-clause +/// data-default-clause +/// data-privatization-clause +/// data-privatization-in-clause +/// data-privatization-out-clause +/// data-sharing-clause +/// data-reduction-clause +/// +/// parallel-sections-clause +/// unique-parallel-clause +/// data-default-clause +/// data-privatization-clause +/// data-privatization-in-clause +/// data-privatization-out-clause +/// data-sharing-clause +/// data-reduction-clause +/// +/// atomic-clause +/// read +/// write +/// update +/// capture +/// +/// unique-parallel-clause: +/// if ( expression ) +/// num_threads ( expression ) +/// copyin ( variable-list ) +/// +/// unique-for-clause +/// ordered +/// schedule ( schedule-kind ) +/// schedule ( schedule-kind , expression ) +/// collapse ( expression ) +/// +/// unique-single-clause +/// copyprivate ( variable-list ) +/// +/// unique-task-clause +/// if ( scalar-expression ) +/// final( scalar-expression ) +/// untied +/// mergeable +/// +/// schedule-kind +/// schedule-kind: +/// static +/// dynamic +/// guided +/// auto +/// runtime +/// +/// data-default-clause +/// default ( shared ) +/// default ( none ) +/// +/// data-privatization-clause +/// private ( variable-list ) +/// +/// data-privatization-in-clause +/// firstprivate ( variable-list ) +/// +/// data-privatization-out-clause +/// lastprivate ( variable-list ) +/// +/// data-sharing-clause +/// shared ( variable-list ) +/// +/// data-reduction-clause +/// reduction ( reduction-operator : variable-list ) +/// +/// reduction-operator +/// One of: + * - & ^ | && || +/// +/// variable-list: +/// [C] identifier +/// variable-list , identifier +/// [C++] id-expression +/// variable-list , id-expression +bool Parser::ParsePragmaOmpClauses(StmtResult *Clauses) { + // FIXME: Parse all clauses. + + if (Tok.isNot(tok::eod)) { + // FIXME: Report diagnostic message. + SkipUntil(tok::semi); + return false; + } + + // Consume the "eod" token. + ConsumeToken(); + + return true; +} + +/// ParsePragmaOmpDirectives - Read 'OpenMP pragma directives'. +/// openmp-directive: +/// barrier-directive +/// taskwait-directive +/// taskyield-directive +/// flush-directive +/// section-directive +/// threadprivate-directive +StmtResult +Parser::ParsePragmaOmpDirectives() { + tok::TokenKind Kind = Tok.getKind(); + switch (Kind) { + case tok::annot_pragma_omp_barrier: + { + return ParsePragmaOmpBarrierDirective(); + } + case tok::annot_pragma_omp_taskwait: + { + return ParsePragmaOmpTaskwaitDirective(); + } + case tok::annot_pragma_omp_taskyield: + { + return ParsePragmaOmpTaskyieldDirective(); + } + case tok::annot_pragma_omp_flush: + { + return ParsePragmaOmpFlushDirective(); + } + case tok::annot_pragma_omp_section: + { + return ParsePragmaOmpSectionDirective(); + } + case tok::annot_pragma_omp_threadprivate: + { + return ParsePragmaOmpThreadPrivateDirective(); + } + default: + { + assert (false && "Not a valid OpenMP pragma directive"); + } + } + + return StmtError(); +} + +/// ParsePragmaOmpBarrierDirective - Read 'OpenMP pragma barrier directive'. +/// barrier-directive: +/// # pragma omp barrier new-line +StmtResult +Parser::ParsePragmaOmpBarrierDirective() { + SourceLocation BarrierLoc; + + if (!ParsePragmaOmpNonListDirective(BarrierLoc)) + return StmtError(); + + return StmtEmpty(); +} + +/// ParsePragmaOmpTaskwaitDirective - Read 'OpenMP pragma taskwait directive'. +/// taskwait-directive: +/// # pragma omp taskwait new-line +StmtResult +Parser::ParsePragmaOmpTaskwaitDirective() { + SourceLocation TaskwaitLoc; + + if (!ParsePragmaOmpNonListDirective(TaskwaitLoc)) + return StmtError(); + + return StmtEmpty(); +} + +/// ParsePragmaOmpTaskyieldDirective - Read 'OpenMP pragma taskyield directive'. +/// taskyield-directive: +/// # pragma omp taskyield new-line +StmtResult +Parser::ParsePragmaOmpTaskyieldDirective() { + SourceLocation TaskyieldLoc; + + if (!ParsePragmaOmpNonListDirective(TaskyieldLoc)) + return StmtError(); + + return StmtEmpty(); +} + +/// ParsePragmaOmpSectionDirective - Read 'OpenMP pragma section directive'. +/// section-directive: +/// # pragma omp section new-line +StmtResult +Parser::ParsePragmaOmpSectionDirective() { + SourceLocation SectionLoc; + + if (!ParsePragmaOmpNonListDirective(SectionLoc)) + return StmtError(); + + return StmtEmpty(); +} + +/// ParsePragmaOmpFlushDirective - Read 'OpenMP pragma flush directive'. +/// flush-directive: +/// # pragma omp flush flush-vars[opt] new-line +/// +/// flush-vars: +/// ( variable-list ) +StmtResult +Parser::ParsePragmaOmpFlushDirective() { + SourceLocation FlushLoc; + SourceLocation LParenLoc; + SourceLocation RParenLoc; + ExprVector DeclRefExprs; + + if (!ParsePragmaOmpListDirective(FlushLoc, LParenLoc, RParenLoc, + DeclRefExprs, true/*=OptVarList*/)) + return StmtError(); + + return StmtEmpty(); +} + +/// ParsePragmaOmpThreadPrivateDirective - Read 'OpenMP pragma threadprivate +/// directive'. +/// threadprivate-directive: +/// # pragma omp threadprivate ( variable-list ) new-line +StmtResult +Parser::ParsePragmaOmpThreadPrivateDirective() { + SourceLocation ThreadPrivateLoc; + SourceLocation LParenLoc; + SourceLocation RParenLoc; + ExprVector DeclRefExprs; + + if (!ParsePragmaOmpListDirective(ThreadPrivateLoc, LParenLoc, RParenLoc, + DeclRefExprs)) + return StmtError(); + + return StmtEmpty(); +} + +/// ParsePragmaOmpNonListDirective - Parse OpenMP pragma directive where the +/// presence of variable decl expression list is *not* valid +bool Parser::ParsePragmaOmpNonListDirective(SourceLocation &DirectiveLoc) { + // Record OpenMP pragma directive's source location information, and consume + // it. + DirectiveLoc = ConsumeToken(); + + // Current token must be an end of pragma directive line token. Check for it. + if (Tok.isNot(tok::eod)) { + // FIXME: Report diagnostic message. + SkipUntil(tok::semi); + return false; + } + + // Consume the "eod" token. + ConsumeToken(); + + return true; +} + +/// ParsePragmaOmpListDirective - Parse OpenMP pragma directive where the +/// presence of variable decl expression list is valid. +bool Parser::ParsePragmaOmpListDirective(SourceLocation &DirectiveLoc, + SourceLocation &LParenLoc, + SourceLocation &RParenLoc, + ExprVector &DeclRefExprs, + bool OptVarList) { + // Record OpenMP pragma directive's source location information, and consume + // it. + DirectiveLoc = ConsumeToken(); + + if (OptVarList) { + // Current token must be either "eod" token in the absence of var list, or + // a left paranthesis token in the presence of var list. + if (Tok.isNot(tok::eod) && Tok.isNot(tok::l_paren)) { + // FIXME: Report diagnostic message. + SkipUntil(tok::semi); + return false; + } + if (Tok.is(tok::eod)) { + // Consume the "eod" token, and return. + ConsumeToken(); + return true; + } + } else { + // Current token must be a left paranthesis token. + if (Tok.isNot(tok::l_paren)) { + // FIXME: Diag(Tok, diag::err_expected_lparen_after) << ""; + SkipUntil(tok::semi); + return false; + } + } + + // Parse the comma seperated parenthesized decl ref variable expressions list. + if (!ParsePragmaOmpClauseVariableExpressions(DeclRefExprs, LParenLoc, + RParenLoc)) + return false; + + // Current token must be an end of pragma directive line token. Check for it. + if (Tok.isNot(tok::eod)) { + // FIXME: Report diagnostic message. + SkipUntil(tok::semi); + return false; + } + + // Consume the "eod" token. + ConsumeToken(); + + return true; +} + +/// ParsePragmaOmpClauseVariableExpressions - Parse OpenMP pragma clause +/// variable expression list. +/// This *overloaded* function assumes that the current token is "left +/// paranthesis" and it handles left paranthesis. +bool Parser::ParsePragmaOmpClauseVariableExpressions( + ExprVector &DeclRefExprs, + SourceLocation &LParenLoc, + SourceLocation &RParenLoc) { + // Record the source location information for left paranthesis, and consume + // it. + LParenLoc = ConsumeParen(); + + // Parse all the comma separated parenthesized decl ref variable expressions + // in the list. + return ParsePragmaOmpClauseVariableExpressions(DeclRefExprs, RParenLoc); +} + +// ParsePragmaOmpClauseVariableExpressions - Parse OpenMP pragma clause +// variable expression list. +// This *overloaded* function assumes that the "left paranthesis" token +// is already handled by the caller routine. +bool Parser::ParsePragmaOmpClauseVariableExpressions( + ExprVector &DeclRefExprs, + SourceLocation &RParenLoc) { + // Parse all the comma separated decl ref variable expressions in the list. + do { + // Next decl ref named variable expression is found. + if (Tok.is(tok::identifier)) { + // FIXME: Anything missed. + ExprResult E = ParseCastExpression(false); + DeclRefExprs.push_back(E.release()); + // Syntax error. Variable name expected. + } else { + // FIXME: syntax error, Variable name expected. + return false; + } + + // Next token must be either "right paranthesis" token or "comma" token. + // Check for it. + if (Tok.isNot(tok::r_paren)) { + // Current token must be "comma". Check for it. + if (Tok.isNot(tok::comma)) { + // FIXME: Report syntax error. + return false; + } else { + // Token "comma" is found, consume it. + ConsumeToken(); + } + } else { + // We have reached the end of the list. Consume the right parenthesis + // token, and record its source location information. + RParenLoc = ConsumeParen(); + return true; + } + } while (1); +} Index: test/Parser/openmp_constructs_without_clauses.c =================================================================== --- test/Parser/openmp_constructs_without_clauses.c (revision 0) +++ test/Parser/openmp_constructs_without_clauses.c (revision 0) @@ -0,0 +1,129 @@ +// OpenMP syntax validation test for simple, legal, +// basic cases which contains *no* clauses. +// No error messages are expected for these cases. + + +// RUN: %clang_cc1 -fsyntax-only -verify -fopenmp %s + + +// expected-no-diagnostics + + +#define LEN 6 + + +// \#pragma omp parallel ... +void omp_parallel_test() { + #pragma omp parallel + { + } +} + +// \#pragam omp for ... +void omp_for_test() { + int i; + #pragma omp parallel + { + #pragma omp for + for (i=0; i