MFortranOmpParser.java
package edu.udel.cis.vsl.abc.front.fortran.parse;
import edu.udel.cis.vsl.abc.front.IF.RuntimeParseException;
import edu.udel.cis.vsl.abc.front.fortran.preproc.*;
// $ANTLR 3.5.2 MFortranOmpParser.g 2023-02-11 20:42:13
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 MFortranOmpParser extends Parser {
public static final String[] tokenNames = new String[] {
"<invalid>", "<EOR>", "<DOWN>", "<UP>", "ABSTRACT", "ACQUIRED_LOCK", "ALL",
"ALLOCATABLE", "ALLOCATE", "AND", "ASSIGNMENT", "ASSOCIATE", "ASTERISK",
"ASYNCHRONOUS", "BACKSPACE", "BIND", "BIN_CONST", "BLOCK", "BLOCKDATA",
"CALL", "CASE", "CHANGE", "CHARACTER", "CHAR_CONST", "CIVL_PRIMITIVE",
"CLASS", "CLOSE", "CODIMENSION", "COLON", "COLON_COLON", "COMMA", "COMMON",
"COMPLEX", "CONCURRENT", "CONTAINS", "CONTIGUOUS", "CONTINUE", "CONTINUE_CHAR",
"CRITICAL", "CYCLE", "DATA", "DEALLOCATE", "DEFAULT", "DEFERRED", "DEFINED_OP",
"DIGIT_STR", "DIMENSION", "DO", "DOUBLE", "DOUBLECOMPLEX", "DOUBLEPRECISION",
"Digit", "EDIT_DESC_MISC", "ELEMENTAL", "ELSE", "ELSEIF", "ELSEWHERE",
"END", "ENTRY", "ENUM", "ENUMERATOR", "EOS", "EQ", "EQUALS", "EQUIVALENCE",
"EQV", "EQ_EQ", "EQ_GT", "ERRMSG", "ERROR", "EVENT", "EVENTWAIT", "EXIT",
"EXTENDS", "EXTERNAL", "FAIL", "FAILIMAGE", "FALSE", "FILE", "FINAL",
"FLUSH", "FORALL", "FORM", "FORMAT", "FORMATTED", "FORMTEAM", "FUNCTION",
"GE", "GENERIC", "GO", "GOTO", "GREATERTHAN", "GREATERTHAN_EQ", "GT",
"HEX_CONST", "IDENT", "IF", "IMAGE", "IMAGES", "IMPLICIT", "IMPORT", "IMPURE",
"IN", "INCLUDE", "INOUT", "INQUIRE", "INTEGER", "INTENT", "INTERFACE",
"INTRINSIC", "IS", "KIND", "LBRACKET", "LE", "LEN", "LESSTHAN", "LESSTHAN_EQ",
"LINE_COMMENT", "LOCAL", "LOCAL_INT", "LOCK", "LOGICAL", "LPAREN", "LT",
"Letter", "MEMORY", "MINUS", "MISC_CHAR", "MODULE", "MOLD", "M_ALLOCATE_STMT_1",
"M_ASSIGNMENT_STMT", "M_CSTR_EDIT_DESC", "M_CTRL_EDIT_DESC", "M_DATA_EDIT_DESC",
"M_EOF", "M_FORALL_CONSTRUCT_STMT", "M_FORALL_STMT", "M_IF_STMT", "M_INCLUDE_NAME",
"M_INQUIRE_STMT_2", "M_LBL_DO_TERMINAL", "M_PTR_ASSIGNMENT_STMT", "M_REAL_CONST",
"M_WHERE_CONSTRUCT_STMT", "M_WHERE_STMT", "NAMELIST", "NE", "NEQV", "NONE",
"NON_INTRINSIC", "NON_OVERRIDABLE", "NON_RECURSIVE", "NOPASS", "NOT",
"NO_LANG_EXT", "NULLIFY", "OCT_CONST", "ONLY", "OPEN", "OPERATOR", "OPTIONAL",
"OR", "OUT", "PARAMETER", "PASS", "PAUSE", "PERCENT", "PERIOD", "PERIOD_EXPONENT",
"PLUS", "POINTER", "POST", "POWER", "PRAGMA", "PRECISION", "PREPROCESS_LINE",
"PRINT", "PRIVATE", "PROCEDURE", "PROGRAM", "PROTECTED", "PUBLIC", "PURE",
"QUIET", "RANK", "RBRACKET", "READ", "REAL", "RECURSIVE", "RESULT", "RETURN",
"REWIND", "RPAREN", "SAVE", "SELECT", "SELECTCASE", "SELECTTYPE", "SEQUENCE",
"SHARED", "SLASH", "SLASH_EQ", "SLASH_SLASH", "SOURCE", "STAT", "STMT_FUNCTION",
"STOP", "SUBMODULE", "SUBROUTINE", "SYNC", "SYNCTEAM", "Sp_Char", "TARGET",
"TEAM", "THEN", "TO", "TRUE", "TYPE", "UNDERSCORE", "UNFORMATTED", "UNLOCK",
"USE", "VALUE", "VOLATILE", "WAIT", "WHERE", "WHILE", "WRITE", "WS", "DODOT",
"ERRORSTOP", "SELECTRANK", "TEAM_NUMBER", "T_AMPERSAND", "T_BARRIER",
"T_BITOR", "T_BITXOR", "T_CAPTURE", "T_COLLAPSE", "T_COPYIN", "T_COPYPRIVATE",
"T_CRITICAL", "T_DYNAMIC", "T_FST_PRIVATE", "T_GUIDED", "T_LST_PRIVATE",
"T_MASTER", "T_NOWAIT", "T_NUM_THREADS", "T_OMPATOMIC", "T_ORDERED", "T_PARALLEL",
"T_REDUCTION", "T_RUNTIME", "T_SCHEDULE", "T_SECTION", "T_SECTIONS", "T_SEQ_CST",
"T_SHARED", "T_SINGLE", "T_STATIC", "T_THD_PRIVATE", "T_UPDATE", "T_AND",
"T_ASTERISK", "T_COLON", "T_COMMA", "T_DATA_CLAUSE", "T_DEFAULT", "T_DIGIT_STRING",
"T_DO", "T_END", "T_FLUSH", "T_FOR_CLAUSE", "T_IDENT", "T_IDENTIFIER_LIST",
"T_IF", "T_LPAREN", "T_MINUS", "T_NONE", "T_OR", "T_PARALLEL_FOR", "T_PARALLEL_SECTIONS",
"T_PLUS", "T_PRIVATE", "T_READ", "T_RPAREN", "T_UNIQUE_FOR", "T_UNIQUE_PARALLEL",
"T_WRITE"
};
public static final int EOF=-1;
public static final int ABSTRACT=4;
public static final int ACQUIRED_LOCK=5;
public static final int ALL=6;
public static final int ALLOCATABLE=7;
public static final int ALLOCATE=8;
public static final int AND=9;
public static final int ASSIGNMENT=10;
public static final int ASSOCIATE=11;
public static final int ASTERISK=12;
public static final int ASYNCHRONOUS=13;
public static final int BACKSPACE=14;
public static final int BIND=15;
public static final int BIN_CONST=16;
public static final int BLOCK=17;
public static final int BLOCKDATA=18;
public static final int CALL=19;
public static final int CASE=20;
public static final int CHANGE=21;
public static final int CHARACTER=22;
public static final int CHAR_CONST=23;
public static final int CIVL_PRIMITIVE=24;
public static final int CLASS=25;
public static final int CLOSE=26;
public static final int CODIMENSION=27;
public static final int COLON=28;
public static final int COLON_COLON=29;
public static final int COMMA=30;
public static final int COMMON=31;
public static final int COMPLEX=32;
public static final int CONCURRENT=33;
public static final int CONTAINS=34;
public static final int CONTIGUOUS=35;
public static final int CONTINUE=36;
public static final int CONTINUE_CHAR=37;
public static final int CRITICAL=38;
public static final int CYCLE=39;
public static final int DATA=40;
public static final int DEALLOCATE=41;
public static final int DEFAULT=42;
public static final int DEFERRED=43;
public static final int DEFINED_OP=44;
public static final int DIGIT_STR=45;
public static final int DIMENSION=46;
public static final int DO=47;
public static final int DOUBLE=48;
public static final int DOUBLECOMPLEX=49;
public static final int DOUBLEPRECISION=50;
public static final int Digit=51;
public static final int EDIT_DESC_MISC=52;
public static final int ELEMENTAL=53;
public static final int ELSE=54;
public static final int ELSEIF=55;
public static final int ELSEWHERE=56;
public static final int END=57;
public static final int ENTRY=58;
public static final int ENUM=59;
public static final int ENUMERATOR=60;
public static final int EOS=61;
public static final int EQ=62;
public static final int EQUALS=63;
public static final int EQUIVALENCE=64;
public static final int EQV=65;
public static final int EQ_EQ=66;
public static final int EQ_GT=67;
public static final int ERRMSG=68;
public static final int ERROR=69;
public static final int EVENT=70;
public static final int EVENTWAIT=71;
public static final int EXIT=72;
public static final int EXTENDS=73;
public static final int EXTERNAL=74;
public static final int FAIL=75;
public static final int FAILIMAGE=76;
public static final int FALSE=77;
public static final int FILE=78;
public static final int FINAL=79;
public static final int FLUSH=80;
public static final int FORALL=81;
public static final int FORM=82;
public static final int FORMAT=83;
public static final int FORMATTED=84;
public static final int FORMTEAM=85;
public static final int FUNCTION=86;
public static final int GE=87;
public static final int GENERIC=88;
public static final int GO=89;
public static final int GOTO=90;
public static final int GREATERTHAN=91;
public static final int GREATERTHAN_EQ=92;
public static final int GT=93;
public static final int HEX_CONST=94;
public static final int IDENT=95;
public static final int IF=96;
public static final int IMAGE=97;
public static final int IMAGES=98;
public static final int IMPLICIT=99;
public static final int IMPORT=100;
public static final int IMPURE=101;
public static final int IN=102;
public static final int INCLUDE=103;
public static final int INOUT=104;
public static final int INQUIRE=105;
public static final int INTEGER=106;
public static final int INTENT=107;
public static final int INTERFACE=108;
public static final int INTRINSIC=109;
public static final int IS=110;
public static final int KIND=111;
public static final int LBRACKET=112;
public static final int LE=113;
public static final int LEN=114;
public static final int LESSTHAN=115;
public static final int LESSTHAN_EQ=116;
public static final int LINE_COMMENT=117;
public static final int LOCAL=118;
public static final int LOCAL_INT=119;
public static final int LOCK=120;
public static final int LOGICAL=121;
public static final int LPAREN=122;
public static final int LT=123;
public static final int Letter=124;
public static final int MEMORY=125;
public static final int MINUS=126;
public static final int MISC_CHAR=127;
public static final int MODULE=128;
public static final int MOLD=129;
public static final int M_ALLOCATE_STMT_1=130;
public static final int M_ASSIGNMENT_STMT=131;
public static final int M_CSTR_EDIT_DESC=132;
public static final int M_CTRL_EDIT_DESC=133;
public static final int M_DATA_EDIT_DESC=134;
public static final int M_EOF=135;
public static final int M_FORALL_CONSTRUCT_STMT=136;
public static final int M_FORALL_STMT=137;
public static final int M_IF_STMT=138;
public static final int M_INCLUDE_NAME=139;
public static final int M_INQUIRE_STMT_2=140;
public static final int M_LBL_DO_TERMINAL=141;
public static final int M_PTR_ASSIGNMENT_STMT=142;
public static final int M_REAL_CONST=143;
public static final int M_WHERE_CONSTRUCT_STMT=144;
public static final int M_WHERE_STMT=145;
public static final int NAMELIST=146;
public static final int NE=147;
public static final int NEQV=148;
public static final int NONE=149;
public static final int NON_INTRINSIC=150;
public static final int NON_OVERRIDABLE=151;
public static final int NON_RECURSIVE=152;
public static final int NOPASS=153;
public static final int NOT=154;
public static final int NO_LANG_EXT=155;
public static final int NULLIFY=156;
public static final int OCT_CONST=157;
public static final int ONLY=158;
public static final int OPEN=159;
public static final int OPERATOR=160;
public static final int OPTIONAL=161;
public static final int OR=162;
public static final int OUT=163;
public static final int PARAMETER=164;
public static final int PASS=165;
public static final int PAUSE=166;
public static final int PERCENT=167;
public static final int PERIOD=168;
public static final int PERIOD_EXPONENT=169;
public static final int PLUS=170;
public static final int POINTER=171;
public static final int POST=172;
public static final int POWER=173;
public static final int PRAGMA=174;
public static final int PRECISION=175;
public static final int PREPROCESS_LINE=176;
public static final int PRINT=177;
public static final int PRIVATE=178;
public static final int PROCEDURE=179;
public static final int PROGRAM=180;
public static final int PROTECTED=181;
public static final int PUBLIC=182;
public static final int PURE=183;
public static final int QUIET=184;
public static final int RANK=185;
public static final int RBRACKET=186;
public static final int READ=187;
public static final int REAL=188;
public static final int RECURSIVE=189;
public static final int RESULT=190;
public static final int RETURN=191;
public static final int REWIND=192;
public static final int RPAREN=193;
public static final int SAVE=194;
public static final int SELECT=195;
public static final int SELECTCASE=196;
public static final int SELECTTYPE=197;
public static final int SEQUENCE=198;
public static final int SHARED=199;
public static final int SLASH=200;
public static final int SLASH_EQ=201;
public static final int SLASH_SLASH=202;
public static final int SOURCE=203;
public static final int STAT=204;
public static final int STMT_FUNCTION=205;
public static final int STOP=206;
public static final int SUBMODULE=207;
public static final int SUBROUTINE=208;
public static final int SYNC=209;
public static final int SYNCTEAM=210;
public static final int Sp_Char=211;
public static final int TARGET=212;
public static final int TEAM=213;
public static final int THEN=214;
public static final int TO=215;
public static final int TRUE=216;
public static final int TYPE=217;
public static final int UNDERSCORE=218;
public static final int UNFORMATTED=219;
public static final int UNLOCK=220;
public static final int USE=221;
public static final int VALUE=222;
public static final int VOLATILE=223;
public static final int WAIT=224;
public static final int WHERE=225;
public static final int WHILE=226;
public static final int WRITE=227;
public static final int WS=228;
public static final int DODOT=229;
public static final int ERRORSTOP=230;
public static final int SELECTRANK=231;
public static final int TEAM_NUMBER=232;
public static final int T_AMPERSAND=233;
public static final int T_BARRIER=234;
public static final int T_BITOR=235;
public static final int T_BITXOR=236;
public static final int T_CAPTURE=237;
public static final int T_COLLAPSE=238;
public static final int T_COPYIN=239;
public static final int T_COPYPRIVATE=240;
public static final int T_CRITICAL=241;
public static final int T_DYNAMIC=242;
public static final int T_FST_PRIVATE=243;
public static final int T_GUIDED=244;
public static final int T_LST_PRIVATE=245;
public static final int T_MASTER=246;
public static final int T_NOWAIT=247;
public static final int T_NUM_THREADS=248;
public static final int T_OMPATOMIC=249;
public static final int T_ORDERED=250;
public static final int T_PARALLEL=251;
public static final int T_REDUCTION=252;
public static final int T_RUNTIME=253;
public static final int T_SCHEDULE=254;
public static final int T_SECTION=255;
public static final int T_SECTIONS=256;
public static final int T_SEQ_CST=257;
public static final int T_SHARED=258;
public static final int T_SINGLE=259;
public static final int T_STATIC=260;
public static final int T_THD_PRIVATE=261;
public static final int T_UPDATE=262;
public static final int T_AND=263;
public static final int T_ASTERISK=264;
public static final int T_COLON=265;
public static final int T_COMMA=266;
public static final int T_DATA_CLAUSE=267;
public static final int T_DEFAULT=268;
public static final int T_DIGIT_STRING=269;
public static final int T_DO=270;
public static final int T_END=271;
public static final int T_FLUSH=272;
public static final int T_FOR_CLAUSE=273;
public static final int T_IDENT=274;
public static final int T_IDENTIFIER_LIST=275;
public static final int T_IF=276;
public static final int T_LPAREN=277;
public static final int T_MINUS=278;
public static final int T_NONE=279;
public static final int T_OR=280;
public static final int T_PARALLEL_FOR=281;
public static final int T_PARALLEL_SECTIONS=282;
public static final int T_PLUS=283;
public static final int T_PRIVATE=284;
public static final int T_READ=285;
public static final int T_RPAREN=286;
public static final int T_UNIQUE_FOR=287;
public static final int T_UNIQUE_PARALLEL=288;
public static final int T_WRITE=289;
// delegates
public Parser[] getDelegates() {
return new Parser[] {};
}
// delegators
public MFortranOmpParser(TokenStream input) {
this(input, new RecognizerSharedState());
}
public MFortranOmpParser(TokenStream input, RecognizerSharedState state) {
super(input, state);
}
protected TreeAdaptor adaptor = new CommonTreeAdaptor();
public void setTreeAdaptor(TreeAdaptor adaptor) {
this.adaptor = adaptor;
}
public TreeAdaptor getTreeAdaptor() {
return adaptor;
}
@Override public String[] getTokenNames() { return MFortranOmpParser.tokenNames; }
@Override public String getGrammarFileName() { return "MFortranOmpParser.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"
// MFortranOmpParser.g:49:1: openmp_construct : ( parallel_for_directive | parallel_sections_directive | parallel_directive | for_directive | sections_directive | single_directive | master_directive | critical_directive | ordered_directive | section_directive | ompatomic_directive | barrier_directive | flush_directive | threadprivate_directive | end_directive );
public final MFortranOmpParser.openmp_construct_return openmp_construct() throws RecognitionException {
MFortranOmpParser.openmp_construct_return retval = new MFortranOmpParser.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 master_directive7 =null;
ParserRuleReturnScope critical_directive8 =null;
ParserRuleReturnScope ordered_directive9 =null;
ParserRuleReturnScope section_directive10 =null;
ParserRuleReturnScope ompatomic_directive11 =null;
ParserRuleReturnScope barrier_directive12 =null;
ParserRuleReturnScope flush_directive13 =null;
ParserRuleReturnScope threadprivate_directive14 =null;
ParserRuleReturnScope end_directive15 =null;
try {
// MFortranOmpParser.g:50:3: ( parallel_for_directive | parallel_sections_directive | parallel_directive | for_directive | sections_directive | single_directive | master_directive | critical_directive | ordered_directive | section_directive | ompatomic_directive | barrier_directive | flush_directive | threadprivate_directive | end_directive )
int alt1=15;
switch ( input.LA(1) ) {
case T_PARALLEL:
{
switch ( input.LA(2) ) {
case T_DO:
{
alt1=1;
}
break;
case T_SECTIONS:
{
alt1=2;
}
break;
case EOF:
case T_COPYIN:
case T_COPYPRIVATE:
case T_FST_PRIVATE:
case T_LST_PRIVATE:
case T_NUM_THREADS:
case T_REDUCTION:
case T_SHARED:
case T_DEFAULT:
case T_IF:
case T_PRIVATE:
{
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 T_DO:
{
alt1=4;
}
break;
case T_SECTIONS:
{
alt1=5;
}
break;
case T_SINGLE:
{
alt1=6;
}
break;
case T_MASTER:
{
alt1=7;
}
break;
case T_CRITICAL:
{
alt1=8;
}
break;
case T_ORDERED:
{
alt1=9;
}
break;
case T_SECTION:
{
alt1=10;
}
break;
case T_OMPATOMIC:
{
alt1=11;
}
break;
case T_BARRIER:
{
alt1=12;
}
break;
case T_FLUSH:
{
alt1=13;
}
break;
case T_THD_PRIVATE:
{
alt1=14;
}
break;
case T_END:
{
alt1=15;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 1, 0, input);
throw nvae;
}
switch (alt1) {
case 1 :
// MFortranOmpParser.g:51:5: parallel_for_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_parallel_for_directive_in_openmp_construct92);
parallel_for_directive1=parallel_for_directive();
state._fsp--;
adaptor.addChild(root_0, parallel_for_directive1.getTree());
}
break;
case 2 :
// MFortranOmpParser.g:52:5: parallel_sections_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_parallel_sections_directive_in_openmp_construct98);
parallel_sections_directive2=parallel_sections_directive();
state._fsp--;
adaptor.addChild(root_0, parallel_sections_directive2.getTree());
}
break;
case 3 :
// MFortranOmpParser.g:53:5: parallel_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_parallel_directive_in_openmp_construct104);
parallel_directive3=parallel_directive();
state._fsp--;
adaptor.addChild(root_0, parallel_directive3.getTree());
}
break;
case 4 :
// MFortranOmpParser.g:54:5: for_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_for_directive_in_openmp_construct110);
for_directive4=for_directive();
state._fsp--;
adaptor.addChild(root_0, for_directive4.getTree());
}
break;
case 5 :
// MFortranOmpParser.g:55:5: sections_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_sections_directive_in_openmp_construct116);
sections_directive5=sections_directive();
state._fsp--;
adaptor.addChild(root_0, sections_directive5.getTree());
}
break;
case 6 :
// MFortranOmpParser.g:56:5: single_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_single_directive_in_openmp_construct122);
single_directive6=single_directive();
state._fsp--;
adaptor.addChild(root_0, single_directive6.getTree());
}
break;
case 7 :
// MFortranOmpParser.g:57:5: master_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_master_directive_in_openmp_construct128);
master_directive7=master_directive();
state._fsp--;
adaptor.addChild(root_0, master_directive7.getTree());
}
break;
case 8 :
// MFortranOmpParser.g:58:5: critical_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_critical_directive_in_openmp_construct134);
critical_directive8=critical_directive();
state._fsp--;
adaptor.addChild(root_0, critical_directive8.getTree());
}
break;
case 9 :
// MFortranOmpParser.g:59:5: ordered_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_ordered_directive_in_openmp_construct140);
ordered_directive9=ordered_directive();
state._fsp--;
adaptor.addChild(root_0, ordered_directive9.getTree());
}
break;
case 10 :
// MFortranOmpParser.g:60:5: section_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_section_directive_in_openmp_construct146);
section_directive10=section_directive();
state._fsp--;
adaptor.addChild(root_0, section_directive10.getTree());
}
break;
case 11 :
// MFortranOmpParser.g:61:5: ompatomic_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_ompatomic_directive_in_openmp_construct152);
ompatomic_directive11=ompatomic_directive();
state._fsp--;
adaptor.addChild(root_0, ompatomic_directive11.getTree());
}
break;
case 12 :
// MFortranOmpParser.g:62:5: barrier_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_barrier_directive_in_openmp_construct158);
barrier_directive12=barrier_directive();
state._fsp--;
adaptor.addChild(root_0, barrier_directive12.getTree());
}
break;
case 13 :
// MFortranOmpParser.g:63:5: flush_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_flush_directive_in_openmp_construct164);
flush_directive13=flush_directive();
state._fsp--;
adaptor.addChild(root_0, flush_directive13.getTree());
}
break;
case 14 :
// MFortranOmpParser.g:64:5: threadprivate_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_threadprivate_directive_in_openmp_construct170);
threadprivate_directive14=threadprivate_directive();
state._fsp--;
adaptor.addChild(root_0, threadprivate_directive14.getTree());
}
break;
case 15 :
// MFortranOmpParser.g:65:5: end_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_end_directive_in_openmp_construct176);
end_directive15=end_directive();
state._fsp--;
adaptor.addChild(root_0, end_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"
// MFortranOmpParser.g:68:1: parallel_directive : T_PARALLEL (p+= parallel_clause )* -> ^( T_PARALLEL ( $p)* ) ;
public final MFortranOmpParser.parallel_directive_return parallel_directive() throws RecognitionException {
MFortranOmpParser.parallel_directive_return retval = new MFortranOmpParser.parallel_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_PARALLEL16=null;
List<Object> list_p=null;
RuleReturnScope p = null;
Object T_PARALLEL16_tree=null;
RewriteRuleTokenStream stream_T_PARALLEL=new RewriteRuleTokenStream(adaptor,"token T_PARALLEL");
RewriteRuleSubtreeStream stream_parallel_clause=new RewriteRuleSubtreeStream(adaptor,"rule parallel_clause");
try {
// MFortranOmpParser.g:69:3: ( T_PARALLEL (p+= parallel_clause )* -> ^( T_PARALLEL ( $p)* ) )
// MFortranOmpParser.g:69:5: T_PARALLEL (p+= parallel_clause )*
{
T_PARALLEL16=(Token)match(input,T_PARALLEL,FOLLOW_T_PARALLEL_in_parallel_directive189);
stream_T_PARALLEL.add(T_PARALLEL16);
// MFortranOmpParser.g:69:17: (p+= parallel_clause )*
loop2:
while (true) {
int alt2=2;
int LA2_0 = input.LA(1);
if ( ((LA2_0 >= T_COPYIN && LA2_0 <= T_COPYPRIVATE)||LA2_0==T_FST_PRIVATE||LA2_0==T_LST_PRIVATE||LA2_0==T_NUM_THREADS||LA2_0==T_REDUCTION||LA2_0==T_SHARED||LA2_0==T_DEFAULT||LA2_0==T_IF||LA2_0==T_PRIVATE) ) {
alt2=1;
}
switch (alt2) {
case 1 :
// MFortranOmpParser.g:69:18: p+= parallel_clause
{
pushFollow(FOLLOW_parallel_clause_in_parallel_directive195);
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: T_PARALLEL, 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();
// 70:3: -> ^( T_PARALLEL ( $p)* )
{
// MFortranOmpParser.g:70:6: ^( T_PARALLEL ( $p)* )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_PARALLEL.nextNode(), root_1);
// MFortranOmpParser.g:70:20: ( $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"
// MFortranOmpParser.g:73:1: parallel_clause : ( unique_parallel_clause | data_clause );
public final MFortranOmpParser.parallel_clause_return parallel_clause() throws RecognitionException {
MFortranOmpParser.parallel_clause_return retval = new MFortranOmpParser.parallel_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
ParserRuleReturnScope unique_parallel_clause17 =null;
ParserRuleReturnScope data_clause18 =null;
try {
// MFortranOmpParser.g:74:3: ( unique_parallel_clause | data_clause )
int alt3=2;
int LA3_0 = input.LA(1);
if ( (LA3_0==T_NUM_THREADS||LA3_0==T_IF) ) {
alt3=1;
}
else if ( ((LA3_0 >= T_COPYIN && LA3_0 <= T_COPYPRIVATE)||LA3_0==T_FST_PRIVATE||LA3_0==T_LST_PRIVATE||LA3_0==T_REDUCTION||LA3_0==T_SHARED||LA3_0==T_DEFAULT||LA3_0==T_PRIVATE) ) {
alt3=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 3, 0, input);
throw nvae;
}
switch (alt3) {
case 1 :
// MFortranOmpParser.g:74:5: unique_parallel_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_unique_parallel_clause_in_parallel_clause222);
unique_parallel_clause17=unique_parallel_clause();
state._fsp--;
adaptor.addChild(root_0, unique_parallel_clause17.getTree());
}
break;
case 2 :
// MFortranOmpParser.g:75:5: data_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_data_clause_in_parallel_clause228);
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"
// MFortranOmpParser.g:78:1: master_directive : T_MASTER -> ^( T_MASTER ) ;
public final MFortranOmpParser.master_directive_return master_directive() throws RecognitionException {
MFortranOmpParser.master_directive_return retval = new MFortranOmpParser.master_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_MASTER19=null;
Object T_MASTER19_tree=null;
RewriteRuleTokenStream stream_T_MASTER=new RewriteRuleTokenStream(adaptor,"token T_MASTER");
try {
// MFortranOmpParser.g:79:3: ( T_MASTER -> ^( T_MASTER ) )
// MFortranOmpParser.g:79:5: T_MASTER
{
T_MASTER19=(Token)match(input,T_MASTER,FOLLOW_T_MASTER_in_master_directive243);
stream_T_MASTER.add(T_MASTER19);
// AST REWRITE
// elements: T_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:14: -> ^( T_MASTER )
{
// MFortranOmpParser.g:79:17: ^( T_MASTER )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:82:1: critical_directive : T_CRITICAL ( T_LPAREN id= T_IDENT T_RPAREN )? -> ^( T_CRITICAL ( $id)? ) ;
public final MFortranOmpParser.critical_directive_return critical_directive() throws RecognitionException {
MFortranOmpParser.critical_directive_return retval = new MFortranOmpParser.critical_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token id=null;
Token T_CRITICAL20=null;
Token T_LPAREN21=null;
Token T_RPAREN22=null;
Object id_tree=null;
Object T_CRITICAL20_tree=null;
Object T_LPAREN21_tree=null;
Object T_RPAREN22_tree=null;
RewriteRuleTokenStream stream_T_LPAREN=new RewriteRuleTokenStream(adaptor,"token T_LPAREN");
RewriteRuleTokenStream stream_T_CRITICAL=new RewriteRuleTokenStream(adaptor,"token T_CRITICAL");
RewriteRuleTokenStream stream_T_RPAREN=new RewriteRuleTokenStream(adaptor,"token T_RPAREN");
RewriteRuleTokenStream stream_T_IDENT=new RewriteRuleTokenStream(adaptor,"token T_IDENT");
try {
// MFortranOmpParser.g:83:3: ( T_CRITICAL ( T_LPAREN id= T_IDENT T_RPAREN )? -> ^( T_CRITICAL ( $id)? ) )
// MFortranOmpParser.g:83:5: T_CRITICAL ( T_LPAREN id= T_IDENT T_RPAREN )?
{
T_CRITICAL20=(Token)match(input,T_CRITICAL,FOLLOW_T_CRITICAL_in_critical_directive262);
stream_T_CRITICAL.add(T_CRITICAL20);
// MFortranOmpParser.g:83:17: ( T_LPAREN id= T_IDENT T_RPAREN )?
int alt4=2;
int LA4_0 = input.LA(1);
if ( (LA4_0==T_LPAREN) ) {
alt4=1;
}
switch (alt4) {
case 1 :
// MFortranOmpParser.g:83:18: T_LPAREN id= T_IDENT T_RPAREN
{
T_LPAREN21=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_critical_directive266);
stream_T_LPAREN.add(T_LPAREN21);
id=(Token)match(input,T_IDENT,FOLLOW_T_IDENT_in_critical_directive271);
stream_T_IDENT.add(id);
T_RPAREN22=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_critical_directive274);
stream_T_RPAREN.add(T_RPAREN22);
}
break;
}
// AST REWRITE
// elements: T_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: -> ^( T_CRITICAL ( $id)? )
{
// MFortranOmpParser.g:84:6: ^( T_CRITICAL ( $id)? )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_CRITICAL.nextNode(), root_1);
// MFortranOmpParser.g:84:20: ( $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"
// MFortranOmpParser.g:87:1: sections_directive : T_SECTIONS (s+= sections_clause )* -> ^( T_SECTIONS ( $s)* ) ;
public final MFortranOmpParser.sections_directive_return sections_directive() throws RecognitionException {
MFortranOmpParser.sections_directive_return retval = new MFortranOmpParser.sections_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_SECTIONS23=null;
List<Object> list_s=null;
RuleReturnScope s = null;
Object T_SECTIONS23_tree=null;
RewriteRuleTokenStream stream_T_SECTIONS=new RewriteRuleTokenStream(adaptor,"token T_SECTIONS");
RewriteRuleSubtreeStream stream_sections_clause=new RewriteRuleSubtreeStream(adaptor,"rule sections_clause");
try {
// MFortranOmpParser.g:88:3: ( T_SECTIONS (s+= sections_clause )* -> ^( T_SECTIONS ( $s)* ) )
// MFortranOmpParser.g:88:5: T_SECTIONS (s+= sections_clause )*
{
T_SECTIONS23=(Token)match(input,T_SECTIONS,FOLLOW_T_SECTIONS_in_sections_directive303);
stream_T_SECTIONS.add(T_SECTIONS23);
// MFortranOmpParser.g:88:17: (s+= sections_clause )*
loop5:
while (true) {
int alt5=2;
int LA5_0 = input.LA(1);
if ( ((LA5_0 >= T_COPYIN && LA5_0 <= T_COPYPRIVATE)||LA5_0==T_FST_PRIVATE||LA5_0==T_LST_PRIVATE||LA5_0==T_NOWAIT||LA5_0==T_REDUCTION||LA5_0==T_SHARED||LA5_0==T_DEFAULT||LA5_0==T_PRIVATE) ) {
alt5=1;
}
switch (alt5) {
case 1 :
// MFortranOmpParser.g:88:18: s+= sections_clause
{
pushFollow(FOLLOW_sections_clause_in_sections_directive309);
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: T_SECTIONS, s
// 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: -> ^( T_SECTIONS ( $s)* )
{
// MFortranOmpParser.g:89:6: ^( T_SECTIONS ( $s)* )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_SECTIONS.nextNode(), root_1);
// MFortranOmpParser.g:89:20: ( $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"
// MFortranOmpParser.g:92:1: sections_clause : ( data_clause | nowait_directive );
public final MFortranOmpParser.sections_clause_return sections_clause() throws RecognitionException {
MFortranOmpParser.sections_clause_return retval = new MFortranOmpParser.sections_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
ParserRuleReturnScope data_clause24 =null;
ParserRuleReturnScope nowait_directive25 =null;
try {
// MFortranOmpParser.g:93:3: ( data_clause | nowait_directive )
int alt6=2;
int LA6_0 = input.LA(1);
if ( ((LA6_0 >= T_COPYIN && LA6_0 <= T_COPYPRIVATE)||LA6_0==T_FST_PRIVATE||LA6_0==T_LST_PRIVATE||LA6_0==T_REDUCTION||LA6_0==T_SHARED||LA6_0==T_DEFAULT||LA6_0==T_PRIVATE) ) {
alt6=1;
}
else if ( (LA6_0==T_NOWAIT) ) {
alt6=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 6, 0, input);
throw nvae;
}
switch (alt6) {
case 1 :
// MFortranOmpParser.g:93:5: data_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_data_clause_in_sections_clause336);
data_clause24=data_clause();
state._fsp--;
adaptor.addChild(root_0, data_clause24.getTree());
}
break;
case 2 :
// MFortranOmpParser.g:94:5: nowait_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_nowait_directive_in_sections_clause342);
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"
// MFortranOmpParser.g:97:1: section_directive : T_SECTION -> ^( T_SECTION ) ;
public final MFortranOmpParser.section_directive_return section_directive() throws RecognitionException {
MFortranOmpParser.section_directive_return retval = new MFortranOmpParser.section_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_SECTION26=null;
Object T_SECTION26_tree=null;
RewriteRuleTokenStream stream_T_SECTION=new RewriteRuleTokenStream(adaptor,"token T_SECTION");
try {
// MFortranOmpParser.g:98:3: ( T_SECTION -> ^( T_SECTION ) )
// MFortranOmpParser.g:98:5: T_SECTION
{
T_SECTION26=(Token)match(input,T_SECTION,FOLLOW_T_SECTION_in_section_directive355);
stream_T_SECTION.add(T_SECTION26);
// AST REWRITE
// elements: T_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:15: -> ^( T_SECTION )
{
// MFortranOmpParser.g:98:18: ^( T_SECTION )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:101:1: parallel_for_directive : T_PARALLEL T_DO (p+= parallel_for_clause )* -> ^( T_PARALLEL_FOR ( $p)* ) ;
public final MFortranOmpParser.parallel_for_directive_return parallel_for_directive() throws RecognitionException {
MFortranOmpParser.parallel_for_directive_return retval = new MFortranOmpParser.parallel_for_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_PARALLEL27=null;
Token T_DO28=null;
List<Object> list_p=null;
RuleReturnScope p = null;
Object T_PARALLEL27_tree=null;
Object T_DO28_tree=null;
RewriteRuleTokenStream stream_T_DO=new RewriteRuleTokenStream(adaptor,"token T_DO");
RewriteRuleTokenStream stream_T_PARALLEL=new RewriteRuleTokenStream(adaptor,"token T_PARALLEL");
RewriteRuleSubtreeStream stream_parallel_for_clause=new RewriteRuleSubtreeStream(adaptor,"rule parallel_for_clause");
try {
// MFortranOmpParser.g:102:3: ( T_PARALLEL T_DO (p+= parallel_for_clause )* -> ^( T_PARALLEL_FOR ( $p)* ) )
// MFortranOmpParser.g:102:5: T_PARALLEL T_DO (p+= parallel_for_clause )*
{
T_PARALLEL27=(Token)match(input,T_PARALLEL,FOLLOW_T_PARALLEL_in_parallel_for_directive376);
stream_T_PARALLEL.add(T_PARALLEL27);
T_DO28=(Token)match(input,T_DO,FOLLOW_T_DO_in_parallel_for_directive378);
stream_T_DO.add(T_DO28);
// MFortranOmpParser.g:102:22: (p+= parallel_for_clause )*
loop7:
while (true) {
int alt7=2;
int LA7_0 = input.LA(1);
if ( ((LA7_0 >= T_COLLAPSE && LA7_0 <= T_COPYPRIVATE)||LA7_0==T_FST_PRIVATE||LA7_0==T_LST_PRIVATE||LA7_0==T_NUM_THREADS||LA7_0==T_ORDERED||LA7_0==T_REDUCTION||LA7_0==T_SCHEDULE||LA7_0==T_SHARED||LA7_0==T_DEFAULT||LA7_0==T_IF||LA7_0==T_PRIVATE) ) {
alt7=1;
}
switch (alt7) {
case 1 :
// MFortranOmpParser.g:102:22: p+= parallel_for_clause
{
pushFollow(FOLLOW_parallel_for_clause_in_parallel_for_directive382);
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: -> ^( T_PARALLEL_FOR ( $p)* )
{
// MFortranOmpParser.g:103:8: ^( T_PARALLEL_FOR ( $p)* )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_PARALLEL_FOR, "T_PARALLEL_FOR"), root_1);
// MFortranOmpParser.g:103:26: ( $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"
// MFortranOmpParser.g:106:1: parallel_for_clause : ( unique_parallel_clause | unique_for_clause | data_clause );
public final MFortranOmpParser.parallel_for_clause_return parallel_for_clause() throws RecognitionException {
MFortranOmpParser.parallel_for_clause_return retval = new MFortranOmpParser.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 {
// MFortranOmpParser.g:107:3: ( unique_parallel_clause | unique_for_clause | data_clause )
int alt8=3;
switch ( input.LA(1) ) {
case T_NUM_THREADS:
case T_IF:
{
alt8=1;
}
break;
case T_COLLAPSE:
case T_ORDERED:
case T_SCHEDULE:
{
alt8=2;
}
break;
case T_COPYIN:
case T_COPYPRIVATE:
case T_FST_PRIVATE:
case T_LST_PRIVATE:
case T_REDUCTION:
case T_SHARED:
case T_DEFAULT:
case T_PRIVATE:
{
alt8=3;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 8, 0, input);
throw nvae;
}
switch (alt8) {
case 1 :
// MFortranOmpParser.g:107:5: unique_parallel_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_unique_parallel_clause_in_parallel_for_clause410);
unique_parallel_clause29=unique_parallel_clause();
state._fsp--;
adaptor.addChild(root_0, unique_parallel_clause29.getTree());
}
break;
case 2 :
// MFortranOmpParser.g:108:5: unique_for_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_unique_for_clause_in_parallel_for_clause416);
unique_for_clause30=unique_for_clause();
state._fsp--;
adaptor.addChild(root_0, unique_for_clause30.getTree());
}
break;
case 3 :
// MFortranOmpParser.g:109:5: data_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_data_clause_in_parallel_for_clause422);
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"
// MFortranOmpParser.g:112:1: parallel_sections_directive : T_PARALLEL T_SECTIONS (p+= parallel_sections_clause )* -> ^( T_PARALLEL_SECTIONS ( $p)* ) ;
public final MFortranOmpParser.parallel_sections_directive_return parallel_sections_directive() throws RecognitionException {
MFortranOmpParser.parallel_sections_directive_return retval = new MFortranOmpParser.parallel_sections_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_PARALLEL32=null;
Token T_SECTIONS33=null;
List<Object> list_p=null;
RuleReturnScope p = null;
Object T_PARALLEL32_tree=null;
Object T_SECTIONS33_tree=null;
RewriteRuleTokenStream stream_T_PARALLEL=new RewriteRuleTokenStream(adaptor,"token T_PARALLEL");
RewriteRuleTokenStream stream_T_SECTIONS=new RewriteRuleTokenStream(adaptor,"token T_SECTIONS");
RewriteRuleSubtreeStream stream_parallel_sections_clause=new RewriteRuleSubtreeStream(adaptor,"rule parallel_sections_clause");
try {
// MFortranOmpParser.g:113:3: ( T_PARALLEL T_SECTIONS (p+= parallel_sections_clause )* -> ^( T_PARALLEL_SECTIONS ( $p)* ) )
// MFortranOmpParser.g:113:5: T_PARALLEL T_SECTIONS (p+= parallel_sections_clause )*
{
T_PARALLEL32=(Token)match(input,T_PARALLEL,FOLLOW_T_PARALLEL_in_parallel_sections_directive435);
stream_T_PARALLEL.add(T_PARALLEL32);
T_SECTIONS33=(Token)match(input,T_SECTIONS,FOLLOW_T_SECTIONS_in_parallel_sections_directive438);
stream_T_SECTIONS.add(T_SECTIONS33);
// MFortranOmpParser.g:113:30: (p+= parallel_sections_clause )*
loop9:
while (true) {
int alt9=2;
int LA9_0 = input.LA(1);
if ( ((LA9_0 >= T_COPYIN && LA9_0 <= T_COPYPRIVATE)||LA9_0==T_FST_PRIVATE||LA9_0==T_LST_PRIVATE||LA9_0==T_NUM_THREADS||LA9_0==T_REDUCTION||LA9_0==T_SHARED||LA9_0==T_DEFAULT||LA9_0==T_IF||LA9_0==T_PRIVATE) ) {
alt9=1;
}
switch (alt9) {
case 1 :
// MFortranOmpParser.g:113:30: p+= parallel_sections_clause
{
pushFollow(FOLLOW_parallel_sections_clause_in_parallel_sections_directive443);
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: -> ^( T_PARALLEL_SECTIONS ( $p)* )
{
// MFortranOmpParser.g:114:8: ^( T_PARALLEL_SECTIONS ( $p)* )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_PARALLEL_SECTIONS, "T_PARALLEL_SECTIONS"), root_1);
// MFortranOmpParser.g:114:31: ( $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"
// MFortranOmpParser.g:117:1: parallel_sections_clause : ( unique_parallel_clause | data_clause );
public final MFortranOmpParser.parallel_sections_clause_return parallel_sections_clause() throws RecognitionException {
MFortranOmpParser.parallel_sections_clause_return retval = new MFortranOmpParser.parallel_sections_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
ParserRuleReturnScope unique_parallel_clause34 =null;
ParserRuleReturnScope data_clause35 =null;
try {
// MFortranOmpParser.g:118:3: ( unique_parallel_clause | data_clause )
int alt10=2;
int LA10_0 = input.LA(1);
if ( (LA10_0==T_NUM_THREADS||LA10_0==T_IF) ) {
alt10=1;
}
else if ( ((LA10_0 >= T_COPYIN && LA10_0 <= T_COPYPRIVATE)||LA10_0==T_FST_PRIVATE||LA10_0==T_LST_PRIVATE||LA10_0==T_REDUCTION||LA10_0==T_SHARED||LA10_0==T_DEFAULT||LA10_0==T_PRIVATE) ) {
alt10=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 10, 0, input);
throw nvae;
}
switch (alt10) {
case 1 :
// MFortranOmpParser.g:118:5: unique_parallel_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_unique_parallel_clause_in_parallel_sections_clause471);
unique_parallel_clause34=unique_parallel_clause();
state._fsp--;
adaptor.addChild(root_0, unique_parallel_clause34.getTree());
}
break;
case 2 :
// MFortranOmpParser.g:119:5: data_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_data_clause_in_parallel_sections_clause477);
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 single_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "single_directive"
// MFortranOmpParser.g:122:1: single_directive : T_SINGLE (s+= single_clause )* -> ^( T_SINGLE ( $s)* ) ;
public final MFortranOmpParser.single_directive_return single_directive() throws RecognitionException {
MFortranOmpParser.single_directive_return retval = new MFortranOmpParser.single_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_SINGLE36=null;
List<Object> list_s=null;
RuleReturnScope s = null;
Object T_SINGLE36_tree=null;
RewriteRuleTokenStream stream_T_SINGLE=new RewriteRuleTokenStream(adaptor,"token T_SINGLE");
RewriteRuleSubtreeStream stream_single_clause=new RewriteRuleSubtreeStream(adaptor,"rule single_clause");
try {
// MFortranOmpParser.g:123:3: ( T_SINGLE (s+= single_clause )* -> ^( T_SINGLE ( $s)* ) )
// MFortranOmpParser.g:123:5: T_SINGLE (s+= single_clause )*
{
T_SINGLE36=(Token)match(input,T_SINGLE,FOLLOW_T_SINGLE_in_single_directive490);
stream_T_SINGLE.add(T_SINGLE36);
// MFortranOmpParser.g:123:16: (s+= single_clause )*
loop11:
while (true) {
int alt11=2;
int LA11_0 = input.LA(1);
if ( ((LA11_0 >= T_COPYIN && LA11_0 <= T_COPYPRIVATE)||LA11_0==T_FST_PRIVATE||LA11_0==T_LST_PRIVATE||LA11_0==T_NOWAIT||LA11_0==T_REDUCTION||LA11_0==T_SHARED||LA11_0==T_DEFAULT||LA11_0==T_PRIVATE) ) {
alt11=1;
}
switch (alt11) {
case 1 :
// MFortranOmpParser.g:123:16: s+= single_clause
{
pushFollow(FOLLOW_single_clause_in_single_directive495);
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 loop11;
}
}
// AST REWRITE
// elements: s, T_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();
// 124:5: -> ^( T_SINGLE ( $s)* )
{
// MFortranOmpParser.g:124:8: ^( T_SINGLE ( $s)* )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_SINGLE.nextNode(), root_1);
// MFortranOmpParser.g:124:20: ( $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"
// MFortranOmpParser.g:127:1: single_clause : ( data_clause | nowait_directive );
public final MFortranOmpParser.single_clause_return single_clause() throws RecognitionException {
MFortranOmpParser.single_clause_return retval = new MFortranOmpParser.single_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
ParserRuleReturnScope data_clause37 =null;
ParserRuleReturnScope nowait_directive38 =null;
try {
// MFortranOmpParser.g:128:3: ( data_clause | nowait_directive )
int alt12=2;
int LA12_0 = input.LA(1);
if ( ((LA12_0 >= T_COPYIN && LA12_0 <= T_COPYPRIVATE)||LA12_0==T_FST_PRIVATE||LA12_0==T_LST_PRIVATE||LA12_0==T_REDUCTION||LA12_0==T_SHARED||LA12_0==T_DEFAULT||LA12_0==T_PRIVATE) ) {
alt12=1;
}
else if ( (LA12_0==T_NOWAIT) ) {
alt12=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 12, 0, input);
throw nvae;
}
switch (alt12) {
case 1 :
// MFortranOmpParser.g:128:5: data_clause
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_data_clause_in_single_clause523);
data_clause37=data_clause();
state._fsp--;
adaptor.addChild(root_0, data_clause37.getTree());
}
break;
case 2 :
// MFortranOmpParser.g:129:5: nowait_directive
{
root_0 = (Object)adaptor.nil();
pushFollow(FOLLOW_nowait_directive_in_single_clause529);
nowait_directive38=nowait_directive();
state._fsp--;
adaptor.addChild(root_0, nowait_directive38.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"
// MFortranOmpParser.g:132:1: barrier_directive : T_BARRIER -> ^( T_BARRIER ) ;
public final MFortranOmpParser.barrier_directive_return barrier_directive() throws RecognitionException {
MFortranOmpParser.barrier_directive_return retval = new MFortranOmpParser.barrier_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_BARRIER39=null;
Object T_BARRIER39_tree=null;
RewriteRuleTokenStream stream_T_BARRIER=new RewriteRuleTokenStream(adaptor,"token T_BARRIER");
try {
// MFortranOmpParser.g:133:3: ( T_BARRIER -> ^( T_BARRIER ) )
// MFortranOmpParser.g:133:5: T_BARRIER
{
T_BARRIER39=(Token)match(input,T_BARRIER,FOLLOW_T_BARRIER_in_barrier_directive542);
stream_T_BARRIER.add(T_BARRIER39);
// AST REWRITE
// elements: T_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();
// 133:15: -> ^( T_BARRIER )
{
// MFortranOmpParser.g:133:18: ^( T_BARRIER )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:136:1: ompatomic_directive : T_OMPATOMIC (c0= atomic_clasue )? (c1= seq_cst_clause )? -> ^( T_OMPATOMIC ( $c0)? ( $c1)? ) ;
public final MFortranOmpParser.ompatomic_directive_return ompatomic_directive() throws RecognitionException {
MFortranOmpParser.ompatomic_directive_return retval = new MFortranOmpParser.ompatomic_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_OMPATOMIC40=null;
ParserRuleReturnScope c0 =null;
ParserRuleReturnScope c1 =null;
Object T_OMPATOMIC40_tree=null;
RewriteRuleTokenStream stream_T_OMPATOMIC=new RewriteRuleTokenStream(adaptor,"token T_OMPATOMIC");
RewriteRuleSubtreeStream stream_atomic_clasue=new RewriteRuleSubtreeStream(adaptor,"rule atomic_clasue");
RewriteRuleSubtreeStream stream_seq_cst_clause=new RewriteRuleSubtreeStream(adaptor,"rule seq_cst_clause");
try {
// MFortranOmpParser.g:137:3: ( T_OMPATOMIC (c0= atomic_clasue )? (c1= seq_cst_clause )? -> ^( T_OMPATOMIC ( $c0)? ( $c1)? ) )
// MFortranOmpParser.g:137:5: T_OMPATOMIC (c0= atomic_clasue )? (c1= seq_cst_clause )?
{
T_OMPATOMIC40=(Token)match(input,T_OMPATOMIC,FOLLOW_T_OMPATOMIC_in_ompatomic_directive563);
stream_T_OMPATOMIC.add(T_OMPATOMIC40);
// MFortranOmpParser.g:137:19: (c0= atomic_clasue )?
int alt13=2;
int LA13_0 = input.LA(1);
if ( (LA13_0==T_CAPTURE||LA13_0==T_UPDATE||LA13_0==T_READ||LA13_0==T_WRITE) ) {
alt13=1;
}
switch (alt13) {
case 1 :
// MFortranOmpParser.g:137:19: c0= atomic_clasue
{
pushFollow(FOLLOW_atomic_clasue_in_ompatomic_directive567);
c0=atomic_clasue();
state._fsp--;
stream_atomic_clasue.add(c0.getTree());
}
break;
}
// MFortranOmpParser.g:137:37: (c1= seq_cst_clause )?
int alt14=2;
int LA14_0 = input.LA(1);
if ( (LA14_0==T_SEQ_CST) ) {
alt14=1;
}
switch (alt14) {
case 1 :
// MFortranOmpParser.g:137:37: c1= seq_cst_clause
{
pushFollow(FOLLOW_seq_cst_clause_in_ompatomic_directive572);
c1=seq_cst_clause();
state._fsp--;
stream_seq_cst_clause.add(c1.getTree());
}
break;
}
// AST REWRITE
// elements: T_OMPATOMIC, c0, c1
// 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();
// 138:5: -> ^( T_OMPATOMIC ( $c0)? ( $c1)? )
{
// MFortranOmpParser.g:138:8: ^( T_OMPATOMIC ( $c0)? ( $c1)? )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_OMPATOMIC.nextNode(), root_1);
// MFortranOmpParser.g:138:23: ( $c0)?
if ( stream_c0.hasNext() ) {
adaptor.addChild(root_1, stream_c0.nextTree());
}
stream_c0.reset();
// MFortranOmpParser.g:138:28: ( $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"
// MFortranOmpParser.g:141:1: atomic_clasue : ( T_READ | T_WRITE | T_UPDATE | T_CAPTURE );
public final MFortranOmpParser.atomic_clasue_return atomic_clasue() throws RecognitionException {
MFortranOmpParser.atomic_clasue_return retval = new MFortranOmpParser.atomic_clasue_return();
retval.start = input.LT(1);
Object root_0 = null;
Token set41=null;
Object set41_tree=null;
try {
// MFortranOmpParser.g:142:2: ( T_READ | T_WRITE | T_UPDATE | T_CAPTURE )
// MFortranOmpParser.g:
{
root_0 = (Object)adaptor.nil();
set41=input.LT(1);
if ( input.LA(1)==T_CAPTURE||input.LA(1)==T_UPDATE||input.LA(1)==T_READ||input.LA(1)==T_WRITE ) {
input.consume();
adaptor.addChild(root_0, (Object)adaptor.create(set41));
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"
// MFortranOmpParser.g:145:1: seq_cst_clause : T_SEQ_CST ;
public final MFortranOmpParser.seq_cst_clause_return seq_cst_clause() throws RecognitionException {
MFortranOmpParser.seq_cst_clause_return retval = new MFortranOmpParser.seq_cst_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_SEQ_CST42=null;
Object T_SEQ_CST42_tree=null;
try {
// MFortranOmpParser.g:146:2: ( T_SEQ_CST )
// MFortranOmpParser.g:146:4: T_SEQ_CST
{
root_0 = (Object)adaptor.nil();
T_SEQ_CST42=(Token)match(input,T_SEQ_CST,FOLLOW_T_SEQ_CST_in_seq_cst_clause631);
T_SEQ_CST42_tree = (Object)adaptor.create(T_SEQ_CST42);
adaptor.addChild(root_0, T_SEQ_CST42_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"
// MFortranOmpParser.g:149:1: flush_directive : T_FLUSH (f= flush_vars )? -> ^( T_FLUSH ( $f)? ) ;
public final MFortranOmpParser.flush_directive_return flush_directive() throws RecognitionException {
MFortranOmpParser.flush_directive_return retval = new MFortranOmpParser.flush_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_FLUSH43=null;
ParserRuleReturnScope f =null;
Object T_FLUSH43_tree=null;
RewriteRuleTokenStream stream_T_FLUSH=new RewriteRuleTokenStream(adaptor,"token T_FLUSH");
RewriteRuleSubtreeStream stream_flush_vars=new RewriteRuleSubtreeStream(adaptor,"rule flush_vars");
try {
// MFortranOmpParser.g:150:3: ( T_FLUSH (f= flush_vars )? -> ^( T_FLUSH ( $f)? ) )
// MFortranOmpParser.g:150:5: T_FLUSH (f= flush_vars )?
{
T_FLUSH43=(Token)match(input,T_FLUSH,FOLLOW_T_FLUSH_in_flush_directive644);
stream_T_FLUSH.add(T_FLUSH43);
// MFortranOmpParser.g:150:15: (f= flush_vars )?
int alt15=2;
int LA15_0 = input.LA(1);
if ( (LA15_0==T_LPAREN) ) {
alt15=1;
}
switch (alt15) {
case 1 :
// MFortranOmpParser.g:150:15: f= flush_vars
{
pushFollow(FOLLOW_flush_vars_in_flush_directive649);
f=flush_vars();
state._fsp--;
stream_flush_vars.add(f.getTree());
}
break;
}
// AST REWRITE
// elements: T_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();
// 151:5: -> ^( T_FLUSH ( $f)? )
{
// MFortranOmpParser.g:151:8: ^( T_FLUSH ( $f)? )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_FLUSH.nextNode(), root_1);
// MFortranOmpParser.g:151:19: ( $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"
// MFortranOmpParser.g:154:1: flush_vars : T_LPAREN i= identifier_list T_RPAREN -> ^( T_IDENTIFIER_LIST $i) ;
public final MFortranOmpParser.flush_vars_return flush_vars() throws RecognitionException {
MFortranOmpParser.flush_vars_return retval = new MFortranOmpParser.flush_vars_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_LPAREN44=null;
Token T_RPAREN45=null;
ParserRuleReturnScope i =null;
Object T_LPAREN44_tree=null;
Object T_RPAREN45_tree=null;
RewriteRuleTokenStream stream_T_LPAREN=new RewriteRuleTokenStream(adaptor,"token T_LPAREN");
RewriteRuleTokenStream stream_T_RPAREN=new RewriteRuleTokenStream(adaptor,"token T_RPAREN");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// MFortranOmpParser.g:155:3: ( T_LPAREN i= identifier_list T_RPAREN -> ^( T_IDENTIFIER_LIST $i) )
// MFortranOmpParser.g:155:5: T_LPAREN i= identifier_list T_RPAREN
{
T_LPAREN44=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_flush_vars677);
stream_T_LPAREN.add(T_LPAREN44);
pushFollow(FOLLOW_identifier_list_in_flush_vars683);
i=identifier_list();
state._fsp--;
stream_identifier_list.add(i.getTree());
T_RPAREN45=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_flush_vars686);
stream_T_RPAREN.add(T_RPAREN45);
// 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();
// 156:5: -> ^( T_IDENTIFIER_LIST $i)
{
// MFortranOmpParser.g:156:8: ^( T_IDENTIFIER_LIST $i)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_IDENTIFIER_LIST, "T_IDENTIFIER_LIST"), 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 "flush_vars"
public static class ordered_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "ordered_directive"
// MFortranOmpParser.g:159:1: ordered_directive : T_ORDERED -> ^( T_ORDERED ) ;
public final MFortranOmpParser.ordered_directive_return ordered_directive() throws RecognitionException {
MFortranOmpParser.ordered_directive_return retval = new MFortranOmpParser.ordered_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_ORDERED46=null;
Object T_ORDERED46_tree=null;
RewriteRuleTokenStream stream_T_ORDERED=new RewriteRuleTokenStream(adaptor,"token T_ORDERED");
try {
// MFortranOmpParser.g:160:3: ( T_ORDERED -> ^( T_ORDERED ) )
// MFortranOmpParser.g:160:5: T_ORDERED
{
T_ORDERED46=(Token)match(input,T_ORDERED,FOLLOW_T_ORDERED_in_ordered_directive712);
stream_T_ORDERED.add(T_ORDERED46);
// AST REWRITE
// elements: T_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();
// 160:15: -> ^( T_ORDERED )
{
// MFortranOmpParser.g:160:18: ^( T_ORDERED )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:163:1: nowait_directive : T_NOWAIT -> ^( T_NOWAIT ) ;
public final MFortranOmpParser.nowait_directive_return nowait_directive() throws RecognitionException {
MFortranOmpParser.nowait_directive_return retval = new MFortranOmpParser.nowait_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_NOWAIT47=null;
Object T_NOWAIT47_tree=null;
RewriteRuleTokenStream stream_T_NOWAIT=new RewriteRuleTokenStream(adaptor,"token T_NOWAIT");
try {
// MFortranOmpParser.g:164:3: ( T_NOWAIT -> ^( T_NOWAIT ) )
// MFortranOmpParser.g:164:5: T_NOWAIT
{
T_NOWAIT47=(Token)match(input,T_NOWAIT,FOLLOW_T_NOWAIT_in_nowait_directive733);
stream_T_NOWAIT.add(T_NOWAIT47);
// AST REWRITE
// elements: T_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();
// 164:14: -> ^( T_NOWAIT )
{
// MFortranOmpParser.g:164:17: ^( T_NOWAIT )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:167:1: threadprivate_directive : T_THD_PRIVATE T_LPAREN i= identifier_list T_RPAREN -> ^( T_THD_PRIVATE $i) ;
public final MFortranOmpParser.threadprivate_directive_return threadprivate_directive() throws RecognitionException {
MFortranOmpParser.threadprivate_directive_return retval = new MFortranOmpParser.threadprivate_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_THD_PRIVATE48=null;
Token T_LPAREN49=null;
Token T_RPAREN50=null;
ParserRuleReturnScope i =null;
Object T_THD_PRIVATE48_tree=null;
Object T_LPAREN49_tree=null;
Object T_RPAREN50_tree=null;
RewriteRuleTokenStream stream_T_LPAREN=new RewriteRuleTokenStream(adaptor,"token T_LPAREN");
RewriteRuleTokenStream stream_T_RPAREN=new RewriteRuleTokenStream(adaptor,"token T_RPAREN");
RewriteRuleTokenStream stream_T_THD_PRIVATE=new RewriteRuleTokenStream(adaptor,"token T_THD_PRIVATE");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// MFortranOmpParser.g:168:3: ( T_THD_PRIVATE T_LPAREN i= identifier_list T_RPAREN -> ^( T_THD_PRIVATE $i) )
// MFortranOmpParser.g:168:5: T_THD_PRIVATE T_LPAREN i= identifier_list T_RPAREN
{
T_THD_PRIVATE48=(Token)match(input,T_THD_PRIVATE,FOLLOW_T_THD_PRIVATE_in_threadprivate_directive752);
stream_T_THD_PRIVATE.add(T_THD_PRIVATE48);
T_LPAREN49=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_threadprivate_directive755);
stream_T_LPAREN.add(T_LPAREN49);
pushFollow(FOLLOW_identifier_list_in_threadprivate_directive760);
i=identifier_list();
state._fsp--;
stream_identifier_list.add(i.getTree());
T_RPAREN50=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_threadprivate_directive763);
stream_T_RPAREN.add(T_RPAREN50);
// AST REWRITE
// elements: T_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();
// 169:5: -> ^( T_THD_PRIVATE $i)
{
// MFortranOmpParser.g:169:8: ^( T_THD_PRIVATE $i)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:172:1: for_directive : T_DO (f+= for_clause )* -> ^( T_DO ( $f)* ) ;
public final MFortranOmpParser.for_directive_return for_directive() throws RecognitionException {
MFortranOmpParser.for_directive_return retval = new MFortranOmpParser.for_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_DO51=null;
List<Object> list_f=null;
RuleReturnScope f = null;
Object T_DO51_tree=null;
RewriteRuleTokenStream stream_T_DO=new RewriteRuleTokenStream(adaptor,"token T_DO");
RewriteRuleSubtreeStream stream_for_clause=new RewriteRuleSubtreeStream(adaptor,"rule for_clause");
try {
// MFortranOmpParser.g:173:3: ( T_DO (f+= for_clause )* -> ^( T_DO ( $f)* ) )
// MFortranOmpParser.g:173:5: T_DO (f+= for_clause )*
{
T_DO51=(Token)match(input,T_DO,FOLLOW_T_DO_in_for_directive789);
stream_T_DO.add(T_DO51);
// MFortranOmpParser.g:173:11: (f+= for_clause )*
loop16:
while (true) {
int alt16=2;
int LA16_0 = input.LA(1);
if ( ((LA16_0 >= T_COLLAPSE && LA16_0 <= T_COPYPRIVATE)||LA16_0==T_FST_PRIVATE||LA16_0==T_LST_PRIVATE||LA16_0==T_NOWAIT||LA16_0==T_ORDERED||LA16_0==T_REDUCTION||LA16_0==T_SCHEDULE||LA16_0==T_SHARED||LA16_0==T_DEFAULT||LA16_0==T_PRIVATE) ) {
alt16=1;
}
switch (alt16) {
case 1 :
// MFortranOmpParser.g:173:12: f+= for_clause
{
pushFollow(FOLLOW_for_clause_in_for_directive795);
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 loop16;
}
}
// AST REWRITE
// elements: f, T_DO
// 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();
// 174:5: -> ^( T_DO ( $f)* )
{
// MFortranOmpParser.g:174:8: ^( T_DO ( $f)* )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_DO.nextNode(), root_1);
// MFortranOmpParser.g:174:16: ( $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"
// MFortranOmpParser.g:177:1: for_clause : (u= unique_for_clause -> ^( T_FOR_CLAUSE $u) |d= data_clause -> ^( T_FOR_CLAUSE $d) |n= nowait_directive -> ^( T_FOR_CLAUSE $n) );
public final MFortranOmpParser.for_clause_return for_clause() throws RecognitionException {
MFortranOmpParser.for_clause_return retval = new MFortranOmpParser.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 {
// MFortranOmpParser.g:178:3: (u= unique_for_clause -> ^( T_FOR_CLAUSE $u) |d= data_clause -> ^( T_FOR_CLAUSE $d) |n= nowait_directive -> ^( T_FOR_CLAUSE $n) )
int alt17=3;
switch ( input.LA(1) ) {
case T_COLLAPSE:
case T_ORDERED:
case T_SCHEDULE:
{
alt17=1;
}
break;
case T_COPYIN:
case T_COPYPRIVATE:
case T_FST_PRIVATE:
case T_LST_PRIVATE:
case T_REDUCTION:
case T_SHARED:
case T_DEFAULT:
case T_PRIVATE:
{
alt17=2;
}
break;
case T_NOWAIT:
{
alt17=3;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 17, 0, input);
throw nvae;
}
switch (alt17) {
case 1 :
// MFortranOmpParser.g:178:5: u= unique_for_clause
{
pushFollow(FOLLOW_unique_for_clause_in_for_clause826);
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();
// 178:25: -> ^( T_FOR_CLAUSE $u)
{
// MFortranOmpParser.g:178:28: ^( T_FOR_CLAUSE $u)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_FOR_CLAUSE, "T_FOR_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_u.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// MFortranOmpParser.g:179:5: d= data_clause
{
pushFollow(FOLLOW_data_clause_in_for_clause843);
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();
// 179:19: -> ^( T_FOR_CLAUSE $d)
{
// MFortranOmpParser.g:179:22: ^( T_FOR_CLAUSE $d)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_FOR_CLAUSE, "T_FOR_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 3 :
// MFortranOmpParser.g:180:5: n= nowait_directive
{
pushFollow(FOLLOW_nowait_directive_in_for_clause860);
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();
// 180:24: -> ^( T_FOR_CLAUSE $n)
{
// MFortranOmpParser.g:180:27: ^( T_FOR_CLAUSE $n)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_FOR_CLAUSE, "T_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"
// MFortranOmpParser.g:183:1: unique_for_clause : ( T_ORDERED -> ^( T_UNIQUE_FOR T_ORDERED ) |s1= schedule_clause -> ^( T_UNIQUE_FOR $s1) |c= collapse_clause -> ^( T_UNIQUE_FOR $c) );
public final MFortranOmpParser.unique_for_clause_return unique_for_clause() throws RecognitionException {
MFortranOmpParser.unique_for_clause_return retval = new MFortranOmpParser.unique_for_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_ORDERED52=null;
ParserRuleReturnScope s1 =null;
ParserRuleReturnScope c =null;
Object T_ORDERED52_tree=null;
RewriteRuleTokenStream stream_T_ORDERED=new RewriteRuleTokenStream(adaptor,"token T_ORDERED");
RewriteRuleSubtreeStream stream_schedule_clause=new RewriteRuleSubtreeStream(adaptor,"rule schedule_clause");
RewriteRuleSubtreeStream stream_collapse_clause=new RewriteRuleSubtreeStream(adaptor,"rule collapse_clause");
try {
// MFortranOmpParser.g:184:3: ( T_ORDERED -> ^( T_UNIQUE_FOR T_ORDERED ) |s1= schedule_clause -> ^( T_UNIQUE_FOR $s1) |c= collapse_clause -> ^( T_UNIQUE_FOR $c) )
int alt18=3;
switch ( input.LA(1) ) {
case T_ORDERED:
{
alt18=1;
}
break;
case T_SCHEDULE:
{
alt18=2;
}
break;
case T_COLLAPSE:
{
alt18=3;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 18, 0, input);
throw nvae;
}
switch (alt18) {
case 1 :
// MFortranOmpParser.g:184:5: T_ORDERED
{
T_ORDERED52=(Token)match(input,T_ORDERED,FOLLOW_T_ORDERED_in_unique_for_clause882);
stream_T_ORDERED.add(T_ORDERED52);
// AST REWRITE
// elements: T_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();
// 184:15: -> ^( T_UNIQUE_FOR T_ORDERED )
{
// MFortranOmpParser.g:184:17: ^( T_UNIQUE_FOR T_ORDERED )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_UNIQUE_FOR, "T_UNIQUE_FOR"), root_1);
adaptor.addChild(root_1, stream_T_ORDERED.nextNode());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// MFortranOmpParser.g:185:5: s1= schedule_clause
{
pushFollow(FOLLOW_schedule_clause_in_unique_for_clause897);
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();
// 185:24: -> ^( T_UNIQUE_FOR $s1)
{
// MFortranOmpParser.g:185:27: ^( T_UNIQUE_FOR $s1)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_UNIQUE_FOR, "T_UNIQUE_FOR"), root_1);
adaptor.addChild(root_1, stream_s1.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 3 :
// MFortranOmpParser.g:186:5: c= collapse_clause
{
pushFollow(FOLLOW_collapse_clause_in_unique_for_clause914);
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();
// 186:23: -> ^( T_UNIQUE_FOR $c)
{
// MFortranOmpParser.g:186:26: ^( T_UNIQUE_FOR $c)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_UNIQUE_FOR, "T_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 schedule_clause_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "schedule_clause"
// MFortranOmpParser.g:189:1: schedule_clause : ( T_SCHEDULE T_LPAREN s1= schedule_kind T_COMMA e= expression T_RPAREN -> ^( T_SCHEDULE $s1 $e) | T_SCHEDULE T_LPAREN s= schedule_kind T_RPAREN -> ^( T_SCHEDULE $s) );
public final MFortranOmpParser.schedule_clause_return schedule_clause() throws RecognitionException {
MFortranOmpParser.schedule_clause_return retval = new MFortranOmpParser.schedule_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_SCHEDULE53=null;
Token T_LPAREN54=null;
Token T_COMMA55=null;
Token T_RPAREN56=null;
Token T_SCHEDULE57=null;
Token T_LPAREN58=null;
Token T_RPAREN59=null;
ParserRuleReturnScope s1 =null;
ParserRuleReturnScope e =null;
ParserRuleReturnScope s =null;
Object T_SCHEDULE53_tree=null;
Object T_LPAREN54_tree=null;
Object T_COMMA55_tree=null;
Object T_RPAREN56_tree=null;
Object T_SCHEDULE57_tree=null;
Object T_LPAREN58_tree=null;
Object T_RPAREN59_tree=null;
RewriteRuleTokenStream stream_T_LPAREN=new RewriteRuleTokenStream(adaptor,"token T_LPAREN");
RewriteRuleTokenStream stream_T_RPAREN=new RewriteRuleTokenStream(adaptor,"token T_RPAREN");
RewriteRuleTokenStream stream_T_COMMA=new RewriteRuleTokenStream(adaptor,"token T_COMMA");
RewriteRuleTokenStream stream_T_SCHEDULE=new RewriteRuleTokenStream(adaptor,"token T_SCHEDULE");
RewriteRuleSubtreeStream stream_schedule_kind=new RewriteRuleSubtreeStream(adaptor,"rule schedule_kind");
RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
try {
// MFortranOmpParser.g:190:2: ( T_SCHEDULE T_LPAREN s1= schedule_kind T_COMMA e= expression T_RPAREN -> ^( T_SCHEDULE $s1 $e) | T_SCHEDULE T_LPAREN s= schedule_kind T_RPAREN -> ^( T_SCHEDULE $s) )
int alt19=2;
int LA19_0 = input.LA(1);
if ( (LA19_0==T_SCHEDULE) ) {
int LA19_1 = input.LA(2);
if ( (LA19_1==T_LPAREN) ) {
switch ( input.LA(3) ) {
case T_STATIC:
{
int LA19_3 = input.LA(4);
if ( (LA19_3==T_COMMA) ) {
alt19=1;
}
else if ( (LA19_3==T_RPAREN) ) {
alt19=2;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 19, 3, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case T_DYNAMIC:
{
int LA19_4 = input.LA(4);
if ( (LA19_4==T_COMMA) ) {
alt19=1;
}
else if ( (LA19_4==T_RPAREN) ) {
alt19=2;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 19, 4, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case T_GUIDED:
{
int LA19_5 = input.LA(4);
if ( (LA19_5==T_COMMA) ) {
alt19=1;
}
else if ( (LA19_5==T_RPAREN) ) {
alt19=2;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 19, 5, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case T_RUNTIME:
{
int LA19_6 = input.LA(4);
if ( (LA19_6==T_COMMA) ) {
alt19=1;
}
else if ( (LA19_6==T_RPAREN) ) {
alt19=2;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 19, 6, 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("", 19, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 19, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
NoViableAltException nvae =
new NoViableAltException("", 19, 0, input);
throw nvae;
}
switch (alt19) {
case 1 :
// MFortranOmpParser.g:190:4: T_SCHEDULE T_LPAREN s1= schedule_kind T_COMMA e= expression T_RPAREN
{
T_SCHEDULE53=(Token)match(input,T_SCHEDULE,FOLLOW_T_SCHEDULE_in_schedule_clause937);
stream_T_SCHEDULE.add(T_SCHEDULE53);
T_LPAREN54=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_schedule_clause940);
stream_T_LPAREN.add(T_LPAREN54);
pushFollow(FOLLOW_schedule_kind_in_schedule_clause945);
s1=schedule_kind();
state._fsp--;
stream_schedule_kind.add(s1.getTree());
T_COMMA55=(Token)match(input,T_COMMA,FOLLOW_T_COMMA_in_schedule_clause948);
stream_T_COMMA.add(T_COMMA55);
pushFollow(FOLLOW_expression_in_schedule_clause953);
e=expression();
state._fsp--;
stream_expression.add(e.getTree());
T_RPAREN56=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_schedule_clause956);
stream_T_RPAREN.add(T_RPAREN56);
// AST REWRITE
// elements: T_SCHEDULE, s1, e
// 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();
// 191:7: -> ^( T_SCHEDULE $s1 $e)
{
// MFortranOmpParser.g:191:10: ^( T_SCHEDULE $s1 $e)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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 :
// MFortranOmpParser.g:192:8: T_SCHEDULE T_LPAREN s= schedule_kind T_RPAREN
{
T_SCHEDULE57=(Token)match(input,T_SCHEDULE,FOLLOW_T_SCHEDULE_in_schedule_clause983);
stream_T_SCHEDULE.add(T_SCHEDULE57);
T_LPAREN58=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_schedule_clause986);
stream_T_LPAREN.add(T_LPAREN58);
pushFollow(FOLLOW_schedule_kind_in_schedule_clause991);
s=schedule_kind();
state._fsp--;
stream_schedule_kind.add(s.getTree());
T_RPAREN59=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_schedule_clause994);
stream_T_RPAREN.add(T_RPAREN59);
// AST REWRITE
// elements: s, T_SCHEDULE
// 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();
// 193:4: -> ^( T_SCHEDULE $s)
{
// MFortranOmpParser.g:193:7: ^( T_SCHEDULE $s)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:196:1: collapse_clause : T_COLLAPSE T_LPAREN i= T_DIGIT_STRING T_RPAREN -> ^( T_COLLAPSE $i) ;
public final MFortranOmpParser.collapse_clause_return collapse_clause() throws RecognitionException {
MFortranOmpParser.collapse_clause_return retval = new MFortranOmpParser.collapse_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token i=null;
Token T_COLLAPSE60=null;
Token T_LPAREN61=null;
Token T_RPAREN62=null;
Object i_tree=null;
Object T_COLLAPSE60_tree=null;
Object T_LPAREN61_tree=null;
Object T_RPAREN62_tree=null;
RewriteRuleTokenStream stream_T_LPAREN=new RewriteRuleTokenStream(adaptor,"token T_LPAREN");
RewriteRuleTokenStream stream_T_RPAREN=new RewriteRuleTokenStream(adaptor,"token T_RPAREN");
RewriteRuleTokenStream stream_T_DIGIT_STRING=new RewriteRuleTokenStream(adaptor,"token T_DIGIT_STRING");
RewriteRuleTokenStream stream_T_COLLAPSE=new RewriteRuleTokenStream(adaptor,"token T_COLLAPSE");
try {
// MFortranOmpParser.g:197:2: ( T_COLLAPSE T_LPAREN i= T_DIGIT_STRING T_RPAREN -> ^( T_COLLAPSE $i) )
// MFortranOmpParser.g:198:2: T_COLLAPSE T_LPAREN i= T_DIGIT_STRING T_RPAREN
{
T_COLLAPSE60=(Token)match(input,T_COLLAPSE,FOLLOW_T_COLLAPSE_in_collapse_clause1019);
stream_T_COLLAPSE.add(T_COLLAPSE60);
T_LPAREN61=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_collapse_clause1022);
stream_T_LPAREN.add(T_LPAREN61);
i=(Token)match(input,T_DIGIT_STRING,FOLLOW_T_DIGIT_STRING_in_collapse_clause1027);
stream_T_DIGIT_STRING.add(i);
T_RPAREN62=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_collapse_clause1030);
stream_T_RPAREN.add(T_RPAREN62);
// AST REWRITE
// elements: i, T_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();
// 199:5: -> ^( T_COLLAPSE $i)
{
// MFortranOmpParser.g:199:8: ^( T_COLLAPSE $i)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:202:1: schedule_kind : ( T_STATIC -> ^( T_STATIC ) | T_DYNAMIC -> ^( T_DYNAMIC ) | T_GUIDED -> ^( T_GUIDED ) | T_RUNTIME -> ^( T_RUNTIME ) );
public final MFortranOmpParser.schedule_kind_return schedule_kind() throws RecognitionException {
MFortranOmpParser.schedule_kind_return retval = new MFortranOmpParser.schedule_kind_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_STATIC63=null;
Token T_DYNAMIC64=null;
Token T_GUIDED65=null;
Token T_RUNTIME66=null;
Object T_STATIC63_tree=null;
Object T_DYNAMIC64_tree=null;
Object T_GUIDED65_tree=null;
Object T_RUNTIME66_tree=null;
RewriteRuleTokenStream stream_T_DYNAMIC=new RewriteRuleTokenStream(adaptor,"token T_DYNAMIC");
RewriteRuleTokenStream stream_T_GUIDED=new RewriteRuleTokenStream(adaptor,"token T_GUIDED");
RewriteRuleTokenStream stream_T_STATIC=new RewriteRuleTokenStream(adaptor,"token T_STATIC");
RewriteRuleTokenStream stream_T_RUNTIME=new RewriteRuleTokenStream(adaptor,"token T_RUNTIME");
try {
// MFortranOmpParser.g:203:3: ( T_STATIC -> ^( T_STATIC ) | T_DYNAMIC -> ^( T_DYNAMIC ) | T_GUIDED -> ^( T_GUIDED ) | T_RUNTIME -> ^( T_RUNTIME ) )
int alt20=4;
switch ( input.LA(1) ) {
case T_STATIC:
{
alt20=1;
}
break;
case T_DYNAMIC:
{
alt20=2;
}
break;
case T_GUIDED:
{
alt20=3;
}
break;
case T_RUNTIME:
{
alt20=4;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 20, 0, input);
throw nvae;
}
switch (alt20) {
case 1 :
// MFortranOmpParser.g:203:5: T_STATIC
{
T_STATIC63=(Token)match(input,T_STATIC,FOLLOW_T_STATIC_in_schedule_kind1055);
stream_T_STATIC.add(T_STATIC63);
// AST REWRITE
// elements: T_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();
// 203:14: -> ^( T_STATIC )
{
// MFortranOmpParser.g:203:17: ^( T_STATIC )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_STATIC.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// MFortranOmpParser.g:204:5: T_DYNAMIC
{
T_DYNAMIC64=(Token)match(input,T_DYNAMIC,FOLLOW_T_DYNAMIC_in_schedule_kind1067);
stream_T_DYNAMIC.add(T_DYNAMIC64);
// AST REWRITE
// elements: T_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();
// 204:15: -> ^( T_DYNAMIC )
{
// MFortranOmpParser.g:204:18: ^( T_DYNAMIC )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_DYNAMIC.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 3 :
// MFortranOmpParser.g:205:5: T_GUIDED
{
T_GUIDED65=(Token)match(input,T_GUIDED,FOLLOW_T_GUIDED_in_schedule_kind1079);
stream_T_GUIDED.add(T_GUIDED65);
// AST REWRITE
// elements: T_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();
// 205:14: -> ^( T_GUIDED )
{
// MFortranOmpParser.g:205:17: ^( T_GUIDED )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_GUIDED.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 4 :
// MFortranOmpParser.g:206:5: T_RUNTIME
{
T_RUNTIME66=(Token)match(input,T_RUNTIME,FOLLOW_T_RUNTIME_in_schedule_kind1091);
stream_T_RUNTIME.add(T_RUNTIME66);
// AST REWRITE
// elements: T_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();
// 206:15: -> ^( T_RUNTIME )
{
// MFortranOmpParser.g:206:18: ^( T_RUNTIME )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_RUNTIME.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"
// MFortranOmpParser.g:209:1: unique_parallel_clause : (i= if_clause -> ^( T_UNIQUE_PARALLEL $i) |n= num_threads_clause -> ^( T_UNIQUE_PARALLEL $n) );
public final MFortranOmpParser.unique_parallel_clause_return unique_parallel_clause() throws RecognitionException {
MFortranOmpParser.unique_parallel_clause_return retval = new MFortranOmpParser.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 {
// MFortranOmpParser.g:210:3: (i= if_clause -> ^( T_UNIQUE_PARALLEL $i) |n= num_threads_clause -> ^( T_UNIQUE_PARALLEL $n) )
int alt21=2;
int LA21_0 = input.LA(1);
if ( (LA21_0==T_IF) ) {
alt21=1;
}
else if ( (LA21_0==T_NUM_THREADS) ) {
alt21=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 21, 0, input);
throw nvae;
}
switch (alt21) {
case 1 :
// MFortranOmpParser.g:210:5: i= if_clause
{
pushFollow(FOLLOW_if_clause_in_unique_parallel_clause1112);
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();
// 211:5: -> ^( T_UNIQUE_PARALLEL $i)
{
// MFortranOmpParser.g:211:8: ^( T_UNIQUE_PARALLEL $i)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_UNIQUE_PARALLEL, "T_UNIQUE_PARALLEL"), root_1);
adaptor.addChild(root_1, stream_i.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// MFortranOmpParser.g:212:5: n= num_threads_clause
{
pushFollow(FOLLOW_num_threads_clause_in_unique_parallel_clause1134);
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();
// 213:5: -> ^( T_UNIQUE_PARALLEL $n)
{
// MFortranOmpParser.g:213:8: ^( T_UNIQUE_PARALLEL $n)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_UNIQUE_PARALLEL, "T_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"
// MFortranOmpParser.g:216:1: if_clause : T_IF T_LPAREN e1= expression T_RPAREN -> ^( T_IF $e1) ;
public final MFortranOmpParser.if_clause_return if_clause() throws RecognitionException {
MFortranOmpParser.if_clause_return retval = new MFortranOmpParser.if_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_IF67=null;
Token T_LPAREN68=null;
Token T_RPAREN69=null;
ParserRuleReturnScope e1 =null;
Object T_IF67_tree=null;
Object T_LPAREN68_tree=null;
Object T_RPAREN69_tree=null;
RewriteRuleTokenStream stream_T_LPAREN=new RewriteRuleTokenStream(adaptor,"token T_LPAREN");
RewriteRuleTokenStream stream_T_RPAREN=new RewriteRuleTokenStream(adaptor,"token T_RPAREN");
RewriteRuleTokenStream stream_T_IF=new RewriteRuleTokenStream(adaptor,"token T_IF");
RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
try {
// MFortranOmpParser.g:217:3: ( T_IF T_LPAREN e1= expression T_RPAREN -> ^( T_IF $e1) )
// MFortranOmpParser.g:217:5: T_IF T_LPAREN e1= expression T_RPAREN
{
T_IF67=(Token)match(input,T_IF,FOLLOW_T_IF_in_if_clause1163);
stream_T_IF.add(T_IF67);
T_LPAREN68=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_if_clause1166);
stream_T_LPAREN.add(T_LPAREN68);
pushFollow(FOLLOW_expression_in_if_clause1171);
e1=expression();
state._fsp--;
stream_expression.add(e1.getTree());
T_RPAREN69=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_if_clause1174);
stream_T_RPAREN.add(T_RPAREN69);
// AST REWRITE
// elements: T_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();
// 218:5: -> ^( T_IF $e1)
{
// MFortranOmpParser.g:218:8: ^( T_IF $e1)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:221:1: num_threads_clause : T_NUM_THREADS T_LPAREN e2= expression T_RPAREN -> ^( T_NUM_THREADS $e2) ;
public final MFortranOmpParser.num_threads_clause_return num_threads_clause() throws RecognitionException {
MFortranOmpParser.num_threads_clause_return retval = new MFortranOmpParser.num_threads_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_NUM_THREADS70=null;
Token T_LPAREN71=null;
Token T_RPAREN72=null;
ParserRuleReturnScope e2 =null;
Object T_NUM_THREADS70_tree=null;
Object T_LPAREN71_tree=null;
Object T_RPAREN72_tree=null;
RewriteRuleTokenStream stream_T_LPAREN=new RewriteRuleTokenStream(adaptor,"token T_LPAREN");
RewriteRuleTokenStream stream_T_RPAREN=new RewriteRuleTokenStream(adaptor,"token T_RPAREN");
RewriteRuleTokenStream stream_T_NUM_THREADS=new RewriteRuleTokenStream(adaptor,"token T_NUM_THREADS");
RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
try {
// MFortranOmpParser.g:222:3: ( T_NUM_THREADS T_LPAREN e2= expression T_RPAREN -> ^( T_NUM_THREADS $e2) )
// MFortranOmpParser.g:222:5: T_NUM_THREADS T_LPAREN e2= expression T_RPAREN
{
T_NUM_THREADS70=(Token)match(input,T_NUM_THREADS,FOLLOW_T_NUM_THREADS_in_num_threads_clause1202);
stream_T_NUM_THREADS.add(T_NUM_THREADS70);
T_LPAREN71=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_num_threads_clause1205);
stream_T_LPAREN.add(T_LPAREN71);
pushFollow(FOLLOW_expression_in_num_threads_clause1210);
e2=expression();
state._fsp--;
stream_expression.add(e2.getTree());
T_RPAREN72=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_num_threads_clause1213);
stream_T_RPAREN.add(T_RPAREN72);
// AST REWRITE
// elements: e2, T_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();
// 223:5: -> ^( T_NUM_THREADS $e2)
{
// MFortranOmpParser.g:223:8: ^( T_NUM_THREADS $e2)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:226:1: data_clause : (d1= private_clause -> ^( T_DATA_CLAUSE $d1) |d2= firstprivate_clause -> ^( T_DATA_CLAUSE $d2) |d3= lastprivate_clause -> ^( T_DATA_CLAUSE $d3) |d4= shared_clause -> ^( T_DATA_CLAUSE $d4) |d5= default_clause -> ^( T_DATA_CLAUSE $d5) |d6= reduction_clause -> ^( T_DATA_CLAUSE $d6) |d7= copyin_clause -> ^( T_DATA_CLAUSE $d7) |d8= copyprivate_clause -> ^( T_DATA_CLAUSE $d8) );
public final MFortranOmpParser.data_clause_return data_clause() throws RecognitionException {
MFortranOmpParser.data_clause_return retval = new MFortranOmpParser.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 {
// MFortranOmpParser.g:227:3: (d1= private_clause -> ^( T_DATA_CLAUSE $d1) |d2= firstprivate_clause -> ^( T_DATA_CLAUSE $d2) |d3= lastprivate_clause -> ^( T_DATA_CLAUSE $d3) |d4= shared_clause -> ^( T_DATA_CLAUSE $d4) |d5= default_clause -> ^( T_DATA_CLAUSE $d5) |d6= reduction_clause -> ^( T_DATA_CLAUSE $d6) |d7= copyin_clause -> ^( T_DATA_CLAUSE $d7) |d8= copyprivate_clause -> ^( T_DATA_CLAUSE $d8) )
int alt22=8;
switch ( input.LA(1) ) {
case T_PRIVATE:
{
alt22=1;
}
break;
case T_FST_PRIVATE:
{
alt22=2;
}
break;
case T_LST_PRIVATE:
{
alt22=3;
}
break;
case T_SHARED:
{
alt22=4;
}
break;
case T_DEFAULT:
{
alt22=5;
}
break;
case T_REDUCTION:
{
alt22=6;
}
break;
case T_COPYIN:
{
alt22=7;
}
break;
case T_COPYPRIVATE:
{
alt22=8;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 22, 0, input);
throw nvae;
}
switch (alt22) {
case 1 :
// MFortranOmpParser.g:227:5: d1= private_clause
{
pushFollow(FOLLOW_private_clause_in_data_clause1241);
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();
// 228:5: -> ^( T_DATA_CLAUSE $d1)
{
// MFortranOmpParser.g:228:8: ^( T_DATA_CLAUSE $d1)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_DATA_CLAUSE, "T_DATA_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d1.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// MFortranOmpParser.g:229:5: d2= firstprivate_clause
{
pushFollow(FOLLOW_firstprivate_clause_in_data_clause1262);
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();
// 230:5: -> ^( T_DATA_CLAUSE $d2)
{
// MFortranOmpParser.g:230:8: ^( T_DATA_CLAUSE $d2)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_DATA_CLAUSE, "T_DATA_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d2.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 3 :
// MFortranOmpParser.g:231:5: d3= lastprivate_clause
{
pushFollow(FOLLOW_lastprivate_clause_in_data_clause1283);
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();
// 232:5: -> ^( T_DATA_CLAUSE $d3)
{
// MFortranOmpParser.g:232:8: ^( T_DATA_CLAUSE $d3)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_DATA_CLAUSE, "T_DATA_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d3.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 4 :
// MFortranOmpParser.g:233:5: d4= shared_clause
{
pushFollow(FOLLOW_shared_clause_in_data_clause1304);
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();
// 234:5: -> ^( T_DATA_CLAUSE $d4)
{
// MFortranOmpParser.g:234:8: ^( T_DATA_CLAUSE $d4)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_DATA_CLAUSE, "T_DATA_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d4.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 5 :
// MFortranOmpParser.g:235:5: d5= default_clause
{
pushFollow(FOLLOW_default_clause_in_data_clause1325);
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();
// 236:5: -> ^( T_DATA_CLAUSE $d5)
{
// MFortranOmpParser.g:236:8: ^( T_DATA_CLAUSE $d5)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_DATA_CLAUSE, "T_DATA_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d5.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 6 :
// MFortranOmpParser.g:237:5: d6= reduction_clause
{
pushFollow(FOLLOW_reduction_clause_in_data_clause1346);
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();
// 238:5: -> ^( T_DATA_CLAUSE $d6)
{
// MFortranOmpParser.g:238:8: ^( T_DATA_CLAUSE $d6)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_DATA_CLAUSE, "T_DATA_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d6.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 7 :
// MFortranOmpParser.g:239:5: d7= copyin_clause
{
pushFollow(FOLLOW_copyin_clause_in_data_clause1367);
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();
// 240:5: -> ^( T_DATA_CLAUSE $d7)
{
// MFortranOmpParser.g:240:8: ^( T_DATA_CLAUSE $d7)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_DATA_CLAUSE, "T_DATA_CLAUSE"), root_1);
adaptor.addChild(root_1, stream_d7.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 8 :
// MFortranOmpParser.g:241:5: d8= copyprivate_clause
{
pushFollow(FOLLOW_copyprivate_clause_in_data_clause1388);
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();
// 242:5: -> ^( T_DATA_CLAUSE $d8)
{
// MFortranOmpParser.g:242:8: ^( T_DATA_CLAUSE $d8)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_DATA_CLAUSE, "T_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"
// MFortranOmpParser.g:245:1: private_clause : T_PRIVATE T_LPAREN i1= identifier_list T_RPAREN -> ^( T_PRIVATE $i1) ;
public final MFortranOmpParser.private_clause_return private_clause() throws RecognitionException {
MFortranOmpParser.private_clause_return retval = new MFortranOmpParser.private_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_PRIVATE73=null;
Token T_LPAREN74=null;
Token T_RPAREN75=null;
ParserRuleReturnScope i1 =null;
Object T_PRIVATE73_tree=null;
Object T_LPAREN74_tree=null;
Object T_RPAREN75_tree=null;
RewriteRuleTokenStream stream_T_LPAREN=new RewriteRuleTokenStream(adaptor,"token T_LPAREN");
RewriteRuleTokenStream stream_T_RPAREN=new RewriteRuleTokenStream(adaptor,"token T_RPAREN");
RewriteRuleTokenStream stream_T_PRIVATE=new RewriteRuleTokenStream(adaptor,"token T_PRIVATE");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// MFortranOmpParser.g:246:3: ( T_PRIVATE T_LPAREN i1= identifier_list T_RPAREN -> ^( T_PRIVATE $i1) )
// MFortranOmpParser.g:246:5: T_PRIVATE T_LPAREN i1= identifier_list T_RPAREN
{
T_PRIVATE73=(Token)match(input,T_PRIVATE,FOLLOW_T_PRIVATE_in_private_clause1416);
stream_T_PRIVATE.add(T_PRIVATE73);
T_LPAREN74=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_private_clause1419);
stream_T_LPAREN.add(T_LPAREN74);
pushFollow(FOLLOW_identifier_list_in_private_clause1424);
i1=identifier_list();
state._fsp--;
stream_identifier_list.add(i1.getTree());
T_RPAREN75=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_private_clause1427);
stream_T_RPAREN.add(T_RPAREN75);
// AST REWRITE
// elements: T_PRIVATE, i1
// 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();
// 247:5: -> ^( T_PRIVATE $i1)
{
// MFortranOmpParser.g:247:8: ^( T_PRIVATE $i1)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:250:1: firstprivate_clause : T_FST_PRIVATE T_LPAREN i2= identifier_list T_RPAREN -> ^( T_FST_PRIVATE $i2) ;
public final MFortranOmpParser.firstprivate_clause_return firstprivate_clause() throws RecognitionException {
MFortranOmpParser.firstprivate_clause_return retval = new MFortranOmpParser.firstprivate_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_FST_PRIVATE76=null;
Token T_LPAREN77=null;
Token T_RPAREN78=null;
ParserRuleReturnScope i2 =null;
Object T_FST_PRIVATE76_tree=null;
Object T_LPAREN77_tree=null;
Object T_RPAREN78_tree=null;
RewriteRuleTokenStream stream_T_LPAREN=new RewriteRuleTokenStream(adaptor,"token T_LPAREN");
RewriteRuleTokenStream stream_T_FST_PRIVATE=new RewriteRuleTokenStream(adaptor,"token T_FST_PRIVATE");
RewriteRuleTokenStream stream_T_RPAREN=new RewriteRuleTokenStream(adaptor,"token T_RPAREN");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// MFortranOmpParser.g:251:3: ( T_FST_PRIVATE T_LPAREN i2= identifier_list T_RPAREN -> ^( T_FST_PRIVATE $i2) )
// MFortranOmpParser.g:251:5: T_FST_PRIVATE T_LPAREN i2= identifier_list T_RPAREN
{
T_FST_PRIVATE76=(Token)match(input,T_FST_PRIVATE,FOLLOW_T_FST_PRIVATE_in_firstprivate_clause1456);
stream_T_FST_PRIVATE.add(T_FST_PRIVATE76);
T_LPAREN77=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_firstprivate_clause1459);
stream_T_LPAREN.add(T_LPAREN77);
pushFollow(FOLLOW_identifier_list_in_firstprivate_clause1464);
i2=identifier_list();
state._fsp--;
stream_identifier_list.add(i2.getTree());
T_RPAREN78=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_firstprivate_clause1467);
stream_T_RPAREN.add(T_RPAREN78);
// AST REWRITE
// elements: i2, T_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();
// 252:5: -> ^( T_FST_PRIVATE $i2)
{
// MFortranOmpParser.g:252:8: ^( T_FST_PRIVATE $i2)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:255:1: lastprivate_clause : T_LST_PRIVATE T_LPAREN i3= identifier_list T_RPAREN -> ^( T_LST_PRIVATE $i3) ;
public final MFortranOmpParser.lastprivate_clause_return lastprivate_clause() throws RecognitionException {
MFortranOmpParser.lastprivate_clause_return retval = new MFortranOmpParser.lastprivate_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_LST_PRIVATE79=null;
Token T_LPAREN80=null;
Token T_RPAREN81=null;
ParserRuleReturnScope i3 =null;
Object T_LST_PRIVATE79_tree=null;
Object T_LPAREN80_tree=null;
Object T_RPAREN81_tree=null;
RewriteRuleTokenStream stream_T_LPAREN=new RewriteRuleTokenStream(adaptor,"token T_LPAREN");
RewriteRuleTokenStream stream_T_RPAREN=new RewriteRuleTokenStream(adaptor,"token T_RPAREN");
RewriteRuleTokenStream stream_T_LST_PRIVATE=new RewriteRuleTokenStream(adaptor,"token T_LST_PRIVATE");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// MFortranOmpParser.g:256:3: ( T_LST_PRIVATE T_LPAREN i3= identifier_list T_RPAREN -> ^( T_LST_PRIVATE $i3) )
// MFortranOmpParser.g:256:5: T_LST_PRIVATE T_LPAREN i3= identifier_list T_RPAREN
{
T_LST_PRIVATE79=(Token)match(input,T_LST_PRIVATE,FOLLOW_T_LST_PRIVATE_in_lastprivate_clause1495);
stream_T_LST_PRIVATE.add(T_LST_PRIVATE79);
T_LPAREN80=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_lastprivate_clause1498);
stream_T_LPAREN.add(T_LPAREN80);
pushFollow(FOLLOW_identifier_list_in_lastprivate_clause1503);
i3=identifier_list();
state._fsp--;
stream_identifier_list.add(i3.getTree());
T_RPAREN81=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_lastprivate_clause1506);
stream_T_RPAREN.add(T_RPAREN81);
// AST REWRITE
// elements: i3, T_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();
// 257:5: -> ^( T_LST_PRIVATE $i3)
{
// MFortranOmpParser.g:257:8: ^( T_LST_PRIVATE $i3)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:260:1: shared_clause : T_SHARED T_LPAREN i4= identifier_list T_RPAREN -> ^( T_SHARED $i4) ;
public final MFortranOmpParser.shared_clause_return shared_clause() throws RecognitionException {
MFortranOmpParser.shared_clause_return retval = new MFortranOmpParser.shared_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_SHARED82=null;
Token T_LPAREN83=null;
Token T_RPAREN84=null;
ParserRuleReturnScope i4 =null;
Object T_SHARED82_tree=null;
Object T_LPAREN83_tree=null;
Object T_RPAREN84_tree=null;
RewriteRuleTokenStream stream_T_LPAREN=new RewriteRuleTokenStream(adaptor,"token T_LPAREN");
RewriteRuleTokenStream stream_T_RPAREN=new RewriteRuleTokenStream(adaptor,"token T_RPAREN");
RewriteRuleTokenStream stream_T_SHARED=new RewriteRuleTokenStream(adaptor,"token T_SHARED");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// MFortranOmpParser.g:261:3: ( T_SHARED T_LPAREN i4= identifier_list T_RPAREN -> ^( T_SHARED $i4) )
// MFortranOmpParser.g:261:5: T_SHARED T_LPAREN i4= identifier_list T_RPAREN
{
T_SHARED82=(Token)match(input,T_SHARED,FOLLOW_T_SHARED_in_shared_clause1534);
stream_T_SHARED.add(T_SHARED82);
T_LPAREN83=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_shared_clause1537);
stream_T_LPAREN.add(T_LPAREN83);
pushFollow(FOLLOW_identifier_list_in_shared_clause1542);
i4=identifier_list();
state._fsp--;
stream_identifier_list.add(i4.getTree());
T_RPAREN84=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_shared_clause1545);
stream_T_RPAREN.add(T_RPAREN84);
// AST REWRITE
// elements: T_SHARED, i4
// 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();
// 262:5: -> ^( T_SHARED $i4)
{
// MFortranOmpParser.g:262:8: ^( T_SHARED $i4)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:265:1: default_clause : ( T_DEFAULT T_LPAREN T_SHARED T_RPAREN -> ^( T_DEFAULT T_SHARED ) | T_DEFAULT T_LPAREN T_PRIVATE T_RPAREN -> ^( T_DEFAULT T_NONE ) | T_DEFAULT T_LPAREN T_NONE T_RPAREN -> ^( T_DEFAULT T_NONE ) );
public final MFortranOmpParser.default_clause_return default_clause() throws RecognitionException {
MFortranOmpParser.default_clause_return retval = new MFortranOmpParser.default_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_DEFAULT85=null;
Token T_LPAREN86=null;
Token T_SHARED87=null;
Token T_RPAREN88=null;
Token T_DEFAULT89=null;
Token T_LPAREN90=null;
Token T_PRIVATE91=null;
Token T_RPAREN92=null;
Token T_DEFAULT93=null;
Token T_LPAREN94=null;
Token T_NONE95=null;
Token T_RPAREN96=null;
Object T_DEFAULT85_tree=null;
Object T_LPAREN86_tree=null;
Object T_SHARED87_tree=null;
Object T_RPAREN88_tree=null;
Object T_DEFAULT89_tree=null;
Object T_LPAREN90_tree=null;
Object T_PRIVATE91_tree=null;
Object T_RPAREN92_tree=null;
Object T_DEFAULT93_tree=null;
Object T_LPAREN94_tree=null;
Object T_NONE95_tree=null;
Object T_RPAREN96_tree=null;
RewriteRuleTokenStream stream_T_LPAREN=new RewriteRuleTokenStream(adaptor,"token T_LPAREN");
RewriteRuleTokenStream stream_T_DEFAULT=new RewriteRuleTokenStream(adaptor,"token T_DEFAULT");
RewriteRuleTokenStream stream_T_RPAREN=new RewriteRuleTokenStream(adaptor,"token T_RPAREN");
RewriteRuleTokenStream stream_T_NONE=new RewriteRuleTokenStream(adaptor,"token T_NONE");
RewriteRuleTokenStream stream_T_PRIVATE=new RewriteRuleTokenStream(adaptor,"token T_PRIVATE");
RewriteRuleTokenStream stream_T_SHARED=new RewriteRuleTokenStream(adaptor,"token T_SHARED");
try {
// MFortranOmpParser.g:266:3: ( T_DEFAULT T_LPAREN T_SHARED T_RPAREN -> ^( T_DEFAULT T_SHARED ) | T_DEFAULT T_LPAREN T_PRIVATE T_RPAREN -> ^( T_DEFAULT T_NONE ) | T_DEFAULT T_LPAREN T_NONE T_RPAREN -> ^( T_DEFAULT T_NONE ) )
int alt23=3;
int LA23_0 = input.LA(1);
if ( (LA23_0==T_DEFAULT) ) {
int LA23_1 = input.LA(2);
if ( (LA23_1==T_LPAREN) ) {
switch ( input.LA(3) ) {
case T_SHARED:
{
alt23=1;
}
break;
case T_PRIVATE:
{
alt23=2;
}
break;
case T_NONE:
{
alt23=3;
}
break;
default:
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 23, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 23, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
NoViableAltException nvae =
new NoViableAltException("", 23, 0, input);
throw nvae;
}
switch (alt23) {
case 1 :
// MFortranOmpParser.g:266:5: T_DEFAULT T_LPAREN T_SHARED T_RPAREN
{
T_DEFAULT85=(Token)match(input,T_DEFAULT,FOLLOW_T_DEFAULT_in_default_clause1573);
stream_T_DEFAULT.add(T_DEFAULT85);
T_LPAREN86=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_default_clause1576);
stream_T_LPAREN.add(T_LPAREN86);
T_SHARED87=(Token)match(input,T_SHARED,FOLLOW_T_SHARED_in_default_clause1579);
stream_T_SHARED.add(T_SHARED87);
T_RPAREN88=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_default_clause1582);
stream_T_RPAREN.add(T_RPAREN88);
// AST REWRITE
// elements: T_SHARED, T_DEFAULT
// 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();
// 267:5: -> ^( T_DEFAULT T_SHARED )
{
// MFortranOmpParser.g:267:8: ^( T_DEFAULT T_SHARED )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_DEFAULT.nextNode(), root_1);
adaptor.addChild(root_1, stream_T_SHARED.nextNode());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// MFortranOmpParser.g:268:5: T_DEFAULT T_LPAREN T_PRIVATE T_RPAREN
{
T_DEFAULT89=(Token)match(input,T_DEFAULT,FOLLOW_T_DEFAULT_in_default_clause1600);
stream_T_DEFAULT.add(T_DEFAULT89);
T_LPAREN90=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_default_clause1603);
stream_T_LPAREN.add(T_LPAREN90);
T_PRIVATE91=(Token)match(input,T_PRIVATE,FOLLOW_T_PRIVATE_in_default_clause1606);
stream_T_PRIVATE.add(T_PRIVATE91);
T_RPAREN92=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_default_clause1609);
stream_T_RPAREN.add(T_RPAREN92);
// AST REWRITE
// elements: T_DEFAULT
// 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();
// 269:5: -> ^( T_DEFAULT T_NONE )
{
// MFortranOmpParser.g:269:8: ^( T_DEFAULT T_NONE )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_DEFAULT.nextNode(), root_1);
adaptor.addChild(root_1, (Object)adaptor.create(T_NONE, "T_NONE"));
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 3 :
// MFortranOmpParser.g:270:5: T_DEFAULT T_LPAREN T_NONE T_RPAREN
{
T_DEFAULT93=(Token)match(input,T_DEFAULT,FOLLOW_T_DEFAULT_in_default_clause1627);
stream_T_DEFAULT.add(T_DEFAULT93);
T_LPAREN94=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_default_clause1630);
stream_T_LPAREN.add(T_LPAREN94);
T_NONE95=(Token)match(input,T_NONE,FOLLOW_T_NONE_in_default_clause1633);
stream_T_NONE.add(T_NONE95);
T_RPAREN96=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_default_clause1636);
stream_T_RPAREN.add(T_RPAREN96);
// AST REWRITE
// elements: T_NONE, T_DEFAULT
// 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();
// 271:5: -> ^( T_DEFAULT T_NONE )
{
// MFortranOmpParser.g:271:8: ^( T_DEFAULT T_NONE )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_DEFAULT.nextNode(), root_1);
adaptor.addChild(root_1, stream_T_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"
// MFortranOmpParser.g:274:1: reduction_clause : T_REDUCTION T_LPAREN r= reduction_operator T_COLON i5= identifier_list T_RPAREN -> ^( T_REDUCTION $r $i5) ;
public final MFortranOmpParser.reduction_clause_return reduction_clause() throws RecognitionException {
MFortranOmpParser.reduction_clause_return retval = new MFortranOmpParser.reduction_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_REDUCTION97=null;
Token T_LPAREN98=null;
Token T_COLON99=null;
Token T_RPAREN100=null;
ParserRuleReturnScope r =null;
ParserRuleReturnScope i5 =null;
Object T_REDUCTION97_tree=null;
Object T_LPAREN98_tree=null;
Object T_COLON99_tree=null;
Object T_RPAREN100_tree=null;
RewriteRuleTokenStream stream_T_LPAREN=new RewriteRuleTokenStream(adaptor,"token T_LPAREN");
RewriteRuleTokenStream stream_T_RPAREN=new RewriteRuleTokenStream(adaptor,"token T_RPAREN");
RewriteRuleTokenStream stream_T_COLON=new RewriteRuleTokenStream(adaptor,"token T_COLON");
RewriteRuleTokenStream stream_T_REDUCTION=new RewriteRuleTokenStream(adaptor,"token T_REDUCTION");
RewriteRuleSubtreeStream stream_reduction_operator=new RewriteRuleSubtreeStream(adaptor,"rule reduction_operator");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// MFortranOmpParser.g:275:3: ( T_REDUCTION T_LPAREN r= reduction_operator T_COLON i5= identifier_list T_RPAREN -> ^( T_REDUCTION $r $i5) )
// MFortranOmpParser.g:275:5: T_REDUCTION T_LPAREN r= reduction_operator T_COLON i5= identifier_list T_RPAREN
{
T_REDUCTION97=(Token)match(input,T_REDUCTION,FOLLOW_T_REDUCTION_in_reduction_clause1663);
stream_T_REDUCTION.add(T_REDUCTION97);
T_LPAREN98=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_reduction_clause1665);
stream_T_LPAREN.add(T_LPAREN98);
pushFollow(FOLLOW_reduction_operator_in_reduction_clause1669);
r=reduction_operator();
state._fsp--;
stream_reduction_operator.add(r.getTree());
T_COLON99=(Token)match(input,T_COLON,FOLLOW_T_COLON_in_reduction_clause1671);
stream_T_COLON.add(T_COLON99);
pushFollow(FOLLOW_identifier_list_in_reduction_clause1675);
i5=identifier_list();
state._fsp--;
stream_identifier_list.add(i5.getTree());
T_RPAREN100=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_reduction_clause1677);
stream_T_RPAREN.add(T_RPAREN100);
// AST REWRITE
// elements: r, T_REDUCTION, i5
// 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();
// 276:5: -> ^( T_REDUCTION $r $i5)
{
// MFortranOmpParser.g:276:8: ^( T_REDUCTION $r $i5)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:279:1: copyin_clause : T_COPYIN T_LPAREN i6= identifier_list T_RPAREN -> ^( T_COPYIN $i6) ;
public final MFortranOmpParser.copyin_clause_return copyin_clause() throws RecognitionException {
MFortranOmpParser.copyin_clause_return retval = new MFortranOmpParser.copyin_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_COPYIN101=null;
Token T_LPAREN102=null;
Token T_RPAREN103=null;
ParserRuleReturnScope i6 =null;
Object T_COPYIN101_tree=null;
Object T_LPAREN102_tree=null;
Object T_RPAREN103_tree=null;
RewriteRuleTokenStream stream_T_LPAREN=new RewriteRuleTokenStream(adaptor,"token T_LPAREN");
RewriteRuleTokenStream stream_T_COPYIN=new RewriteRuleTokenStream(adaptor,"token T_COPYIN");
RewriteRuleTokenStream stream_T_RPAREN=new RewriteRuleTokenStream(adaptor,"token T_RPAREN");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// MFortranOmpParser.g:280:3: ( T_COPYIN T_LPAREN i6= identifier_list T_RPAREN -> ^( T_COPYIN $i6) )
// MFortranOmpParser.g:280:5: T_COPYIN T_LPAREN i6= identifier_list T_RPAREN
{
T_COPYIN101=(Token)match(input,T_COPYIN,FOLLOW_T_COPYIN_in_copyin_clause1708);
stream_T_COPYIN.add(T_COPYIN101);
T_LPAREN102=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_copyin_clause1711);
stream_T_LPAREN.add(T_LPAREN102);
pushFollow(FOLLOW_identifier_list_in_copyin_clause1716);
i6=identifier_list();
state._fsp--;
stream_identifier_list.add(i6.getTree());
T_RPAREN103=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_copyin_clause1719);
stream_T_RPAREN.add(T_RPAREN103);
// AST REWRITE
// elements: i6, T_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();
// 281:5: -> ^( T_COPYIN $i6)
{
// MFortranOmpParser.g:281:8: ^( T_COPYIN $i6)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:284:1: copyprivate_clause : T_COPYPRIVATE T_LPAREN i7= identifier_list T_RPAREN -> ^( T_COPYPRIVATE $i7) ;
public final MFortranOmpParser.copyprivate_clause_return copyprivate_clause() throws RecognitionException {
MFortranOmpParser.copyprivate_clause_return retval = new MFortranOmpParser.copyprivate_clause_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_COPYPRIVATE104=null;
Token T_LPAREN105=null;
Token T_RPAREN106=null;
ParserRuleReturnScope i7 =null;
Object T_COPYPRIVATE104_tree=null;
Object T_LPAREN105_tree=null;
Object T_RPAREN106_tree=null;
RewriteRuleTokenStream stream_T_LPAREN=new RewriteRuleTokenStream(adaptor,"token T_LPAREN");
RewriteRuleTokenStream stream_T_COPYPRIVATE=new RewriteRuleTokenStream(adaptor,"token T_COPYPRIVATE");
RewriteRuleTokenStream stream_T_RPAREN=new RewriteRuleTokenStream(adaptor,"token T_RPAREN");
RewriteRuleSubtreeStream stream_identifier_list=new RewriteRuleSubtreeStream(adaptor,"rule identifier_list");
try {
// MFortranOmpParser.g:285:3: ( T_COPYPRIVATE T_LPAREN i7= identifier_list T_RPAREN -> ^( T_COPYPRIVATE $i7) )
// MFortranOmpParser.g:285:5: T_COPYPRIVATE T_LPAREN i7= identifier_list T_RPAREN
{
T_COPYPRIVATE104=(Token)match(input,T_COPYPRIVATE,FOLLOW_T_COPYPRIVATE_in_copyprivate_clause1747);
stream_T_COPYPRIVATE.add(T_COPYPRIVATE104);
T_LPAREN105=(Token)match(input,T_LPAREN,FOLLOW_T_LPAREN_in_copyprivate_clause1750);
stream_T_LPAREN.add(T_LPAREN105);
pushFollow(FOLLOW_identifier_list_in_copyprivate_clause1755);
i7=identifier_list();
state._fsp--;
stream_identifier_list.add(i7.getTree());
T_RPAREN106=(Token)match(input,T_RPAREN,FOLLOW_T_RPAREN_in_copyprivate_clause1758);
stream_T_RPAREN.add(T_RPAREN106);
// AST REWRITE
// elements: i7, T_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();
// 286:5: -> ^( T_COPYPRIVATE $i7)
{
// MFortranOmpParser.g:286:8: ^( T_COPYPRIVATE $i7)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_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"
// MFortranOmpParser.g:289:1: reduction_operator : ( T_PLUS -> ^( T_PLUS ) | T_ASTERISK -> ^( T_ASTERISK ) | T_MINUS -> ^( T_MINUS ) | T_AMPERSAND -> ^( T_AMPERSAND ) | T_BITXOR -> ^( T_BITXOR ) | T_BITOR -> ^( T_BITOR ) | T_AND -> ^( T_AND ) | T_OR -> ^( T_OR ) | T_IDENT -> ^( T_IDENT ) );
public final MFortranOmpParser.reduction_operator_return reduction_operator() throws RecognitionException {
MFortranOmpParser.reduction_operator_return retval = new MFortranOmpParser.reduction_operator_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_PLUS107=null;
Token T_ASTERISK108=null;
Token T_MINUS109=null;
Token T_AMPERSAND110=null;
Token T_BITXOR111=null;
Token T_BITOR112=null;
Token T_AND113=null;
Token T_OR114=null;
Token T_IDENT115=null;
Object T_PLUS107_tree=null;
Object T_ASTERISK108_tree=null;
Object T_MINUS109_tree=null;
Object T_AMPERSAND110_tree=null;
Object T_BITXOR111_tree=null;
Object T_BITOR112_tree=null;
Object T_AND113_tree=null;
Object T_OR114_tree=null;
Object T_IDENT115_tree=null;
RewriteRuleTokenStream stream_T_PLUS=new RewriteRuleTokenStream(adaptor,"token T_PLUS");
RewriteRuleTokenStream stream_T_MINUS=new RewriteRuleTokenStream(adaptor,"token T_MINUS");
RewriteRuleTokenStream stream_T_ASTERISK=new RewriteRuleTokenStream(adaptor,"token T_ASTERISK");
RewriteRuleTokenStream stream_T_BITXOR=new RewriteRuleTokenStream(adaptor,"token T_BITXOR");
RewriteRuleTokenStream stream_T_AND=new RewriteRuleTokenStream(adaptor,"token T_AND");
RewriteRuleTokenStream stream_T_BITOR=new RewriteRuleTokenStream(adaptor,"token T_BITOR");
RewriteRuleTokenStream stream_T_OR=new RewriteRuleTokenStream(adaptor,"token T_OR");
RewriteRuleTokenStream stream_T_IDENT=new RewriteRuleTokenStream(adaptor,"token T_IDENT");
RewriteRuleTokenStream stream_T_AMPERSAND=new RewriteRuleTokenStream(adaptor,"token T_AMPERSAND");
try {
// MFortranOmpParser.g:290:3: ( T_PLUS -> ^( T_PLUS ) | T_ASTERISK -> ^( T_ASTERISK ) | T_MINUS -> ^( T_MINUS ) | T_AMPERSAND -> ^( T_AMPERSAND ) | T_BITXOR -> ^( T_BITXOR ) | T_BITOR -> ^( T_BITOR ) | T_AND -> ^( T_AND ) | T_OR -> ^( T_OR ) | T_IDENT -> ^( T_IDENT ) )
int alt24=9;
switch ( input.LA(1) ) {
case T_PLUS:
{
alt24=1;
}
break;
case T_ASTERISK:
{
alt24=2;
}
break;
case T_MINUS:
{
alt24=3;
}
break;
case T_AMPERSAND:
{
alt24=4;
}
break;
case T_BITXOR:
{
alt24=5;
}
break;
case T_BITOR:
{
alt24=6;
}
break;
case T_AND:
{
alt24=7;
}
break;
case T_OR:
{
alt24=8;
}
break;
case T_IDENT:
{
alt24=9;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 24, 0, input);
throw nvae;
}
switch (alt24) {
case 1 :
// MFortranOmpParser.g:290:5: T_PLUS
{
T_PLUS107=(Token)match(input,T_PLUS,FOLLOW_T_PLUS_in_reduction_operator1784);
stream_T_PLUS.add(T_PLUS107);
// AST REWRITE
// elements: T_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();
// 290:12: -> ^( T_PLUS )
{
// MFortranOmpParser.g:290:15: ^( T_PLUS )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_PLUS.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// MFortranOmpParser.g:291:5: T_ASTERISK
{
T_ASTERISK108=(Token)match(input,T_ASTERISK,FOLLOW_T_ASTERISK_in_reduction_operator1796);
stream_T_ASTERISK.add(T_ASTERISK108);
// AST REWRITE
// elements: T_ASTERISK
// 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:16: -> ^( T_ASTERISK )
{
// MFortranOmpParser.g:291:19: ^( T_ASTERISK )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_ASTERISK.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 3 :
// MFortranOmpParser.g:292:5: T_MINUS
{
T_MINUS109=(Token)match(input,T_MINUS,FOLLOW_T_MINUS_in_reduction_operator1808);
stream_T_MINUS.add(T_MINUS109);
// AST REWRITE
// elements: T_MINUS
// 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();
// 292:13: -> ^( T_MINUS )
{
// MFortranOmpParser.g:292:16: ^( T_MINUS )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_MINUS.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 4 :
// MFortranOmpParser.g:293:5: T_AMPERSAND
{
T_AMPERSAND110=(Token)match(input,T_AMPERSAND,FOLLOW_T_AMPERSAND_in_reduction_operator1820);
stream_T_AMPERSAND.add(T_AMPERSAND110);
// AST REWRITE
// elements: T_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();
// 293:17: -> ^( T_AMPERSAND )
{
// MFortranOmpParser.g:293:20: ^( T_AMPERSAND )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_AMPERSAND.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 5 :
// MFortranOmpParser.g:294:5: T_BITXOR
{
T_BITXOR111=(Token)match(input,T_BITXOR,FOLLOW_T_BITXOR_in_reduction_operator1832);
stream_T_BITXOR.add(T_BITXOR111);
// AST REWRITE
// elements: T_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();
// 294:14: -> ^( T_BITXOR )
{
// MFortranOmpParser.g:294:17: ^( T_BITXOR )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_BITXOR.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 6 :
// MFortranOmpParser.g:295:5: T_BITOR
{
T_BITOR112=(Token)match(input,T_BITOR,FOLLOW_T_BITOR_in_reduction_operator1844);
stream_T_BITOR.add(T_BITOR112);
// AST REWRITE
// elements: T_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();
// 295:13: -> ^( T_BITOR )
{
// MFortranOmpParser.g:295:16: ^( T_BITOR )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_BITOR.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 7 :
// MFortranOmpParser.g:296:5: T_AND
{
T_AND113=(Token)match(input,T_AND,FOLLOW_T_AND_in_reduction_operator1856);
stream_T_AND.add(T_AND113);
// AST REWRITE
// elements: T_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();
// 296:11: -> ^( T_AND )
{
// MFortranOmpParser.g:296:14: ^( T_AND )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_AND.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 8 :
// MFortranOmpParser.g:297:5: T_OR
{
T_OR114=(Token)match(input,T_OR,FOLLOW_T_OR_in_reduction_operator1868);
stream_T_OR.add(T_OR114);
// AST REWRITE
// elements: T_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();
// 297:10: -> ^( T_OR )
{
// MFortranOmpParser.g:297:13: ^( T_OR )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_OR.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 9 :
// MFortranOmpParser.g:298:5: T_IDENT
{
T_IDENT115=(Token)match(input,T_IDENT,FOLLOW_T_IDENT_in_reduction_operator1880);
stream_T_IDENT.add(T_IDENT115);
// AST REWRITE
// elements: T_IDENT
// 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();
// 298:13: -> ^( T_IDENT )
{
// MFortranOmpParser.g:298:16: ^( T_IDENT )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_IDENT.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"
// MFortranOmpParser.g:301:1: identifier_list : i1= T_IDENT ( T_COMMA i2+= T_IDENT )* -> ^( T_IDENTIFIER_LIST $i1 ( $i2)* ) ;
public final MFortranOmpParser.identifier_list_return identifier_list() throws RecognitionException {
MFortranOmpParser.identifier_list_return retval = new MFortranOmpParser.identifier_list_return();
retval.start = input.LT(1);
Object root_0 = null;
Token i1=null;
Token T_COMMA116=null;
Token i2=null;
List<Object> list_i2=null;
Object i1_tree=null;
Object T_COMMA116_tree=null;
Object i2_tree=null;
RewriteRuleTokenStream stream_T_COMMA=new RewriteRuleTokenStream(adaptor,"token T_COMMA");
RewriteRuleTokenStream stream_T_IDENT=new RewriteRuleTokenStream(adaptor,"token T_IDENT");
try {
// MFortranOmpParser.g:302:3: (i1= T_IDENT ( T_COMMA i2+= T_IDENT )* -> ^( T_IDENTIFIER_LIST $i1 ( $i2)* ) )
// MFortranOmpParser.g:303:3: i1= T_IDENT ( T_COMMA i2+= T_IDENT )*
{
i1=(Token)match(input,T_IDENT,FOLLOW_T_IDENT_in_identifier_list1903);
stream_T_IDENT.add(i1);
// MFortranOmpParser.g:303:14: ( T_COMMA i2+= T_IDENT )*
loop25:
while (true) {
int alt25=2;
int LA25_0 = input.LA(1);
if ( (LA25_0==T_COMMA) ) {
alt25=1;
}
switch (alt25) {
case 1 :
// MFortranOmpParser.g:303:16: T_COMMA i2+= T_IDENT
{
T_COMMA116=(Token)match(input,T_COMMA,FOLLOW_T_COMMA_in_identifier_list1907);
stream_T_COMMA.add(T_COMMA116);
i2=(Token)match(input,T_IDENT,FOLLOW_T_IDENT_in_identifier_list1912);
stream_T_IDENT.add(i2);
if (list_i2==null) list_i2=new ArrayList<Object>();
list_i2.add(i2);
}
break;
default :
break loop25;
}
}
// 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();
// 304:3: -> ^( T_IDENTIFIER_LIST $i1 ( $i2)* )
{
// MFortranOmpParser.g:304:6: ^( T_IDENTIFIER_LIST $i1 ( $i2)* )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(T_IDENTIFIER_LIST, "T_IDENTIFIER_LIST"), root_1);
adaptor.addChild(root_1, stream_i1.nextNode());
// MFortranOmpParser.g:304:31: ( $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"
public static class expression_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "expression"
// MFortranOmpParser.g:308:1: expression : (i1= T_IDENT ) -> ^( $i1) ;
public final MFortranOmpParser.expression_return expression() throws RecognitionException {
MFortranOmpParser.expression_return retval = new MFortranOmpParser.expression_return();
retval.start = input.LT(1);
Object root_0 = null;
Token i1=null;
Object i1_tree=null;
RewriteRuleTokenStream stream_T_IDENT=new RewriteRuleTokenStream(adaptor,"token T_IDENT");
try {
// MFortranOmpParser.g:309:4: ( (i1= T_IDENT ) -> ^( $i1) )
// MFortranOmpParser.g:310:4: (i1= T_IDENT )
{
// MFortranOmpParser.g:310:4: (i1= T_IDENT )
// MFortranOmpParser.g:310:5: i1= T_IDENT
{
i1=(Token)match(input,T_IDENT,FOLLOW_T_IDENT_in_expression1954);
stream_T_IDENT.add(i1);
}
// AST REWRITE
// elements: i1
// token labels: i1
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleTokenStream stream_i1=new RewriteRuleTokenStream(adaptor,"token i1",i1);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 311:4: -> ^( $i1)
{
// MFortranOmpParser.g:311:7: ^( $i1)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_i1.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 "expression"
public static class end_directive_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "end_directive"
// MFortranOmpParser.g:314:1: end_directive : T_END kl= keyword_list -> ^( T_END $kl) ;
public final MFortranOmpParser.end_directive_return end_directive() throws RecognitionException {
MFortranOmpParser.end_directive_return retval = new MFortranOmpParser.end_directive_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_END117=null;
ParserRuleReturnScope kl =null;
Object T_END117_tree=null;
RewriteRuleTokenStream stream_T_END=new RewriteRuleTokenStream(adaptor,"token T_END");
RewriteRuleSubtreeStream stream_keyword_list=new RewriteRuleSubtreeStream(adaptor,"rule keyword_list");
try {
// MFortranOmpParser.g:315:2: ( T_END kl= keyword_list -> ^( T_END $kl) )
// MFortranOmpParser.g:316:2: T_END kl= keyword_list
{
T_END117=(Token)match(input,T_END,FOLLOW_T_END_in_end_directive1982);
stream_T_END.add(T_END117);
pushFollow(FOLLOW_keyword_list_in_end_directive1986);
kl=keyword_list();
state._fsp--;
stream_keyword_list.add(kl.getTree());
// AST REWRITE
// elements: kl, T_END
// token labels:
// rule labels: kl, retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_kl=new RewriteRuleSubtreeStream(adaptor,"rule kl",kl!=null?kl.getTree():null);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (Object)adaptor.nil();
// 317:2: -> ^( T_END $kl)
{
// MFortranOmpParser.g:317:5: ^( T_END $kl)
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_END.nextNode(), root_1);
adaptor.addChild(root_1, stream_kl.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 "end_directive"
public static class keyword_list_return extends ParserRuleReturnScope {
Object tree;
@Override
public Object getTree() { return tree; }
};
// $ANTLR start "keyword_list"
// MFortranOmpParser.g:320:1: keyword_list : ( T_PARALLEL -> ^( T_PARALLEL ) | T_DO -> ^( T_DO ) | T_SECTIONS -> ^( T_SECTIONS ) | T_SINGLE -> ^( T_SINGLE ) | T_MASTER -> ^( T_MASTER ) | T_CRITICAL -> ^( T_CRITICAL ) | T_ORDERED -> ^( T_ORDERED ) | T_SECTION -> ^( T_SECTION ) | T_OMPATOMIC -> ^( T_OMPATOMIC ) | T_BARRIER -> ^( T_BARRIER ) | T_FLUSH -> ^( T_FLUSH ) | T_THD_PRIVATE -> ^( T_THD_PRIVATE ) );
public final MFortranOmpParser.keyword_list_return keyword_list() throws RecognitionException {
MFortranOmpParser.keyword_list_return retval = new MFortranOmpParser.keyword_list_return();
retval.start = input.LT(1);
Object root_0 = null;
Token T_PARALLEL118=null;
Token T_DO119=null;
Token T_SECTIONS120=null;
Token T_SINGLE121=null;
Token T_MASTER122=null;
Token T_CRITICAL123=null;
Token T_ORDERED124=null;
Token T_SECTION125=null;
Token T_OMPATOMIC126=null;
Token T_BARRIER127=null;
Token T_FLUSH128=null;
Token T_THD_PRIVATE129=null;
Object T_PARALLEL118_tree=null;
Object T_DO119_tree=null;
Object T_SECTIONS120_tree=null;
Object T_SINGLE121_tree=null;
Object T_MASTER122_tree=null;
Object T_CRITICAL123_tree=null;
Object T_ORDERED124_tree=null;
Object T_SECTION125_tree=null;
Object T_OMPATOMIC126_tree=null;
Object T_BARRIER127_tree=null;
Object T_FLUSH128_tree=null;
Object T_THD_PRIVATE129_tree=null;
RewriteRuleTokenStream stream_T_DO=new RewriteRuleTokenStream(adaptor,"token T_DO");
RewriteRuleTokenStream stream_T_PARALLEL=new RewriteRuleTokenStream(adaptor,"token T_PARALLEL");
RewriteRuleTokenStream stream_T_OMPATOMIC=new RewriteRuleTokenStream(adaptor,"token T_OMPATOMIC");
RewriteRuleTokenStream stream_T_CRITICAL=new RewriteRuleTokenStream(adaptor,"token T_CRITICAL");
RewriteRuleTokenStream stream_T_SECTION=new RewriteRuleTokenStream(adaptor,"token T_SECTION");
RewriteRuleTokenStream stream_T_BARRIER=new RewriteRuleTokenStream(adaptor,"token T_BARRIER");
RewriteRuleTokenStream stream_T_SECTIONS=new RewriteRuleTokenStream(adaptor,"token T_SECTIONS");
RewriteRuleTokenStream stream_T_SINGLE=new RewriteRuleTokenStream(adaptor,"token T_SINGLE");
RewriteRuleTokenStream stream_T_ORDERED=new RewriteRuleTokenStream(adaptor,"token T_ORDERED");
RewriteRuleTokenStream stream_T_MASTER=new RewriteRuleTokenStream(adaptor,"token T_MASTER");
RewriteRuleTokenStream stream_T_FLUSH=new RewriteRuleTokenStream(adaptor,"token T_FLUSH");
RewriteRuleTokenStream stream_T_THD_PRIVATE=new RewriteRuleTokenStream(adaptor,"token T_THD_PRIVATE");
try {
// MFortranOmpParser.g:321:2: ( T_PARALLEL -> ^( T_PARALLEL ) | T_DO -> ^( T_DO ) | T_SECTIONS -> ^( T_SECTIONS ) | T_SINGLE -> ^( T_SINGLE ) | T_MASTER -> ^( T_MASTER ) | T_CRITICAL -> ^( T_CRITICAL ) | T_ORDERED -> ^( T_ORDERED ) | T_SECTION -> ^( T_SECTION ) | T_OMPATOMIC -> ^( T_OMPATOMIC ) | T_BARRIER -> ^( T_BARRIER ) | T_FLUSH -> ^( T_FLUSH ) | T_THD_PRIVATE -> ^( T_THD_PRIVATE ) )
int alt26=12;
switch ( input.LA(1) ) {
case T_PARALLEL:
{
alt26=1;
}
break;
case T_DO:
{
alt26=2;
}
break;
case T_SECTIONS:
{
alt26=3;
}
break;
case T_SINGLE:
{
alt26=4;
}
break;
case T_MASTER:
{
alt26=5;
}
break;
case T_CRITICAL:
{
alt26=6;
}
break;
case T_ORDERED:
{
alt26=7;
}
break;
case T_SECTION:
{
alt26=8;
}
break;
case T_OMPATOMIC:
{
alt26=9;
}
break;
case T_BARRIER:
{
alt26=10;
}
break;
case T_FLUSH:
{
alt26=11;
}
break;
case T_THD_PRIVATE:
{
alt26=12;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 26, 0, input);
throw nvae;
}
switch (alt26) {
case 1 :
// MFortranOmpParser.g:322:2: T_PARALLEL
{
T_PARALLEL118=(Token)match(input,T_PARALLEL,FOLLOW_T_PARALLEL_in_keyword_list2009);
stream_T_PARALLEL.add(T_PARALLEL118);
// AST REWRITE
// elements: T_PARALLEL
// 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();
// 322:13: -> ^( T_PARALLEL )
{
// MFortranOmpParser.g:322:16: ^( T_PARALLEL )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_PARALLEL.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// MFortranOmpParser.g:323:3: T_DO
{
T_DO119=(Token)match(input,T_DO,FOLLOW_T_DO_in_keyword_list2019);
stream_T_DO.add(T_DO119);
// AST REWRITE
// elements: T_DO
// 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();
// 323:8: -> ^( T_DO )
{
// MFortranOmpParser.g:323:11: ^( T_DO )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_DO.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 3 :
// MFortranOmpParser.g:324:3: T_SECTIONS
{
T_SECTIONS120=(Token)match(input,T_SECTIONS,FOLLOW_T_SECTIONS_in_keyword_list2029);
stream_T_SECTIONS.add(T_SECTIONS120);
// AST REWRITE
// elements: T_SECTIONS
// 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();
// 324:14: -> ^( T_SECTIONS )
{
// MFortranOmpParser.g:324:17: ^( T_SECTIONS )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_SECTIONS.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 4 :
// MFortranOmpParser.g:325:3: T_SINGLE
{
T_SINGLE121=(Token)match(input,T_SINGLE,FOLLOW_T_SINGLE_in_keyword_list2039);
stream_T_SINGLE.add(T_SINGLE121);
// AST REWRITE
// elements: T_SINGLE
// 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();
// 325:12: -> ^( T_SINGLE )
{
// MFortranOmpParser.g:325:15: ^( T_SINGLE )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_SINGLE.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 5 :
// MFortranOmpParser.g:326:3: T_MASTER
{
T_MASTER122=(Token)match(input,T_MASTER,FOLLOW_T_MASTER_in_keyword_list2049);
stream_T_MASTER.add(T_MASTER122);
// AST REWRITE
// elements: T_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();
// 326:12: -> ^( T_MASTER )
{
// MFortranOmpParser.g:326:15: ^( T_MASTER )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_MASTER.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 6 :
// MFortranOmpParser.g:327:3: T_CRITICAL
{
T_CRITICAL123=(Token)match(input,T_CRITICAL,FOLLOW_T_CRITICAL_in_keyword_list2059);
stream_T_CRITICAL.add(T_CRITICAL123);
// AST REWRITE
// elements: T_CRITICAL
// 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();
// 327:14: -> ^( T_CRITICAL )
{
// MFortranOmpParser.g:327:17: ^( T_CRITICAL )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_CRITICAL.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 7 :
// MFortranOmpParser.g:328:3: T_ORDERED
{
T_ORDERED124=(Token)match(input,T_ORDERED,FOLLOW_T_ORDERED_in_keyword_list2069);
stream_T_ORDERED.add(T_ORDERED124);
// AST REWRITE
// elements: T_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();
// 328:13: -> ^( T_ORDERED )
{
// MFortranOmpParser.g:328:16: ^( T_ORDERED )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_ORDERED.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 8 :
// MFortranOmpParser.g:329:3: T_SECTION
{
T_SECTION125=(Token)match(input,T_SECTION,FOLLOW_T_SECTION_in_keyword_list2079);
stream_T_SECTION.add(T_SECTION125);
// AST REWRITE
// elements: T_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();
// 329:13: -> ^( T_SECTION )
{
// MFortranOmpParser.g:329:16: ^( T_SECTION )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_SECTION.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 9 :
// MFortranOmpParser.g:330:3: T_OMPATOMIC
{
T_OMPATOMIC126=(Token)match(input,T_OMPATOMIC,FOLLOW_T_OMPATOMIC_in_keyword_list2089);
stream_T_OMPATOMIC.add(T_OMPATOMIC126);
// AST REWRITE
// elements: T_OMPATOMIC
// 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();
// 330:15: -> ^( T_OMPATOMIC )
{
// MFortranOmpParser.g:330:18: ^( T_OMPATOMIC )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_OMPATOMIC.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 10 :
// MFortranOmpParser.g:331:3: T_BARRIER
{
T_BARRIER127=(Token)match(input,T_BARRIER,FOLLOW_T_BARRIER_in_keyword_list2099);
stream_T_BARRIER.add(T_BARRIER127);
// AST REWRITE
// elements: T_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();
// 331:13: -> ^( T_BARRIER )
{
// MFortranOmpParser.g:331:16: ^( T_BARRIER )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_BARRIER.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 11 :
// MFortranOmpParser.g:332:3: T_FLUSH
{
T_FLUSH128=(Token)match(input,T_FLUSH,FOLLOW_T_FLUSH_in_keyword_list2109);
stream_T_FLUSH.add(T_FLUSH128);
// AST REWRITE
// elements: T_FLUSH
// 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();
// 332:11: -> ^( T_FLUSH )
{
// MFortranOmpParser.g:332:14: ^( T_FLUSH )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_FLUSH.nextNode(), root_1);
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 12 :
// MFortranOmpParser.g:333:3: T_THD_PRIVATE
{
T_THD_PRIVATE129=(Token)match(input,T_THD_PRIVATE,FOLLOW_T_THD_PRIVATE_in_keyword_list2119);
stream_T_THD_PRIVATE.add(T_THD_PRIVATE129);
// AST REWRITE
// elements: T_THD_PRIVATE
// 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();
// 333:17: -> ^( T_THD_PRIVATE )
{
// MFortranOmpParser.g:333:20: ^( T_THD_PRIVATE )
{
Object root_1 = (Object)adaptor.nil();
root_1 = (Object)adaptor.becomeRoot(stream_T_THD_PRIVATE.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 "keyword_list"
// Delegated rules
public static final BitSet FOLLOW_parallel_for_directive_in_openmp_construct92 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_parallel_sections_directive_in_openmp_construct98 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_parallel_directive_in_openmp_construct104 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_for_directive_in_openmp_construct110 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_sections_directive_in_openmp_construct116 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_single_directive_in_openmp_construct122 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_master_directive_in_openmp_construct128 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_critical_directive_in_openmp_construct134 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ordered_directive_in_openmp_construct140 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_section_directive_in_openmp_construct146 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ompatomic_directive_in_openmp_construct152 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_barrier_directive_in_openmp_construct158 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_flush_directive_in_openmp_construct164 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_threadprivate_directive_in_openmp_construct170 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_end_directive_in_openmp_construct176 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_PARALLEL_in_parallel_directive189 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x1129800000000000L,0x0000000010101004L});
public static final BitSet FOLLOW_parallel_clause_in_parallel_directive195 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x1129800000000000L,0x0000000010101004L});
public static final BitSet FOLLOW_unique_parallel_clause_in_parallel_clause222 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_data_clause_in_parallel_clause228 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_MASTER_in_master_directive243 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_CRITICAL_in_critical_directive262 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_critical_directive266 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
public static final BitSet FOLLOW_T_IDENT_in_critical_directive271 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_critical_directive274 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_SECTIONS_in_sections_directive303 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x10A9800000000000L,0x0000000010001004L});
public static final BitSet FOLLOW_sections_clause_in_sections_directive309 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x10A9800000000000L,0x0000000010001004L});
public static final BitSet FOLLOW_data_clause_in_sections_clause336 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_nowait_directive_in_sections_clause342 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_SECTION_in_section_directive355 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_PARALLEL_in_parallel_for_directive376 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000004000L});
public static final BitSet FOLLOW_T_DO_in_parallel_for_directive378 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x5529C00000000000L,0x0000000010101004L});
public static final BitSet FOLLOW_parallel_for_clause_in_parallel_for_directive382 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x5529C00000000000L,0x0000000010101004L});
public static final BitSet FOLLOW_unique_parallel_clause_in_parallel_for_clause410 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_unique_for_clause_in_parallel_for_clause416 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_data_clause_in_parallel_for_clause422 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_PARALLEL_in_parallel_sections_directive435 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000001L});
public static final BitSet FOLLOW_T_SECTIONS_in_parallel_sections_directive438 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x1129800000000000L,0x0000000010101004L});
public static final BitSet FOLLOW_parallel_sections_clause_in_parallel_sections_directive443 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x1129800000000000L,0x0000000010101004L});
public static final BitSet FOLLOW_unique_parallel_clause_in_parallel_sections_clause471 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_data_clause_in_parallel_sections_clause477 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_SINGLE_in_single_directive490 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x10A9800000000000L,0x0000000010001004L});
public static final BitSet FOLLOW_single_clause_in_single_directive495 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x10A9800000000000L,0x0000000010001004L});
public static final BitSet FOLLOW_data_clause_in_single_clause523 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_nowait_directive_in_single_clause529 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_BARRIER_in_barrier_directive542 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_OMPATOMIC_in_ompatomic_directive563 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000200000000000L,0x0000000220000042L});
public static final BitSet FOLLOW_atomic_clasue_in_ompatomic_directive567 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000002L});
public static final BitSet FOLLOW_seq_cst_clause_in_ompatomic_directive572 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_SEQ_CST_in_seq_cst_clause631 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_FLUSH_in_flush_directive644 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_flush_vars_in_flush_directive649 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_LPAREN_in_flush_vars677 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
public static final BitSet FOLLOW_identifier_list_in_flush_vars683 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_flush_vars686 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_ORDERED_in_ordered_directive712 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_NOWAIT_in_nowait_directive733 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_THD_PRIVATE_in_threadprivate_directive752 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_threadprivate_directive755 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
public static final BitSet FOLLOW_identifier_list_in_threadprivate_directive760 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_threadprivate_directive763 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_DO_in_for_directive789 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x54A9C00000000000L,0x0000000010001004L});
public static final BitSet FOLLOW_for_clause_in_for_directive795 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x54A9C00000000000L,0x0000000010001004L});
public static final BitSet FOLLOW_unique_for_clause_in_for_clause826 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_data_clause_in_for_clause843 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_nowait_directive_in_for_clause860 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_ORDERED_in_unique_for_clause882 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_schedule_clause_in_unique_for_clause897 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_collapse_clause_in_unique_for_clause914 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_SCHEDULE_in_schedule_clause937 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_schedule_clause940 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x2014000000000000L,0x0000000000000010L});
public static final BitSet FOLLOW_schedule_kind_in_schedule_clause945 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L});
public static final BitSet FOLLOW_T_COMMA_in_schedule_clause948 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
public static final BitSet FOLLOW_expression_in_schedule_clause953 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_schedule_clause956 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_SCHEDULE_in_schedule_clause983 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_schedule_clause986 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x2014000000000000L,0x0000000000000010L});
public static final BitSet FOLLOW_schedule_kind_in_schedule_clause991 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_schedule_clause994 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_COLLAPSE_in_collapse_clause1019 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_collapse_clause1022 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002000L});
public static final BitSet FOLLOW_T_DIGIT_STRING_in_collapse_clause1027 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_collapse_clause1030 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_STATIC_in_schedule_kind1055 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_DYNAMIC_in_schedule_kind1067 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_GUIDED_in_schedule_kind1079 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_RUNTIME_in_schedule_kind1091 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_if_clause_in_unique_parallel_clause1112 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_num_threads_clause_in_unique_parallel_clause1134 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_IF_in_if_clause1163 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_if_clause1166 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
public static final BitSet FOLLOW_expression_in_if_clause1171 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_if_clause1174 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_NUM_THREADS_in_num_threads_clause1202 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_num_threads_clause1205 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
public static final BitSet FOLLOW_expression_in_num_threads_clause1210 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_num_threads_clause1213 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_private_clause_in_data_clause1241 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_firstprivate_clause_in_data_clause1262 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_lastprivate_clause_in_data_clause1283 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_shared_clause_in_data_clause1304 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_default_clause_in_data_clause1325 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_reduction_clause_in_data_clause1346 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_copyin_clause_in_data_clause1367 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_copyprivate_clause_in_data_clause1388 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_PRIVATE_in_private_clause1416 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_private_clause1419 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
public static final BitSet FOLLOW_identifier_list_in_private_clause1424 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_private_clause1427 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_FST_PRIVATE_in_firstprivate_clause1456 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_firstprivate_clause1459 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
public static final BitSet FOLLOW_identifier_list_in_firstprivate_clause1464 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_firstprivate_clause1467 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_LST_PRIVATE_in_lastprivate_clause1495 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_lastprivate_clause1498 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
public static final BitSet FOLLOW_identifier_list_in_lastprivate_clause1503 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_lastprivate_clause1506 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_SHARED_in_shared_clause1534 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_shared_clause1537 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
public static final BitSet FOLLOW_identifier_list_in_shared_clause1542 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_shared_clause1545 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_DEFAULT_in_default_clause1573 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_default_clause1576 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000004L});
public static final BitSet FOLLOW_T_SHARED_in_default_clause1579 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_default_clause1582 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_DEFAULT_in_default_clause1600 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_default_clause1603 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000010000000L});
public static final BitSet FOLLOW_T_PRIVATE_in_default_clause1606 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_default_clause1609 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_DEFAULT_in_default_clause1627 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_default_clause1630 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000800000L});
public static final BitSet FOLLOW_T_NONE_in_default_clause1633 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_default_clause1636 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_REDUCTION_in_reduction_clause1663 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_reduction_clause1665 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x00001A0000000000L,0x0000000009440180L});
public static final BitSet FOLLOW_reduction_operator_in_reduction_clause1669 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000200L});
public static final BitSet FOLLOW_T_COLON_in_reduction_clause1671 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
public static final BitSet FOLLOW_identifier_list_in_reduction_clause1675 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_reduction_clause1677 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_COPYIN_in_copyin_clause1708 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_copyin_clause1711 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
public static final BitSet FOLLOW_identifier_list_in_copyin_clause1716 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_copyin_clause1719 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_COPYPRIVATE_in_copyprivate_clause1747 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000200000L});
public static final BitSet FOLLOW_T_LPAREN_in_copyprivate_clause1750 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
public static final BitSet FOLLOW_identifier_list_in_copyprivate_clause1755 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
public static final BitSet FOLLOW_T_RPAREN_in_copyprivate_clause1758 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_PLUS_in_reduction_operator1784 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_ASTERISK_in_reduction_operator1796 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_MINUS_in_reduction_operator1808 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_AMPERSAND_in_reduction_operator1820 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_BITXOR_in_reduction_operator1832 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_BITOR_in_reduction_operator1844 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_AND_in_reduction_operator1856 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_OR_in_reduction_operator1868 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_IDENT_in_reduction_operator1880 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_IDENT_in_identifier_list1903 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L});
public static final BitSet FOLLOW_T_COMMA_in_identifier_list1907 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
public static final BitSet FOLLOW_T_IDENT_in_identifier_list1912 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000400L});
public static final BitSet FOLLOW_T_IDENT_in_expression1954 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_END_in_end_directive1982 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x8E42040000000000L,0x0000000000014029L});
public static final BitSet FOLLOW_keyword_list_in_end_directive1986 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_PARALLEL_in_keyword_list2009 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_DO_in_keyword_list2019 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_SECTIONS_in_keyword_list2029 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_SINGLE_in_keyword_list2039 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_MASTER_in_keyword_list2049 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_CRITICAL_in_keyword_list2059 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_ORDERED_in_keyword_list2069 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_SECTION_in_keyword_list2079 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_OMPATOMIC_in_keyword_list2089 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_BARRIER_in_keyword_list2099 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_FLUSH_in_keyword_list2109 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_T_THD_PRIVATE_in_keyword_list2119 = new BitSet(new long[]{0x0000000000000002L});
}