OmpParser.java
package edu.udel.cis.vsl.abc.front.c.parse;
import edu.udel.cis.vsl.abc.front.IF.RuntimeParseException;
import edu.udel.cis.vsl.abc.front.c.preproc.*;
// $ANTLR 3.5.2 OmpParser.g 2023-02-11 20:42:09
import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import org.antlr.runtime.tree.*;
@SuppressWarnings("all")
public class OmpParser extends Parser {
public static final String[] tokenNames = new String[] {
"<invalid>", "<EOR>", "<DOWN>", "<UP>", "AMPERSAND", "AND", "ANNOTATION_END",
"ANNOTATION_START", "ARROW", "ASSIGN", "AT", "BITANDEQ", "BITOR", "BITOREQ",
"BITXOR", "BITXOREQ", "BLOCK_COMMENT", "BinaryExponentPart", "CChar",
"CHARACTER_CONSTANT", "COLON", "COMMA", "COMMENT", "DEFINE", "DEFINED",
"DIV", "DIVEQ", "DOT", "DOTDOT", "DecimalConstant", "DecimalFloatingConstant",
"Digit", "ELIF", "ELLIPSIS", "ELSE", "ENDIF", "EQUALS", "EQUIV_ACSL",
"ERROR", "EXTENDED_IDENTIFIER", "EscapeSequence", "ExponentPart", "FLOATING_CONSTANT",
"FloatingSuffix", "FractionalConstant", "GT", "GTE", "HASH", "HASHHASH",
"HexEscape", "HexFractionalConstant", "HexPrefix", "HexQuad", "HexadecimalConstant",
"HexadecimalDigit", "HexadecimalFloatingConstant", "IDENTIFIER", "IF",
"IFDEF", "IFNDEF", "IMPLIES", "IMPLIES_ACSL", "INCLUDE", "INLINE_ANNOTATION_START",
"INLINE_COMMENT", "INTEGER_CONSTANT", "IdentifierNonDigit", "IntegerSuffix",
"LCURLY", "LEXCON", "LINE", "LPAREN", "LSLIST", "LSQUARE", "LT", "LTE",
"LongLongSuffix", "LongSuffix", "MINUSMINUS", "MOD", "MODEQ", "NEQ", "NEWLINE",
"NOT", "NonDigit", "NonZeroDigit", "OR", "OTHER", "OctalConstant", "OctalDigit",
"OctalEscape", "PLUS", "PLUSEQ", "PLUSPLUS", "PP_NUMBER", "PRAGMA", "QMARK",
"RCURLY", "REXCON", "RPAREN", "RSLIST", "RSQUARE", "SChar", "SEMI", "SHIFTLEFT",
"SHIFTLEFTEQ", "SHIFTRIGHT", "SHIFTRIGHTEQ", "STAR", "STAREQ", "STRING_LITERAL",
"SUB", "SUBEQ", "TILDE", "UNDEF", "UniversalCharacterName", "UnsignedSuffix",
"WS", "XOR_ACSL", "Zero", "ABSTRACT", "ALIGNAS", "ALIGNOF", "ASM", "ASSIGNS",
"ATOMIC", "AUTO", "BIG_O", "BODY", "BOOL", "BREAK", "CALLS", "CASE", "CATCH",
"CHAR", "CHOOSE", "CIVLATOMIC", "CIVLFOR", "COLLECTIVE", "COMPLEX", "CONST",
"CONTIN", "CONTINUE", "DEFAULT", "DEPENDS", "DERIV", "DEVICE", "DIFFERENTIABLE",
"DO", "DOMAIN", "DOUBLE", "ENSURES", "ENUM", "EXISTS", "EXPR", "EXTERN",
"FATOMIC", "FILE", "FLOAT", "FOR", "FORALL", "GENERIC", "GLOBAL", "GOTO",
"GUARD", "HERE", "IMAGINARY", "INLINE", "INPUT", "INT", "INVARIANT", "LAMBDA",
"LONG", "MEM_TYPE", "NORETURN", "ORIGINAL", "OUTPUT", "PARAMLIST", "PARFOR",
"PELSE", "PIF", "PPRAGMA", "PROCNULL", "PURE", "RANGE", "READS", "REAL",
"REGISTER", "REQUIRES", "RESTRICT", "RESULT", "RETURN", "RUN", "SCOPEOF",
"SELF", "SEQUENCE", "SHARED", "SHORT", "SIGNED", "SIZEOF", "SPAWN", "STATE_F",
"STATE_NULL", "STATIC", "STATICASSERT", "STRUCT", "SWITCH", "SYSTEM",
"TEXT_BLOCK", "THREADLOCAL", "TYPEDEF", "TYPEOF", "UNIFORM", "UNION",
"UNSIGNED", "UPDATE", "VALUE_AT", "VOID", "VOLATILE", "WHEN", "WHILE",
"WITH", "ABSENT", "ABSTRACT_DECLARATOR", "ANNOTATION", "ARGUMENT_LIST",
"ARRAY_ELEMENT_DESIGNATOR", "ARRAY_SUFFIX", "BLOCK_ITEM_LIST", "BOUND_VARIABLE_DECLARATION",
"BOUND_VARIABLE_DECLARATION_LIST", "BOUND_VARIABLE_NAME_LIST", "BOUND_VARIABLE_RANGE",
"BOUND_VARIABLE_RANGE_LIST", "CALL", "CASE_LABELED_STATEMENT", "CAST",
"COMPOUND_LITERAL", "COMPOUND_STATEMENT", "CONTRACT", "DECLARATION", "DECLARATION_LIST",
"DECLARATION_SPECIFIERS", "DECLARATOR", "DEFAULT_LABELED_STATEMENT", "DERIVATIVE_EXPRESSION",
"DESIGNATED_INITIALIZER", "DESIGNATION", "DIRECT_ABSTRACT_DECLARATOR",
"DIRECT_DECLARATOR", "ENUMERATION_CONSTANT", "ENUMERATOR", "ENUMERATOR_LIST",
"EXPRESSION_STATEMENT", "FIELD_DESIGNATOR", "FUNCTION_DEFINITION", "FUNCTION_SUFFIX",
"GENERIC_ASSOCIATION", "GENERIC_ASSOC_LIST", "IDENTIFIER_LABELED_STATEMENT",
"IDENTIFIER_LIST", "INDEX", "INITIALIZER_LIST", "INIT_DECLARATOR", "INIT_DECLARATOR_LIST",
"INTERVAL", "INTERVAL_SEQ", "LIB_NAME", "OPERATOR", "PARAMETER_DECLARATION",
"PARAMETER_LIST", "PARAMETER_TYPE_LIST", "PARENTHESIZED_EXPRESSION", "PARTIAL",
"PARTIAL_LIST", "POINTER", "POST_DECREMENT", "POST_INCREMENT", "PRE_DECREMENT",
"PRE_INCREMENT", "PROGRAM", "QUANTIFIED", "SCALAR_INITIALIZER", "SPECIFIER_QUALIFIER_LIST",
"STATEMENT", "STATEMENT_EXPRESSION", "STRUCT_DECLARATION", "STRUCT_DECLARATION_LIST",
"STRUCT_DECLARATOR", "STRUCT_DECLARATOR_LIST", "TOKEN_LIST", "TRANSLATION_UNIT",
"TYPE", "TYPEDEF_NAME", "TYPEOF_EXPRESSION", "TYPEOF_TYPE", "TYPE_NAME",
"TYPE_QUALIFIER_LIST", "BARRIER", "CAPTURE", "COLLAPSE", "COPYIN", "COPYPRIVATE",
"CRITICAL", "DYNAMIC", "FLUSH", "FST_PRIVATE", "GUIDED", "LST_PRIVATE",
"MASTER", "NONE", "NOWAIT", "NUM_THREADS", "OMPATOMIC", "ORDERED", "PARALLEL",
"PRIVATE", "READ", "REDUCTION", "RUNTIME", "SAFELEN", "SCHEDULE", "SECTION",
"SECTIONS", "SEQ_CST", "SIMD", "SIMDLEN", "SINGLE", "THD_PRIVATE", "WRITE",
"DATA_CLAUSE", "FOR_CLAUSE", "PARALLEL_FOR", "PARALLEL_SECTIONS", "UNIQUE_FOR",
"UNIQUE_PARALLEL", "558", "559", "560", "561", "562", "563", "564", "565"
};
public static final int EOF=-1;
public static final int AMPERSAND=4;
public static final int AND=5;
public static final int ANNOTATION_END=6;
public static final int ANNOTATION_START=7;
public static final int ARROW=8;
public static final int ASSIGN=9;
public static final int AT=10;
public static final int BITANDEQ=11;
public static final int BITOR=12;
public static final int BITOREQ=13;
public static final int BITXOR=14;
public static final int BITXOREQ=15;
public static final int BLOCK_COMMENT=16;
public static final int BinaryExponentPart=17;
public static final int CChar=18;
public static final int CHARACTER_CONSTANT=19;
public static final int COLON=20;
public static final int COMMA=21;
public static final int COMMENT=22;
public static final int DEFINE=23;
public static final int DEFINED=24;
public static final int DIV=25;
public static final int DIVEQ=26;
public static final int DOT=27;
public static final int DOTDOT=28;
public static final int DecimalConstant=29;
public static final int DecimalFloatingConstant=30;
public static final int Digit=31;
public static final int ELIF=32;
public static final int ELLIPSIS=33;
public static final int ELSE=34;
public static final int ENDIF=35;
public static final int EQUALS=36;
public static final int EQUIV_ACSL=37;
public static final int ERROR=38;
public static final int EXTENDED_IDENTIFIER=39;
public static final int EscapeSequence=40;
public static final int ExponentPart=41;
public static final int FLOATING_CONSTANT=42;
public static final int FloatingSuffix=43;
public static final int FractionalConstant=44;
public static final int GT=45;
public static final int GTE=46;
public static final int HASH=47;
public static final int HASHHASH=48;
public static final int HexEscape=49;
public static final int HexFractionalConstant=50;
public static final int HexPrefix=51;
public static final int HexQuad=52;
public static final int HexadecimalConstant=53;
public static final int HexadecimalDigit=54;
public static final int HexadecimalFloatingConstant=55;
public static final int IDENTIFIER=56;
public static final int IF=57;
public static final int IFDEF=58;
public static final int IFNDEF=59;
public static final int IMPLIES=60;
public static final int IMPLIES_ACSL=61;
public static final int INCLUDE=62;
public static final int INLINE_ANNOTATION_START=63;
public static final int INLINE_COMMENT=64;
public static final int INTEGER_CONSTANT=65;
public static final int IdentifierNonDigit=66;
public static final int IntegerSuffix=67;
public static final int LCURLY=68;
public static final int LEXCON=69;
public static final int LINE=70;
public static final int LPAREN=71;
public static final int LSLIST=72;
public static final int LSQUARE=73;
public static final int LT=74;
public static final int LTE=75;
public static final int LongLongSuffix=76;
public static final int LongSuffix=77;
public static final int MINUSMINUS=78;
public static final int MOD=79;
public static final int MODEQ=80;
public static final int NEQ=81;
public static final int NEWLINE=82;
public static final int NOT=83;
public static final int NonDigit=84;
public static final int NonZeroDigit=85;
public static final int OR=86;
public static final int OTHER=87;
public static final int OctalConstant=88;
public static final int OctalDigit=89;
public static final int OctalEscape=90;
public static final int PLUS=91;
public static final int PLUSEQ=92;
public static final int PLUSPLUS=93;
public static final int PP_NUMBER=94;
public static final int PRAGMA=95;
public static final int QMARK=96;
public static final int RCURLY=97;
public static final int REXCON=98;
public static final int RPAREN=99;
public static final int RSLIST=100;
public static final int RSQUARE=101;
public static final int SChar=102;
public static final int SEMI=103;
public static final int SHIFTLEFT=104;
public static final int SHIFTLEFTEQ=105;
public static final int SHIFTRIGHT=106;
public static final int SHIFTRIGHTEQ=107;
public static final int STAR=108;
public static final int STAREQ=109;
public static final int STRING_LITERAL=110;
public static final int SUB=111;
public static final int SUBEQ=112;
public static final int TILDE=113;
public static final int UNDEF=114;
public static final int UniversalCharacterName=115;
public static final int UnsignedSuffix=116;
public static final int WS=117;
public static final int XOR_ACSL=118;
public static final int Zero=119;
public static final int ABSTRACT=120;
public static final int ALIGNAS=121;
public static final int ALIGNOF=122;
public static final int ASM=123;
public static final int ASSIGNS=124;
public static final int ATOMIC=125;
public static final int AUTO=126;
public static final int BIG_O=127;
public static final int BODY=128;
public static final int BOOL=129;
public static final int BREAK=130;
public static final int CALLS=131;
public static final int CASE=132;
public static final int CATCH=133;
public static final int CHAR=134;
public static final int CHOOSE=135;
public static final int CIVLATOMIC=136;
public static final int CIVLFOR=137;
public static final int COLLECTIVE=138;
public static final int COMPLEX=139;
public static final int CONST=140;
public static final int CONTIN=141;
public static final int CONTINUE=142;
public static final int DEFAULT=143;
public static final int DEPENDS=144;
public static final int DERIV=145;
public static final int DEVICE=146;
public static final int DIFFERENTIABLE=147;
public static final int DO=148;
public static final int DOMAIN=149;
public static final int DOUBLE=150;
public static final int ENSURES=151;
public static final int ENUM=152;
public static final int EXISTS=153;
public static final int EXPR=154;
public static final int EXTERN=155;
public static final int FATOMIC=156;
public static final int FILE=157;
public static final int FLOAT=158;
public static final int FOR=159;
public static final int FORALL=160;
public static final int GENERIC=161;
public static final int GLOBAL=162;
public static final int GOTO=163;
public static final int GUARD=164;
public static final int HERE=165;
public static final int IMAGINARY=166;
public static final int INLINE=167;
public static final int INPUT=168;
public static final int INT=169;
public static final int INVARIANT=170;
public static final int LAMBDA=171;
public static final int LONG=172;
public static final int MEM_TYPE=173;
public static final int NORETURN=174;
public static final int ORIGINAL=175;
public static final int OUTPUT=176;
public static final int PARAMLIST=177;
public static final int PARFOR=178;
public static final int PELSE=179;
public static final int PIF=180;
public static final int PPRAGMA=181;
public static final int PROCNULL=182;
public static final int PURE=183;
public static final int RANGE=184;
public static final int READS=185;
public static final int REAL=186;
public static final int REGISTER=187;
public static final int REQUIRES=188;
public static final int RESTRICT=189;
public static final int RESULT=190;
public static final int RETURN=191;
public static final int RUN=192;
public static final int SCOPEOF=193;
public static final int SELF=194;
public static final int SEQUENCE=195;
public static final int SHARED=196;
public static final int SHORT=197;
public static final int SIGNED=198;
public static final int SIZEOF=199;
public static final int SPAWN=200;
public static final int STATE_F=201;
public static final int STATE_NULL=202;
public static final int STATIC=203;
public static final int STATICASSERT=204;
public static final int STRUCT=205;
public static final int SWITCH=206;
public static final int SYSTEM=207;
public static final int TEXT_BLOCK=208;
public static final int THREADLOCAL=209;
public static final int TYPEDEF=210;
public static final int TYPEOF=211;
public static final int UNIFORM=212;
public static final int UNION=213;
public static final int UNSIGNED=214;
public static final int UPDATE=215;
public static final int VALUE_AT=216;
public static final int VOID=217;
public static final int VOLATILE=218;
public static final int WHEN=219;
public static final int WHILE=220;
public static final int WITH=221;
public static final int ABSENT=222;
public static final int ABSTRACT_DECLARATOR=223;
public static final int ANNOTATION=224;
public static final int ARGUMENT_LIST=225;
public static final int ARRAY_ELEMENT_DESIGNATOR=226;
public static final int ARRAY_SUFFIX=227;
public static final int BLOCK_ITEM_LIST=228;
public static final int BOUND_VARIABLE_DECLARATION=229;
public static final int BOUND_VARIABLE_DECLARATION_LIST=230;
public static final int BOUND_VARIABLE_NAME_LIST=231;
public static final int BOUND_VARIABLE_RANGE=232;
public static final int BOUND_VARIABLE_RANGE_LIST=233;
public static final int CALL=234;
public static final int CASE_LABELED_STATEMENT=235;
public static final int CAST=236;
public static final int COMPOUND_LITERAL=237;
public static final int COMPOUND_STATEMENT=238;
public static final int CONTRACT=239;
public static final int DECLARATION=240;
public static final int DECLARATION_LIST=241;
public static final int DECLARATION_SPECIFIERS=242;
public static final int DECLARATOR=243;
public static final int DEFAULT_LABELED_STATEMENT=244;
public static final int DERIVATIVE_EXPRESSION=245;
public static final int DESIGNATED_INITIALIZER=246;
public static final int DESIGNATION=247;
public static final int DIRECT_ABSTRACT_DECLARATOR=248;
public static final int DIRECT_DECLARATOR=249;
public static final int ENUMERATION_CONSTANT=250;
public static final int ENUMERATOR=251;
public static final int ENUMERATOR_LIST=252;
public static final int EXPRESSION_STATEMENT=253;
public static final int FIELD_DESIGNATOR=254;
public static final int FUNCTION_DEFINITION=255;
public static final int FUNCTION_SUFFIX=256;
public static final int GENERIC_ASSOCIATION=257;
public static final int GENERIC_ASSOC_LIST=258;
public static final int IDENTIFIER_LABELED_STATEMENT=259;
public static final int IDENTIFIER_LIST=260;
public static final int INDEX=261;
public static final int INITIALIZER_LIST=262;
public static final int INIT_DECLARATOR=263;
public static final int INIT_DECLARATOR_LIST=264;
public static final int INTERVAL=265;
public static final int INTERVAL_SEQ=266;
public static final int LIB_NAME=267;
public static final int OPERATOR=268;
public static final int PARAMETER_DECLARATION=269;
public static final int PARAMETER_LIST=270;
public static final int PARAMETER_TYPE_LIST=271;
public static final int PARENTHESIZED_EXPRESSION=272;
public static final int PARTIAL=273;
public static final int PARTIAL_LIST=274;
public static final int POINTER=275;
public static final int POST_DECREMENT=276;
public static final int POST_INCREMENT=277;
public static final int PRE_DECREMENT=278;
public static final int PRE_INCREMENT=279;
public static final int PROGRAM=280;
public static final int QUANTIFIED=281;
public static final int SCALAR_INITIALIZER=282;
public static final int SPECIFIER_QUALIFIER_LIST=283;
public static final int STATEMENT=284;
public static final int STATEMENT_EXPRESSION=285;
public static final int STRUCT_DECLARATION=286;
public static final int STRUCT_DECLARATION_LIST=287;
public static final int STRUCT_DECLARATOR=288;
public static final int STRUCT_DECLARATOR_LIST=289;
public static final int TOKEN_LIST=290;
public static final int TRANSLATION_UNIT=291;
public static final int TYPE=292;
public static final int TYPEDEF_NAME=293;
public static final int TYPEOF_EXPRESSION=294;
public static final int TYPEOF_TYPE=295;
public static final int TYPE_NAME=296;
public static final int TYPE_QUALIFIER_LIST=297;
public static final int BARRIER=298;
public static final int CAPTURE=299;
public static final int COLLAPSE=300;
public static final int COPYIN=301;
public static final int COPYPRIVATE=302;
public static final int CRITICAL=303;
public static final int DYNAMIC=304;
public static final int FLUSH=305;
public static final int FST_PRIVATE=306;
public static final int GUIDED=307;
public static final int LST_PRIVATE=308;
public static final int MASTER=309;
public static final int NONE=310;
public static final int NOWAIT=311;
public static final int NUM_THREADS=312;
public static final int OMPATOMIC=313;
public static final int ORDERED=314;
public static final int PARALLEL=315;
public static final int PRIVATE=316;
public static final int READ=317;
public static final int REDUCTION=318;
public static final int RUNTIME=319;
public static final int SAFELEN=320;
public static final int SCHEDULE=321;
public static final int SECTION=322;
public static final int SECTIONS=323;
public static final int SEQ_CST=324;
public static final int SIMD=325;
public static final int SIMDLEN=326;
public static final int SINGLE=327;
public static final int THD_PRIVATE=328;
public static final int WRITE=329;
public static final int DATA_CLAUSE=383;
public static final int FOR_CLAUSE=424;
public static final int PARALLEL_FOR=474;
public static final int PARALLEL_SECTIONS=475;
public static final int UNIQUE_FOR=556;
public static final int UNIQUE_PARALLEL=557;
// delegates
public OmpParser_CivlCParser gCivlCParser;
public Parser[] getDelegates() {
return new Parser[] {gCivlCParser};
}
// delegators
public OmpParser(TokenStream input) {
this(input, new RecognizerSharedState());
}
public OmpParser(TokenStream input, RecognizerSharedState state) {
super(input, state);
gCivlCParser = new OmpParser_CivlCParser(input, state, this);
}
protected TreeAdaptor adaptor = new CommonTreeAdaptor();
public void setTreeAdaptor(TreeAdaptor adaptor) {
this.adaptor = adaptor;
gCivlCParser.setTreeAdaptor(this.adaptor);
}
public TreeAdaptor getTreeAdaptor() {
return adaptor;
}
@Override public String[] getTokenNames() { return OmpParser.tokenNames; }
@Override public String getGrammarFileName() { return "OmpParser.g"; }
@Override
public void displayRecognitionError(String[] tokenNames, RecognitionException e) {
String hdr = getErrorHeader(e);
String msg = getErrorMessage(e, tokenNames);
throw new RuntimeParseException(hdr+" "+msg, e.token);
}
@Override
public void emitErrorMessage(String msg) { // don't try to recover!
throw new RuntimeParseException(msg);
}
public static class openmp_construct_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "openmp_construct"
// OmpParser.g:49:1: openmp_construct : ( parallel_for_directive | parallel_sections_directive | parallel_directive | for_directive | sections_directive | single_directive | simd_directive | master_directive | critical_directive | ordered_directive | section_directive | ompatomic_directive | barrier_directive | flush_directive | threadprivate_directive );
public final OmpParser.openmp_construct_return openmp_construct() throws RecognitionException {
OmpParser.openmp_construct_return retval = new OmpParser.openmp_construct_return();
retval.start = input.LT(1);
Object root_0 = null;
ParserRuleReturnScope parallel_for_directive1 =null;
ParserRuleReturnScope parallel_sections_directive2 =null;
ParserRuleReturnScope parallel_directive3 =null;
ParserRuleReturnScope for_directive4 =null;
ParserRuleReturnScope sections_directive5 =null;
ParserRuleReturnScope single_directive6 =null;
ParserRuleReturnScope simd_directive7 =null;
ParserRuleReturnScope master_directive8 =null;
ParserRuleReturnScope critical_directive9 =null;
ParserRuleReturnScope ordered_directive10 =null;
ParserRuleReturnScope section_directive11 =null;
ParserRuleReturnScope ompatomic_directive12 =null;
ParserRuleReturnScope barrier_directive13 =null;
ParserRuleReturnScope flush_directive14 =null;
ParserRuleReturnScope threadprivate_directive15 =null;
try {
// OmpParser.g:50:3: ( parallel_for_directive | parallel_sections_directive | parallel_directive | for_directive | sections_directive | single_directive | simd_directive | master_directive | critical_directive | ordered_directive | section_directive | ompatomic_directive | barrier_directive | flush_directive | threadprivate_directive )
int alt1=15;
switch ( input.LA(1) ) {
case PARALLEL:
{
switch ( input.LA(2) ) {
case FOR:
{
alt1=1;
}
break;
case SECTIONS:
{
alt1=2;
}
break;
case EOF:
case IF:
case DEFAULT:
case SHARED:
case COPYIN:
case COPYPRIVATE:
case FST_PRIVATE:
case LST_PRIVATE:
case NUM_THREADS:
case PRIVATE:
case REDUCTION:
{
alt1=3;
}
break;
default:
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 1, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case FOR:
{
alt1=4;
}
break;
case SECTIONS:
{
alt1=5;
}
break;
case SINGLE:
{
alt1=6;
}
break;
case SIMD:
{
alt1=7;
}
break;
case MASTER:
{
alt1=8;
}
break;
case CRITICAL:
{
alt1=9;
}
break;
case ORDERED:
{
alt1=10;
}
break;
case SECTION:
{
alt1=11;
}
break;
case OMPATOMIC:
{
alt1=12;
}
break;
case BARRIER:
{
alt1=13;
}
break;
case FLUSH:
{
alt1=14;
}
break;
case THD_PRIVATE:
{
alt1=15;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 1, 0, input);
throw nvae;
}
switch (alt1) {
case 1 :
// OmpParser.g:51:5: parallel_for_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_parallel_for_directive_in_openmp_construct96);
parallel_for_directive1=parallel_for_directive();
state._fsp--;
adaptor.addChild(root_0, parallel_for_directive1.getTree());
}
break;
case 2 :
// OmpParser.g:52:5: parallel_sections_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_parallel_sections_directive_in_openmp_construct102);
parallel_sections_directive2=parallel_sections_directive();
state._fsp--;
adaptor.addChild(root_0, parallel_sections_directive2.getTree());
}
break;
case 3 :
// OmpParser.g:53:5: parallel_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_parallel_directive_in_openmp_construct108);
parallel_directive3=parallel_directive();
state._fsp--;
adaptor.addChild(root_0, parallel_directive3.getTree());
}
break;
case 4 :
// OmpParser.g:54:5: for_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_for_directive_in_openmp_construct114);
for_directive4=for_directive();
state._fsp--;
adaptor.addChild(root_0, for_directive4.getTree());
}
break;
case 5 :
// OmpParser.g:55:5: sections_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_sections_directive_in_openmp_construct120);
sections_directive5=sections_directive();
state._fsp--;
adaptor.addChild(root_0, sections_directive5.getTree());
}
break;
case 6 :
// OmpParser.g:56:5: single_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_single_directive_in_openmp_construct126);
single_directive6=single_directive();
state._fsp--;
adaptor.addChild(root_0, single_directive6.getTree());
}
break;
case 7 :
// OmpParser.g:57:5: simd_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_simd_directive_in_openmp_construct132);
simd_directive7=simd_directive();
state._fsp--;
adaptor.addChild(root_0, simd_directive7.getTree());
}
break;
case 8 :
// OmpParser.g:58:5: master_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_master_directive_in_openmp_construct138);
master_directive8=master_directive();
state._fsp--;
adaptor.addChild(root_0, master_directive8.getTree());
}
break;
case 9 :
// OmpParser.g:59:5: critical_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_critical_directive_in_openmp_construct144);
critical_directive9=critical_directive();
state._fsp--;
adaptor.addChild(root_0, critical_directive9.getTree());
}
break;
case 10 :
// OmpParser.g:60:5: ordered_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_ordered_directive_in_openmp_construct150);
ordered_directive10=ordered_directive();
state._fsp--;
adaptor.addChild(root_0, ordered_directive10.getTree());
}
break;
case 11 :
// OmpParser.g:61:5: section_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_section_directive_in_openmp_construct156);
section_directive11=section_directive();
state._fsp--;
adaptor.addChild(root_0, section_directive11.getTree());
}
break;
case 12 :
// OmpParser.g:62:5: ompatomic_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_ompatomic_directive_in_openmp_construct162);
ompatomic_directive12=ompatomic_directive();
state._fsp--;
adaptor.addChild(root_0, ompatomic_directive12.getTree());
}
break;
case 13 :
// OmpParser.g:63:5: barrier_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_barrier_directive_in_openmp_construct168);
barrier_directive13=barrier_directive();
state._fsp--;
adaptor.addChild(root_0, barrier_directive13.getTree());
}
break;
case 14 :
// OmpParser.g:64:5: flush_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_flush_directive_in_openmp_construct174);
flush_directive14=flush_directive();
state._fsp--;
adaptor.addChild(root_0, flush_directive14.getTree());
}
break;
case 15 :
// OmpParser.g:65:5: threadprivate_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_threadprivate_directive_in_openmp_construct180);
threadprivate_directive15=threadprivate_directive();
state._fsp--;
adaptor.addChild(root_0, threadprivate_directive15.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "openmp_construct"
public static class parallel_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "parallel_directive"
// OmpParser.g:68:1: parallel_directive : PARALLEL (p+= parallel_clause )* -> ^( PARALLEL ( $p)* ) ;
public final OmpParser.parallel_directive_return parallel_directive() throws RecognitionException {
OmpParser.parallel_directive_return retval = new OmpParser.parallel_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token PARALLEL16=null;
List<Object> list_p=null;
RuleReturnScope p = null;
Object PARALLEL16_tree=null;
RewriteRuleTokenStream stream_PARALLEL=new RewriteRuleTokenStream(adaptor,"token PARALLEL");
RewriteRuleSubtreeStream stream_parallel_clause=new RewriteRuleSubtreeStream(adaptor,"rule parallel_clause");
try {
// OmpParser.g:69:3: ( PARALLEL (p+= parallel_clause )* -> ^( PARALLEL ( $p)* ) )
// OmpParser.g:69:5: PARALLEL (p+= parallel_clause )*
{
PARALLEL16=(Token)match(input,PARALLEL,FOLLOW_PARALLEL_in_parallel_directive193);
stream_PARALLEL.add(PARALLEL16);
// OmpParser.g:69:15: (p+= parallel_clause )*
loop2:
while (true) {
int alt2=2;
int LA2_0 = input.LA(1);
if ( (LA2_0==IF||LA2_0==DEFAULT||LA2_0==SHARED||(LA2_0 >= COPYIN && LA2_0 <= COPYPRIVATE)||LA2_0==FST_PRIVATE||LA2_0==LST_PRIVATE||LA2_0==NUM_THREADS||LA2_0==PRIVATE||LA2_0==REDUCTION) ) {
alt2=1;
}
switch (alt2) {
case 1 :
// OmpParser.g:69:16: p+= parallel_clause
{
pushFollow(FOLLOW_parallel_clause_in_parallel_directive199);
p=parallel_clause();
state._fsp--;
stream_parallel_clause.add(p.getTree());
if (list_p==null) list_p=new ArrayList<Object>();
list_p.add(p.getTree());
}
break;
default :
break loop2;
}
}
// AST REWRITE
// elements: p, PARALLEL
// token labels:
// rule labels: retval
// token list labels:
// rule list labels: p
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
RewriteRuleSubtreeStream stream_p=new RewriteRuleSubtreeStream(adaptor,"token p",list_p);
root_0 = (Object)adaptor.nil();
// 70:3: -> ^( PARALLEL ( $p)* )
{
// OmpParser.g:70:6: ^( PARALLEL ( $p)* )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_PARALLEL.nextNode(), root_1);
// OmpParser.g:70:18: ( $p)*
while ( stream_p.hasNext() ) {
adaptor.addChild(root_1, stream_p.nextTree());
}
stream_p.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "parallel_directive"
public static class parallel_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "parallel_clause"
// OmpParser.g:73:1: parallel_clause : ( unique_parallel_clause | data_clause );
public final OmpParser.parallel_clause_return parallel_clause() throws RecognitionException {
OmpParser.parallel_clause_return retval = new OmpParser.parallel_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
ParserRuleReturnScope unique_parallel_clause17 =null;
ParserRuleReturnScope data_clause18 =null;
try {
// OmpParser.g:74:3: ( unique_parallel_clause | data_clause )
int alt3=2;
int LA3_0 = input.LA(1);
if ( (LA3_0==IF||LA3_0==NUM_THREADS) ) {
alt3=1;
}
else if ( (LA3_0==DEFAULT||LA3_0==SHARED||(LA3_0 >= COPYIN && LA3_0 <= COPYPRIVATE)||LA3_0==FST_PRIVATE||LA3_0==LST_PRIVATE||LA3_0==PRIVATE||LA3_0==REDUCTION) ) {
alt3=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 3, 0, input);
throw nvae;
}
switch (alt3) {
case 1 :
// OmpParser.g:74:5: unique_parallel_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_unique_parallel_clause_in_parallel_clause226);
unique_parallel_clause17=unique_parallel_clause();
state._fsp--;
adaptor.addChild(root_0, unique_parallel_clause17.getTree());
}
break;
case 2 :
// OmpParser.g:75:5: data_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_data_clause_in_parallel_clause232);
data_clause18=data_clause();
state._fsp--;
adaptor.addChild(root_0, data_clause18.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "parallel_clause"
public static class master_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "master_directive"
// OmpParser.g:78:1: master_directive : MASTER -> ^( MASTER ) ;
public final OmpParser.master_directive_return master_directive() throws RecognitionException {
OmpParser.master_directive_return retval = new OmpParser.master_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token MASTER19=null;
Object MASTER19_tree=null;
RewriteRuleTokenStream stream_MASTER=new RewriteRuleTokenStream(adaptor,"token MASTER");
try {
// OmpParser.g:79:3: ( MASTER -> ^( MASTER ) )
// OmpParser.g:79:5: MASTER
{
MASTER19=(Token)match(input,MASTER,FOLLOW_MASTER_in_master_directive247);
stream_MASTER.add(MASTER19);
// AST REWRITE
// elements: MASTER
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 79:12: -> ^( MASTER )
{
// OmpParser.g:79:15: ^( MASTER )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_MASTER.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "master_directive"
public static class critical_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "critical_directive"
// OmpParser.g:82:1: critical_directive : CRITICAL ( LPAREN id= IDENTIFIER RPAREN )? -> ^( CRITICAL ( $id)? ) ;
public final OmpParser.critical_directive_return critical_directive() throws RecognitionException {
OmpParser.critical_directive_return retval = new OmpParser.critical_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token id=null;
Token CRITICAL20=null;
Token LPAREN21=null;
Token RPAREN22=null;
Object id_tree=null;
Object CRITICAL20_tree=null;
Object LPAREN21_tree=null;
Object RPAREN22_tree=null;
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleTokenStream stream_CRITICAL=new RewriteRuleTokenStream(adaptor,"token CRITICAL");
try {
// OmpParser.g:83:3: ( CRITICAL ( LPAREN id= IDENTIFIER RPAREN )? -> ^( CRITICAL ( $id)? ) )
// OmpParser.g:83:5: CRITICAL ( LPAREN id= IDENTIFIER RPAREN )?
{
CRITICAL20=(Token)match(input,CRITICAL,FOLLOW_CRITICAL_in_critical_directive266);
stream_CRITICAL.add(CRITICAL20);
// OmpParser.g:83:15: ( LPAREN id= IDENTIFIER RPAREN )?
int alt4=2;
int LA4_0 = input.LA(1);
if ( (LA4_0==LPAREN) ) {
alt4=1;
}
switch (alt4) {
case 1 :
// OmpParser.g:83:16: LPAREN id= IDENTIFIER RPAREN
{
LPAREN21=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_critical_directive270);
stream_LPAREN.add(LPAREN21);
id=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_critical_directive275);
stream_IDENTIFIER.add(id);
RPAREN22=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_critical_directive278);
stream_RPAREN.add(RPAREN22);
}
break;
}
// AST REWRITE
// elements: CRITICAL, id
// token labels: id
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleTokenStream stream_id=new RewriteRuleTokenStream(adaptor,"token id",id);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 84:3: -> ^( CRITICAL ( $id)? )
{
// OmpParser.g:84:6: ^( CRITICAL ( $id)? )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_CRITICAL.nextNode(), root_1);
// OmpParser.g:84:18: ( $id)?
if ( stream_id.hasNext() ) {
adaptor.addChild(root_1, stream_id.nextNode());
}
stream_id.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "critical_directive"
public static class sections_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "sections_directive"
// OmpParser.g:87:1: sections_directive : SECTIONS (s+= sections_clause )* -> ^( SECTIONS ( $s)* ) ;
public final OmpParser.sections_directive_return sections_directive() throws RecognitionException {
OmpParser.sections_directive_return retval = new OmpParser.sections_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token SECTIONS23=null;
List<Object> list_s=null;
RuleReturnScope s = null;
Object SECTIONS23_tree=null;
RewriteRuleTokenStream stream_SECTIONS=new RewriteRuleTokenStream(adaptor,"token SECTIONS");
RewriteRuleSubtreeStream stream_sections_clause=new RewriteRuleSubtreeStream(adaptor,"rule sections_clause");
try {
// OmpParser.g:88:3: ( SECTIONS (s+= sections_clause )* -> ^( SECTIONS ( $s)* ) )
// OmpParser.g:88:5: SECTIONS (s+= sections_clause )*
{
SECTIONS23=(Token)match(input,SECTIONS,FOLLOW_SECTIONS_in_sections_directive307);
stream_SECTIONS.add(SECTIONS23);
// OmpParser.g:88:15: (s+= sections_clause )*
loop5:
while (true) {
int alt5=2;
int LA5_0 = input.LA(1);
if ( (LA5_0==DEFAULT||LA5_0==SHARED||(LA5_0 >= COPYIN && LA5_0 <= COPYPRIVATE)||LA5_0==FST_PRIVATE||LA5_0==LST_PRIVATE||LA5_0==NOWAIT||LA5_0==PRIVATE||LA5_0==REDUCTION) ) {
alt5=1;
}
switch (alt5) {
case 1 :
// OmpParser.g:88:16: s+= sections_clause
{
pushFollow(FOLLOW_sections_clause_in_sections_directive313);
s=sections_clause();
state._fsp--;
stream_sections_clause.add(s.getTree());
if (list_s==null) list_s=new ArrayList<Object>();
list_s.add(s.getTree());
}
break;
default :
break loop5;
}
}
// AST REWRITE
// elements: s, SECTIONS
// token labels:
// rule labels: retval
// token list labels:
// rule list labels: s
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
RewriteRuleSubtreeStream stream_s=new RewriteRuleSubtreeStream(adaptor,"token s",list_s);
root_0 = (Object)adaptor.nil();
// 89:3: -> ^( SECTIONS ( $s)* )
{
// OmpParser.g:89:6: ^( SECTIONS ( $s)* )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_SECTIONS.nextNode(), root_1);
// OmpParser.g:89:18: ( $s)*
while ( stream_s.hasNext() ) {
adaptor.addChild(root_1, stream_s.nextTree());
}
stream_s.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "sections_directive"
public static class sections_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "sections_clause"
// OmpParser.g:92:1: sections_clause : ( data_clause | nowait_directive );
public final OmpParser.sections_clause_return sections_clause() throws RecognitionException {
OmpParser.sections_clause_return retval = new OmpParser.sections_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
ParserRuleReturnScope data_clause24 =null;
ParserRuleReturnScope nowait_directive25 =null;
try {
// OmpParser.g:93:3: ( data_clause | nowait_directive )
int alt6=2;
int LA6_0 = input.LA(1);
if ( (LA6_0==DEFAULT||LA6_0==SHARED||(LA6_0 >= COPYIN && LA6_0 <= COPYPRIVATE)||LA6_0==FST_PRIVATE||LA6_0==LST_PRIVATE||LA6_0==PRIVATE||LA6_0==REDUCTION) ) {
alt6=1;
}
else if ( (LA6_0==NOWAIT) ) {
alt6=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 6, 0, input);
throw nvae;
}
switch (alt6) {
case 1 :
// OmpParser.g:93:5: data_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_data_clause_in_sections_clause340);
data_clause24=data_clause();
state._fsp--;
adaptor.addChild(root_0, data_clause24.getTree());
}
break;
case 2 :
// OmpParser.g:94:5: nowait_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_nowait_directive_in_sections_clause346);
nowait_directive25=nowait_directive();
state._fsp--;
adaptor.addChild(root_0, nowait_directive25.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "sections_clause"
public static class section_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "section_directive"
// OmpParser.g:97:1: section_directive : SECTION -> ^( SECTION ) ;
public final OmpParser.section_directive_return section_directive() throws RecognitionException {
OmpParser.section_directive_return retval = new OmpParser.section_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token SECTION26=null;
Object SECTION26_tree=null;
RewriteRuleTokenStream stream_SECTION=new RewriteRuleTokenStream(adaptor,"token SECTION");
try {
// OmpParser.g:98:3: ( SECTION -> ^( SECTION ) )
// OmpParser.g:98:5: SECTION
{
SECTION26=(Token)match(input,SECTION,FOLLOW_SECTION_in_section_directive359);
stream_SECTION.add(SECTION26);
// AST REWRITE
// elements: SECTION
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 98:13: -> ^( SECTION )
{
// OmpParser.g:98:16: ^( SECTION )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_SECTION.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "section_directive"
public static class parallel_for_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "parallel_for_directive"
// OmpParser.g:101:1: parallel_for_directive : PARALLEL FOR (p+= parallel_for_clause )* -> ^( PARALLEL_FOR ( $p)* ) ;
public final OmpParser.parallel_for_directive_return parallel_for_directive() throws RecognitionException {
OmpParser.parallel_for_directive_return retval = new OmpParser.parallel_for_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token PARALLEL27=null;
Token FOR28=null;
List<Object> list_p=null;
RuleReturnScope p = null;
Object PARALLEL27_tree=null;
Object FOR28_tree=null;
RewriteRuleTokenStream stream_FOR=new RewriteRuleTokenStream(adaptor,"token FOR");
RewriteRuleTokenStream stream_PARALLEL=new RewriteRuleTokenStream(adaptor,"token PARALLEL");
RewriteRuleSubtreeStream stream_parallel_for_clause=new RewriteRuleSubtreeStream(adaptor,"rule parallel_for_clause");
try {
// OmpParser.g:102:3: ( PARALLEL FOR (p+= parallel_for_clause )* -> ^( PARALLEL_FOR ( $p)* ) )
// OmpParser.g:102:5: PARALLEL FOR (p+= parallel_for_clause )*
{
PARALLEL27=(Token)match(input,PARALLEL,FOLLOW_PARALLEL_in_parallel_for_directive380);
stream_PARALLEL.add(PARALLEL27);
FOR28=(Token)match(input,FOR,FOLLOW_FOR_in_parallel_for_directive382);
stream_FOR.add(FOR28);
// OmpParser.g:102:19: (p+= parallel_for_clause )*
loop7:
while (true) {
int alt7=2;
int LA7_0 = input.LA(1);
if ( (LA7_0==IF||LA7_0==DEFAULT||LA7_0==SHARED||(LA7_0 >= COLLAPSE && LA7_0 <= COPYPRIVATE)||LA7_0==FST_PRIVATE||LA7_0==LST_PRIVATE||LA7_0==NUM_THREADS||LA7_0==ORDERED||LA7_0==PRIVATE||LA7_0==REDUCTION||LA7_0==SCHEDULE) ) {
alt7=1;
}
switch (alt7) {
case 1 :
// OmpParser.g:102:19: p+= parallel_for_clause
{
pushFollow(FOLLOW_parallel_for_clause_in_parallel_for_directive386);
p=parallel_for_clause();
state._fsp--;
stream_parallel_for_clause.add(p.getTree());
if (list_p==null) list_p=new ArrayList<Object>();
list_p.add(p.getTree());
}
break;
default :
break loop7;
}
}
// AST REWRITE
// elements: p
// token labels:
// rule labels: retval
// token list labels:
// rule list labels: p
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
RewriteRuleSubtreeStream stream_p=new RewriteRuleSubtreeStream(adaptor,"token p",list_p);
root_0 = (Object)adaptor.nil();
// 103:5: -> ^( PARALLEL_FOR ( $p)* )
{
// OmpParser.g:103:8: ^( PARALLEL_FOR ( $p)* )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PARALLEL_FOR, "PARALLEL_FOR"), root_1);
// OmpParser.g:103:24: ( $p)*
while ( stream_p.hasNext() ) {
adaptor.addChild(root_1, stream_p.nextTree());
}
stream_p.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "parallel_for_directive"
public static class parallel_for_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "parallel_for_clause"
// OmpParser.g:106:1: parallel_for_clause : ( unique_parallel_clause | unique_for_clause | data_clause );
public final OmpParser.parallel_for_clause_return parallel_for_clause() throws RecognitionException {
OmpParser.parallel_for_clause_return retval = new OmpParser.parallel_for_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
ParserRuleReturnScope unique_parallel_clause29 =null;
ParserRuleReturnScope unique_for_clause30 =null;
ParserRuleReturnScope data_clause31 =null;
try {
// OmpParser.g:107:3: ( unique_parallel_clause | unique_for_clause | data_clause )
int alt8=3;
switch ( input.LA(1) ) {
case IF:
case NUM_THREADS:
{
alt8=1;
}
break;
case COLLAPSE:
case ORDERED:
case SCHEDULE:
{
alt8=2;
}
break;
case DEFAULT:
case SHARED:
case COPYIN:
case COPYPRIVATE:
case FST_PRIVATE:
case LST_PRIVATE:
case PRIVATE:
case REDUCTION:
{
alt8=3;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 8, 0, input);
throw nvae;
}
switch (alt8) {
case 1 :
// OmpParser.g:107:5: unique_parallel_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_unique_parallel_clause_in_parallel_for_clause414);
unique_parallel_clause29=unique_parallel_clause();
state._fsp--;
adaptor.addChild(root_0, unique_parallel_clause29.getTree());
}
break;
case 2 :
// OmpParser.g:108:5: unique_for_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_unique_for_clause_in_parallel_for_clause420);
unique_for_clause30=unique_for_clause();
state._fsp--;
adaptor.addChild(root_0, unique_for_clause30.getTree());
}
break;
case 3 :
// OmpParser.g:109:5: data_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_data_clause_in_parallel_for_clause426);
data_clause31=data_clause();
state._fsp--;
adaptor.addChild(root_0, data_clause31.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "parallel_for_clause"
public static class parallel_sections_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "parallel_sections_directive"
// OmpParser.g:112:1: parallel_sections_directive : PARALLEL SECTIONS (p+= parallel_sections_clause )* -> ^( PARALLEL_SECTIONS ( $p)* ) ;
public final OmpParser.parallel_sections_directive_return parallel_sections_directive() throws RecognitionException {
OmpParser.parallel_sections_directive_return retval = new OmpParser.parallel_sections_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token PARALLEL32=null;
Token SECTIONS33=null;
List<Object> list_p=null;
RuleReturnScope p = null;
Object PARALLEL32_tree=null;
Object SECTIONS33_tree=null;
RewriteRuleTokenStream stream_SECTIONS=new RewriteRuleTokenStream(adaptor,"token SECTIONS");
RewriteRuleTokenStream stream_PARALLEL=new RewriteRuleTokenStream(adaptor,"token PARALLEL");
RewriteRuleSubtreeStream stream_parallel_sections_clause=new RewriteRuleSubtreeStream(adaptor,"rule parallel_sections_clause");
try {
// OmpParser.g:113:3: ( PARALLEL SECTIONS (p+= parallel_sections_clause )* -> ^( PARALLEL_SECTIONS ( $p)* ) )
// OmpParser.g:113:5: PARALLEL SECTIONS (p+= parallel_sections_clause )*
{
PARALLEL32=(Token)match(input,PARALLEL,FOLLOW_PARALLEL_in_parallel_sections_directive439);
stream_PARALLEL.add(PARALLEL32);
SECTIONS33=(Token)match(input,SECTIONS,FOLLOW_SECTIONS_in_parallel_sections_directive442);
stream_SECTIONS.add(SECTIONS33);
// OmpParser.g:113:26: (p+= parallel_sections_clause )*
loop9:
while (true) {
int alt9=2;
int LA9_0 = input.LA(1);
if ( (LA9_0==IF||LA9_0==DEFAULT||LA9_0==SHARED||(LA9_0 >= COPYIN && LA9_0 <= COPYPRIVATE)||LA9_0==FST_PRIVATE||LA9_0==LST_PRIVATE||LA9_0==NUM_THREADS||LA9_0==PRIVATE||LA9_0==REDUCTION) ) {
alt9=1;
}
switch (alt9) {
case 1 :
// OmpParser.g:113:26: p+= parallel_sections_clause
{
pushFollow(FOLLOW_parallel_sections_clause_in_parallel_sections_directive447);
p=parallel_sections_clause();
state._fsp--;
stream_parallel_sections_clause.add(p.getTree());
if (list_p==null) list_p=new ArrayList<Object>();
list_p.add(p.getTree());
}
break;
default :
break loop9;
}
}
// AST REWRITE
// elements: p
// token labels:
// rule labels: retval
// token list labels:
// rule list labels: p
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
RewriteRuleSubtreeStream stream_p=new RewriteRuleSubtreeStream(adaptor,"token p",list_p);
root_0 = (Object)adaptor.nil();
// 114:5: -> ^( PARALLEL_SECTIONS ( $p)* )
{
// OmpParser.g:114:8: ^( PARALLEL_SECTIONS ( $p)* )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(PARALLEL_SECTIONS, "PARALLEL_SECTIONS"), root_1);
// OmpParser.g:114:29: ( $p)*
while ( stream_p.hasNext() ) {
adaptor.addChild(root_1, stream_p.nextTree());
}
stream_p.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "parallel_sections_directive"
public static class parallel_sections_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "parallel_sections_clause"
// OmpParser.g:117:1: parallel_sections_clause : ( unique_parallel_clause | data_clause );
public final OmpParser.parallel_sections_clause_return parallel_sections_clause() throws RecognitionException {
OmpParser.parallel_sections_clause_return retval = new OmpParser.parallel_sections_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
ParserRuleReturnScope unique_parallel_clause34 =null;
ParserRuleReturnScope data_clause35 =null;
try {
// OmpParser.g:118:3: ( unique_parallel_clause | data_clause )
int alt10=2;
int LA10_0 = input.LA(1);
if ( (LA10_0==IF||LA10_0==NUM_THREADS) ) {
alt10=1;
}
else if ( (LA10_0==DEFAULT||LA10_0==SHARED||(LA10_0 >= COPYIN && LA10_0 <= COPYPRIVATE)||LA10_0==FST_PRIVATE||LA10_0==LST_PRIVATE||LA10_0==PRIVATE||LA10_0==REDUCTION) ) {
alt10=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 10, 0, input);
throw nvae;
}
switch (alt10) {
case 1 :
// OmpParser.g:118:5: unique_parallel_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_unique_parallel_clause_in_parallel_sections_clause475);
unique_parallel_clause34=unique_parallel_clause();
state._fsp--;
adaptor.addChild(root_0, unique_parallel_clause34.getTree());
}
break;
case 2 :
// OmpParser.g:119:5: data_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_data_clause_in_parallel_sections_clause481);
data_clause35=data_clause();
state._fsp--;
adaptor.addChild(root_0, data_clause35.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "parallel_sections_clause"
public static class simd_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "simd_directive"
// OmpParser.g:122:1: simd_directive : SIMD (a+= simd_clause )* -> ^( SIMD ( $a)* ) ;
public final OmpParser.simd_directive_return simd_directive() throws RecognitionException {
OmpParser.simd_directive_return retval = new OmpParser.simd_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token SIMD36=null;
List<Object> list_a=null;
RuleReturnScope a = null;
Object SIMD36_tree=null;
RewriteRuleTokenStream stream_SIMD=new RewriteRuleTokenStream(adaptor,"token SIMD");
RewriteRuleSubtreeStream stream_simd_clause=new RewriteRuleSubtreeStream(adaptor,"rule simd_clause");
try {
// OmpParser.g:123:3: ( SIMD (a+= simd_clause )* -> ^( SIMD ( $a)* ) )
// OmpParser.g:123:5: SIMD (a+= simd_clause )*
{
SIMD36=(Token)match(input,SIMD,FOLLOW_SIMD_in_simd_directive494);
stream_SIMD.add(SIMD36);
// OmpParser.g:123:11: (a+= simd_clause )*
loop11:
while (true) {
int alt11=2;
int LA11_0 = input.LA(1);
if ( (LA11_0==IF||LA11_0==DEFAULT||LA11_0==SHARED||(LA11_0 >= COLLAPSE && LA11_0 <= COPYPRIVATE)||LA11_0==FST_PRIVATE||LA11_0==LST_PRIVATE||LA11_0==PRIVATE||LA11_0==REDUCTION||LA11_0==SAFELEN||LA11_0==SIMDLEN) ) {
alt11=1;
}
switch (alt11) {
case 1 :
// OmpParser.g:123:11: a+= simd_clause
{
pushFollow(FOLLOW_simd_clause_in_simd_directive498);
a=simd_clause();
state._fsp--;
stream_simd_clause.add(a.getTree());
if (list_a==null) list_a=new ArrayList<Object>();
list_a.add(a.getTree());
}
break;
default :
break loop11;
}
}
// AST REWRITE
// elements: SIMD, a
// token labels:
// rule labels: retval
// token list labels:
// rule list labels: a
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
RewriteRuleSubtreeStream stream_a=new RewriteRuleSubtreeStream(adaptor,"token a",list_a);
root_0 = (Object)adaptor.nil();
// 124:5: -> ^( SIMD ( $a)* )
{
// OmpParser.g:124:8: ^( SIMD ( $a)* )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_SIMD.nextNode(), root_1);
// OmpParser.g:124:16: ( $a)*
while ( stream_a.hasNext() ) {
adaptor.addChild(root_1, stream_a.nextTree());
}
stream_a.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "simd_directive"
public static class simd_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "simd_clause"
// OmpParser.g:127:1: simd_clause : ( SAFELEN LPAREN e= expression RPAREN -> ^( SAFELEN $e) | SIMDLEN LPAREN e= expression RPAREN -> ^( SIMDLEN $e) | if_clause | data_clause | collapse_clause );
public final OmpParser.simd_clause_return simd_clause() throws RecognitionException {
OmpParser.simd_clause_return retval = new OmpParser.simd_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token SAFELEN37=null;
Token LPAREN38=null;
Token RPAREN39=null;
Token SIMDLEN40=null;
Token LPAREN41=null;
Token RPAREN42=null;
ParserRuleReturnScope e =null;
ParserRuleReturnScope if_clause43 =null;
ParserRuleReturnScope data_clause44 =null;
ParserRuleReturnScope collapse_clause45 =null;
Object SAFELEN37_tree=null;
Object LPAREN38_tree=null;
Object RPAREN39_tree=null;
Object SIMDLEN40_tree=null;
Object LPAREN41_tree=null;
Object RPAREN42_tree=null;
RewriteRuleTokenStream stream_SAFELEN=new RewriteRuleTokenStream(adaptor,"token SAFELEN");
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleTokenStream stream_SIMDLEN=new RewriteRuleTokenStream(adaptor,"token SIMDLEN");
RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
try {
// OmpParser.g:128:3: ( SAFELEN LPAREN e= expression RPAREN -> ^( SAFELEN $e) | SIMDLEN LPAREN e= expression RPAREN -> ^( SIMDLEN $e) | if_clause | data_clause | collapse_clause )
int alt12=5;
switch ( input.LA(1) ) {
case SAFELEN:
{
alt12=1;
}
break;
case SIMDLEN:
{
alt12=2;
}
break;
case IF:
{
alt12=3;
}
break;
case DEFAULT:
case SHARED:
case COPYIN:
case COPYPRIVATE:
case FST_PRIVATE:
case LST_PRIVATE:
case PRIVATE:
case REDUCTION:
{
alt12=4;
}
break;
case COLLAPSE:
{
alt12=5;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 12, 0, input);
throw nvae;
}
switch (alt12) {
case 1 :
// OmpParser.g:128:5: SAFELEN LPAREN e= expression RPAREN
{
SAFELEN37=(Token)match(input,SAFELEN,FOLLOW_SAFELEN_in_simd_clause527);
stream_SAFELEN.add(SAFELEN37);
LPAREN38=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_simd_clause529);
stream_LPAREN.add(LPAREN38);
pushFollow(FOLLOW_expression_in_simd_clause533);
e=expression();
state._fsp--;
stream_expression.add(e.getTree());
RPAREN39=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_simd_clause535);
stream_RPAREN.add(RPAREN39);
// AST REWRITE
// elements: SAFELEN, e
// token labels:
// rule labels: e, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_e=new RewriteRuleSubtreeStream(adaptor,"rule e",e!=null?e.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 129:5: -> ^( SAFELEN $e)
{
// OmpParser.g:129:8: ^( SAFELEN $e)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_SAFELEN.nextNode(), root_1);
adaptor.addChild(root_1, stream_e.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// OmpParser.g:130:5: SIMDLEN LPAREN e= expression RPAREN
{
SIMDLEN40=(Token)match(input,SIMDLEN,FOLLOW_SIMDLEN_in_simd_clause554);
stream_SIMDLEN.add(SIMDLEN40);
LPAREN41=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_simd_clause556);
stream_LPAREN.add(LPAREN41);
pushFollow(FOLLOW_expression_in_simd_clause560);
e=expression();
state._fsp--;
stream_expression.add(e.getTree());
RPAREN42=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_simd_clause562);
stream_RPAREN.add(RPAREN42);
// AST REWRITE
// elements: SIMDLEN, e
// token labels:
// rule labels: e, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_e=new RewriteRuleSubtreeStream(adaptor,"rule e",e!=null?e.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 131:5: -> ^( SIMDLEN $e)
{
// OmpParser.g:131:8: ^( SIMDLEN $e)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_SIMDLEN.nextNode(), root_1);
adaptor.addChild(root_1, stream_e.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 3 :
// OmpParser.g:132:8: if_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_if_clause_in_simd_clause584);
if_clause43=if_clause();
state._fsp--;
adaptor.addChild(root_0, if_clause43.getTree());
}
break;
case 4 :
// OmpParser.g:133:8: data_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_data_clause_in_simd_clause593);
data_clause44=data_clause();
state._fsp--;
adaptor.addChild(root_0, data_clause44.getTree());
}
break;
case 5 :
// OmpParser.g:134:8: collapse_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_collapse_clause_in_simd_clause602);
collapse_clause45=collapse_clause();
state._fsp--;
adaptor.addChild(root_0, collapse_clause45.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "simd_clause"
public static class single_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "single_directive"
// OmpParser.g:137:1: single_directive : SINGLE (s+= single_clause )* -> ^( SINGLE ( $s)* ) ;
public final OmpParser.single_directive_return single_directive() throws RecognitionException {
OmpParser.single_directive_return retval = new OmpParser.single_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token SINGLE46=null;
List<Object> list_s=null;
RuleReturnScope s = null;
Object SINGLE46_tree=null;
RewriteRuleTokenStream stream_SINGLE=new RewriteRuleTokenStream(adaptor,"token SINGLE");
RewriteRuleSubtreeStream stream_single_clause=new RewriteRuleSubtreeStream(adaptor,"rule single_clause");
try {
// OmpParser.g:138:3: ( SINGLE (s+= single_clause )* -> ^( SINGLE ( $s)* ) )
// OmpParser.g:138:5: SINGLE (s+= single_clause )*
{
SINGLE46=(Token)match(input,SINGLE,FOLLOW_SINGLE_in_single_directive619);
stream_SINGLE.add(SINGLE46);
// OmpParser.g:138:14: (s+= single_clause )*
loop13:
while (true) {
int alt13=2;
int LA13_0 = input.LA(1);
if ( (LA13_0==DEFAULT||LA13_0==SHARED||(LA13_0 >= COPYIN && LA13_0 <= COPYPRIVATE)||LA13_0==FST_PRIVATE||LA13_0==LST_PRIVATE||LA13_0==NOWAIT||LA13_0==PRIVATE||LA13_0==REDUCTION) ) {
alt13=1;
}
switch (alt13) {
case 1 :
// OmpParser.g:138:14: s+= single_clause
{
pushFollow(FOLLOW_single_clause_in_single_directive624);
s=single_clause();
state._fsp--;
stream_single_clause.add(s.getTree());
if (list_s==null) list_s=new ArrayList<Object>();
list_s.add(s.getTree());
}
break;
default :
break loop13;
}
}
// AST REWRITE
// elements: s, SINGLE
// token labels:
// rule labels: retval
// token list labels:
// rule list labels: s
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
RewriteRuleSubtreeStream stream_s=new RewriteRuleSubtreeStream(adaptor,"token s",list_s);
root_0 = (Object)adaptor.nil();
// 139:5: -> ^( SINGLE ( $s)* )
{
// OmpParser.g:139:8: ^( SINGLE ( $s)* )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_SINGLE.nextNode(), root_1);
// OmpParser.g:139:18: ( $s)*
while ( stream_s.hasNext() ) {
adaptor.addChild(root_1, stream_s.nextTree());
}
stream_s.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "single_directive"
public static class single_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "single_clause"
// OmpParser.g:142:1: single_clause : ( data_clause | nowait_directive );
public final OmpParser.single_clause_return single_clause() throws RecognitionException {
OmpParser.single_clause_return retval = new OmpParser.single_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
ParserRuleReturnScope data_clause47 =null;
ParserRuleReturnScope nowait_directive48 =null;
try {
// OmpParser.g:143:3: ( data_clause | nowait_directive )
int alt14=2;
int LA14_0 = input.LA(1);
if ( (LA14_0==DEFAULT||LA14_0==SHARED||(LA14_0 >= COPYIN && LA14_0 <= COPYPRIVATE)||LA14_0==FST_PRIVATE||LA14_0==LST_PRIVATE||LA14_0==PRIVATE||LA14_0==REDUCTION) ) {
alt14=1;
}
else if ( (LA14_0==NOWAIT) ) {
alt14=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 14, 0, input);
throw nvae;
}
switch (alt14) {
case 1 :
// OmpParser.g:143:5: data_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_data_clause_in_single_clause652);
data_clause47=data_clause();
state._fsp--;
adaptor.addChild(root_0, data_clause47.getTree());
}
break;
case 2 :
// OmpParser.g:144:5: nowait_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_nowait_directive_in_single_clause658);
nowait_directive48=nowait_directive();
state._fsp--;
adaptor.addChild(root_0, nowait_directive48.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "single_clause"
public static class barrier_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "barrier_directive"
// OmpParser.g:147:1: barrier_directive : BARRIER -> ^( BARRIER ) ;
public final OmpParser.barrier_directive_return barrier_directive() throws RecognitionException {
OmpParser.barrier_directive_return retval = new OmpParser.barrier_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token BARRIER49=null;
Object BARRIER49_tree=null;
RewriteRuleTokenStream stream_BARRIER=new RewriteRuleTokenStream(adaptor,"token BARRIER");
try {
// OmpParser.g:148:3: ( BARRIER -> ^( BARRIER ) )
// OmpParser.g:148:5: BARRIER
{
BARRIER49=(Token)match(input,BARRIER,FOLLOW_BARRIER_in_barrier_directive671);
stream_BARRIER.add(BARRIER49);
// AST REWRITE
// elements: BARRIER
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 148:13: -> ^( BARRIER )
{
// OmpParser.g:148:16: ^( BARRIER )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_BARRIER.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "barrier_directive"
public static class ompatomic_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "ompatomic_directive"
// OmpParser.g:151:1: ompatomic_directive : OMPATOMIC (c0= atomic_clasue )? (c1= seq_cst_clause )? -> ^( OMPATOMIC ( $c0)? ( $c1)? ) ;
public final OmpParser.ompatomic_directive_return ompatomic_directive() throws RecognitionException {
OmpParser.ompatomic_directive_return retval = new OmpParser.ompatomic_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token OMPATOMIC50=null;
ParserRuleReturnScope c0 =null;
ParserRuleReturnScope c1 =null;
Object OMPATOMIC50_tree=null;
RewriteRuleTokenStream stream_OMPATOMIC=new RewriteRuleTokenStream(adaptor,"token OMPATOMIC");
RewriteRuleSubtreeStream stream_atomic_clasue=new RewriteRuleSubtreeStream(adaptor,"rule atomic_clasue");
RewriteRuleSubtreeStream stream_seq_cst_clause=new RewriteRuleSubtreeStream(adaptor,"rule seq_cst_clause");
try {
// OmpParser.g:152:3: ( OMPATOMIC (c0= atomic_clasue )? (c1= seq_cst_clause )? -> ^( OMPATOMIC ( $c0)? ( $c1)? ) )
// OmpParser.g:152:5: OMPATOMIC (c0= atomic_clasue )? (c1= seq_cst_clause )?
{
OMPATOMIC50=(Token)match(input,OMPATOMIC,FOLLOW_OMPATOMIC_in_ompatomic_directive692);
stream_OMPATOMIC.add(OMPATOMIC50);
// OmpParser.g:152:17: (c0= atomic_clasue )?
int alt15=2;
int LA15_0 = input.LA(1);
if ( (LA15_0==UPDATE||LA15_0==CAPTURE||LA15_0==READ||LA15_0==WRITE) ) {
alt15=1;
}
switch (alt15) {
case 1 :
// OmpParser.g:152:17: c0= atomic_clasue
{
pushFollow(FOLLOW_atomic_clasue_in_ompatomic_directive696);
c0=atomic_clasue();
state._fsp--;
stream_atomic_clasue.add(c0.getTree());
}
break;
}
// OmpParser.g:152:35: (c1= seq_cst_clause )?
int alt16=2;
int LA16_0 = input.LA(1);
if ( (LA16_0==SEQ_CST) ) {
alt16=1;
}
switch (alt16) {
case 1 :
// OmpParser.g:152:35: c1= seq_cst_clause
{
pushFollow(FOLLOW_seq_cst_clause_in_ompatomic_directive701);
c1=seq_cst_clause();
state._fsp--;
stream_seq_cst_clause.add(c1.getTree());
}
break;
}
// AST REWRITE
// elements: c0, c1, OMPATOMIC
// token labels:
// rule labels: c0, c1, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_c0=new RewriteRuleSubtreeStream(adaptor,"rule c0",c0!=null?c0.getTree():null);
RewriteRuleSubtreeStream stream_c1=new RewriteRuleSubtreeStream(adaptor,"rule c1",c1!=null?c1.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 153:5: -> ^( OMPATOMIC ( $c0)? ( $c1)? )
{
// OmpParser.g:153:8: ^( OMPATOMIC ( $c0)? ( $c1)? )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_OMPATOMIC.nextNode(), root_1);
// OmpParser.g:153:21: ( $c0)?
if ( stream_c0.hasNext() ) {
adaptor.addChild(root_1, stream_c0.nextTree());
}
stream_c0.reset();
// OmpParser.g:153:26: ( $c1)?
if ( stream_c1.hasNext() ) {
adaptor.addChild(root_1, stream_c1.nextTree());
}
stream_c1.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "ompatomic_directive"
public static class atomic_clasue_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "atomic_clasue"
// OmpParser.g:156:1: atomic_clasue : ( READ | WRITE | UPDATE | CAPTURE );
public final OmpParser.atomic_clasue_return atomic_clasue() throws RecognitionException {
OmpParser.atomic_clasue_return retval = new OmpParser.atomic_clasue_return();
retval.start = input.LT(1);
Object root_0 = null;
Token set51=null;
Object set51_tree=null;
try {
// OmpParser.g:157:2: ( READ | WRITE | UPDATE | CAPTURE )
// OmpParser.g:
{
root_0 = (Object)adaptor.nil();
set51=input.LT(1);
if ( input.LA(1)==UPDATE||input.LA(1)==CAPTURE||input.LA(1)==READ||input.LA(1)==WRITE ) {
input.consume();
adaptor.addChild(root_0, (Object)adaptor.create(set51));
state.errorRecovery=false;
}
else {
MismatchedSetException mse = new MismatchedSetException(null,input);
throw mse;
}
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "atomic_clasue"
public static class seq_cst_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "seq_cst_clause"
// OmpParser.g:160:1: seq_cst_clause : SEQ_CST ;
public final OmpParser.seq_cst_clause_return seq_cst_clause() throws RecognitionException {
OmpParser.seq_cst_clause_return retval = new OmpParser.seq_cst_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token SEQ_CST52=null;
Object SEQ_CST52_tree=null;
try {
// OmpParser.g:161:2: ( SEQ_CST )
// OmpParser.g:161:4: SEQ_CST
{
root_0 = (Object)adaptor.nil();
SEQ_CST52=(Token)match(input,SEQ_CST,FOLLOW_SEQ_CST_in_seq_cst_clause760);
SEQ_CST52_tree = (Object)adaptor.create(SEQ_CST52);
adaptor.addChild(root_0, SEQ_CST52_tree);
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "seq_cst_clause"
public static class flush_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "flush_directive"
// OmpParser.g:164:1: flush_directive : FLUSH (f= flush_vars )? -> ^( FLUSH ( $f)? ) ;
public final OmpParser.flush_directive_return flush_directive() throws RecognitionException {
OmpParser.flush_directive_return retval = new OmpParser.flush_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token FLUSH53=null;
ParserRuleReturnScope f =null;
Object FLUSH53_tree=null;
RewriteRuleTokenStream stream_FLUSH=new RewriteRuleTokenStream(adaptor,"token FLUSH");
RewriteRuleSubtreeStream stream_flush_vars=new RewriteRuleSubtreeStream(adaptor,"rule flush_vars");
try {
// OmpParser.g:165:3: ( FLUSH (f= flush_vars )? -> ^( FLUSH ( $f)? ) )
// OmpParser.g:165:5: FLUSH (f= flush_vars )?
{
FLUSH53=(Token)match(input,FLUSH,FOLLOW_FLUSH_in_flush_directive773);
stream_FLUSH.add(FLUSH53);
// OmpParser.g:165:13: (f= flush_vars )?
int alt17=2;
int LA17_0 = input.LA(1);
if ( (LA17_0==LPAREN) ) {
alt17=1;
}
switch (alt17) {
case 1 :
// OmpParser.g:165:13: f= flush_vars
{
pushFollow(FOLLOW_flush_vars_in_flush_directive778);
f=flush_vars();
state._fsp--;
stream_flush_vars.add(f.getTree());
}
break;
}
// AST REWRITE
// elements: FLUSH, f
// token labels:
// rule labels: f, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_f=new RewriteRuleSubtreeStream(adaptor,"rule f",f!=null?f.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 166:5: -> ^( FLUSH ( $f)? )
{
// OmpParser.g:166:8: ^( FLUSH ( $f)? )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_FLUSH.nextNode(), root_1);
// OmpParser.g:166:17: ( $f)?
if ( stream_f.hasNext() ) {
adaptor.addChild(root_1, stream_f.nextTree());
}
stream_f.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "flush_directive"
public static class flush_vars_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "flush_vars"
// OmpParser.g:169:1: flush_vars : LPAREN i= identifier_list RPAREN -> $i;
public final OmpParser.flush_vars_return flush_vars() throws RecognitionException {
OmpParser.flush_vars_return retval = new OmpParser.flush_vars_return();
retval.start = input.LT(1);
Object root_0 = null;
Token LPAREN54=null;
Token RPAREN55=null;
ParserRuleReturnScope i =null;
Object LPAREN54_tree=null;
Object RPAREN55_tree=null;
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// OmpParser.g:170:3: ( LPAREN i= identifier_list RPAREN -> $i)
// OmpParser.g:170:5: LPAREN i= identifier_list RPAREN
{
LPAREN54=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_flush_vars806);
stream_LPAREN.add(LPAREN54);
pushFollow(FOLLOW_identifier_list_in_flush_vars812);
i=identifier_list();
state._fsp--;
stream_identifier_list.add(i.getTree());
RPAREN55=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_flush_vars815);
stream_RPAREN.add(RPAREN55);
// AST REWRITE
// elements: i
// token labels:
// rule labels: i, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_i=new RewriteRuleSubtreeStream(adaptor,"rule i",i!=null?i.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 171:5: -> $i
{
adaptor.addChild(root_0, stream_i.nextTree());
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "flush_vars"
public static class ordered_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "ordered_directive"
// OmpParser.g:174:1: ordered_directive : ORDERED -> ^( ORDERED ) ;
public final OmpParser.ordered_directive_return ordered_directive() throws RecognitionException {
OmpParser.ordered_directive_return retval = new OmpParser.ordered_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token ORDERED56=null;
Object ORDERED56_tree=null;
RewriteRuleTokenStream stream_ORDERED=new RewriteRuleTokenStream(adaptor,"token ORDERED");
try {
// OmpParser.g:175:3: ( ORDERED -> ^( ORDERED ) )
// OmpParser.g:175:5: ORDERED
{
ORDERED56=(Token)match(input,ORDERED,FOLLOW_ORDERED_in_ordered_directive837);
stream_ORDERED.add(ORDERED56);
// AST REWRITE
// elements: ORDERED
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 175:13: -> ^( ORDERED )
{
// OmpParser.g:175:16: ^( ORDERED )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_ORDERED.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "ordered_directive"
public static class nowait_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "nowait_directive"
// OmpParser.g:178:1: nowait_directive : NOWAIT -> ^( NOWAIT ) ;
public final OmpParser.nowait_directive_return nowait_directive() throws RecognitionException {
OmpParser.nowait_directive_return retval = new OmpParser.nowait_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token NOWAIT57=null;
Object NOWAIT57_tree=null;
RewriteRuleTokenStream stream_NOWAIT=new RewriteRuleTokenStream(adaptor,"token NOWAIT");
try {
// OmpParser.g:179:3: ( NOWAIT -> ^( NOWAIT ) )
// OmpParser.g:179:5: NOWAIT
{
NOWAIT57=(Token)match(input,NOWAIT,FOLLOW_NOWAIT_in_nowait_directive858);
stream_NOWAIT.add(NOWAIT57);
// AST REWRITE
// elements: NOWAIT
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 179:12: -> ^( NOWAIT )
{
// OmpParser.g:179:15: ^( NOWAIT )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_NOWAIT.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "nowait_directive"
public static class threadprivate_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "threadprivate_directive"
// OmpParser.g:182:1: threadprivate_directive : THD_PRIVATE LPAREN i= identifier_list RPAREN -> ^( THD_PRIVATE $i) ;
public final OmpParser.threadprivate_directive_return threadprivate_directive() throws RecognitionException {
OmpParser.threadprivate_directive_return retval = new OmpParser.threadprivate_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token THD_PRIVATE58=null;
Token LPAREN59=null;
Token RPAREN60=null;
ParserRuleReturnScope i =null;
Object THD_PRIVATE58_tree=null;
Object LPAREN59_tree=null;
Object RPAREN60_tree=null;
RewriteRuleTokenStream stream_THD_PRIVATE=new RewriteRuleTokenStream(adaptor,"token THD_PRIVATE");
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// OmpParser.g:183:3: ( THD_PRIVATE LPAREN i= identifier_list RPAREN -> ^( THD_PRIVATE $i) )
// OmpParser.g:183:5: THD_PRIVATE LPAREN i= identifier_list RPAREN
{
THD_PRIVATE58=(Token)match(input,THD_PRIVATE,FOLLOW_THD_PRIVATE_in_threadprivate_directive877);
stream_THD_PRIVATE.add(THD_PRIVATE58);
LPAREN59=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_threadprivate_directive880);
stream_LPAREN.add(LPAREN59);
pushFollow(FOLLOW_identifier_list_in_threadprivate_directive885);
i=identifier_list();
state._fsp--;
stream_identifier_list.add(i.getTree());
RPAREN60=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_threadprivate_directive888);
stream_RPAREN.add(RPAREN60);
// AST REWRITE
// elements: THD_PRIVATE, i
// token labels:
// rule labels: i, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_i=new RewriteRuleSubtreeStream(adaptor,"rule i",i!=null?i.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 184:5: -> ^( THD_PRIVATE $i)
{
// OmpParser.g:184:8: ^( THD_PRIVATE $i)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_THD_PRIVATE.nextNode(), root_1);
adaptor.addChild(root_1, stream_i.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "threadprivate_directive"
public static class for_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "for_directive"
// OmpParser.g:187:1: for_directive : FOR (f+= for_clause )* -> ^( FOR ( $f)* ) ;
public final OmpParser.for_directive_return for_directive() throws RecognitionException {
OmpParser.for_directive_return retval = new OmpParser.for_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token FOR61=null;
List<Object> list_f=null;
RuleReturnScope f = null;
Object FOR61_tree=null;
RewriteRuleTokenStream stream_FOR=new RewriteRuleTokenStream(adaptor,"token FOR");
RewriteRuleSubtreeStream stream_for_clause=new RewriteRuleSubtreeStream(adaptor,"rule for_clause");
try {
// OmpParser.g:188:3: ( FOR (f+= for_clause )* -> ^( FOR ( $f)* ) )
// OmpParser.g:188:5: FOR (f+= for_clause )*
{
FOR61=(Token)match(input,FOR,FOLLOW_FOR_in_for_directive914);
stream_FOR.add(FOR61);
// OmpParser.g:188:10: (f+= for_clause )*
loop18:
while (true) {
int alt18=2;
int LA18_0 = input.LA(1);
if ( (LA18_0==DEFAULT||LA18_0==SHARED||(LA18_0 >= COLLAPSE && LA18_0 <= COPYPRIVATE)||LA18_0==FST_PRIVATE||LA18_0==LST_PRIVATE||LA18_0==NOWAIT||LA18_0==ORDERED||LA18_0==PRIVATE||LA18_0==REDUCTION||LA18_0==SCHEDULE) ) {
alt18=1;
}
switch (alt18) {
case 1 :
// OmpParser.g:188:11: f+= for_clause
{
pushFollow(FOLLOW_for_clause_in_for_directive920);
f=for_clause();
state._fsp--;
stream_for_clause.add(f.getTree());
if (list_f==null) list_f=new ArrayList<Object>();
list_f.add(f.getTree());
}
break;
default :
break loop18;
}
}
// AST REWRITE
// elements: f, FOR
// token labels:
// rule labels: retval
// token list labels:
// rule list labels: f
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
RewriteRuleSubtreeStream stream_f=new RewriteRuleSubtreeStream(adaptor,"token f",list_f);
root_0 = (Object)adaptor.nil();
// 189:5: -> ^( FOR ( $f)* )
{
// OmpParser.g:189:8: ^( FOR ( $f)* )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_FOR.nextNode(), root_1);
// OmpParser.g:189:15: ( $f)*
while ( stream_f.hasNext() ) {
adaptor.addChild(root_1, stream_f.nextTree());
}
stream_f.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "for_directive"
public static class for_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "for_clause"
// OmpParser.g:192:1: for_clause : (u= unique_for_clause -> ^( FOR_CLAUSE $u) |d= data_clause -> ^( FOR_CLAUSE $d) |n= nowait_directive -> ^( FOR_CLAUSE $n) );
public final OmpParser.for_clause_return for_clause() throws RecognitionException {
OmpParser.for_clause_return retval = new OmpParser.for_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
ParserRuleReturnScope u =null;
ParserRuleReturnScope d =null;
ParserRuleReturnScope n =null;
RewriteRuleSubtreeStream stream_data_clause=new RewriteRuleSubtreeStream(adaptor,"rule data_clause");
RewriteRuleSubtreeStream stream_nowait_directive=new RewriteRuleSubtreeStream(adaptor,"rule nowait_directive");
RewriteRuleSubtreeStream stream_unique_for_clause=new RewriteRuleSubtreeStream(adaptor,"rule unique_for_clause");
try {
// OmpParser.g:193:3: (u= unique_for_clause -> ^( FOR_CLAUSE $u) |d= data_clause -> ^( FOR_CLAUSE $d) |n= nowait_directive -> ^( FOR_CLAUSE $n) )
int alt19=3;
switch ( input.LA(1) ) {
case COLLAPSE:
case ORDERED:
case SCHEDULE:
{
alt19=1;
}
break;
case DEFAULT:
case SHARED:
case COPYIN:
case COPYPRIVATE:
case FST_PRIVATE:
case LST_PRIVATE:
case PRIVATE:
case REDUCTION:
{
alt19=2;
}
break;
case NOWAIT:
{
alt19=3;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 19, 0, input);
throw nvae;
}
switch (alt19) {
case 1 :
// OmpParser.g:193:5: u= unique_for_clause
{
pushFollow(FOLLOW_unique_for_clause_in_for_clause951);
u=unique_for_clause();
state._fsp--;
stream_unique_for_clause.add(u.getTree());
// AST REWRITE
// elements: u
// token labels:
// rule labels: u, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_u=new RewriteRuleSubtreeStream(adaptor,"rule u",u!=null?u.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 193:25: -> ^( FOR_CLAUSE $u)
{
// OmpParser.g:193:28: ^( FOR_CLAUSE $u)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(FOR_CLAUSE, "FOR_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_u.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// OmpParser.g:194:5: d= data_clause
{
pushFollow(FOLLOW_data_clause_in_for_clause968);
d=data_clause();
state._fsp--;
stream_data_clause.add(d.getTree());
// AST REWRITE
// elements: d
// token labels:
// rule labels: d, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_d=new RewriteRuleSubtreeStream(adaptor,"rule d",d!=null?d.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 194:19: -> ^( FOR_CLAUSE $d)
{
// OmpParser.g:194:22: ^( FOR_CLAUSE $d)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(FOR_CLAUSE, "FOR_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 3 :
// OmpParser.g:195:5: n= nowait_directive
{
pushFollow(FOLLOW_nowait_directive_in_for_clause985);
n=nowait_directive();
state._fsp--;
stream_nowait_directive.add(n.getTree());
// AST REWRITE
// elements: n
// token labels:
// rule labels: n, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_n=new RewriteRuleSubtreeStream(adaptor,"rule n",n!=null?n.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 195:24: -> ^( FOR_CLAUSE $n)
{
// OmpParser.g:195:27: ^( FOR_CLAUSE $n)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(FOR_CLAUSE, "FOR_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_n.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "for_clause"
public static class unique_for_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "unique_for_clause"
// OmpParser.g:198:1: unique_for_clause : (o= ordered_clause -> ^( UNIQUE_FOR $o) |s1= schedule_clause -> ^( UNIQUE_FOR $s1) |c= collapse_clause -> ^( UNIQUE_FOR $c) );
public final OmpParser.unique_for_clause_return unique_for_clause() throws RecognitionException {
OmpParser.unique_for_clause_return retval = new OmpParser.unique_for_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
ParserRuleReturnScope o =null;
ParserRuleReturnScope s1 =null;
ParserRuleReturnScope c =null;
RewriteRuleSubtreeStream stream_schedule_clause=new RewriteRuleSubtreeStream(adaptor,"rule schedule_clause");
RewriteRuleSubtreeStream stream_ordered_clause=new RewriteRuleSubtreeStream(adaptor,"rule ordered_clause");
RewriteRuleSubtreeStream stream_collapse_clause=new RewriteRuleSubtreeStream(adaptor,"rule collapse_clause");
try {
// OmpParser.g:199:3: (o= ordered_clause -> ^( UNIQUE_FOR $o) |s1= schedule_clause -> ^( UNIQUE_FOR $s1) |c= collapse_clause -> ^( UNIQUE_FOR $c) )
int alt20=3;
switch ( input.LA(1) ) {
case ORDERED:
{
alt20=1;
}
break;
case SCHEDULE:
{
alt20=2;
}
break;
case COLLAPSE:
{
alt20=3;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 20, 0, input);
throw nvae;
}
switch (alt20) {
case 1 :
// OmpParser.g:199:5: o= ordered_clause
{
pushFollow(FOLLOW_ordered_clause_in_unique_for_clause1009);
o=ordered_clause();
state._fsp--;
stream_ordered_clause.add(o.getTree());
// AST REWRITE
// elements: o
// token labels:
// rule labels: retval, o
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
RewriteRuleSubtreeStream stream_o=new RewriteRuleSubtreeStream(adaptor,"rule o",o!=null?o.getTree():null);
root_0 = (Object)adaptor.nil();
// 199:22: -> ^( UNIQUE_FOR $o)
{
// OmpParser.g:199:24: ^( UNIQUE_FOR $o)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(UNIQUE_FOR, "UNIQUE_FOR"), root_1);
adaptor.addChild(root_1, stream_o.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// OmpParser.g:200:5: s1= schedule_clause
{
pushFollow(FOLLOW_schedule_clause_in_unique_for_clause1025);
s1=schedule_clause();
state._fsp--;
stream_schedule_clause.add(s1.getTree());
// AST REWRITE
// elements: s1
// token labels:
// rule labels: s1, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_s1=new RewriteRuleSubtreeStream(adaptor,"rule s1",s1!=null?s1.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 200:24: -> ^( UNIQUE_FOR $s1)
{
// OmpParser.g:200:27: ^( UNIQUE_FOR $s1)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(UNIQUE_FOR, "UNIQUE_FOR"), root_1);
adaptor.addChild(root_1, stream_s1.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 3 :
// OmpParser.g:201:5: c= collapse_clause
{
pushFollow(FOLLOW_collapse_clause_in_unique_for_clause1042);
c=collapse_clause();
state._fsp--;
stream_collapse_clause.add(c.getTree());
// AST REWRITE
// elements: c
// token labels:
// rule labels: c, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_c=new RewriteRuleSubtreeStream(adaptor,"rule c",c!=null?c.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 201:23: -> ^( UNIQUE_FOR $c)
{
// OmpParser.g:201:26: ^( UNIQUE_FOR $c)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(UNIQUE_FOR, "UNIQUE_FOR"), root_1);
adaptor.addChild(root_1, stream_c.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "unique_for_clause"
public static class ordered_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "ordered_clause"
// OmpParser.g:204:1: ordered_clause : ORDERED ( LPAREN e1= expression RPAREN )? -> ^( ORDERED ( $e1)? ) ;
public final OmpParser.ordered_clause_return ordered_clause() throws RecognitionException {
OmpParser.ordered_clause_return retval = new OmpParser.ordered_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token ORDERED62=null;
Token LPAREN63=null;
Token RPAREN64=null;
ParserRuleReturnScope e1 =null;
Object ORDERED62_tree=null;
Object LPAREN63_tree=null;
Object RPAREN64_tree=null;
RewriteRuleTokenStream stream_ORDERED=new RewriteRuleTokenStream(adaptor,"token ORDERED");
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
try {
// OmpParser.g:205:3: ( ORDERED ( LPAREN e1= expression RPAREN )? -> ^( ORDERED ( $e1)? ) )
// OmpParser.g:206:3: ORDERED ( LPAREN e1= expression RPAREN )?
{
ORDERED62=(Token)match(input,ORDERED,FOLLOW_ORDERED_in_ordered_clause1066);
stream_ORDERED.add(ORDERED62);
// OmpParser.g:206:11: ( LPAREN e1= expression RPAREN )?
int alt21=2;
int LA21_0 = input.LA(1);
if ( (LA21_0==LPAREN) ) {
alt21=1;
}
switch (alt21) {
case 1 :
// OmpParser.g:206:12: LPAREN e1= expression RPAREN
{
LPAREN63=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_ordered_clause1069);
stream_LPAREN.add(LPAREN63);
pushFollow(FOLLOW_expression_in_ordered_clause1073);
e1=expression();
state._fsp--;
stream_expression.add(e1.getTree());
RPAREN64=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_ordered_clause1075);
stream_RPAREN.add(RPAREN64);
}
break;
}
// AST REWRITE
// elements: e1, ORDERED
// token labels:
// rule labels: e1, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_e1=new RewriteRuleSubtreeStream(adaptor,"rule e1",e1!=null?e1.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 207:3: -> ^( ORDERED ( $e1)? )
{
// OmpParser.g:207:6: ^( ORDERED ( $e1)? )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_ORDERED.nextNode(), root_1);
// OmpParser.g:207:17: ( $e1)?
if ( stream_e1.hasNext() ) {
adaptor.addChild(root_1, stream_e1.nextTree());
}
stream_e1.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "ordered_clause"
public static class schedule_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "schedule_clause"
// OmpParser.g:210:1: schedule_clause : ( SCHEDULE LPAREN s1= schedule_kind COMMA e= expression RPAREN -> ^( SCHEDULE $s1 $e) | SCHEDULE LPAREN s= schedule_kind RPAREN -> ^( SCHEDULE $s) );
public final OmpParser.schedule_clause_return schedule_clause() throws RecognitionException {
OmpParser.schedule_clause_return retval = new OmpParser.schedule_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token SCHEDULE65=null;
Token LPAREN66=null;
Token COMMA67=null;
Token RPAREN68=null;
Token SCHEDULE69=null;
Token LPAREN70=null;
Token RPAREN71=null;
ParserRuleReturnScope s1 =null;
ParserRuleReturnScope e =null;
ParserRuleReturnScope s =null;
Object SCHEDULE65_tree=null;
Object LPAREN66_tree=null;
Object COMMA67_tree=null;
Object RPAREN68_tree=null;
Object SCHEDULE69_tree=null;
Object LPAREN70_tree=null;
Object RPAREN71_tree=null;
RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_SCHEDULE=new RewriteRuleTokenStream(adaptor,"token SCHEDULE");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_schedule_kind=new RewriteRuleSubtreeStream(adaptor,"rule schedule_kind");
RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
try {
// OmpParser.g:211:2: ( SCHEDULE LPAREN s1= schedule_kind COMMA e= expression RPAREN -> ^( SCHEDULE $s1 $e) | SCHEDULE LPAREN s= schedule_kind RPAREN -> ^( SCHEDULE $s) )
int alt22=2;
int LA22_0 = input.LA(1);
if ( (LA22_0==SCHEDULE) ) {
int LA22_1 = input.LA(2);
if ( (LA22_1==LPAREN) ) {
switch ( input.LA(3) ) {
case STATIC:
{
int LA22_3 = input.LA(4);
if ( (LA22_3==COMMA) ) {
alt22=1;
}
else if ( (LA22_3==RPAREN) ) {
alt22=2;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 22, 3, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case DYNAMIC:
{
int LA22_4 = input.LA(4);
if ( (LA22_4==COMMA) ) {
alt22=1;
}
else if ( (LA22_4==RPAREN) ) {
alt22=2;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 22, 4, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case GUIDED:
{
int LA22_5 = input.LA(4);
if ( (LA22_5==COMMA) ) {
alt22=1;
}
else if ( (LA22_5==RPAREN) ) {
alt22=2;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 22, 5, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case RUNTIME:
{
int LA22_6 = input.LA(4);
if ( (LA22_6==COMMA) ) {
alt22=1;
}
else if ( (LA22_6==RPAREN) ) {
alt22=2;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 22, 6, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case AUTO:
{
int LA22_7 = input.LA(4);
if ( (LA22_7==COMMA) ) {
alt22=1;
}
else if ( (LA22_7==RPAREN) ) {
alt22=2;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 22, 7, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
default:
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 22, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 22, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
NoViableAltException nvae =
new NoViableAltException("", 22, 0, input);
throw nvae;
}
switch (alt22) {
case 1 :
// OmpParser.g:211:4: SCHEDULE LPAREN s1= schedule_kind COMMA e= expression RPAREN
{
SCHEDULE65=(Token)match(input,SCHEDULE,FOLLOW_SCHEDULE_in_schedule_clause1103);
stream_SCHEDULE.add(SCHEDULE65);
LPAREN66=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_schedule_clause1106);
stream_LPAREN.add(LPAREN66);
pushFollow(FOLLOW_schedule_kind_in_schedule_clause1111);
s1=schedule_kind();
state._fsp--;
stream_schedule_kind.add(s1.getTree());
COMMA67=(Token)match(input,COMMA,FOLLOW_COMMA_in_schedule_clause1114);
stream_COMMA.add(COMMA67);
pushFollow(FOLLOW_expression_in_schedule_clause1119);
e=expression();
state._fsp--;
stream_expression.add(e.getTree());
RPAREN68=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_schedule_clause1122);
stream_RPAREN.add(RPAREN68);
// AST REWRITE
// elements: e, s1, SCHEDULE
// token labels:
// rule labels: e, s1, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_e=new RewriteRuleSubtreeStream(adaptor,"rule e",e!=null?e.getTree():null);
RewriteRuleSubtreeStream stream_s1=new RewriteRuleSubtreeStream(adaptor,"rule s1",s1!=null?s1.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 212:7: -> ^( SCHEDULE $s1 $e)
{
// OmpParser.g:212:10: ^( SCHEDULE $s1 $e)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_SCHEDULE.nextNode(), root_1);
adaptor.addChild(root_1, stream_s1.nextTree());
adaptor.addChild(root_1, stream_e.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// OmpParser.g:213:8: SCHEDULE LPAREN s= schedule_kind RPAREN
{
SCHEDULE69=(Token)match(input,SCHEDULE,FOLLOW_SCHEDULE_in_schedule_clause1149);
stream_SCHEDULE.add(SCHEDULE69);
LPAREN70=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_schedule_clause1152);
stream_LPAREN.add(LPAREN70);
pushFollow(FOLLOW_schedule_kind_in_schedule_clause1157);
s=schedule_kind();
state._fsp--;
stream_schedule_kind.add(s.getTree());
RPAREN71=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_schedule_clause1160);
stream_RPAREN.add(RPAREN71);
// AST REWRITE
// elements: SCHEDULE, s
// token labels:
// rule labels: s, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_s=new RewriteRuleSubtreeStream(adaptor,"rule s",s!=null?s.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 214:4: -> ^( SCHEDULE $s)
{
// OmpParser.g:214:7: ^( SCHEDULE $s)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_SCHEDULE.nextNode(), root_1);
adaptor.addChild(root_1, stream_s.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "schedule_clause"
public static class collapse_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "collapse_clause"
// OmpParser.g:217:1: collapse_clause : COLLAPSE LPAREN i= INTEGER_CONSTANT RPAREN -> ^( COLLAPSE $i) ;
public final OmpParser.collapse_clause_return collapse_clause() throws RecognitionException {
OmpParser.collapse_clause_return retval = new OmpParser.collapse_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token i=null;
Token COLLAPSE72=null;
Token LPAREN73=null;
Token RPAREN74=null;
Object i_tree=null;
Object COLLAPSE72_tree=null;
Object LPAREN73_tree=null;
Object RPAREN74_tree=null;
RewriteRuleTokenStream stream_COLLAPSE=new RewriteRuleTokenStream(adaptor,"token COLLAPSE");
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleTokenStream stream_INTEGER_CONSTANT=new RewriteRuleTokenStream(adaptor,"token INTEGER_CONSTANT");
try {
// OmpParser.g:218:2: ( COLLAPSE LPAREN i= INTEGER_CONSTANT RPAREN -> ^( COLLAPSE $i) )
// OmpParser.g:219:2: COLLAPSE LPAREN i= INTEGER_CONSTANT RPAREN
{
COLLAPSE72=(Token)match(input,COLLAPSE,FOLLOW_COLLAPSE_in_collapse_clause1185);
stream_COLLAPSE.add(COLLAPSE72);
LPAREN73=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_collapse_clause1188);
stream_LPAREN.add(LPAREN73);
i=(Token)match(input,INTEGER_CONSTANT,FOLLOW_INTEGER_CONSTANT_in_collapse_clause1193);
stream_INTEGER_CONSTANT.add(i);
RPAREN74=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_collapse_clause1196);
stream_RPAREN.add(RPAREN74);
// AST REWRITE
// elements: i, COLLAPSE
// token labels: i
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleTokenStream stream_i=new RewriteRuleTokenStream(adaptor,"token i",i);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 220:5: -> ^( COLLAPSE $i)
{
// OmpParser.g:220:8: ^( COLLAPSE $i)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_COLLAPSE.nextNode(), root_1);
adaptor.addChild(root_1, stream_i.nextNode());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "collapse_clause"
public static class schedule_kind_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "schedule_kind"
// OmpParser.g:223:1: schedule_kind : ( STATIC -> ^( STATIC ) | DYNAMIC -> ^( DYNAMIC ) | GUIDED -> ^( GUIDED ) | RUNTIME -> ^( RUNTIME ) | AUTO -> ^( AUTO ) );
public final OmpParser.schedule_kind_return schedule_kind() throws RecognitionException {
OmpParser.schedule_kind_return retval = new OmpParser.schedule_kind_return();
retval.start = input.LT(1);
Object root_0 = null;
Token STATIC75=null;
Token DYNAMIC76=null;
Token GUIDED77=null;
Token RUNTIME78=null;
Token AUTO79=null;
Object STATIC75_tree=null;
Object DYNAMIC76_tree=null;
Object GUIDED77_tree=null;
Object RUNTIME78_tree=null;
Object AUTO79_tree=null;
RewriteRuleTokenStream stream_GUIDED=new RewriteRuleTokenStream(adaptor,"token GUIDED");
RewriteRuleTokenStream stream_AUTO=new RewriteRuleTokenStream(adaptor,"token AUTO");
RewriteRuleTokenStream stream_RUNTIME=new RewriteRuleTokenStream(adaptor,"token RUNTIME");
RewriteRuleTokenStream stream_STATIC=new RewriteRuleTokenStream(adaptor,"token STATIC");
RewriteRuleTokenStream stream_DYNAMIC=new RewriteRuleTokenStream(adaptor,"token DYNAMIC");
try {
// OmpParser.g:224:3: ( STATIC -> ^( STATIC ) | DYNAMIC -> ^( DYNAMIC ) | GUIDED -> ^( GUIDED ) | RUNTIME -> ^( RUNTIME ) | AUTO -> ^( AUTO ) )
int alt23=5;
switch ( input.LA(1) ) {
case STATIC:
{
alt23=1;
}
break;
case DYNAMIC:
{
alt23=2;
}
break;
case GUIDED:
{
alt23=3;
}
break;
case RUNTIME:
{
alt23=4;
}
break;
case AUTO:
{
alt23=5;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 23, 0, input);
throw nvae;
}
switch (alt23) {
case 1 :
// OmpParser.g:224:5: STATIC
{
STATIC75=(Token)match(input,STATIC,FOLLOW_STATIC_in_schedule_kind1221);
stream_STATIC.add(STATIC75);
// AST REWRITE
// elements: STATIC
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 224:12: -> ^( STATIC )
{
// OmpParser.g:224:15: ^( STATIC )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_STATIC.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// OmpParser.g:225:5: DYNAMIC
{
DYNAMIC76=(Token)match(input,DYNAMIC,FOLLOW_DYNAMIC_in_schedule_kind1233);
stream_DYNAMIC.add(DYNAMIC76);
// AST REWRITE
// elements: DYNAMIC
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 225:13: -> ^( DYNAMIC )
{
// OmpParser.g:225:16: ^( DYNAMIC )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_DYNAMIC.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 3 :
// OmpParser.g:226:5: GUIDED
{
GUIDED77=(Token)match(input,GUIDED,FOLLOW_GUIDED_in_schedule_kind1245);
stream_GUIDED.add(GUIDED77);
// AST REWRITE
// elements: GUIDED
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 226:12: -> ^( GUIDED )
{
// OmpParser.g:226:15: ^( GUIDED )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_GUIDED.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 4 :
// OmpParser.g:227:5: RUNTIME
{
RUNTIME78=(Token)match(input,RUNTIME,FOLLOW_RUNTIME_in_schedule_kind1257);
stream_RUNTIME.add(RUNTIME78);
// AST REWRITE
// elements: RUNTIME
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 227:13: -> ^( RUNTIME )
{
// OmpParser.g:227:16: ^( RUNTIME )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_RUNTIME.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 5 :
// OmpParser.g:228:5: AUTO
{
AUTO79=(Token)match(input,AUTO,FOLLOW_AUTO_in_schedule_kind1269);
stream_AUTO.add(AUTO79);
// AST REWRITE
// elements: AUTO
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 228:10: -> ^( AUTO )
{
// OmpParser.g:228:13: ^( AUTO )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_AUTO.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "schedule_kind"
public static class unique_parallel_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "unique_parallel_clause"
// OmpParser.g:231:1: unique_parallel_clause : (i= if_clause -> ^( UNIQUE_PARALLEL $i) |n= num_threads_clause -> ^( UNIQUE_PARALLEL $n) );
public final OmpParser.unique_parallel_clause_return unique_parallel_clause() throws RecognitionException {
OmpParser.unique_parallel_clause_return retval = new OmpParser.unique_parallel_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
ParserRuleReturnScope i =null;
ParserRuleReturnScope n =null;
RewriteRuleSubtreeStream stream_num_threads_clause=new RewriteRuleSubtreeStream(adaptor,"rule num_threads_clause");
RewriteRuleSubtreeStream stream_if_clause=new RewriteRuleSubtreeStream(adaptor,"rule if_clause");
try {
// OmpParser.g:232:3: (i= if_clause -> ^( UNIQUE_PARALLEL $i) |n= num_threads_clause -> ^( UNIQUE_PARALLEL $n) )
int alt24=2;
int LA24_0 = input.LA(1);
if ( (LA24_0==IF) ) {
alt24=1;
}
else if ( (LA24_0==NUM_THREADS) ) {
alt24=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 24, 0, input);
throw nvae;
}
switch (alt24) {
case 1 :
// OmpParser.g:232:5: i= if_clause
{
pushFollow(FOLLOW_if_clause_in_unique_parallel_clause1290);
i=if_clause();
state._fsp--;
stream_if_clause.add(i.getTree());
// AST REWRITE
// elements: i
// token labels:
// rule labels: i, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_i=new RewriteRuleSubtreeStream(adaptor,"rule i",i!=null?i.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 233:5: -> ^( UNIQUE_PARALLEL $i)
{
// OmpParser.g:233:8: ^( UNIQUE_PARALLEL $i)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(UNIQUE_PARALLEL, "UNIQUE_PARALLEL"), root_1);
adaptor.addChild(root_1, stream_i.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// OmpParser.g:234:5: n= num_threads_clause
{
pushFollow(FOLLOW_num_threads_clause_in_unique_parallel_clause1312);
n=num_threads_clause();
state._fsp--;
stream_num_threads_clause.add(n.getTree());
// AST REWRITE
// elements: n
// token labels:
// rule labels: n, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_n=new RewriteRuleSubtreeStream(adaptor,"rule n",n!=null?n.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 235:5: -> ^( UNIQUE_PARALLEL $n)
{
// OmpParser.g:235:8: ^( UNIQUE_PARALLEL $n)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(UNIQUE_PARALLEL, "UNIQUE_PARALLEL"), root_1);
adaptor.addChild(root_1, stream_n.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "unique_parallel_clause"
public static class if_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "if_clause"
// OmpParser.g:238:1: if_clause : IF LPAREN e1= expression RPAREN -> ^( IF $e1) ;
public final OmpParser.if_clause_return if_clause() throws RecognitionException {
OmpParser.if_clause_return retval = new OmpParser.if_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token IF80=null;
Token LPAREN81=null;
Token RPAREN82=null;
ParserRuleReturnScope e1 =null;
Object IF80_tree=null;
Object LPAREN81_tree=null;
Object RPAREN82_tree=null;
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleTokenStream stream_IF=new RewriteRuleTokenStream(adaptor,"token IF");
RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
try {
// OmpParser.g:239:3: ( IF LPAREN e1= expression RPAREN -> ^( IF $e1) )
// OmpParser.g:239:5: IF LPAREN e1= expression RPAREN
{
IF80=(Token)match(input,IF,FOLLOW_IF_in_if_clause1341);
stream_IF.add(IF80);
LPAREN81=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_if_clause1344);
stream_LPAREN.add(LPAREN81);
pushFollow(FOLLOW_expression_in_if_clause1349);
e1=expression();
state._fsp--;
stream_expression.add(e1.getTree());
RPAREN82=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_if_clause1352);
stream_RPAREN.add(RPAREN82);
// AST REWRITE
// elements: IF, e1
// token labels:
// rule labels: e1, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_e1=new RewriteRuleSubtreeStream(adaptor,"rule e1",e1!=null?e1.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 240:5: -> ^( IF $e1)
{
// OmpParser.g:240:8: ^( IF $e1)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_IF.nextNode(), root_1);
adaptor.addChild(root_1, stream_e1.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "if_clause"
public static class num_threads_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "num_threads_clause"
// OmpParser.g:243:1: num_threads_clause : NUM_THREADS LPAREN e2= expression RPAREN -> ^( NUM_THREADS $e2) ;
public final OmpParser.num_threads_clause_return num_threads_clause() throws RecognitionException {
OmpParser.num_threads_clause_return retval = new OmpParser.num_threads_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token NUM_THREADS83=null;
Token LPAREN84=null;
Token RPAREN85=null;
ParserRuleReturnScope e2 =null;
Object NUM_THREADS83_tree=null;
Object LPAREN84_tree=null;
Object RPAREN85_tree=null;
RewriteRuleTokenStream stream_NUM_THREADS=new RewriteRuleTokenStream(adaptor,"token NUM_THREADS");
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
try {
// OmpParser.g:244:3: ( NUM_THREADS LPAREN e2= expression RPAREN -> ^( NUM_THREADS $e2) )
// OmpParser.g:244:5: NUM_THREADS LPAREN e2= expression RPAREN
{
NUM_THREADS83=(Token)match(input,NUM_THREADS,FOLLOW_NUM_THREADS_in_num_threads_clause1380);
stream_NUM_THREADS.add(NUM_THREADS83);
LPAREN84=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_num_threads_clause1383);
stream_LPAREN.add(LPAREN84);
pushFollow(FOLLOW_expression_in_num_threads_clause1388);
e2=expression();
state._fsp--;
stream_expression.add(e2.getTree());
RPAREN85=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_num_threads_clause1391);
stream_RPAREN.add(RPAREN85);
// AST REWRITE
// elements: e2, NUM_THREADS
// token labels:
// rule labels: e2, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_e2=new RewriteRuleSubtreeStream(adaptor,"rule e2",e2!=null?e2.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 245:5: -> ^( NUM_THREADS $e2)
{
// OmpParser.g:245:8: ^( NUM_THREADS $e2)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_NUM_THREADS.nextNode(), root_1);
adaptor.addChild(root_1, stream_e2.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "num_threads_clause"
public static class data_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "data_clause"
// OmpParser.g:248:1: data_clause : (d1= private_clause -> ^( DATA_CLAUSE $d1) |d2= firstprivate_clause -> ^( DATA_CLAUSE $d2) |d3= lastprivate_clause -> ^( DATA_CLAUSE $d3) |d4= shared_clause -> ^( DATA_CLAUSE $d4) |d5= default_clause -> ^( DATA_CLAUSE $d5) |d6= reduction_clause -> ^( DATA_CLAUSE $d6) |d7= copyin_clause -> ^( DATA_CLAUSE $d7) |d8= copyprivate_clause -> ^( DATA_CLAUSE $d8) );
public final OmpParser.data_clause_return data_clause() throws RecognitionException {
OmpParser.data_clause_return retval = new OmpParser.data_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
ParserRuleReturnScope d1 =null;
ParserRuleReturnScope d2 =null;
ParserRuleReturnScope d3 =null;
ParserRuleReturnScope d4 =null;
ParserRuleReturnScope d5 =null;
ParserRuleReturnScope d6 =null;
ParserRuleReturnScope d7 =null;
ParserRuleReturnScope d8 =null;
RewriteRuleSubtreeStream stream_lastprivate_clause=new RewriteRuleSubtreeStream(adaptor,"rule lastprivate_clause");
RewriteRuleSubtreeStream stream_shared_clause=new RewriteRuleSubtreeStream(adaptor,"rule shared_clause");
RewriteRuleSubtreeStream stream_reduction_clause=new RewriteRuleSubtreeStream(adaptor,"rule reduction_clause");
RewriteRuleSubtreeStream stream_default_clause=new RewriteRuleSubtreeStream(adaptor,"rule default_clause");
RewriteRuleSubtreeStream stream_copyprivate_clause=new RewriteRuleSubtreeStream(adaptor,"rule copyprivate_clause");
RewriteRuleSubtreeStream stream_copyin_clause=new RewriteRuleSubtreeStream(adaptor,"rule copyin_clause");
RewriteRuleSubtreeStream stream_firstprivate_clause=new RewriteRuleSubtreeStream(adaptor,"rule firstprivate_clause");
RewriteRuleSubtreeStream stream_private_clause=new RewriteRuleSubtreeStream(adaptor,"rule private_clause");
try {
// OmpParser.g:249:3: (d1= private_clause -> ^( DATA_CLAUSE $d1) |d2= firstprivate_clause -> ^( DATA_CLAUSE $d2) |d3= lastprivate_clause -> ^( DATA_CLAUSE $d3) |d4= shared_clause -> ^( DATA_CLAUSE $d4) |d5= default_clause -> ^( DATA_CLAUSE $d5) |d6= reduction_clause -> ^( DATA_CLAUSE $d6) |d7= copyin_clause -> ^( DATA_CLAUSE $d7) |d8= copyprivate_clause -> ^( DATA_CLAUSE $d8) )
int alt25=8;
switch ( input.LA(1) ) {
case PRIVATE:
{
alt25=1;
}
break;
case FST_PRIVATE:
{
alt25=2;
}
break;
case LST_PRIVATE:
{
alt25=3;
}
break;
case SHARED:
{
alt25=4;
}
break;
case DEFAULT:
{
alt25=5;
}
break;
case REDUCTION:
{
alt25=6;
}
break;
case COPYIN:
{
alt25=7;
}
break;
case COPYPRIVATE:
{
alt25=8;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 25, 0, input);
throw nvae;
}
switch (alt25) {
case 1 :
// OmpParser.g:249:5: d1= private_clause
{
pushFollow(FOLLOW_private_clause_in_data_clause1419);
d1=private_clause();
state._fsp--;
stream_private_clause.add(d1.getTree());
// AST REWRITE
// elements: d1
// token labels:
// rule labels: d1, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_d1=new RewriteRuleSubtreeStream(adaptor,"rule d1",d1!=null?d1.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 250:5: -> ^( DATA_CLAUSE $d1)
{
// OmpParser.g:250:8: ^( DATA_CLAUSE $d1)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(DATA_CLAUSE, "DATA_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d1.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// OmpParser.g:251:5: d2= firstprivate_clause
{
pushFollow(FOLLOW_firstprivate_clause_in_data_clause1440);
d2=firstprivate_clause();
state._fsp--;
stream_firstprivate_clause.add(d2.getTree());
// AST REWRITE
// elements: d2
// token labels:
// rule labels: d2, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_d2=new RewriteRuleSubtreeStream(adaptor,"rule d2",d2!=null?d2.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 252:5: -> ^( DATA_CLAUSE $d2)
{
// OmpParser.g:252:8: ^( DATA_CLAUSE $d2)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(DATA_CLAUSE, "DATA_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d2.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 3 :
// OmpParser.g:253:5: d3= lastprivate_clause
{
pushFollow(FOLLOW_lastprivate_clause_in_data_clause1461);
d3=lastprivate_clause();
state._fsp--;
stream_lastprivate_clause.add(d3.getTree());
// AST REWRITE
// elements: d3
// token labels:
// rule labels: retval, d3
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
RewriteRuleSubtreeStream stream_d3=new RewriteRuleSubtreeStream(adaptor,"rule d3",d3!=null?d3.getTree():null);
root_0 = (Object)adaptor.nil();
// 254:5: -> ^( DATA_CLAUSE $d3)
{
// OmpParser.g:254:8: ^( DATA_CLAUSE $d3)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(DATA_CLAUSE, "DATA_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d3.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 4 :
// OmpParser.g:255:5: d4= shared_clause
{
pushFollow(FOLLOW_shared_clause_in_data_clause1482);
d4=shared_clause();
state._fsp--;
stream_shared_clause.add(d4.getTree());
// AST REWRITE
// elements: d4
// token labels:
// rule labels: d4, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_d4=new RewriteRuleSubtreeStream(adaptor,"rule d4",d4!=null?d4.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 256:5: -> ^( DATA_CLAUSE $d4)
{
// OmpParser.g:256:8: ^( DATA_CLAUSE $d4)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(DATA_CLAUSE, "DATA_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d4.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 5 :
// OmpParser.g:257:5: d5= default_clause
{
pushFollow(FOLLOW_default_clause_in_data_clause1503);
d5=default_clause();
state._fsp--;
stream_default_clause.add(d5.getTree());
// AST REWRITE
// elements: d5
// token labels:
// rule labels: d5, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_d5=new RewriteRuleSubtreeStream(adaptor,"rule d5",d5!=null?d5.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 258:5: -> ^( DATA_CLAUSE $d5)
{
// OmpParser.g:258:8: ^( DATA_CLAUSE $d5)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(DATA_CLAUSE, "DATA_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d5.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 6 :
// OmpParser.g:259:5: d6= reduction_clause
{
pushFollow(FOLLOW_reduction_clause_in_data_clause1524);
d6=reduction_clause();
state._fsp--;
stream_reduction_clause.add(d6.getTree());
// AST REWRITE
// elements: d6
// token labels:
// rule labels: d6, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_d6=new RewriteRuleSubtreeStream(adaptor,"rule d6",d6!=null?d6.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 260:5: -> ^( DATA_CLAUSE $d6)
{
// OmpParser.g:260:8: ^( DATA_CLAUSE $d6)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(DATA_CLAUSE, "DATA_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d6.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 7 :
// OmpParser.g:261:5: d7= copyin_clause
{
pushFollow(FOLLOW_copyin_clause_in_data_clause1545);
d7=copyin_clause();
state._fsp--;
stream_copyin_clause.add(d7.getTree());
// AST REWRITE
// elements: d7
// token labels:
// rule labels: d7, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_d7=new RewriteRuleSubtreeStream(adaptor,"rule d7",d7!=null?d7.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 262:5: -> ^( DATA_CLAUSE $d7)
{
// OmpParser.g:262:8: ^( DATA_CLAUSE $d7)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(DATA_CLAUSE, "DATA_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d7.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 8 :
// OmpParser.g:263:5: d8= copyprivate_clause
{
pushFollow(FOLLOW_copyprivate_clause_in_data_clause1566);
d8=copyprivate_clause();
state._fsp--;
stream_copyprivate_clause.add(d8.getTree());
// AST REWRITE
// elements: d8
// token labels:
// rule labels: d8, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_d8=new RewriteRuleSubtreeStream(adaptor,"rule d8",d8!=null?d8.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 264:5: -> ^( DATA_CLAUSE $d8)
{
// OmpParser.g:264:8: ^( DATA_CLAUSE $d8)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(DATA_CLAUSE, "DATA_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d8.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "data_clause"
public static class private_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "private_clause"
// OmpParser.g:267:1: private_clause : PRIVATE LPAREN i1= identifier_list RPAREN -> ^( PRIVATE $i1) ;
public final OmpParser.private_clause_return private_clause() throws RecognitionException {
OmpParser.private_clause_return retval = new OmpParser.private_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token PRIVATE86=null;
Token LPAREN87=null;
Token RPAREN88=null;
ParserRuleReturnScope i1 =null;
Object PRIVATE86_tree=null;
Object LPAREN87_tree=null;
Object RPAREN88_tree=null;
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleTokenStream stream_PRIVATE=new RewriteRuleTokenStream(adaptor,"token PRIVATE");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// OmpParser.g:268:3: ( PRIVATE LPAREN i1= identifier_list RPAREN -> ^( PRIVATE $i1) )
// OmpParser.g:268:5: PRIVATE LPAREN i1= identifier_list RPAREN
{
PRIVATE86=(Token)match(input,PRIVATE,FOLLOW_PRIVATE_in_private_clause1594);
stream_PRIVATE.add(PRIVATE86);
LPAREN87=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_private_clause1597);
stream_LPAREN.add(LPAREN87);
pushFollow(FOLLOW_identifier_list_in_private_clause1602);
i1=identifier_list();
state._fsp--;
stream_identifier_list.add(i1.getTree());
RPAREN88=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_private_clause1605);
stream_RPAREN.add(RPAREN88);
// AST REWRITE
// elements: i1, PRIVATE
// token labels:
// rule labels: i1, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_i1=new RewriteRuleSubtreeStream(adaptor,"rule i1",i1!=null?i1.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 269:5: -> ^( PRIVATE $i1)
{
// OmpParser.g:269:8: ^( PRIVATE $i1)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_PRIVATE.nextNode(), root_1);
adaptor.addChild(root_1, stream_i1.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "private_clause"
public static class firstprivate_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "firstprivate_clause"
// OmpParser.g:272:1: firstprivate_clause : FST_PRIVATE LPAREN i2= identifier_list RPAREN -> ^( FST_PRIVATE $i2) ;
public final OmpParser.firstprivate_clause_return firstprivate_clause() throws RecognitionException {
OmpParser.firstprivate_clause_return retval = new OmpParser.firstprivate_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token FST_PRIVATE89=null;
Token LPAREN90=null;
Token RPAREN91=null;
ParserRuleReturnScope i2 =null;
Object FST_PRIVATE89_tree=null;
Object LPAREN90_tree=null;
Object RPAREN91_tree=null;
RewriteRuleTokenStream stream_FST_PRIVATE=new RewriteRuleTokenStream(adaptor,"token FST_PRIVATE");
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// OmpParser.g:273:3: ( FST_PRIVATE LPAREN i2= identifier_list RPAREN -> ^( FST_PRIVATE $i2) )
// OmpParser.g:273:5: FST_PRIVATE LPAREN i2= identifier_list RPAREN
{
FST_PRIVATE89=(Token)match(input,FST_PRIVATE,FOLLOW_FST_PRIVATE_in_firstprivate_clause1634);
stream_FST_PRIVATE.add(FST_PRIVATE89);
LPAREN90=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_firstprivate_clause1637);
stream_LPAREN.add(LPAREN90);
pushFollow(FOLLOW_identifier_list_in_firstprivate_clause1642);
i2=identifier_list();
state._fsp--;
stream_identifier_list.add(i2.getTree());
RPAREN91=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_firstprivate_clause1645);
stream_RPAREN.add(RPAREN91);
// AST REWRITE
// elements: i2, FST_PRIVATE
// token labels:
// rule labels: i2, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_i2=new RewriteRuleSubtreeStream(adaptor,"rule i2",i2!=null?i2.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 274:5: -> ^( FST_PRIVATE $i2)
{
// OmpParser.g:274:8: ^( FST_PRIVATE $i2)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_FST_PRIVATE.nextNode(), root_1);
adaptor.addChild(root_1, stream_i2.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "firstprivate_clause"
public static class lastprivate_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "lastprivate_clause"
// OmpParser.g:277:1: lastprivate_clause : LST_PRIVATE LPAREN i3= identifier_list RPAREN -> ^( LST_PRIVATE $i3) ;
public final OmpParser.lastprivate_clause_return lastprivate_clause() throws RecognitionException {
OmpParser.lastprivate_clause_return retval = new OmpParser.lastprivate_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token LST_PRIVATE92=null;
Token LPAREN93=null;
Token RPAREN94=null;
ParserRuleReturnScope i3 =null;
Object LST_PRIVATE92_tree=null;
Object LPAREN93_tree=null;
Object RPAREN94_tree=null;
RewriteRuleTokenStream stream_LST_PRIVATE=new RewriteRuleTokenStream(adaptor,"token LST_PRIVATE");
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// OmpParser.g:278:3: ( LST_PRIVATE LPAREN i3= identifier_list RPAREN -> ^( LST_PRIVATE $i3) )
// OmpParser.g:278:5: LST_PRIVATE LPAREN i3= identifier_list RPAREN
{
LST_PRIVATE92=(Token)match(input,LST_PRIVATE,FOLLOW_LST_PRIVATE_in_lastprivate_clause1673);
stream_LST_PRIVATE.add(LST_PRIVATE92);
LPAREN93=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_lastprivate_clause1676);
stream_LPAREN.add(LPAREN93);
pushFollow(FOLLOW_identifier_list_in_lastprivate_clause1681);
i3=identifier_list();
state._fsp--;
stream_identifier_list.add(i3.getTree());
RPAREN94=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_lastprivate_clause1684);
stream_RPAREN.add(RPAREN94);
// AST REWRITE
// elements: i3, LST_PRIVATE
// token labels:
// rule labels: i3, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_i3=new RewriteRuleSubtreeStream(adaptor,"rule i3",i3!=null?i3.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 279:5: -> ^( LST_PRIVATE $i3)
{
// OmpParser.g:279:8: ^( LST_PRIVATE $i3)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_LST_PRIVATE.nextNode(), root_1);
adaptor.addChild(root_1, stream_i3.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lastprivate_clause"
public static class shared_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "shared_clause"
// OmpParser.g:282:1: shared_clause : SHARED LPAREN i4= identifier_list RPAREN -> ^( SHARED $i4) ;
public final OmpParser.shared_clause_return shared_clause() throws RecognitionException {
OmpParser.shared_clause_return retval = new OmpParser.shared_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token SHARED95=null;
Token LPAREN96=null;
Token RPAREN97=null;
ParserRuleReturnScope i4 =null;
Object SHARED95_tree=null;
Object LPAREN96_tree=null;
Object RPAREN97_tree=null;
RewriteRuleTokenStream stream_SHARED=new RewriteRuleTokenStream(adaptor,"token SHARED");
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// OmpParser.g:283:3: ( SHARED LPAREN i4= identifier_list RPAREN -> ^( SHARED $i4) )
// OmpParser.g:283:5: SHARED LPAREN i4= identifier_list RPAREN
{
SHARED95=(Token)match(input,SHARED,FOLLOW_SHARED_in_shared_clause1712);
stream_SHARED.add(SHARED95);
LPAREN96=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_shared_clause1715);
stream_LPAREN.add(LPAREN96);
pushFollow(FOLLOW_identifier_list_in_shared_clause1720);
i4=identifier_list();
state._fsp--;
stream_identifier_list.add(i4.getTree());
RPAREN97=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_shared_clause1723);
stream_RPAREN.add(RPAREN97);
// AST REWRITE
// elements: i4, SHARED
// token labels:
// rule labels: i4, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_i4=new RewriteRuleSubtreeStream(adaptor,"rule i4",i4!=null?i4.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 284:5: -> ^( SHARED $i4)
{
// OmpParser.g:284:8: ^( SHARED $i4)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_SHARED.nextNode(), root_1);
adaptor.addChild(root_1, stream_i4.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "shared_clause"
public static class default_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "default_clause"
// OmpParser.g:287:1: default_clause : ( DEFAULT LPAREN SHARED RPAREN -> ^( DEFAULT SHARED ) | DEFAULT LPAREN NONE RPAREN -> ^( DEFAULT NONE ) );
public final OmpParser.default_clause_return default_clause() throws RecognitionException {
OmpParser.default_clause_return retval = new OmpParser.default_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token DEFAULT98=null;
Token LPAREN99=null;
Token SHARED100=null;
Token RPAREN101=null;
Token DEFAULT102=null;
Token LPAREN103=null;
Token NONE104=null;
Token RPAREN105=null;
Object DEFAULT98_tree=null;
Object LPAREN99_tree=null;
Object SHARED100_tree=null;
Object RPAREN101_tree=null;
Object DEFAULT102_tree=null;
Object LPAREN103_tree=null;
Object NONE104_tree=null;
Object RPAREN105_tree=null;
RewriteRuleTokenStream stream_SHARED=new RewriteRuleTokenStream(adaptor,"token SHARED");
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleTokenStream stream_NONE=new RewriteRuleTokenStream(adaptor,"token NONE");
RewriteRuleTokenStream stream_DEFAULT=new RewriteRuleTokenStream(adaptor,"token DEFAULT");
try {
// OmpParser.g:288:3: ( DEFAULT LPAREN SHARED RPAREN -> ^( DEFAULT SHARED ) | DEFAULT LPAREN NONE RPAREN -> ^( DEFAULT NONE ) )
int alt26=2;
int LA26_0 = input.LA(1);
if ( (LA26_0==DEFAULT) ) {
int LA26_1 = input.LA(2);
if ( (LA26_1==LPAREN) ) {
int LA26_2 = input.LA(3);
if ( (LA26_2==SHARED) ) {
alt26=1;
}
else if ( (LA26_2==NONE) ) {
alt26=2;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 26, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 26, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
NoViableAltException nvae =
new NoViableAltException("", 26, 0, input);
throw nvae;
}
switch (alt26) {
case 1 :
// OmpParser.g:288:5: DEFAULT LPAREN SHARED RPAREN
{
DEFAULT98=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_default_clause1751);
stream_DEFAULT.add(DEFAULT98);
LPAREN99=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_default_clause1754);
stream_LPAREN.add(LPAREN99);
SHARED100=(Token)match(input,SHARED,FOLLOW_SHARED_in_default_clause1757);
stream_SHARED.add(SHARED100);
RPAREN101=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_default_clause1760);
stream_RPAREN.add(RPAREN101);
// AST REWRITE
// elements: DEFAULT, SHARED
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 289:5: -> ^( DEFAULT SHARED )
{
// OmpParser.g:289:8: ^( DEFAULT SHARED )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_DEFAULT.nextNode(), root_1);
adaptor.addChild(root_1, stream_SHARED.nextNode());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// OmpParser.g:290:5: DEFAULT LPAREN NONE RPAREN
{
DEFAULT102=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_default_clause1778);
stream_DEFAULT.add(DEFAULT102);
LPAREN103=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_default_clause1781);
stream_LPAREN.add(LPAREN103);
NONE104=(Token)match(input,NONE,FOLLOW_NONE_in_default_clause1784);
stream_NONE.add(NONE104);
RPAREN105=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_default_clause1787);
stream_RPAREN.add(RPAREN105);
// AST REWRITE
// elements: DEFAULT, NONE
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 291:5: -> ^( DEFAULT NONE )
{
// OmpParser.g:291:8: ^( DEFAULT NONE )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_DEFAULT.nextNode(), root_1);
adaptor.addChild(root_1, stream_NONE.nextNode());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "default_clause"
public static class reduction_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "reduction_clause"
// OmpParser.g:294:1: reduction_clause : REDUCTION LPAREN r= reduction_operator COLON i5= identifier_list RPAREN -> ^( REDUCTION $r $i5) ;
public final OmpParser.reduction_clause_return reduction_clause() throws RecognitionException {
OmpParser.reduction_clause_return retval = new OmpParser.reduction_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token REDUCTION106=null;
Token LPAREN107=null;
Token COLON108=null;
Token RPAREN109=null;
ParserRuleReturnScope r =null;
ParserRuleReturnScope i5 =null;
Object REDUCTION106_tree=null;
Object LPAREN107_tree=null;
Object COLON108_tree=null;
Object RPAREN109_tree=null;
RewriteRuleTokenStream stream_REDUCTION=new RewriteRuleTokenStream(adaptor,"token REDUCTION");
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_reduction_operator=new RewriteRuleSubtreeStream(adaptor,"rule reduction_operator");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// OmpParser.g:295:3: ( REDUCTION LPAREN r= reduction_operator COLON i5= identifier_list RPAREN -> ^( REDUCTION $r $i5) )
// OmpParser.g:295:5: REDUCTION LPAREN r= reduction_operator COLON i5= identifier_list RPAREN
{
REDUCTION106=(Token)match(input,REDUCTION,FOLLOW_REDUCTION_in_reduction_clause1814);
stream_REDUCTION.add(REDUCTION106);
LPAREN107=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_reduction_clause1816);
stream_LPAREN.add(LPAREN107);
pushFollow(FOLLOW_reduction_operator_in_reduction_clause1820);
r=reduction_operator();
state._fsp--;
stream_reduction_operator.add(r.getTree());
COLON108=(Token)match(input,COLON,FOLLOW_COLON_in_reduction_clause1822);
stream_COLON.add(COLON108);
pushFollow(FOLLOW_identifier_list_in_reduction_clause1826);
i5=identifier_list();
state._fsp--;
stream_identifier_list.add(i5.getTree());
RPAREN109=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_reduction_clause1828);
stream_RPAREN.add(RPAREN109);
// AST REWRITE
// elements: i5, REDUCTION, r
// token labels:
// rule labels: r, i5, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_r=new RewriteRuleSubtreeStream(adaptor,"rule r",r!=null?r.getTree():null);
RewriteRuleSubtreeStream stream_i5=new RewriteRuleSubtreeStream(adaptor,"rule i5",i5!=null?i5.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 296:5: -> ^( REDUCTION $r $i5)
{
// OmpParser.g:296:8: ^( REDUCTION $r $i5)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_REDUCTION.nextNode(), root_1);
adaptor.addChild(root_1, stream_r.nextTree());
adaptor.addChild(root_1, stream_i5.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "reduction_clause"
public static class copyin_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "copyin_clause"
// OmpParser.g:299:1: copyin_clause : COPYIN LPAREN i6= identifier_list RPAREN -> ^( COPYIN $i6) ;
public final OmpParser.copyin_clause_return copyin_clause() throws RecognitionException {
OmpParser.copyin_clause_return retval = new OmpParser.copyin_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token COPYIN110=null;
Token LPAREN111=null;
Token RPAREN112=null;
ParserRuleReturnScope i6 =null;
Object COPYIN110_tree=null;
Object LPAREN111_tree=null;
Object RPAREN112_tree=null;
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_COPYIN=new RewriteRuleTokenStream(adaptor,"token COPYIN");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// OmpParser.g:300:3: ( COPYIN LPAREN i6= identifier_list RPAREN -> ^( COPYIN $i6) )
// OmpParser.g:300:5: COPYIN LPAREN i6= identifier_list RPAREN
{
COPYIN110=(Token)match(input,COPYIN,FOLLOW_COPYIN_in_copyin_clause1859);
stream_COPYIN.add(COPYIN110);
LPAREN111=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_copyin_clause1862);
stream_LPAREN.add(LPAREN111);
pushFollow(FOLLOW_identifier_list_in_copyin_clause1867);
i6=identifier_list();
state._fsp--;
stream_identifier_list.add(i6.getTree());
RPAREN112=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_copyin_clause1870);
stream_RPAREN.add(RPAREN112);
// AST REWRITE
// elements: i6, COPYIN
// token labels:
// rule labels: i6, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_i6=new RewriteRuleSubtreeStream(adaptor,"rule i6",i6!=null?i6.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 301:5: -> ^( COPYIN $i6)
{
// OmpParser.g:301:8: ^( COPYIN $i6)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_COPYIN.nextNode(), root_1);
adaptor.addChild(root_1, stream_i6.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "copyin_clause"
public static class copyprivate_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "copyprivate_clause"
// OmpParser.g:304:1: copyprivate_clause : COPYPRIVATE LPAREN i7= identifier_list RPAREN -> ^( COPYPRIVATE $i7) ;
public final OmpParser.copyprivate_clause_return copyprivate_clause() throws RecognitionException {
OmpParser.copyprivate_clause_return retval = new OmpParser.copyprivate_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token COPYPRIVATE113=null;
Token LPAREN114=null;
Token RPAREN115=null;
ParserRuleReturnScope i7 =null;
Object COPYPRIVATE113_tree=null;
Object LPAREN114_tree=null;
Object RPAREN115_tree=null;
RewriteRuleTokenStream stream_COPYPRIVATE=new RewriteRuleTokenStream(adaptor,"token COPYPRIVATE");
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// OmpParser.g:305:3: ( COPYPRIVATE LPAREN i7= identifier_list RPAREN -> ^( COPYPRIVATE $i7) )
// OmpParser.g:305:5: COPYPRIVATE LPAREN i7= identifier_list RPAREN
{
COPYPRIVATE113=(Token)match(input,COPYPRIVATE,FOLLOW_COPYPRIVATE_in_copyprivate_clause1898);
stream_COPYPRIVATE.add(COPYPRIVATE113);
LPAREN114=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_copyprivate_clause1901);
stream_LPAREN.add(LPAREN114);
pushFollow(FOLLOW_identifier_list_in_copyprivate_clause1906);
i7=identifier_list();
state._fsp--;
stream_identifier_list.add(i7.getTree());
RPAREN115=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_copyprivate_clause1909);
stream_RPAREN.add(RPAREN115);
// AST REWRITE
// elements: i7, COPYPRIVATE
// token labels:
// rule labels: i7, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_i7=new RewriteRuleSubtreeStream(adaptor,"rule i7",i7!=null?i7.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 306:5: -> ^( COPYPRIVATE $i7)
{
// OmpParser.g:306:8: ^( COPYPRIVATE $i7)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_COPYPRIVATE.nextNode(), root_1);
adaptor.addChild(root_1, stream_i7.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "copyprivate_clause"
public static class reduction_operator_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "reduction_operator"
// OmpParser.g:309:1: reduction_operator : ( PLUS -> ^( PLUS ) | STAR -> ^( STAR ) | SUB -> ^( SUB ) | AMPERSAND -> ^( AMPERSAND ) | BITXOR -> ^( BITXOR ) | BITOR -> ^( BITOR ) | AND -> ^( AND ) | OR -> ^( OR ) | IDENTIFIER -> ^( IDENTIFIER ) );
public final OmpParser.reduction_operator_return reduction_operator() throws RecognitionException {
OmpParser.reduction_operator_return retval = new OmpParser.reduction_operator_return();
retval.start = input.LT(1);
Object root_0 = null;
Token PLUS116=null;
Token STAR117=null;
Token SUB118=null;
Token AMPERSAND119=null;
Token BITXOR120=null;
Token BITOR121=null;
Token AND122=null;
Token OR123=null;
Token IDENTIFIER124=null;
Object PLUS116_tree=null;
Object STAR117_tree=null;
Object SUB118_tree=null;
Object AMPERSAND119_tree=null;
Object BITXOR120_tree=null;
Object BITOR121_tree=null;
Object AND122_tree=null;
Object OR123_tree=null;
Object IDENTIFIER124_tree=null;
RewriteRuleTokenStream stream_AMPERSAND=new RewriteRuleTokenStream(adaptor,"token AMPERSAND");
RewriteRuleTokenStream stream_SUB=new RewriteRuleTokenStream(adaptor,"token SUB");
RewriteRuleTokenStream stream_BITXOR=new RewriteRuleTokenStream(adaptor,"token BITXOR");
RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
RewriteRuleTokenStream stream_STAR=new RewriteRuleTokenStream(adaptor,"token STAR");
RewriteRuleTokenStream stream_BITOR=new RewriteRuleTokenStream(adaptor,"token BITOR");
RewriteRuleTokenStream stream_AND=new RewriteRuleTokenStream(adaptor,"token AND");
RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
RewriteRuleTokenStream stream_PLUS=new RewriteRuleTokenStream(adaptor,"token PLUS");
try {
// OmpParser.g:310:3: ( PLUS -> ^( PLUS ) | STAR -> ^( STAR ) | SUB -> ^( SUB ) | AMPERSAND -> ^( AMPERSAND ) | BITXOR -> ^( BITXOR ) | BITOR -> ^( BITOR ) | AND -> ^( AND ) | OR -> ^( OR ) | IDENTIFIER -> ^( IDENTIFIER ) )
int alt27=9;
switch ( input.LA(1) ) {
case PLUS:
{
alt27=1;
}
break;
case STAR:
{
alt27=2;
}
break;
case SUB:
{
alt27=3;
}
break;
case AMPERSAND:
{
alt27=4;
}
break;
case BITXOR:
{
alt27=5;
}
break;
case BITOR:
{
alt27=6;
}
break;
case AND:
{
alt27=7;
}
break;
case OR:
{
alt27=8;
}
break;
case IDENTIFIER:
{
alt27=9;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 27, 0, input);
throw nvae;
}
switch (alt27) {
case 1 :
// OmpParser.g:310:5: PLUS
{
PLUS116=(Token)match(input,PLUS,FOLLOW_PLUS_in_reduction_operator1935);
stream_PLUS.add(PLUS116);
// AST REWRITE
// elements: PLUS
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 310:10: -> ^( PLUS )
{
// OmpParser.g:310:13: ^( PLUS )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_PLUS.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// OmpParser.g:311:5: STAR
{
STAR117=(Token)match(input,STAR,FOLLOW_STAR_in_reduction_operator1947);
stream_STAR.add(STAR117);
// AST REWRITE
// elements: STAR
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 311:10: -> ^( STAR )
{
// OmpParser.g:311:13: ^( STAR )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_STAR.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 3 :
// OmpParser.g:312:5: SUB
{
SUB118=(Token)match(input,SUB,FOLLOW_SUB_in_reduction_operator1959);
stream_SUB.add(SUB118);
// AST REWRITE
// elements: SUB
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 312:9: -> ^( SUB )
{
// OmpParser.g:312:12: ^( SUB )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_SUB.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 4 :
// OmpParser.g:313:5: AMPERSAND
{
AMPERSAND119=(Token)match(input,AMPERSAND,FOLLOW_AMPERSAND_in_reduction_operator1971);
stream_AMPERSAND.add(AMPERSAND119);
// AST REWRITE
// elements: AMPERSAND
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 313:15: -> ^( AMPERSAND )
{
// OmpParser.g:313:18: ^( AMPERSAND )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_AMPERSAND.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 5 :
// OmpParser.g:314:5: BITXOR
{
BITXOR120=(Token)match(input,BITXOR,FOLLOW_BITXOR_in_reduction_operator1983);
stream_BITXOR.add(BITXOR120);
// AST REWRITE
// elements: BITXOR
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 314:12: -> ^( BITXOR )
{
// OmpParser.g:314:15: ^( BITXOR )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_BITXOR.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 6 :
// OmpParser.g:315:5: BITOR
{
BITOR121=(Token)match(input,BITOR,FOLLOW_BITOR_in_reduction_operator1995);
stream_BITOR.add(BITOR121);
// AST REWRITE
// elements: BITOR
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 315:11: -> ^( BITOR )
{
// OmpParser.g:315:14: ^( BITOR )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_BITOR.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 7 :
// OmpParser.g:316:5: AND
{
AND122=(Token)match(input,AND,FOLLOW_AND_in_reduction_operator2007);
stream_AND.add(AND122);
// AST REWRITE
// elements: AND
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 316:9: -> ^( AND )
{
// OmpParser.g:316:12: ^( AND )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_AND.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 8 :
// OmpParser.g:317:5: OR
{
OR123=(Token)match(input,OR,FOLLOW_OR_in_reduction_operator2019);
stream_OR.add(OR123);
// AST REWRITE
// elements: OR
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 317:8: -> ^( OR )
{
// OmpParser.g:317:11: ^( OR )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_OR.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 9 :
// OmpParser.g:318:5: IDENTIFIER
{
IDENTIFIER124=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_reduction_operator2031);
stream_IDENTIFIER.add(IDENTIFIER124);
// AST REWRITE
// elements: IDENTIFIER
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 318:16: -> ^( IDENTIFIER )
{
// OmpParser.g:318:19: ^( IDENTIFIER )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_IDENTIFIER.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "reduction_operator"
public static class identifier_list_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "identifier_list"
// OmpParser.g:321:1: identifier_list : i1= IDENTIFIER ( COMMA i2+= IDENTIFIER )* -> ^( IDENTIFIER_LIST $i1 ( $i2)* ) ;
public final OmpParser.identifier_list_return identifier_list() throws RecognitionException {
OmpParser.identifier_list_return retval = new OmpParser.identifier_list_return();
retval.start = input.LT(1);
Object root_0 = null;
Token i1=null;
Token COMMA125=null;
Token i2=null;
List<Object> list_i2=null;
Object i1_tree=null;
Object COMMA125_tree=null;
Object i2_tree=null;
RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
try {
// OmpParser.g:322:3: (i1= IDENTIFIER ( COMMA i2+= IDENTIFIER )* -> ^( IDENTIFIER_LIST $i1 ( $i2)* ) )
// OmpParser.g:323:3: i1= IDENTIFIER ( COMMA i2+= IDENTIFIER )*
{
i1=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifier_list2054);
stream_IDENTIFIER.add(i1);
// OmpParser.g:323:17: ( COMMA i2+= IDENTIFIER )*
loop28:
while (true) {
int alt28=2;
int LA28_0 = input.LA(1);
if ( (LA28_0==COMMA) ) {
alt28=1;
}
switch (alt28) {
case 1 :
// OmpParser.g:323:19: COMMA i2+= IDENTIFIER
{
COMMA125=(Token)match(input,COMMA,FOLLOW_COMMA_in_identifier_list2058);
stream_COMMA.add(COMMA125);
i2=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifier_list2063);
stream_IDENTIFIER.add(i2);
if (list_i2==null) list_i2=new ArrayList<Object>();
list_i2.add(i2);
}
break;
default :
break loop28;
}
}
// AST REWRITE
// elements: i1, i2
// token labels: i1
// rule labels: retval
// token list labels: i2
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleTokenStream stream_i1=new RewriteRuleTokenStream(adaptor,"token i1",i1);
RewriteRuleTokenStream stream_i2=new RewriteRuleTokenStream(adaptor,"token i2", list_i2);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 324:3: -> ^( IDENTIFIER_LIST $i1 ( $i2)* )
{
// OmpParser.g:324:6: ^( IDENTIFIER_LIST $i1 ( $i2)* )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(IDENTIFIER_LIST, "IDENTIFIER_LIST"), root_1);
adaptor.addChild(root_1, stream_i1.nextNode());
// OmpParser.g:324:29: ( $i2)*
while ( stream_i2.hasNext() ) {
adaptor.addChild(root_1, stream_i2.nextNode());
}
stream_i2.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "identifier_list"
// Delegated rules
public OmpParser_CivlCParser.expression_return expression() throws RecognitionException { return gCivlCParser.expression(); }
public OmpParser_CivlCParser.translationUnit_return translationUnit() throws RecognitionException { return gCivlCParser.translationUnit(); }
public OmpParser_CivlCParser.typeName_return typeName() throws RecognitionException { return gCivlCParser.typeName(); }
public OmpParser_CivlCParser.pragma_return pragma() throws RecognitionException { return gCivlCParser.pragma(); }
public OmpParser_CivlCParser.inclusiveOrExpression_return inclusiveOrExpression() throws RecognitionException { return gCivlCParser.inclusiveOrExpression(); }
public OmpParser_CivlCParser.initializerList_return initializerList() throws RecognitionException { return gCivlCParser.initializerList(); }
public OmpParser_CivlCParser.remoteExpression_return remoteExpression() throws RecognitionException { return gCivlCParser.remoteExpression(); }
public OmpParser_CivlCParser.designatorList_return designatorList() throws RecognitionException { return gCivlCParser.designatorList(); }
public OmpParser_CivlCParser.domainSpecifier_return domainSpecifier() throws RecognitionException { return gCivlCParser.domainSpecifier(); }
public OmpParser_CivlCParser.memSpecifier_return memSpecifier() throws RecognitionException { return gCivlCParser.memSpecifier(); }
public OmpParser_CivlCParser.jumpStatement_return jumpStatement() throws RecognitionException { return gCivlCParser.jumpStatement(); }
public OmpParser_CivlCParser.primaryExpression_return primaryExpression() throws RecognitionException { return gCivlCParser.primaryExpression(); }
public OmpParser_CivlCParser.designatedInitializer_return designatedInitializer() throws RecognitionException { return gCivlCParser.designatedInitializer(); }
public OmpParser_CivlCParser.castExpression_return castExpression() throws RecognitionException { return gCivlCParser.castExpression(); }
public OmpParser_CivlCParser.directDeclaratorArraySuffix_return directDeclaratorArraySuffix() throws RecognitionException { return gCivlCParser.directDeclaratorArraySuffix(); }
public OmpParser_CivlCParser.multiplicativeExpression_return multiplicativeExpression() throws RecognitionException { return gCivlCParser.multiplicativeExpression(); }
public OmpParser_CivlCParser.genericAssocList_return genericAssocList() throws RecognitionException { return gCivlCParser.genericAssocList(); }
public OmpParser_CivlCParser.declarationSpecifierList_return declarationSpecifierList() throws RecognitionException { return gCivlCParser.declarationSpecifierList(); }
public OmpParser_CivlCParser.designator_return designator() throws RecognitionException { return gCivlCParser.designator(); }
public OmpParser_CivlCParser.updateStatement_return updateStatement() throws RecognitionException { return gCivlCParser.updateStatement(); }
public OmpParser_CivlCParser.partialList_return partialList() throws RecognitionException { return gCivlCParser.partialList(); }
public OmpParser_CivlCParser.parameterList_return parameterList() throws RecognitionException { return gCivlCParser.parameterList(); }
public OmpParser_CivlCParser.directDeclaratorSuffix_return directDeclaratorSuffix() throws RecognitionException { return gCivlCParser.directDeclaratorSuffix(); }
public OmpParser_CivlCParser.runStatement_return runStatement() throws RecognitionException { return gCivlCParser.runStatement(); }
public OmpParser_CivlCParser.labeledStatement_return labeledStatement() throws RecognitionException { return gCivlCParser.labeledStatement(); }
public OmpParser_CivlCParser.structDeclarator_return structDeclarator() throws RecognitionException { return gCivlCParser.structDeclarator(); }
public OmpParser_CivlCParser.relationalExpression_return relationalExpression() throws RecognitionException { return gCivlCParser.relationalExpression(); }
public OmpParser_CivlCParser.constantExpression_return constantExpression() throws RecognitionException { return gCivlCParser.constantExpression(); }
public OmpParser_CivlCParser.blockItem_return blockItem() throws RecognitionException { return gCivlCParser.blockItem(); }
public OmpParser_CivlCParser.initDeclarator_return initDeclarator() throws RecognitionException { return gCivlCParser.initDeclarator(); }
public OmpParser_CivlCParser.directDeclarator_return directDeclarator() throws RecognitionException { return gCivlCParser.directDeclarator(); }
public OmpParser_CivlCParser.typeofSpecifier_return typeofSpecifier() throws RecognitionException { return gCivlCParser.typeofSpecifier(); }
public OmpParser_CivlCParser.interval_return interval() throws RecognitionException { return gCivlCParser.interval(); }
public OmpParser_CivlCParser.asmStatement_return asmStatement() throws RecognitionException { return gCivlCParser.asmStatement(); }
public OmpParser_CivlCParser.blockItemWithScope_return blockItemWithScope() throws RecognitionException { return gCivlCParser.blockItemWithScope(); }
public OmpParser_CivlCParser.specifierQualifierList_return specifierQualifierList() throws RecognitionException { return gCivlCParser.specifierQualifierList(); }
public OmpParser_CivlCParser.shiftExpression_return shiftExpression() throws RecognitionException { return gCivlCParser.shiftExpression(); }
public OmpParser_CivlCParser.declarationSpecifier_return declarationSpecifier() throws RecognitionException { return gCivlCParser.declarationSpecifier(); }
public OmpParser_CivlCParser.partial_return partial() throws RecognitionException { return gCivlCParser.partial(); }
public OmpParser_CivlCParser.arrayLambdaExpression_return arrayLambdaExpression() throws RecognitionException { return gCivlCParser.arrayLambdaExpression(); }
public OmpParser_CivlCParser.atomicStatement_return atomicStatement() throws RecognitionException { return gCivlCParser.atomicStatement(); }
public OmpParser_CivlCParser.structOrUnionSpecifier_return structOrUnionSpecifier() throws RecognitionException { return gCivlCParser.structOrUnionSpecifier(); }
public OmpParser_CivlCParser.boundVariableDeclarationList_return boundVariableDeclarationList() throws RecognitionException { return gCivlCParser.boundVariableDeclarationList(); }
public OmpParser_CivlCParser.pointer_return pointer() throws RecognitionException { return gCivlCParser.pointer(); }
public OmpParser_CivlCParser.declarator_return declarator() throws RecognitionException { return gCivlCParser.declarator(); }
public OmpParser_CivlCParser.expression_opt_return expression_opt() throws RecognitionException { return gCivlCParser.expression_opt(); }
public OmpParser_CivlCParser.genericSelection_return genericSelection() throws RecognitionException { return gCivlCParser.genericSelection(); }
public OmpParser_CivlCParser.iterationStatement_return iterationStatement() throws RecognitionException { return gCivlCParser.iterationStatement(); }
public OmpParser_CivlCParser.relationalOperator_return relationalOperator() throws RecognitionException { return gCivlCParser.relationalOperator(); }
public OmpParser_CivlCParser.structDeclaration_return structDeclaration() throws RecognitionException { return gCivlCParser.structDeclaration(); }
public OmpParser_CivlCParser.quantifier_return quantifier() throws RecognitionException { return gCivlCParser.quantifier(); }
public OmpParser_CivlCParser.equalityOperator_return equalityOperator() throws RecognitionException { return gCivlCParser.equalityOperator(); }
public OmpParser_CivlCParser.typeSpecifierOrQualifier_return typeSpecifierOrQualifier() throws RecognitionException { return gCivlCParser.typeSpecifierOrQualifier(); }
public OmpParser_CivlCParser.rangeSuffix_return rangeSuffix() throws RecognitionException { return gCivlCParser.rangeSuffix(); }
public OmpParser_CivlCParser.declaration_return declaration() throws RecognitionException { return gCivlCParser.declaration(); }
public OmpParser_CivlCParser.assignmentExpression_return assignmentExpression() throws RecognitionException { return gCivlCParser.assignmentExpression(); }
public OmpParser_CivlCParser.structOrUnion_return structOrUnion() throws RecognitionException { return gCivlCParser.structOrUnion(); }
public OmpParser_CivlCParser.porItem_return porItem() throws RecognitionException { return gCivlCParser.porItem(); }
public OmpParser_CivlCParser.parameterDeclaration_return parameterDeclaration() throws RecognitionException { return gCivlCParser.parameterDeclaration(); }
public OmpParser_CivlCParser.expressionStatement_return expressionStatement() throws RecognitionException { return gCivlCParser.expressionStatement(); }
public OmpParser_CivlCParser.directDeclaratorFunctionSuffix_return directDeclaratorFunctionSuffix() throws RecognitionException { return gCivlCParser.directDeclaratorFunctionSuffix(); }
public OmpParser_CivlCParser.quantifiedExpression_return quantifiedExpression() throws RecognitionException { return gCivlCParser.quantifiedExpression(); }
public OmpParser_CivlCParser.declarationList_opt_return declarationList_opt() throws RecognitionException { return gCivlCParser.declarationList_opt(); }
public OmpParser_CivlCParser.differentiableSpecifier_return differentiableSpecifier() throws RecognitionException { return gCivlCParser.differentiableSpecifier(); }
public OmpParser_CivlCParser.storageClassSpecifier_return storageClassSpecifier() throws RecognitionException { return gCivlCParser.storageClassSpecifier(); }
public OmpParser_CivlCParser.staticAssertDeclaration_return staticAssertDeclaration() throws RecognitionException { return gCivlCParser.staticAssertDeclaration(); }
public OmpParser_CivlCParser.alignmentSpecifier_return alignmentSpecifier() throws RecognitionException { return gCivlCParser.alignmentSpecifier(); }
public OmpParser_CivlCParser.identifierList_return identifierList() throws RecognitionException { return gCivlCParser.identifierList(); }
public OmpParser_CivlCParser.balancedToken_return balancedToken() throws RecognitionException { return gCivlCParser.balancedToken(); }
public OmpParser_CivlCParser.structDeclaratorList_return structDeclaratorList() throws RecognitionException { return gCivlCParser.structDeclaratorList(); }
public OmpParser_CivlCParser.inlineList_return inlineList() throws RecognitionException { return gCivlCParser.inlineList(); }
public OmpParser_CivlCParser.separationLogicItem_return separationLogicItem() throws RecognitionException { return gCivlCParser.separationLogicItem(); }
public OmpParser_CivlCParser.contract_return contract() throws RecognitionException { return gCivlCParser.contract(); }
public OmpParser_CivlCParser.designation_return designation() throws RecognitionException { return gCivlCParser.designation(); }
public OmpParser_CivlCParser.pointer_part_return pointer_part() throws RecognitionException { return gCivlCParser.pointer_part(); }
public OmpParser_CivlCParser.functionDefinition_return functionDefinition() throws RecognitionException { return gCivlCParser.functionDefinition(); }
public OmpParser_CivlCParser.conditionalExpression_return conditionalExpression() throws RecognitionException { return gCivlCParser.conditionalExpression(); }
public OmpParser_CivlCParser.enumerator_return enumerator() throws RecognitionException { return gCivlCParser.enumerator(); }
public OmpParser_CivlCParser.contractItem_return contractItem() throws RecognitionException { return gCivlCParser.contractItem(); }
public OmpParser_CivlCParser.declarationSpecifiers_return declarationSpecifiers() throws RecognitionException { return gCivlCParser.declarationSpecifiers(); }
public OmpParser_CivlCParser.assignmentOperator_return assignmentOperator() throws RecognitionException { return gCivlCParser.assignmentOperator(); }
public OmpParser_CivlCParser.typeQualifierList_opt_return typeQualifierList_opt() throws RecognitionException { return gCivlCParser.typeQualifierList_opt(); }
public OmpParser_CivlCParser.typeQualifier_return typeQualifier() throws RecognitionException { return gCivlCParser.typeQualifier(); }
public OmpParser_CivlCParser.spawnExpression_return spawnExpression() throws RecognitionException { return gCivlCParser.spawnExpression(); }
public OmpParser_CivlCParser.parameterTypeListWithScope_return parameterTypeListWithScope() throws RecognitionException { return gCivlCParser.parameterTypeListWithScope(); }
public OmpParser_CivlCParser.enumerationConstant_return enumerationConstant() throws RecognitionException { return gCivlCParser.enumerationConstant(); }
public OmpParser_CivlCParser.typeSpecifier_return typeSpecifier() throws RecognitionException { return gCivlCParser.typeSpecifier(); }
public OmpParser_CivlCParser.blockItemList_return blockItemList() throws RecognitionException { return gCivlCParser.blockItemList(); }
public OmpParser_CivlCParser.declaratorOrAbstractDeclarator_return declaratorOrAbstractDeclarator() throws RecognitionException { return gCivlCParser.declaratorOrAbstractDeclarator(); }
public OmpParser_CivlCParser.boundVariableDeclarationSubList_return boundVariableDeclarationSubList() throws RecognitionException { return gCivlCParser.boundVariableDeclarationSubList(); }
public OmpParser_CivlCParser.compoundStatement_return compoundStatement() throws RecognitionException { return gCivlCParser.compoundStatement(); }
public OmpParser_CivlCParser.postfixExpression_return postfixExpression() throws RecognitionException { return gCivlCParser.postfixExpression(); }
public OmpParser_CivlCParser.intervalSeq_return intervalSeq() throws RecognitionException { return gCivlCParser.intervalSeq(); }
public OmpParser_CivlCParser.typeQualifierList_return typeQualifierList() throws RecognitionException { return gCivlCParser.typeQualifierList(); }
public OmpParser_CivlCParser.commaExpression_return commaExpression() throws RecognitionException { return gCivlCParser.commaExpression(); }
public OmpParser_CivlCParser.logicalImpliesExpression_return logicalImpliesExpression() throws RecognitionException { return gCivlCParser.logicalImpliesExpression(); }
public OmpParser_CivlCParser.whenStatement_return whenStatement() throws RecognitionException { return gCivlCParser.whenStatement(); }
public OmpParser_CivlCParser.unaryExpression_return unaryExpression() throws RecognitionException { return gCivlCParser.unaryExpression(); }
public OmpParser_CivlCParser.constant_return constant() throws RecognitionException { return gCivlCParser.constant(); }
public OmpParser_CivlCParser.logicalAndExpression_return logicalAndExpression() throws RecognitionException { return gCivlCParser.logicalAndExpression(); }
public OmpParser_CivlCParser.logicalOrExpression_return logicalOrExpression() throws RecognitionException { return gCivlCParser.logicalOrExpression(); }
public OmpParser_CivlCParser.directDeclaratorPrefix_return directDeclaratorPrefix() throws RecognitionException { return gCivlCParser.directDeclaratorPrefix(); }
public OmpParser_CivlCParser.selectionStatement_return selectionStatement() throws RecognitionException { return gCivlCParser.selectionStatement(); }
public OmpParser_CivlCParser.argumentExpressionList_return argumentExpressionList() throws RecognitionException { return gCivlCParser.argumentExpressionList(); }
public OmpParser_CivlCParser.chooseStatement_return chooseStatement() throws RecognitionException { return gCivlCParser.chooseStatement(); }
public OmpParser_CivlCParser.rangeExpression_return rangeExpression() throws RecognitionException { return gCivlCParser.rangeExpression(); }
public OmpParser_CivlCParser.typeName_opt_return typeName_opt() throws RecognitionException { return gCivlCParser.typeName_opt(); }
public OmpParser_CivlCParser.assignmentExpression_opt_return assignmentExpression_opt() throws RecognitionException { return gCivlCParser.assignmentExpression_opt(); }
public OmpParser_CivlCParser.annotation_return annotation() throws RecognitionException { return gCivlCParser.annotation(); }
public OmpParser_CivlCParser.libraryName_return libraryName() throws RecognitionException { return gCivlCParser.libraryName(); }
public OmpParser_CivlCParser.statementWithScope_return statementWithScope() throws RecognitionException { return gCivlCParser.statementWithScope(); }
public OmpParser_CivlCParser.statement_return statement() throws RecognitionException { return gCivlCParser.statement(); }
public OmpParser_CivlCParser.typedefName_return typedefName() throws RecognitionException { return gCivlCParser.typedefName(); }
public OmpParser_CivlCParser.withStatement_return withStatement() throws RecognitionException { return gCivlCParser.withStatement(); }
public OmpParser_CivlCParser.equalityExpression_return equalityExpression() throws RecognitionException { return gCivlCParser.equalityExpression(); }
public OmpParser_CivlCParser.genericAssociation_return genericAssociation() throws RecognitionException { return gCivlCParser.genericAssociation(); }
public OmpParser_CivlCParser.postfixExpressionRoot_return postfixExpressionRoot() throws RecognitionException { return gCivlCParser.postfixExpressionRoot(); }
public OmpParser_CivlCParser.derivativeExpression_return derivativeExpression() throws RecognitionException { return gCivlCParser.derivativeExpression(); }
public OmpParser_CivlCParser.enumSpecifier_return enumSpecifier() throws RecognitionException { return gCivlCParser.enumSpecifier(); }
public OmpParser_CivlCParser.abstractDeclarator_return abstractDeclarator() throws RecognitionException { return gCivlCParser.abstractDeclarator(); }
public OmpParser_CivlCParser.parameterTypeListWithoutScope_return parameterTypeListWithoutScope() throws RecognitionException { return gCivlCParser.parameterTypeListWithoutScope(); }
public OmpParser_CivlCParser.exclusiveOrExpression_return exclusiveOrExpression() throws RecognitionException { return gCivlCParser.exclusiveOrExpression(); }
public OmpParser_CivlCParser.enumeratorList_return enumeratorList() throws RecognitionException { return gCivlCParser.enumeratorList(); }
public OmpParser_CivlCParser.andExpression_return andExpression() throws RecognitionException { return gCivlCParser.andExpression(); }
public OmpParser_CivlCParser.additiveExpression_return additiveExpression() throws RecognitionException { return gCivlCParser.additiveExpression(); }
public OmpParser_CivlCParser.directAbstractDeclarator_return directAbstractDeclarator() throws RecognitionException { return gCivlCParser.directAbstractDeclarator(); }
public OmpParser_CivlCParser.parameterTypeList_return parameterTypeList() throws RecognitionException { return gCivlCParser.parameterTypeList(); }
public OmpParser_CivlCParser.invariant_opt_return invariant_opt() throws RecognitionException { return gCivlCParser.invariant_opt(); }
public OmpParser_CivlCParser.initializer_return initializer() throws RecognitionException { return gCivlCParser.initializer(); }
public OmpParser_CivlCParser.directAbstractDeclaratorSuffix_return directAbstractDeclaratorSuffix() throws RecognitionException { return gCivlCParser.directAbstractDeclaratorSuffix(); }
public OmpParser_CivlCParser.callsExpression_return callsExpression() throws RecognitionException { return gCivlCParser.callsExpression(); }
public OmpParser_CivlCParser.annotationBody_return annotationBody() throws RecognitionException { return gCivlCParser.annotationBody(); }
public OmpParser_CivlCParser.atomicTypeSpecifier_return atomicTypeSpecifier() throws RecognitionException { return gCivlCParser.atomicTypeSpecifier(); }
public OmpParser_CivlCParser.functionSpecifier_return functionSpecifier() throws RecognitionException { return gCivlCParser.functionSpecifier(); }
public OmpParser_CivlCParser.structDeclarationList_return structDeclarationList() throws RecognitionException { return gCivlCParser.structDeclarationList(); }
public OmpParser_CivlCParser.unaryOperator_return unaryOperator() throws RecognitionException { return gCivlCParser.unaryOperator(); }
public OmpParser_CivlCParser.initDeclaratorList_return initDeclaratorList() throws RecognitionException { return gCivlCParser.initDeclaratorList(); }
public static final BitSet FOLLOW_parallel_for_directive_in_openmp_construct96 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_parallel_sections_directive_in_openmp_construct102 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_parallel_directive_in_openmp_construct108 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_for_directive_in_openmp_construct114 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_sections_directive_in_openmp_construct120 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_single_directive_in_openmp_construct126 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_simd_directive_in_openmp_construct132 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_master_directive_in_openmp_construct138 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_critical_directive_in_openmp_construct144 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ordered_directive_in_openmp_construct150 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_section_directive_in_openmp_construct156 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ompatomic_directive_in_openmp_construct162 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_barrier_directive_in_openmp_construct168 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_flush_directive_in_openmp_construct174 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_threadprivate_directive_in_openmp_construct180 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_PARALLEL_in_parallel_directive193 = new BitSet(new long[]{0x0200000000000002L,0x0000000000000000L,0x0000000000008000L,0x0000000000000010L,0x5114600000000000L});
public static final BitSet FOLLOW_parallel_clause_in_parallel_directive199 = new BitSet(new long[]{0x0200000000000002L,0x0000000000000000L,0x0000000000008000L,0x0000000000000010L,0x5114600000000000L});
public static final BitSet FOLLOW_unique_parallel_clause_in_parallel_clause226 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_data_clause_in_parallel_clause232 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_MASTER_in_master_directive247 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_CRITICAL_in_critical_directive266 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_critical_directive270 = new BitSet(new long[]{0x0100000000000000L});
public static final BitSet FOLLOW_IDENTIFIER_in_critical_directive275 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_critical_directive278 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_SECTIONS_in_sections_directive307 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000008000L,0x0000000000000010L,0x5094600000000000L});
public static final BitSet FOLLOW_sections_clause_in_sections_directive313 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000008000L,0x0000000000000010L,0x5094600000000000L});
public static final BitSet FOLLOW_data_clause_in_sections_clause340 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_nowait_directive_in_sections_clause346 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_SECTION_in_section_directive359 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_PARALLEL_in_parallel_for_directive380 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000080000000L});
public static final BitSet FOLLOW_FOR_in_parallel_for_directive382 = new BitSet(new long[]{0x0200000000000002L,0x0000000000000000L,0x0000000000008000L,0x0000000000000010L,0x5514700000000000L,0x0000000000000002L});
public static final BitSet FOLLOW_parallel_for_clause_in_parallel_for_directive386 = new BitSet(new long[]{0x0200000000000002L,0x0000000000000000L,0x0000000000008000L,0x0000000000000010L,0x5514700000000000L,0x0000000000000002L});
public static final BitSet FOLLOW_unique_parallel_clause_in_parallel_for_clause414 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_unique_for_clause_in_parallel_for_clause420 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_data_clause_in_parallel_for_clause426 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_PARALLEL_in_parallel_sections_directive439 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000008L});
public static final BitSet FOLLOW_SECTIONS_in_parallel_sections_directive442 = new BitSet(new long[]{0x0200000000000002L,0x0000000000000000L,0x0000000000008000L,0x0000000000000010L,0x5114600000000000L});
public static final BitSet FOLLOW_parallel_sections_clause_in_parallel_sections_directive447 = new BitSet(new long[]{0x0200000000000002L,0x0000000000000000L,0x0000000000008000L,0x0000000000000010L,0x5114600000000000L});
public static final BitSet FOLLOW_unique_parallel_clause_in_parallel_sections_clause475 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_data_clause_in_parallel_sections_clause481 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_SIMD_in_simd_directive494 = new BitSet(new long[]{0x0200000000000002L,0x0000000000000000L,0x0000000000008000L,0x0000000000000010L,0x5014700000000000L,0x0000000000000041L});
public static final BitSet FOLLOW_simd_clause_in_simd_directive498 = new BitSet(new long[]{0x0200000000000002L,0x0000000000000000L,0x0000000000008000L,0x0000000000000010L,0x5014700000000000L,0x0000000000000041L});
public static final BitSet FOLLOW_SAFELEN_in_simd_clause527 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_simd_clause529 = new BitSet(new long[]{0x0100040200080010L,0x8402D00028084082L,0x4040002302020008L,0x0000000001100586L});
public static final BitSet FOLLOW_expression_in_simd_clause533 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_simd_clause535 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_SIMDLEN_in_simd_clause554 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_simd_clause556 = new BitSet(new long[]{0x0100040200080010L,0x8402D00028084082L,0x4040002302020008L,0x0000000001100586L});
public static final BitSet FOLLOW_expression_in_simd_clause560 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_simd_clause562 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_if_clause_in_simd_clause584 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_data_clause_in_simd_clause593 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_collapse_clause_in_simd_clause602 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_SINGLE_in_single_directive619 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000008000L,0x0000000000000010L,0x5094600000000000L});
public static final BitSet FOLLOW_single_clause_in_single_directive624 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000008000L,0x0000000000000010L,0x5094600000000000L});
public static final BitSet FOLLOW_data_clause_in_single_clause652 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_nowait_directive_in_single_clause658 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_BARRIER_in_barrier_directive671 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_OMPATOMIC_in_ompatomic_directive692 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000800000L,0x2000080000000000L,0x0000000000000210L});
public static final BitSet FOLLOW_atomic_clasue_in_ompatomic_directive696 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000010L});
public static final BitSet FOLLOW_seq_cst_clause_in_ompatomic_directive701 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_SEQ_CST_in_seq_cst_clause760 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_FLUSH_in_flush_directive773 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
public static final BitSet FOLLOW_flush_vars_in_flush_directive778 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_LPAREN_in_flush_vars806 = new BitSet(new long[]{0x0100000000000000L});
public static final BitSet FOLLOW_identifier_list_in_flush_vars812 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_flush_vars815 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ORDERED_in_ordered_directive837 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_NOWAIT_in_nowait_directive858 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_THD_PRIVATE_in_threadprivate_directive877 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_threadprivate_directive880 = new BitSet(new long[]{0x0100000000000000L});
public static final BitSet FOLLOW_identifier_list_in_threadprivate_directive885 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_threadprivate_directive888 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_FOR_in_for_directive914 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000008000L,0x0000000000000010L,0x5494700000000000L,0x0000000000000002L});
public static final BitSet FOLLOW_for_clause_in_for_directive920 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000008000L,0x0000000000000010L,0x5494700000000000L,0x0000000000000002L});
public static final BitSet FOLLOW_unique_for_clause_in_for_clause951 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_data_clause_in_for_clause968 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_nowait_directive_in_for_clause985 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ordered_clause_in_unique_for_clause1009 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_schedule_clause_in_unique_for_clause1025 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_collapse_clause_in_unique_for_clause1042 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ORDERED_in_ordered_clause1066 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_ordered_clause1069 = new BitSet(new long[]{0x0100040200080010L,0x8402D00028084082L,0x4040002302020008L,0x0000000001100586L});
public static final BitSet FOLLOW_expression_in_ordered_clause1073 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_ordered_clause1075 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_SCHEDULE_in_schedule_clause1103 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_schedule_clause1106 = new BitSet(new long[]{0x0000000000000000L,0x4000000000000000L,0x0000000000000000L,0x0000000000000800L,0x8009000000000000L});
public static final BitSet FOLLOW_schedule_kind_in_schedule_clause1111 = new BitSet(new long[]{0x0000000000200000L});
public static final BitSet FOLLOW_COMMA_in_schedule_clause1114 = new BitSet(new long[]{0x0100040200080010L,0x8402D00028084082L,0x4040002302020008L,0x0000000001100586L});
public static final BitSet FOLLOW_expression_in_schedule_clause1119 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_schedule_clause1122 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_SCHEDULE_in_schedule_clause1149 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_schedule_clause1152 = new BitSet(new long[]{0x0000000000000000L,0x4000000000000000L,0x0000000000000000L,0x0000000000000800L,0x8009000000000000L});
public static final BitSet FOLLOW_schedule_kind_in_schedule_clause1157 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_schedule_clause1160 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_COLLAPSE_in_collapse_clause1185 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_collapse_clause1188 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
public static final BitSet FOLLOW_INTEGER_CONSTANT_in_collapse_clause1193 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_collapse_clause1196 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_STATIC_in_schedule_kind1221 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_DYNAMIC_in_schedule_kind1233 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_GUIDED_in_schedule_kind1245 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_RUNTIME_in_schedule_kind1257 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_AUTO_in_schedule_kind1269 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_if_clause_in_unique_parallel_clause1290 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_num_threads_clause_in_unique_parallel_clause1312 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_IF_in_if_clause1341 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_if_clause1344 = new BitSet(new long[]{0x0100040200080010L,0x8402D00028084082L,0x4040002302020008L,0x0000000001100586L});
public static final BitSet FOLLOW_expression_in_if_clause1349 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_if_clause1352 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_NUM_THREADS_in_num_threads_clause1380 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_num_threads_clause1383 = new BitSet(new long[]{0x0100040200080010L,0x8402D00028084082L,0x4040002302020008L,0x0000000001100586L});
public static final BitSet FOLLOW_expression_in_num_threads_clause1388 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_num_threads_clause1391 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_private_clause_in_data_clause1419 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_firstprivate_clause_in_data_clause1440 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_lastprivate_clause_in_data_clause1461 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_shared_clause_in_data_clause1482 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_default_clause_in_data_clause1503 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_reduction_clause_in_data_clause1524 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_copyin_clause_in_data_clause1545 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_copyprivate_clause_in_data_clause1566 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_PRIVATE_in_private_clause1594 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_private_clause1597 = new BitSet(new long[]{0x0100000000000000L});
public static final BitSet FOLLOW_identifier_list_in_private_clause1602 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_private_clause1605 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_FST_PRIVATE_in_firstprivate_clause1634 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_firstprivate_clause1637 = new BitSet(new long[]{0x0100000000000000L});
public static final BitSet FOLLOW_identifier_list_in_firstprivate_clause1642 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_firstprivate_clause1645 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_LST_PRIVATE_in_lastprivate_clause1673 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_lastprivate_clause1676 = new BitSet(new long[]{0x0100000000000000L});
public static final BitSet FOLLOW_identifier_list_in_lastprivate_clause1681 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_lastprivate_clause1684 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_SHARED_in_shared_clause1712 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_shared_clause1715 = new BitSet(new long[]{0x0100000000000000L});
public static final BitSet FOLLOW_identifier_list_in_shared_clause1720 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_shared_clause1723 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_DEFAULT_in_default_clause1751 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_default_clause1754 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000010L});
public static final BitSet FOLLOW_SHARED_in_default_clause1757 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_default_clause1760 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_DEFAULT_in_default_clause1778 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_default_clause1781 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0040000000000000L});
public static final BitSet FOLLOW_NONE_in_default_clause1784 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_default_clause1787 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_REDUCTION_in_reduction_clause1814 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_reduction_clause1816 = new BitSet(new long[]{0x0100000000005030L,0x0000900008400000L});
public static final BitSet FOLLOW_reduction_operator_in_reduction_clause1820 = new BitSet(new long[]{0x0000000000100000L});
public static final BitSet FOLLOW_COLON_in_reduction_clause1822 = new BitSet(new long[]{0x0100000000000000L});
public static final BitSet FOLLOW_identifier_list_in_reduction_clause1826 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_reduction_clause1828 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_COPYIN_in_copyin_clause1859 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_copyin_clause1862 = new BitSet(new long[]{0x0100000000000000L});
public static final BitSet FOLLOW_identifier_list_in_copyin_clause1867 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_copyin_clause1870 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_COPYPRIVATE_in_copyprivate_clause1898 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
public static final BitSet FOLLOW_LPAREN_in_copyprivate_clause1901 = new BitSet(new long[]{0x0100000000000000L});
public static final BitSet FOLLOW_identifier_list_in_copyprivate_clause1906 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
public static final BitSet FOLLOW_RPAREN_in_copyprivate_clause1909 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_PLUS_in_reduction_operator1935 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_STAR_in_reduction_operator1947 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_SUB_in_reduction_operator1959 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_AMPERSAND_in_reduction_operator1971 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_BITXOR_in_reduction_operator1983 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_BITOR_in_reduction_operator1995 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_AND_in_reduction_operator2007 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_OR_in_reduction_operator2019 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_IDENTIFIER_in_reduction_operator2031 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_IDENTIFIER_in_identifier_list2054 = new BitSet(new long[]{0x0000000000200002L});
public static final BitSet FOLLOW_COMMA_in_identifier_list2058 = new BitSet(new long[]{0x0100000000000000L});
public static final BitSet FOLLOW_IDENTIFIER_in_identifier_list2063 = new BitSet(new long[]{0x0000000000200002L});
}