def consumeUntil(self, input, tokenTypes):
"""
Consume tokens until one matches the given token or token set
tokenTypes can be a single token type or a set of token types
"""
if not isinstance(tokenTypes, (set, frozenset)):
tokenTypes = frozenset([tokenTypes])
ttype = input.LA(1)
while ttype != EOF and ttype not in tokenTypes:
input.consume()
ttype = input.LA(1)
class cp_treeparser(TreeParser):
grammarFileName = "cp_treeparser.g"
antlr_version = version_str_to_tuple("3.1.2")
antlr_version_str = "3.1.2"
tokenNames = tokenNames
def __init__(self, input, state=None):
if state is None:
state = RecognizerSharedState()
TreeParser.__init__(self, input, state)
import logging
self.logger = logging.getLogger("Main.cp_treeparser")
self.refs = []
self.prev_ref = {}
self.curr_ref = None
self.count = 0
self.levels = []
# $ANTLR start "doc"
# cp_treeparser.g:24:1: doc : ( citation )+ ;
def doc(self, ):
try:
try:
# cp_treeparser.g:24:5: ( ( citation )+ )
# cp_treeparser.g:24:7: ( citation )+
pass
# cp_treeparser.g:24:7: ( citation )+
cnt1 = 0
while True: #loop1
alt1 = 2
LA1_0 = self.input.LA(1)
if (LA1_0 == CITATION):
alt1 = 1
if alt1 == 1:
# cp_treeparser.g:24:7: citation
pass
self._state.following.append(
self.FOLLOW_citation_in_doc56)
self.citation()
self._state.following.pop()
else:
if cnt1 >= 1:
break #loop1
eee = EarlyExitException(1, self.input)
raise eee
cnt1 += 1
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "doc"
# $ANTLR start "citation"
# cp_treeparser.g:27:1: citation : ^( CITATION ref ( ref )* ) ;
def citation(self, ):
try:
try:
# cp_treeparser.g:31:2: ( ^( CITATION ref ( ref )* ) )
# cp_treeparser.g:32:1: ^( CITATION ref ( ref )* )
pass
self.match(self.input, CITATION,
self.FOLLOW_CITATION_in_citation70)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_ref_in_citation72)
self.ref()
self._state.following.pop()
# cp_treeparser.g:32:16: ( ref )*
while True: #loop2
alt2 = 2
LA2_0 = self.input.LA(1)
if (LA2_0 == REF):
alt2 = 1
if alt2 == 1:
# cp_treeparser.g:32:16: ref
pass
self._state.following.append(
self.FOLLOW_ref_in_citation74)
self.ref()
self._state.following.pop()
else:
break #loop2
self.match(self.input, UP, None)
#action start
result = {}
result["refs"] = self.refs
#action end
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "citation"
# $ANTLR start "ref"
# cp_treeparser.g:35:1: ref : ^( REF ( work )* scp ( editor )* ) ;
def ref(self, ):
if (self.curr_ref is None):
self.curr_ref = {}
else:
self.prev_ref = dict(self.curr_ref)
self.curr_ref = {}
try:
try:
# cp_treeparser.g:51:1: ( ^( REF ( work )* scp ( editor )* ) )
# cp_treeparser.g:52:1: ^( REF ( work )* scp ( editor )* )
pass
self.match(self.input, REF, self.FOLLOW_REF_in_ref97)
self.match(self.input, DOWN, None)
# cp_treeparser.g:52:7: ( work )*
while True: #loop3
alt3 = 2
LA3_0 = self.input.LA(1)
if (LA3_0 == WORK):
alt3 = 1
if alt3 == 1:
# cp_treeparser.g:52:7: work
pass
self._state.following.append(self.FOLLOW_work_in_ref99)
self.work()
self._state.following.pop()
else:
break #loop3
self._state.following.append(self.FOLLOW_scp_in_ref102)
self.scp()
self._state.following.pop()
# cp_treeparser.g:52:17: ( editor )*
while True: #loop4
alt4 = 2
LA4_0 = self.input.LA(1)
if (LA4_0 == EDITOR):
alt4 = 1
if alt4 == 1:
# cp_treeparser.g:52:17: editor
pass
self._state.following.append(
self.FOLLOW_editor_in_ref104)
self.editor()
self._state.following.pop()
else:
break #loop4
self.match(self.input, UP, None)
#action start
if ('work' not in self.curr_ref and 'work' in self.prev_ref):
self.curr_ref["work"] = self.prev_ref["work"]
elif ('work' not in self.curr_ref):
self.curr_ref["work"] = None
self.refs.append(dict(self.curr_ref))
#action end
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "ref"
# $ANTLR start "work"
# cp_treeparser.g:55:1: work : ^( WORK (x+= LITERAL )+ ) ;
def work(self, ):
x = None
list_x = None
try:
try:
# cp_treeparser.g:55:5: ( ^( WORK (x+= LITERAL )+ ) )
# cp_treeparser.g:56:1: ^( WORK (x+= LITERAL )+ )
pass
self.match(self.input, WORK, self.FOLLOW_WORK_in_work115)
self.match(self.input, DOWN, None)
# cp_treeparser.g:56:9: (x+= LITERAL )+
cnt5 = 0
while True: #loop5
alt5 = 2
LA5_0 = self.input.LA(1)
if (LA5_0 == LITERAL):
alt5 = 1
if alt5 == 1:
# cp_treeparser.g:56:9: x+= LITERAL
pass
x = self.match(self.input, LITERAL,
self.FOLLOW_LITERAL_in_work119)
if list_x is None:
list_x = []
list_x.append(x)
else:
if cnt5 >= 1:
break #loop5
eee = EarlyExitException(5, self.input)
raise eee
cnt5 += 1
self.match(self.input, UP, None)
#action start
y = [n.toString() for n in list_x]
self.curr_ref["work"] = " ".join(y)
#action end
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "work"
# $ANTLR start "editor"
# cp_treeparser.g:63:1: editor : ^( EDITOR LITERAL ) ;
def editor(self, ):
try:
try:
# cp_treeparser.g:63:7: ( ^( EDITOR LITERAL ) )
# cp_treeparser.g:64:1: ^( EDITOR LITERAL )
pass
self.match(self.input, EDITOR, self.FOLLOW_EDITOR_in_editor132)
self.match(self.input, DOWN, None)
self.match(self.input, LITERAL,
self.FOLLOW_LITERAL_in_editor134)
self.match(self.input, UP, None)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "editor"
# $ANTLR start "level"
# cp_treeparser.g:67:1: level[typ] returns [List levs] : ^( LEVEL lev+= INT ) ( ^( LEVEL lev1+= INT ) )* ;
def level(self, typ):
levs = None
lev = None
lev1 = None
list_lev = None
list_lev1 = None
if (typ == "end"):
self.levels = []
try:
try:
# cp_treeparser.g:78:1: ( ^( LEVEL lev+= INT ) ( ^( LEVEL lev1+= INT ) )* )
# cp_treeparser.g:79:1: ^( LEVEL lev+= INT ) ( ^( LEVEL lev1+= INT ) )*
pass
self.match(self.input, LEVEL, self.FOLLOW_LEVEL_in_level158)
self.match(self.input, DOWN, None)
lev = self.match(self.input, INT, self.FOLLOW_INT_in_level162)
if list_lev is None:
list_lev = []
list_lev.append(lev)
self.match(self.input, UP, None)
# cp_treeparser.g:79:19: ( ^( LEVEL lev1+= INT ) )*
while True: #loop6
alt6 = 2
LA6_0 = self.input.LA(1)
if (LA6_0 == LEVEL):
alt6 = 1
if alt6 == 1:
# cp_treeparser.g:79:20: ^( LEVEL lev1+= INT )
pass
self.match(self.input, LEVEL,
self.FOLLOW_LEVEL_in_level167)
self.match(self.input, DOWN, None)
lev1 = self.match(self.input, INT,
self.FOLLOW_INT_in_level171)
if list_lev1 is None:
list_lev1 = []
list_lev1.append(lev1)
#action start
self.count += 1
self.levels.append(str(lev1))
#action end
self.match(self.input, UP, None)
else:
break #loop6
#action start
if (not typ == "end"):
self.count += 1
temp = []
temp = self.levels
self.levels = []
self.levels.append(str(lev))
self.levels += temp
#action end
#action start
if (typ == "single"):
self.curr_ref["scp"]["start"] = self.levels
else:
self.curr_ref["scp"][typ] = self.levels
#action end
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return levs
# $ANTLR end "level"
# $ANTLR start "scp"
# cp_treeparser.g:94:1: scp : ( scp_single | scp_range ) ;
def scp(self, ):
self.count = 0
self.levels = []
try:
try:
# cp_treeparser.g:100:1: ( ( scp_single | scp_range ) )
# cp_treeparser.g:100:3: ( scp_single | scp_range )
pass
# cp_treeparser.g:100:3: ( scp_single | scp_range )
alt7 = 2
LA7_0 = self.input.LA(1)
if (LA7_0 == SCOPE_S):
alt7 = 1
elif (LA7_0 == SCOPE_R):
alt7 = 2
else:
nvae = NoViableAltException("", 7, 0, self.input)
raise nvae
if alt7 == 1:
# cp_treeparser.g:100:4: scp_single
pass
self._state.following.append(
self.FOLLOW_scp_single_in_scp193)
self.scp_single()
self._state.following.pop()
elif alt7 == 2:
# cp_treeparser.g:100:15: scp_range
pass
self._state.following.append(
self.FOLLOW_scp_range_in_scp195)
self.scp_range()
self._state.following.pop()
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "scp"
# $ANTLR start "scp_single"
# cp_treeparser.g:103:1: scp_single : ^( SCOPE_S level[\"single\"] ) ;
def scp_single(self, ):
self.curr_ref["scp"] = {}
try:
try:
# cp_treeparser.g:107:1: ( ^( SCOPE_S level[\"single\"] ) )
# cp_treeparser.g:108:1: ^( SCOPE_S level[\"single\"] )
pass
self.match(self.input, SCOPE_S,
self.FOLLOW_SCOPE_S_in_scp_single210)
self.match(self.input, DOWN, None)
self._state.following.append(
self.FOLLOW_level_in_scp_single212)
self.level("single")
self._state.following.pop()
self.match(self.input, UP, None)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "scp_single"
# $ANTLR start "scp_range"
# cp_treeparser.g:111:1: scp_range : ^( SCOPE_R ^( START level[\"start\"] ) ^( END level[\"end\"] ) ) ;
def scp_range(self, ):
self.curr_ref["scp"] = {}
self.curr_ref["scp"]["start"] = []
self.curr_ref["scp"]["end"] = []
try:
try:
# cp_treeparser.g:133:1: ( ^( SCOPE_R ^( START level[\"start\"] ) ^( END level[\"end\"] ) ) )
# cp_treeparser.g:134:1: ^( SCOPE_R ^( START level[\"start\"] ) ^( END level[\"end\"] ) )
pass
self.match(self.input, SCOPE_R,
self.FOLLOW_SCOPE_R_in_scp_range232)
self.match(self.input, DOWN, None)
self.match(self.input, START,
self.FOLLOW_START_in_scp_range235)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_level_in_scp_range237)
self.level("start")
self._state.following.pop()
self.match(self.input, UP, None)
self.match(self.input, END, self.FOLLOW_END_in_scp_range242)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_level_in_scp_range244)
self.level("end")
self._state.following.pop()
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
sl = len(self.curr_ref["scp"]["start"])
el = len(self.curr_ref["scp"]["end"])
if (el != sl):
count = 0
self.curr_ref["scp"]["start"].reverse()
while (len(self.curr_ref["scp"]["start"]) > len(
self.curr_ref["scp"]["end"])):
self.curr_ref["scp"]["end"].append(None)
count += 1
for n, l in enumerate(self.curr_ref["scp"]["end"]):
if (l is None):
self.curr_ref["scp"]["end"][n] = self.curr_ref[
"scp"]["start"][n]
self.curr_ref["scp"]["start"].reverse()
self.curr_ref["scp"]["end"].reverse()
#action end
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "scp_range"
# Delegated rules
FOLLOW_citation_in_doc56 = frozenset([1, 19])
FOLLOW_CITATION_in_citation70 = frozenset([2])
FOLLOW_ref_in_citation72 = frozenset([3, 18])
FOLLOW_ref_in_citation74 = frozenset([3, 18])
FOLLOW_REF_in_ref97 = frozenset([2])
FOLLOW_work_in_ref99 = frozenset([20, 23, 24])
FOLLOW_scp_in_ref102 = frozenset([3, 21])
FOLLOW_editor_in_ref104 = frozenset([3, 21])
FOLLOW_WORK_in_work115 = frozenset([2])
FOLLOW_LITERAL_in_work119 = frozenset([3, 17])
FOLLOW_EDITOR_in_editor132 = frozenset([2])
FOLLOW_LITERAL_in_editor134 = frozenset([3])
FOLLOW_LEVEL_in_level158 = frozenset([2])
FOLLOW_INT_in_level162 = frozenset([3])
FOLLOW_LEVEL_in_level167 = frozenset([2])
FOLLOW_INT_in_level171 = frozenset([3])
FOLLOW_scp_single_in_scp193 = frozenset([1])
FOLLOW_scp_range_in_scp195 = frozenset([1])
FOLLOW_SCOPE_S_in_scp_single210 = frozenset([2])
FOLLOW_level_in_scp_single212 = frozenset([3])
FOLLOW_SCOPE_R_in_scp_range232 = frozenset([2])
FOLLOW_START_in_scp_range235 = frozenset([2])
FOLLOW_level_in_scp_range237 = frozenset([3])
FOLLOW_END_in_scp_range242 = frozenset([2])
FOLLOW_level_in_scp_range244 = frozenset([3])
class BuildFSM(DebugTreeParser):
grammarFileName = "/homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g"
antlr_version = version_str_to_tuple("3.2 Sep 23, 2009 12:02:23")
antlr_version_str = "3.2 Sep 23, 2009 12:02:23"
tokenNames = tokenNames
def __init__(self, input, state=None, *args, **kwargs):
if state is None:
state = RecognizerSharedState()
debug_socket = kwargs.pop('debug_socket', None)
port = kwargs.pop('port', None)
super(BuildFSM, self).__init__(input, state, *args, **kwargs)
self.ruleLevel = 0
if self._dbg is None:
proxy = DebugEventSocketProxy(self,
adaptor=self.input.getTreeAdaptor(),
debug=debug_socket,
port=port)
self.setDebugListener(proxy)
proxy.handshake()
ruleNames = [
"invalidRule", "activityDef", "protocolDef", "blockDef", "description",
"roleName", "labelName", "protocolBlockDef"
]
def getRuleLevel(self):
return self.ruleLevel
def incRuleLevel(self):
self.ruleLevel += 1
def decRuleLevel(self):
self.ruleLevel -= 1
def evalPredicate(self, result, predicate):
self._dbg.semanticPredicate(result, predicate)
return result
# $ANTLR start "description"
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:10:1: description : protocolDef ;
def description(self, ):
try:
self._dbg.enterRule(self.getGrammarFileName(), "description")
if self.getRuleLevel() == 0:
self._dbg.commence()
self.incRuleLevel()
self._dbg.location(10, 1)
try:
try:
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:10:12: ( protocolDef )
self._dbg.enterAlt(1)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:10:14: protocolDef
pass
self._dbg.location(10, 14)
self._state.following.append(
self.FOLLOW_protocolDef_in_description40)
self.protocolDef()
self._state.following.pop()
self._dbg.location(10, 26)
#action start
print "Enter protocol"
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
self._dbg.location(10, 50)
finally:
self._dbg.exitRule(self.getGrammarFileName(), "description")
self.decRuleLevel()
if self.getRuleLevel() == 0:
self._dbg.terminate()
return
# $ANTLR end "description"
# $ANTLR start "protocolDef"
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:13:1: protocolDef : ^( 'protocol' protocolBlockDef ( protocolDef )* ) ;
def protocolDef(self, ):
try:
self._dbg.enterRule(self.getGrammarFileName(), "protocolDef")
if self.getRuleLevel() == 0:
self._dbg.commence()
self.incRuleLevel()
self._dbg.location(13, 1)
try:
try:
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:13:12: ( ^( 'protocol' protocolBlockDef ( protocolDef )* ) )
self._dbg.enterAlt(1)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:13:15: ^( 'protocol' protocolBlockDef ( protocolDef )* )
pass
self._dbg.location(13, 15)
self._dbg.location(13, 17)
self.match(self.input, 24, self.FOLLOW_24_in_protocolDef52)
self.match(self.input, DOWN, None)
self._dbg.location(13, 28)
self._state.following.append(
self.FOLLOW_protocolBlockDef_in_protocolDef54)
self.protocolBlockDef()
self._state.following.pop()
self._dbg.location(13, 45)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:13:45: ( protocolDef )*
try:
self._dbg.enterSubRule(1)
while True: #loop1
alt1 = 2
try:
self._dbg.enterDecision(1)
LA1_0 = self.input.LA(1)
if (LA1_0 == 24):
alt1 = 1
finally:
self._dbg.exitDecision(1)
if alt1 == 1:
self._dbg.enterAlt(1)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:13:45: protocolDef
pass
self._dbg.location(13, 45)
self._state.following.append(
self.FOLLOW_protocolDef_in_protocolDef56)
self.protocolDef()
self._state.following.pop()
else:
break #loop1
finally:
self._dbg.exitSubRule(1)
self.match(self.input, UP, None)
self._dbg.location(13, 59)
#action start
print "ProtocolDefinition"
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
self._dbg.location(13, 87)
finally:
self._dbg.exitRule(self.getGrammarFileName(), "protocolDef")
self.decRuleLevel()
if self.getRuleLevel() == 0:
self._dbg.terminate()
return
# $ANTLR end "protocolDef"
# $ANTLR start "activityDef"
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:15:1: activityDef : ( ^( 'RESV' ( ID )+ roleName ) | ^( 'SEND' ( ID )+ roleName ) | ^( 'RECLABEL' labelName ) | ^( 'choice' ( blockDef )+ ) | ^( 'parallel' ( blockDef )+ ) | ^( 'UNORDERED' blockDef ) | ^( 'rec' blockDef ) | ^( 'repeat' blockDef ) );
def activityDef(self, ):
try:
self._dbg.enterRule(self.getGrammarFileName(), "activityDef")
if self.getRuleLevel() == 0:
self._dbg.commence()
self.incRuleLevel()
self._dbg.location(15, 1)
try:
try:
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:15:12: ( ^( 'RESV' ( ID )+ roleName ) | ^( 'SEND' ( ID )+ roleName ) | ^( 'RECLABEL' labelName ) | ^( 'choice' ( blockDef )+ ) | ^( 'parallel' ( blockDef )+ ) | ^( 'UNORDERED' blockDef ) | ^( 'rec' blockDef ) | ^( 'repeat' blockDef ) )
alt6 = 8
try:
self._dbg.enterDecision(6)
LA6 = self.input.LA(1)
if LA6 == RESV:
alt6 = 1
elif LA6 == SEND:
alt6 = 2
elif LA6 == RECLABEL:
alt6 = 3
elif LA6 == 37:
alt6 = 4
elif LA6 == 45:
alt6 = 5
elif LA6 == UNORDERED:
alt6 = 6
elif LA6 == 41:
alt6 = 7
elif LA6 == 40:
alt6 = 8
else:
nvae = NoViableAltException("", 6, 0, self.input)
self._dbg.recognitionException(nvae)
raise nvae
finally:
self._dbg.exitDecision(6)
if alt6 == 1:
self._dbg.enterAlt(1)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:17:2: ^( 'RESV' ( ID )+ roleName )
pass
self._dbg.location(17, 2)
self._dbg.location(17, 4)
self.match(self.input, RESV,
self.FOLLOW_RESV_in_activityDef71)
self.match(self.input, DOWN, None)
self._dbg.location(17, 11)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:17:11: ( ID )+
cnt2 = 0
try:
self._dbg.enterSubRule(2)
while True: #loop2
alt2 = 2
try:
self._dbg.enterDecision(2)
LA2_0 = self.input.LA(1)
if (LA2_0 == ID):
LA2_1 = self.input.LA(2)
if (LA2_1 == ID):
alt2 = 1
finally:
self._dbg.exitDecision(2)
if alt2 == 1:
self._dbg.enterAlt(1)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:17:11: ID
pass
self._dbg.location(17, 11)
self.match(self.input, ID,
self.FOLLOW_ID_in_activityDef73)
else:
if cnt2 >= 1:
break #loop2
eee = EarlyExitException(2, self.input)
self._dbg.recognitionException(eee)
raise eee
cnt2 += 1
finally:
self._dbg.exitSubRule(2)
self._dbg.location(17, 15)
self._state.following.append(
self.FOLLOW_roleName_in_activityDef76)
self.roleName()
self._state.following.pop()
self.match(self.input, UP, None)
elif alt6 == 2:
self._dbg.enterAlt(2)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:18:4: ^( 'SEND' ( ID )+ roleName )
pass
self._dbg.location(18, 4)
self._dbg.location(18, 6)
self.match(self.input, SEND,
self.FOLLOW_SEND_in_activityDef83)
self.match(self.input, DOWN, None)
self._dbg.location(18, 13)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:18:13: ( ID )+
cnt3 = 0
try:
self._dbg.enterSubRule(3)
while True: #loop3
alt3 = 2
try:
self._dbg.enterDecision(3)
LA3_0 = self.input.LA(1)
if (LA3_0 == ID):
LA3_1 = self.input.LA(2)
if (LA3_1 == ID):
alt3 = 1
finally:
self._dbg.exitDecision(3)
if alt3 == 1:
self._dbg.enterAlt(1)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:18:13: ID
pass
self._dbg.location(18, 13)
self.match(self.input, ID,
self.FOLLOW_ID_in_activityDef85)
else:
if cnt3 >= 1:
break #loop3
eee = EarlyExitException(3, self.input)
self._dbg.recognitionException(eee)
raise eee
cnt3 += 1
finally:
self._dbg.exitSubRule(3)
self._dbg.location(18, 17)
self._state.following.append(
self.FOLLOW_roleName_in_activityDef88)
self.roleName()
self._state.following.pop()
self.match(self.input, UP, None)
elif alt6 == 3:
self._dbg.enterAlt(3)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:20:3: ^( 'RECLABEL' labelName )
pass
self._dbg.location(20, 3)
self._dbg.location(20, 5)
self.match(self.input, RECLABEL,
self.FOLLOW_RECLABEL_in_activityDef96)
self.match(self.input, DOWN, None)
self._dbg.location(20, 16)
self._state.following.append(
self.FOLLOW_labelName_in_activityDef98)
self.labelName()
self._state.following.pop()
self.match(self.input, UP, None)
elif alt6 == 4:
self._dbg.enterAlt(4)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:22:3: ^( 'choice' ( blockDef )+ )
pass
self._dbg.location(22, 3)
self._dbg.location(22, 5)
self.match(self.input, 37,
self.FOLLOW_37_in_activityDef106)
self.match(self.input, DOWN, None)
self._dbg.location(22, 14)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:22:14: ( blockDef )+
cnt4 = 0
try:
self._dbg.enterSubRule(4)
while True: #loop4
alt4 = 2
try:
self._dbg.enterDecision(4)
LA4_0 = self.input.LA(1)
if (LA4_0 == BRANCH):
alt4 = 1
finally:
self._dbg.exitDecision(4)
if alt4 == 1:
self._dbg.enterAlt(1)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:22:14: blockDef
pass
self._dbg.location(22, 14)
self._state.following.append(
self.FOLLOW_blockDef_in_activityDef108)
self.blockDef()
self._state.following.pop()
else:
if cnt4 >= 1:
break #loop4
eee = EarlyExitException(4, self.input)
self._dbg.recognitionException(eee)
raise eee
cnt4 += 1
finally:
self._dbg.exitSubRule(4)
self.match(self.input, UP, None)
elif alt6 == 5:
self._dbg.enterAlt(5)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:24:4: ^( 'parallel' ( blockDef )+ )
pass
self._dbg.location(24, 4)
self._dbg.location(24, 6)
self.match(self.input, 45,
self.FOLLOW_45_in_activityDef118)
self.match(self.input, DOWN, None)
self._dbg.location(24, 17)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:24:17: ( blockDef )+
cnt5 = 0
try:
self._dbg.enterSubRule(5)
while True: #loop5
alt5 = 2
try:
self._dbg.enterDecision(5)
LA5_0 = self.input.LA(1)
if (LA5_0 == BRANCH):
alt5 = 1
finally:
self._dbg.exitDecision(5)
if alt5 == 1:
self._dbg.enterAlt(1)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:24:17: blockDef
pass
self._dbg.location(24, 17)
self._state.following.append(
self.FOLLOW_blockDef_in_activityDef120)
self.blockDef()
self._state.following.pop()
else:
if cnt5 >= 1:
break #loop5
eee = EarlyExitException(5, self.input)
self._dbg.recognitionException(eee)
raise eee
cnt5 += 1
finally:
self._dbg.exitSubRule(5)
self.match(self.input, UP, None)
elif alt6 == 6:
self._dbg.enterAlt(6)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:26:3: ^( 'UNORDERED' blockDef )
pass
self._dbg.location(26, 3)
self._dbg.location(26, 5)
self.match(self.input, UNORDERED,
self.FOLLOW_UNORDERED_in_activityDef129)
self.match(self.input, DOWN, None)
self._dbg.location(26, 17)
self._state.following.append(
self.FOLLOW_blockDef_in_activityDef131)
self.blockDef()
self._state.following.pop()
self.match(self.input, UP, None)
elif alt6 == 7:
self._dbg.enterAlt(7)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:28:3: ^( 'rec' blockDef )
pass
self._dbg.location(28, 3)
self._dbg.location(28, 5)
self.match(self.input, 41,
self.FOLLOW_41_in_activityDef139)
self.match(self.input, DOWN, None)
self._dbg.location(28, 11)
self._state.following.append(
self.FOLLOW_blockDef_in_activityDef141)
self.blockDef()
self._state.following.pop()
self.match(self.input, UP, None)
elif alt6 == 8:
self._dbg.enterAlt(8)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:30:3: ^( 'repeat' blockDef )
pass
self._dbg.location(30, 3)
self._dbg.location(30, 5)
self.match(self.input, 40,
self.FOLLOW_40_in_activityDef149)
self.match(self.input, DOWN, None)
self._dbg.location(30, 14)
self._state.following.append(
self.FOLLOW_blockDef_in_activityDef151)
self.blockDef()
self._state.following.pop()
self.match(self.input, UP, None)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
self._dbg.location(30, 23)
finally:
self._dbg.exitRule(self.getGrammarFileName(), "activityDef")
self.decRuleLevel()
if self.getRuleLevel() == 0:
self._dbg.terminate()
return
# $ANTLR end "activityDef"
# $ANTLR start "roleName"
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:32:1: roleName : ID ;
def roleName(self, ):
try:
self._dbg.enterRule(self.getGrammarFileName(), "roleName")
if self.getRuleLevel() == 0:
self._dbg.commence()
self.incRuleLevel()
self._dbg.location(32, 1)
try:
try:
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:32:9: ( ID )
self._dbg.enterAlt(1)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:32:11: ID
pass
self._dbg.location(32, 11)
self.match(self.input, ID, self.FOLLOW_ID_in_roleName159)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
self._dbg.location(32, 13)
finally:
self._dbg.exitRule(self.getGrammarFileName(), "roleName")
self.decRuleLevel()
if self.getRuleLevel() == 0:
self._dbg.terminate()
return
# $ANTLR end "roleName"
# $ANTLR start "labelName"
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:33:1: labelName : ID ;
def labelName(self, ):
try:
self._dbg.enterRule(self.getGrammarFileName(), "labelName")
if self.getRuleLevel() == 0:
self._dbg.commence()
self.incRuleLevel()
self._dbg.location(33, 1)
try:
try:
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:33:10: ( ID )
self._dbg.enterAlt(1)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:33:12: ID
pass
self._dbg.location(33, 12)
self.match(self.input, ID, self.FOLLOW_ID_in_labelName165)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
self._dbg.location(33, 15)
finally:
self._dbg.exitRule(self.getGrammarFileName(), "labelName")
self.decRuleLevel()
if self.getRuleLevel() == 0:
self._dbg.terminate()
return
# $ANTLR end "labelName"
# $ANTLR start "protocolBlockDef"
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:36:1: protocolBlockDef : ( activityDef )+ ;
def protocolBlockDef(self, ):
try:
self._dbg.enterRule(self.getGrammarFileName(), "protocolBlockDef")
if self.getRuleLevel() == 0:
self._dbg.commence()
self.incRuleLevel()
self._dbg.location(36, 1)
try:
try:
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:36:17: ( ( activityDef )+ )
self._dbg.enterAlt(1)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:36:19: ( activityDef )+
pass
self._dbg.location(36, 19)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:36:19: ( activityDef )+
cnt7 = 0
try:
self._dbg.enterSubRule(7)
while True: #loop7
alt7 = 2
try:
self._dbg.enterDecision(7)
LA7_0 = self.input.LA(1)
if ((RESV <= LA7_0 <= SEND)
or (UNORDERED <= LA7_0 <= RECLABEL)
or LA7_0 == 37 or (40 <= LA7_0 <= 41)
or LA7_0 == 45):
alt7 = 1
finally:
self._dbg.exitDecision(7)
if alt7 == 1:
self._dbg.enterAlt(1)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:36:19: activityDef
pass
self._dbg.location(36, 19)
self._state.following.append(
self.
FOLLOW_activityDef_in_protocolBlockDef174)
self.activityDef()
self._state.following.pop()
else:
if cnt7 >= 1:
break #loop7
eee = EarlyExitException(7, self.input)
self._dbg.recognitionException(eee)
raise eee
cnt7 += 1
finally:
self._dbg.exitSubRule(7)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
self._dbg.location(36, 31)
finally:
self._dbg.exitRule(self.getGrammarFileName(), "protocolBlockDef")
self.decRuleLevel()
if self.getRuleLevel() == 0:
self._dbg.terminate()
return
# $ANTLR end "protocolBlockDef"
# $ANTLR start "blockDef"
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:37:1: blockDef : ^( 'BRANCH' ( activityDef )* ) ;
def blockDef(self, ):
try:
self._dbg.enterRule(self.getGrammarFileName(), "blockDef")
if self.getRuleLevel() == 0:
self._dbg.commence()
self.incRuleLevel()
self._dbg.location(37, 1)
try:
try:
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:37:9: ( ^( 'BRANCH' ( activityDef )* ) )
self._dbg.enterAlt(1)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:37:12: ^( 'BRANCH' ( activityDef )* )
pass
self._dbg.location(37, 12)
self._dbg.location(37, 14)
self.match(self.input, BRANCH,
self.FOLLOW_BRANCH_in_blockDef183)
if self.input.LA(1) == DOWN:
self.match(self.input, DOWN, None)
self._dbg.location(37, 23)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:37:23: ( activityDef )*
try:
self._dbg.enterSubRule(8)
while True: #loop8
alt8 = 2
try:
self._dbg.enterDecision(8)
LA8_0 = self.input.LA(1)
if ((RESV <= LA8_0 <= SEND)
or (UNORDERED <= LA8_0 <= RECLABEL)
or LA8_0 == 37
or (40 <= LA8_0 <= 41)
or LA8_0 == 45):
alt8 = 1
finally:
self._dbg.exitDecision(8)
if alt8 == 1:
self._dbg.enterAlt(1)
# /homes/rn710/workspace/MonitorPrototype/src/BuildFSM.g:37:23: activityDef
pass
self._dbg.location(37, 23)
self._state.following.append(
self.FOLLOW_activityDef_in_blockDef185)
self.activityDef()
self._state.following.pop()
else:
break #loop8
finally:
self._dbg.exitSubRule(8)
self.match(self.input, UP, None)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
self._dbg.location(37, 36)
finally:
self._dbg.exitRule(self.getGrammarFileName(), "blockDef")
self.decRuleLevel()
if self.getRuleLevel() == 0:
self._dbg.terminate()
return
# $ANTLR end "blockDef"
# Delegated rules
FOLLOW_protocolDef_in_description40 = frozenset([1])
FOLLOW_24_in_protocolDef52 = frozenset([2])
FOLLOW_protocolBlockDef_in_protocolDef54 = frozenset([3, 24])
FOLLOW_protocolDef_in_protocolDef56 = frozenset([3, 24])
FOLLOW_RESV_in_activityDef71 = frozenset([2])
FOLLOW_ID_in_activityDef73 = frozenset([16])
FOLLOW_roleName_in_activityDef76 = frozenset([3])
FOLLOW_SEND_in_activityDef83 = frozenset([2])
FOLLOW_ID_in_activityDef85 = frozenset([16])
FOLLOW_roleName_in_activityDef88 = frozenset([3])
FOLLOW_RECLABEL_in_activityDef96 = frozenset([2])
FOLLOW_labelName_in_activityDef98 = frozenset([3])
FOLLOW_37_in_activityDef106 = frozenset([2])
FOLLOW_blockDef_in_activityDef108 = frozenset([3, 12])
FOLLOW_45_in_activityDef118 = frozenset([2])
FOLLOW_blockDef_in_activityDef120 = frozenset([3, 12])
FOLLOW_UNORDERED_in_activityDef129 = frozenset([2])
FOLLOW_blockDef_in_activityDef131 = frozenset([3])
FOLLOW_41_in_activityDef139 = frozenset([2])
FOLLOW_blockDef_in_activityDef141 = frozenset([3])
FOLLOW_40_in_activityDef149 = frozenset([2])
FOLLOW_blockDef_in_activityDef151 = frozenset([3])
FOLLOW_ID_in_roleName159 = frozenset([1])
FOLLOW_ID_in_labelName165 = frozenset([1])
FOLLOW_activityDef_in_protocolBlockDef174 = frozenset(
[1, 10, 11, 13, 14, 37, 40, 41, 45])
FOLLOW_BRANCH_in_blockDef183 = frozenset([2])
FOLLOW_activityDef_in_blockDef185 = frozenset(
[3, 10, 11, 13, 14, 37, 40, 41, 45])
class PyFuncParser(Parser):
grammarFileName = "PyFunc.g"
api_version = 1
tokenNames = tokenNames
def __init__(self, input, state=None, *args, **kwargs):
if state is None:
state = RecognizerSharedState()
super(PyFuncParser, self).__init__(input, state, *args, **kwargs)
self.delegates = []
# $ANTLR start "pyfunc"
# PyFunc.g:6:1: pyfunc : ( pkgdef '.' )? NAME parameters ( asvar )? ;
def pyfunc(self):
func = Function()
try:
try:
# PyFunc.g:6:8: ( ( pkgdef '.' )? NAME parameters ( asvar )? )
# PyFunc.g:6:10: ( pkgdef '.' )? NAME parameters ( asvar )?
pass
# PyFunc.g:6:10: ( pkgdef '.' )?
alt1 = 2
LA1_0 = self.input.LA(1)
if (LA1_0 == NAME):
LA1_1 = self.input.LA(2)
if (LA1_1 == DOT):
alt1 = 1
if alt1 == 1:
# PyFunc.g:6:11: pkgdef '.'
pass
self._state.following.append(
self.FOLLOW_pkgdef_in_pyfunc24)
self.pkgdef(func.packages)
self._state.following.pop()
self.match(self.input, DOT, self.FOLLOW_DOT_in_pyfunc26)
token = self.match(self.input, NAME,
self.FOLLOW_NAME_in_pyfunc30)
func.name = token.text
self._state.following.append(
self.FOLLOW_parameters_in_pyfunc32)
self.parameters(func.arguments)
self._state.following.pop()
# PyFunc.g:6:40: ( asvar )?
alt2 = 2
LA2_0 = self.input.LA(1)
if (LA2_0 == AS):
alt2 = 1
if alt2 == 1:
# PyFunc.g:6:41: asvar
pass
self._state.following.append(self.FOLLOW_asvar_in_pyfunc35)
self.asvar(func)
self._state.following.pop()
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return func
# $ANTLR end "pyfunc"
# $ANTLR start "pkgdef"
# PyFunc.g:8:1: pkgdef : NAME ( '.' NAME )* ;
def pkgdef(self, pkgs):
try:
try:
# PyFunc.g:8:8: ( NAME ( '.' NAME )* )
# PyFunc.g:8:10: NAME ( '.' NAME )*
pass
token = self.match(self.input, NAME,
self.FOLLOW_NAME_in_pkgdef46)
pkgs.append(token.text)
# PyFunc.g:8:15: ( '.' NAME )*
while True: #loop3
alt3 = 2
LA3_0 = self.input.LA(1)
if (LA3_0 == DOT):
LA3_1 = self.input.LA(2)
if (LA3_1 == NAME):
LA3_2 = self.input.LA(3)
if (LA3_2 == DOT):
alt3 = 1
if alt3 == 1:
# PyFunc.g:8:16: '.' NAME
pass
self.match(self.input, DOT,
self.FOLLOW_DOT_in_pkgdef49)
token = self.match(self.input, NAME,
self.FOLLOW_NAME_in_pkgdef51)
pkgs.append(token.text)
else:
break #loop3
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "pkgdef"
# $ANTLR start "parameters"
# PyFunc.g:10:1: parameters : '(' ( arguments )? ')' ;
def parameters(self, args):
try:
try:
# PyFunc.g:10:12: ( '(' ( arguments )? ')' )
# PyFunc.g:10:14: '(' ( arguments )? ')'
pass
self.match(self.input, LPAREN,
self.FOLLOW_LPAREN_in_parameters62)
# PyFunc.g:10:18: ( arguments )?
alt4 = 2
LA4_0 = self.input.LA(1)
if (LA4_0 == FLOAT or (INT <= LA4_0 <= LONGINT)
or LA4_0 == NAME or LA4_0 == STRING):
alt4 = 1
if alt4 == 1:
# PyFunc.g:10:19: arguments
pass
self._state.following.append(
self.FOLLOW_arguments_in_parameters65)
self.arguments(args)
self._state.following.pop()
self.match(self.input, RPAREN,
self.FOLLOW_RPAREN_in_parameters69)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "parameters"
# $ANTLR start "arguments"
# PyFunc.g:12:1: arguments : argument ( ',' argument )* ;
def arguments(self, args):
try:
try:
# PyFunc.g:12:11: ( argument ( ',' argument )* )
# PyFunc.g:12:13: argument ( ',' argument )*
pass
self._state.following.append(
self.FOLLOW_argument_in_arguments78)
self.argument(args)
self._state.following.pop()
# PyFunc.g:12:22: ( ',' argument )*
while True: #loop5
alt5 = 2
LA5_0 = self.input.LA(1)
if (LA5_0 == COMMA):
alt5 = 1
if alt5 == 1:
# PyFunc.g:12:23: ',' argument
pass
self.match(self.input, COMMA,
self.FOLLOW_COMMA_in_arguments81)
self._state.following.append(
self.FOLLOW_argument_in_arguments83)
self.argument(args)
self._state.following.pop()
else:
break #loop5
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "arguments"
# $ANTLR start "argument"
# PyFunc.g:14:1: argument : ( var | numeric | string ) ;
def argument(self, args):
try:
try:
# PyFunc.g:14:10: ( ( var | numeric | string ) )
# PyFunc.g:14:12: ( var | numeric | string )
pass
# PyFunc.g:14:12: ( var | numeric | string )
alt6 = 3
LA6 = self.input.LA(1)
if LA6 == NAME:
alt6 = 1
elif LA6 == FLOAT or LA6 == INT or LA6 == LONGINT:
alt6 = 2
elif LA6 == STRING:
alt6 = 3
else:
nvae = NoViableAltException("", 6, 0, self.input)
raise nvae
if alt6 == 1:
# PyFunc.g:14:13: var
pass
self._state.following.append(self.FOLLOW_var_in_argument95)
self.var(args)
self._state.following.pop()
elif alt6 == 2:
# PyFunc.g:14:19: numeric
pass
self._state.following.append(
self.FOLLOW_numeric_in_argument99)
self.numeric(args)
self._state.following.pop()
elif alt6 == 3:
# PyFunc.g:14:29: string
pass
self._state.following.append(
self.FOLLOW_string_in_argument103)
self.string(args)
self._state.following.pop()
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "argument"
# $ANTLR start "asvar"
# PyFunc.g:16:1: asvar : AS NAME ;
def asvar(self, func):
try:
try:
# PyFunc.g:16:7: ( AS NAME )
# PyFunc.g:16:9: AS NAME
pass
self.match(self.input, AS, self.FOLLOW_AS_in_asvar113)
token = self.match(self.input, NAME,
self.FOLLOW_NAME_in_asvar115)
func.alias = token.text
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "asvar"
# $ANTLR start "var"
# PyFunc.g:18:1: var : NAME ;
def var(self, args):
try:
try:
# PyFunc.g:18:5: ( NAME )
# PyFunc.g:18:7: NAME
pass
token = self.match(self.input, NAME,
self.FOLLOW_NAME_in_var124)
args.append(('var', token.text))
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "var"
# $ANTLR start "numeric"
# PyFunc.g:20:1: numeric : ( INT | FLOAT | LONGINT );
def numeric(self, args):
try:
try:
# PyFunc.g:20:9: ( INT | FLOAT | LONGINT )
# PyFunc.g:
pass
if self.input.LA(1) == FLOAT or (INT <= self.input.LA(1) <=
LONGINT):
token = self.input.consume()
args.append(('numeric', token.text))
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "numeric"
# $ANTLR start "string"
# PyFunc.g:23:1: string : STRING ;
def string(self, args):
try:
try:
# PyFunc.g:23:8: ( STRING )
# PyFunc.g:23:10: STRING
pass
token = self.match(self.input, STRING,
self.FOLLOW_STRING_in_string154)
args.append(('string', token.text))
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "string"
FOLLOW_pkgdef_in_pyfunc24 = frozenset([6])
FOLLOW_DOT_in_pyfunc26 = frozenset([14])
FOLLOW_NAME_in_pyfunc30 = frozenset([13])
FOLLOW_parameters_in_pyfunc32 = frozenset([1, 4])
FOLLOW_asvar_in_pyfunc35 = frozenset([1])
FOLLOW_NAME_in_pkgdef46 = frozenset([1, 6])
FOLLOW_DOT_in_pkgdef49 = frozenset([14])
FOLLOW_NAME_in_pkgdef51 = frozenset([1, 6])
FOLLOW_LPAREN_in_parameters62 = frozenset([9, 11, 12, 14, 16, 18])
FOLLOW_arguments_in_parameters65 = frozenset([16])
FOLLOW_RPAREN_in_parameters69 = frozenset([1])
FOLLOW_argument_in_arguments78 = frozenset([1, 5])
FOLLOW_COMMA_in_arguments81 = frozenset([9, 11, 12, 14, 18])
FOLLOW_argument_in_arguments83 = frozenset([1, 5])
FOLLOW_var_in_argument95 = frozenset([1])
FOLLOW_numeric_in_argument99 = frozenset([1])
FOLLOW_string_in_argument103 = frozenset([1])
FOLLOW_AS_in_asvar113 = frozenset([14])
FOLLOW_NAME_in_asvar115 = frozenset([1])
FOLLOW_NAME_in_var124 = frozenset([1])
FOLLOW_STRING_in_string154 = frozenset([1])
class BuildFSM(TreeParser):
grammarFileName = "src/SavedFSM/BuildFSM.g"
antlr_version = version_str_to_tuple("3.1.3 Mar 18, 2009 10:09:25")
antlr_version_str = "3.1.3 Mar 18, 2009 10:09:25"
tokenNames = tokenNames
def __init__(self, input, state=None, *args, **kwargs):
if state is None:
state = RecognizerSharedState()
super(BuildFSM, self).__init__(input, state, *args, **kwargs)
# memory here is used only for logging and debugging purposes.
# We append bebugging information to memory so we can print it later.
self.memory = []
self.roles = []
self.main_fsm = FSMBuilderState()
self.current_fsm = self.main_fsm
# $ANTLR start "description"
# src/SavedFSM/BuildFSM.g:107:1: description : ^( PROTOCOL roleName parameterDefs ( activityDef )+ ) ;
def description(self, ):
try:
try:
# src/SavedFSM/BuildFSM.g:107:12: ( ^( PROTOCOL roleName parameterDefs ( activityDef )+ ) )
# src/SavedFSM/BuildFSM.g:107:14: ^( PROTOCOL roleName parameterDefs ( activityDef )+ )
pass
self.match(self.input, PROTOCOL, self.FOLLOW_PROTOCOL_in_description52)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_roleName_in_description54)
self.roleName()
self._state.following.pop()
self._state.following.append(self.FOLLOW_parameterDefs_in_description56)
self.parameterDefs()
self._state.following.pop()
# src/SavedFSM/BuildFSM.g:107:48: ( activityDef )+
cnt1 = 0
while True: #loop1
alt1 = 2
LA1_0 = self.input.LA(1)
if ((RESV <= LA1_0 <= SEND) or (RECLABEL <= LA1_0 <= PARALLEL) or LA1_0 == GLOBAL_ESCAPE or LA1_0 == 49 or (51 <= LA1_0 <= 52)) :
alt1 = 1
if alt1 == 1:
# src/SavedFSM/BuildFSM.g:107:48: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_description58)
self.activityDef()
self._state.following.pop()
else:
if cnt1 >= 1:
break #loop1
eee = EarlyExitException(1, self.input)
raise eee
cnt1 += 1
self.match(self.input, UP, None)
#action start
#print "ProtocolDefinition"
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "description"
# $ANTLR start "parameterDefs"
# src/SavedFSM/BuildFSM.g:108:1: parameterDefs : ^( ROLES ( roleName )+ ) ;
def parameterDefs(self, ):
try:
try:
# src/SavedFSM/BuildFSM.g:108:14: ( ^( ROLES ( roleName )+ ) )
# src/SavedFSM/BuildFSM.g:108:16: ^( ROLES ( roleName )+ )
pass
self.match(self.input, ROLES, self.FOLLOW_ROLES_in_parameterDefs71)
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:108:24: ( roleName )+
cnt2 = 0
while True: #loop2
alt2 = 2
LA2_0 = self.input.LA(1)
if (LA2_0 == ID) :
alt2 = 1
if alt2 == 1:
# src/SavedFSM/BuildFSM.g:108:24: roleName
pass
self._state.following.append(self.FOLLOW_roleName_in_parameterDefs73)
self.roleName()
self._state.following.pop()
else:
if cnt2 >= 1:
break #loop2
eee = EarlyExitException(2, self.input)
raise eee
cnt2 += 1
self.match(self.input, UP, None)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "parameterDefs"
# $ANTLR start "activityDef"
# src/SavedFSM/BuildFSM.g:109:1: activityDef : ( ^( RESV (rlabel= ID )? ( ^( VALUE ( (val= ID (vtype= ( INT | STRING ) )? ) )* ) ) role= ID ( ^( ASSERT (assertion= ASSERTION )? ) ) ) | ^( SEND (slabel= ID )? ( ^( VALUE ( (val= ID (vtype= ( INT | STRING ) )? ) )* ) ) role= ID ( ^( ASSERT (assertion= ASSERTION )? ) ) ) | ^( 'choice' ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( PARALLEL ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( 'repeat' ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'rec' label= ID ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'RECLABEL' labelID= ID ) | ^( GLOBAL_ESCAPE ( ^( 'do' ( ( activityDef )+ ) ) ) ( ^( 'interrupt' roleName ( ( activityDef )+ ) ) ) ) );
def activityDef(self, ):
rlabel = None
val = None
vtype = None
role = None
assertion = None
slabel = None
label = None
labelID = None
try:
try:
# src/SavedFSM/BuildFSM.g:109:12: ( ^( RESV (rlabel= ID )? ( ^( VALUE ( (val= ID (vtype= ( INT | STRING ) )? ) )* ) ) role= ID ( ^( ASSERT (assertion= ASSERTION )? ) ) ) | ^( SEND (slabel= ID )? ( ^( VALUE ( (val= ID (vtype= ( INT | STRING ) )? ) )* ) ) role= ID ( ^( ASSERT (assertion= ASSERTION )? ) ) ) | ^( 'choice' ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( PARALLEL ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( 'repeat' ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'rec' label= ID ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'RECLABEL' labelID= ID ) | ^( GLOBAL_ESCAPE ( ^( 'do' ( ( activityDef )+ ) ) ) ( ^( 'interrupt' roleName ( ( activityDef )+ ) ) ) ) )
alt19 = 8
LA19 = self.input.LA(1)
if LA19 == RESV:
alt19 = 1
elif LA19 == SEND:
alt19 = 2
elif LA19 == 49:
alt19 = 3
elif LA19 == PARALLEL:
alt19 = 4
elif LA19 == 51:
alt19 = 5
elif LA19 == 52:
alt19 = 6
elif LA19 == RECLABEL:
alt19 = 7
elif LA19 == GLOBAL_ESCAPE:
alt19 = 8
else:
nvae = NoViableAltException("", 19, 0, self.input)
raise nvae
if alt19 == 1:
# src/SavedFSM/BuildFSM.g:110:2: ^( RESV (rlabel= ID )? ( ^( VALUE ( (val= ID (vtype= ( INT | STRING ) )? ) )* ) ) role= ID ( ^( ASSERT (assertion= ASSERTION )? ) ) )
pass
self.match(self.input, RESV, self.FOLLOW_RESV_in_activityDef85)
#action start
local_context = []
label = ''
#action end
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:113:5: (rlabel= ID )?
alt3 = 2
LA3_0 = self.input.LA(1)
if (LA3_0 == ID) :
alt3 = 1
if alt3 == 1:
# src/SavedFSM/BuildFSM.g:113:6: rlabel= ID
pass
rlabel=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef98)
#action start
if (rlabel is not None): label = rlabel.text
self.memory.append('before setting the label:' + label)
#action end
# src/SavedFSM/BuildFSM.g:116:5: ( ^( VALUE ( (val= ID (vtype= ( INT | STRING ) )? ) )* ) )
# src/SavedFSM/BuildFSM.g:116:6: ^( VALUE ( (val= ID (vtype= ( INT | STRING ) )? ) )* )
pass
self.match(self.input, VALUE, self.FOLLOW_VALUE_in_activityDef110)
if self.input.LA(1) == DOWN:
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:116:14: ( (val= ID (vtype= ( INT | STRING ) )? ) )*
while True: #loop5
alt5 = 2
LA5_0 = self.input.LA(1)
if (LA5_0 == ID) :
alt5 = 1
if alt5 == 1:
# src/SavedFSM/BuildFSM.g:116:15: (val= ID (vtype= ( INT | STRING ) )? )
pass
# src/SavedFSM/BuildFSM.g:116:15: (val= ID (vtype= ( INT | STRING ) )? )
# src/SavedFSM/BuildFSM.g:116:16: val= ID (vtype= ( INT | STRING ) )?
pass
val=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef116)
# src/SavedFSM/BuildFSM.g:116:28: (vtype= ( INT | STRING ) )?
alt4 = 2
LA4_0 = self.input.LA(1)
if ((INT <= LA4_0 <= STRING)) :
alt4 = 1
if alt4 == 1:
# src/SavedFSM/BuildFSM.g:116:28: vtype= ( INT | STRING )
pass
vtype = self.input.LT(1)
if (INT <= self.input.LA(1) <= STRING):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
#action start
if ((val is not None) and (vtype is not None)): local_context.append((val.text, vtype.text))
#action end
else:
break #loop5
self.match(self.input, UP, None)
role=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef141)
#action start
if not(role.text in self.roles): self.roles.append(role.text)
#action end
# src/SavedFSM/BuildFSM.g:118:5: ( ^( ASSERT (assertion= ASSERTION )? ) )
# src/SavedFSM/BuildFSM.g:118:6: ^( ASSERT (assertion= ASSERTION )? )
pass
self.match(self.input, ASSERT, self.FOLLOW_ASSERT_in_activityDef151)
if self.input.LA(1) == DOWN:
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:118:15: (assertion= ASSERTION )?
alt6 = 2
LA6_0 = self.input.LA(1)
if (LA6_0 == ASSERTION) :
alt6 = 1
if alt6 == 1:
# src/SavedFSM/BuildFSM.g:118:16: assertion= ASSERTION
pass
assertion=self.match(self.input, ASSERTION, self.FOLLOW_ASSERTION_in_activityDef156)
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
self.memory.append('label is:' + label);
self.current_fsm.add_transition(TransitionFactory.create(LocalType.RESV, label, role), assertion, local_context)
#action end
elif alt19 == 2:
# src/SavedFSM/BuildFSM.g:123:3: ^( SEND (slabel= ID )? ( ^( VALUE ( (val= ID (vtype= ( INT | STRING ) )? ) )* ) ) role= ID ( ^( ASSERT (assertion= ASSERTION )? ) ) )
pass
self.match(self.input, SEND, self.FOLLOW_SEND_in_activityDef169)
#action start
local_context = []
label = ''
#action end
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:126:5: (slabel= ID )?
alt7 = 2
LA7_0 = self.input.LA(1)
if (LA7_0 == ID) :
alt7 = 1
if alt7 == 1:
# src/SavedFSM/BuildFSM.g:126:6: slabel= ID
pass
slabel=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef182)
#action start
self.memory.append('send' + slabel.text)
if (slabel is not None): label = slabel.text
#action end
# src/SavedFSM/BuildFSM.g:129:12: ( ^( VALUE ( (val= ID (vtype= ( INT | STRING ) )? ) )* ) )
# src/SavedFSM/BuildFSM.g:129:13: ^( VALUE ( (val= ID (vtype= ( INT | STRING ) )? ) )* )
pass
self.match(self.input, VALUE, self.FOLLOW_VALUE_in_activityDef201)
if self.input.LA(1) == DOWN:
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:129:21: ( (val= ID (vtype= ( INT | STRING ) )? ) )*
while True: #loop9
alt9 = 2
LA9_0 = self.input.LA(1)
if (LA9_0 == ID) :
alt9 = 1
if alt9 == 1:
# src/SavedFSM/BuildFSM.g:129:22: (val= ID (vtype= ( INT | STRING ) )? )
pass
# src/SavedFSM/BuildFSM.g:129:22: (val= ID (vtype= ( INT | STRING ) )? )
# src/SavedFSM/BuildFSM.g:129:23: val= ID (vtype= ( INT | STRING ) )?
pass
val=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef207)
# src/SavedFSM/BuildFSM.g:129:35: (vtype= ( INT | STRING ) )?
alt8 = 2
LA8_0 = self.input.LA(1)
if ((INT <= LA8_0 <= STRING)) :
alt8 = 1
if alt8 == 1:
# src/SavedFSM/BuildFSM.g:129:35: vtype= ( INT | STRING )
pass
vtype = self.input.LT(1)
if (INT <= self.input.LA(1) <= STRING):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
#action start
if ((val is not None) and (vtype is not None)): local_context.append((val.text, vtype.text))
#action end
else:
break #loop9
self.match(self.input, UP, None)
role=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef236)
#action start
if not(role.text in self.roles): self.roles.append(role.text)
#action end
# src/SavedFSM/BuildFSM.g:131:5: ( ^( ASSERT (assertion= ASSERTION )? ) )
# src/SavedFSM/BuildFSM.g:131:6: ^( ASSERT (assertion= ASSERTION )? )
pass
self.match(self.input, ASSERT, self.FOLLOW_ASSERT_in_activityDef246)
if self.input.LA(1) == DOWN:
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:131:15: (assertion= ASSERTION )?
alt10 = 2
LA10_0 = self.input.LA(1)
if (LA10_0 == ASSERTION) :
alt10 = 1
if alt10 == 1:
# src/SavedFSM/BuildFSM.g:131:16: assertion= ASSERTION
pass
assertion=self.match(self.input, ASSERTION, self.FOLLOW_ASSERTION_in_activityDef251)
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
self.memory.append('In SEND assertion')
#action end
#action start
self.current_fsm.add_transition(TransitionFactory.create(LocalType.SEND, label, role), assertion, local_context)
#action end
elif alt19 == 3:
# src/SavedFSM/BuildFSM.g:136:3: ^( 'choice' ( ^( BRANCH ( activityDef )+ ) )+ )
pass
self.match(self.input, 49, self.FOLLOW_49_in_activityDef270)
#action start
self.memory.append('enter choice state')
self.current_fsm.choice_start_state.append(self.current_fsm.get_current_state())
self.current_fsm.choice_end_state.append(self.current_fsm.state_gen.next())
#action end
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:141:2: ( ^( BRANCH ( activityDef )+ ) )+
cnt12 = 0
while True: #loop12
alt12 = 2
LA12_0 = self.input.LA(1)
if (LA12_0 == BRANCH) :
alt12 = 1
if alt12 == 1:
# src/SavedFSM/BuildFSM.g:141:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef280)
#action start
self.memory.append('enter choice branch and save the current state')
self.current_fsm.move_current_state(self.current_fsm.choice_start_state[-1])
#action end
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:146:4: ( activityDef )+
cnt11 = 0
while True: #loop11
alt11 = 2
LA11_0 = self.input.LA(1)
if ((RESV <= LA11_0 <= SEND) or (RECLABEL <= LA11_0 <= PARALLEL) or LA11_0 == GLOBAL_ESCAPE or LA11_0 == 49 or (51 <= LA11_0 <= 52)) :
alt11 = 1
if alt11 == 1:
# src/SavedFSM/BuildFSM.g:146:4: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef286)
self.activityDef()
self._state.following.pop()
else:
if cnt11 >= 1:
break #loop11
eee = EarlyExitException(11, self.input)
raise eee
cnt11 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('exit choice branch and set the current state to the end state for the choice')
self.current_fsm.fsm.add_transition(self.current_fsm.fsm.EMPTY_TRANSITION, self.current_fsm.get_current_state(), self.current_fsm.choice_end_state[-1])
#action end
else:
if cnt12 >= 1:
break #loop12
eee = EarlyExitException(12, self.input)
raise eee
cnt12 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('set the current state to be equal to the end state for the choice')
self.current_fsm.move_current_state(self.current_fsm.choice_end_state[-1])
self.current_fsm.choice_end_state.pop()
self.current_fsm.choice_start_state.pop()
#action end
elif alt19 == 4:
# src/SavedFSM/BuildFSM.g:158:4: ^( PARALLEL ( ^( BRANCH ( activityDef )+ ) )+ )
pass
self.match(self.input, PARALLEL, self.FOLLOW_PARALLEL_in_activityDef305)
#action start
self.memory.append('enter parallel state')
self.parallel_root = self.current_fsm
#action end
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:163:2: ( ^( BRANCH ( activityDef )+ ) )+
cnt14 = 0
while True: #loop14
alt14 = 2
LA14_0 = self.input.LA(1)
if (LA14_0 == BRANCH) :
alt14 = 1
if alt14 == 1:
# src/SavedFSM/BuildFSM.g:163:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef322)
#action start
self.memory.append('enter parallel branch')
nested_fsm = FSMBuilderState(self.parallel_root)
self.parallel_root.fsm.add_fsm_to_memory(self.parallel_root.get_current_state(), nested_fsm.fsm)
self.current_fsm = nested_fsm
#action end
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:170:2: ( activityDef )+
cnt13 = 0
while True: #loop13
alt13 = 2
LA13_0 = self.input.LA(1)
if ((RESV <= LA13_0 <= SEND) or (RECLABEL <= LA13_0 <= PARALLEL) or LA13_0 == GLOBAL_ESCAPE or LA13_0 == 49 or (51 <= LA13_0 <= 52)) :
alt13 = 1
if alt13 == 1:
# src/SavedFSM/BuildFSM.g:170:3: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef331)
self.activityDef()
self._state.following.pop()
else:
if cnt13 >= 1:
break #loop13
eee = EarlyExitException(13, self.input)
raise eee
cnt13 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('exit parallel branch')
self.current_fsm.add_transition(self.current_fsm.fsm.END_PAR_TRANSITION)
#action end
else:
if cnt14 >= 1:
break #loop14
eee = EarlyExitException(14, self.input)
raise eee
cnt14 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('exit parallel state')
self.current_fsm = self.current_fsm.parent
self.current_fsm.fsm.add_transition(self.current_fsm.fsm.EMPTY_TRANSITION, self.current_fsm.get_current_state(), self.current_fsm.move_current_state())
#action end
elif alt19 == 5:
# src/SavedFSM/BuildFSM.g:180:3: ^( 'repeat' ( ^( BRANCH ( activityDef )+ ) ) )
pass
self.match(self.input, 51, self.FOLLOW_51_in_activityDef352)
#action start
self.memory.append('enter repeat state')
#action end
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:182:2: ( ^( BRANCH ( activityDef )+ ) )
# src/SavedFSM/BuildFSM.g:182:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef361)
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:182:12: ( activityDef )+
cnt15 = 0
while True: #loop15
alt15 = 2
LA15_0 = self.input.LA(1)
if ((RESV <= LA15_0 <= SEND) or (RECLABEL <= LA15_0 <= PARALLEL) or LA15_0 == GLOBAL_ESCAPE or LA15_0 == 49 or (51 <= LA15_0 <= 52)) :
alt15 = 1
if alt15 == 1:
# src/SavedFSM/BuildFSM.g:182:13: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef364)
self.activityDef()
self._state.following.pop()
#action start
self.memory.append('repeat statement')
#action end
else:
if cnt15 >= 1:
break #loop15
eee = EarlyExitException(15, self.input)
raise eee
cnt15 += 1
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
self.memory.append('exit repeat state')
#action end
elif alt19 == 6:
# src/SavedFSM/BuildFSM.g:185:10: ^( 'rec' label= ID ( ^( BRANCH ( activityDef )+ ) ) )
pass
self.match(self.input, 52, self.FOLLOW_52_in_activityDef388)
self.match(self.input, DOWN, None)
label=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef394)
#action start
self.memory.append('enter rec state ' + label.text + str(self.current_fsm.get_current_state()))
self.current_fsm.recursions_states.setdefault(label.text, (self.current_fsm.format_state_name(self.current_fsm.get_current_state()), True))
#action end
# src/SavedFSM/BuildFSM.g:189:2: ( ^( BRANCH ( activityDef )+ ) )
# src/SavedFSM/BuildFSM.g:189:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef410)
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:189:12: ( activityDef )+
cnt16 = 0
while True: #loop16
alt16 = 2
LA16_0 = self.input.LA(1)
if ((RESV <= LA16_0 <= SEND) or (RECLABEL <= LA16_0 <= PARALLEL) or LA16_0 == GLOBAL_ESCAPE or LA16_0 == 49 or (51 <= LA16_0 <= 52)) :
alt16 = 1
if alt16 == 1:
# src/SavedFSM/BuildFSM.g:189:13: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef413)
self.activityDef()
self._state.following.pop()
#action start
self.memory.append('rec statement')
#action end
else:
if cnt16 >= 1:
break #loop16
eee = EarlyExitException(16, self.input)
raise eee
cnt16 += 1
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
(start_state, isActive) = self.current_fsm.recursions_states.get(label.text)
self.memory.append('exit rec state ' + label.text + 'start_state' + str(start_state))
self.current_fsm.recursions_states[label.text] = (start_state, False)
#action end
elif alt19 == 7:
# src/SavedFSM/BuildFSM.g:196:3: ^( 'RECLABEL' labelID= ID )
pass
self.match(self.input, RECLABEL, self.FOLLOW_RECLABEL_in_activityDef431)
self.match(self.input, DOWN, None)
labelID=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef438)
#action start
(start_rec_state, isActive) = self.current_fsm.recursions_states.get(labelID.text)
self.memory.append('rec label:' + labelID.text + 'starts from state:' + str(start_rec_state))
if isActive:
self.current_fsm.fsm.add_transition(self.current_fsm.fsm.EMPTY_TRANSITION,
self.current_fsm.format_state_name(self.current_fsm.get_current_state()),
start_rec_state)
# Generate unreachable state for the choice construct
self.current_fsm.move_current_state()
else: raise ExceptionFSM('Calling a recusrion label from a recursion that is not valid')
#action end
self.match(self.input, UP, None)
#action start
# Do not need it for no
#self.current_fsm.fsm.copy_transitions(self.current_fsm.recursions_states[labelID.text], self.current_fsm.get_current_state())
#action end
elif alt19 == 8:
# src/SavedFSM/BuildFSM.g:213:3: ^( GLOBAL_ESCAPE ( ^( 'do' ( ( activityDef )+ ) ) ) ( ^( 'interrupt' roleName ( ( activityDef )+ ) ) ) )
pass
self.match(self.input, GLOBAL_ESCAPE, self.FOLLOW_GLOBAL_ESCAPE_in_activityDef452)
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:214:5: ( ^( 'do' ( ( activityDef )+ ) ) )
# src/SavedFSM/BuildFSM.g:214:6: ^( 'do' ( ( activityDef )+ ) )
pass
self.match(self.input, 58, self.FOLLOW_58_in_activityDef461)
self.match(self.input, DOWN, None)
# src/SavedFSM/BuildFSM.g:214:13: ( ( activityDef )+ )
# src/SavedFSM/BuildFSM.g:214:14: ( activityDef )+
pass
# src/SavedFSM/BuildFSM.g:214:14: ( activityDef )+
cnt17 = 0
while True: #loop17
alt17 = 2
LA17_0 = self.input.LA(1)
if ((RESV <= LA17_0 <= SEND) or (RECLABEL <= LA17_0 <= PARALLEL) or LA17_0 == GLOBAL_ESCAPE or LA17_0 == 49 or (51 <= LA17_0 <= 52)) :
alt17 = 1
if alt17 == 1:
# src/SavedFSM/BuildFSM.g:214:14: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef464)
self.activityDef()
self._state.following.pop()
else:
if cnt17 >= 1:
break #loop17
eee = EarlyExitException(17, self.input)
raise eee
cnt17 += 1
#action start
self.current_fsm.fsm.final_state = self.current_fsm.get_current_state()
#action end
self.match(self.input, UP, None)
# src/SavedFSM/BuildFSM.g:215:5: ( ^( 'interrupt' roleName ( ( activityDef )+ ) ) )
# src/SavedFSM/BuildFSM.g:215:6: ^( 'interrupt' roleName ( ( activityDef )+ ) )
pass
self.match(self.input, 59, self.FOLLOW_59_in_activityDef477)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_roleName_in_activityDef479)
self.roleName()
self._state.following.pop()
#action start
self.memory.append('before setting interrupt_transition to True')
self.current_fsm.interrupt_start_state = self.current_fsm.move_current_state()
self.current_fsm.set_interrupt_transition = True
#action end
# src/SavedFSM/BuildFSM.g:218:56: ( ( activityDef )+ )
# src/SavedFSM/BuildFSM.g:218:57: ( activityDef )+
pass
# src/SavedFSM/BuildFSM.g:218:57: ( activityDef )+
cnt18 = 0
while True: #loop18
alt18 = 2
LA18_0 = self.input.LA(1)
if ((RESV <= LA18_0 <= SEND) or (RECLABEL <= LA18_0 <= PARALLEL) or LA18_0 == GLOBAL_ESCAPE or LA18_0 == 49 or (51 <= LA18_0 <= 52)) :
alt18 = 1
if alt18 == 1:
# src/SavedFSM/BuildFSM.g:218:57: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef488)
self.activityDef()
self._state.following.pop()
else:
if cnt18 >= 1:
break #loop18
eee = EarlyExitException(18, self.input)
raise eee
cnt18 += 1
self.match(self.input, UP, None)
self.match(self.input, UP, None)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "activityDef"
# $ANTLR start "roleName"
# src/SavedFSM/BuildFSM.g:220:1: roleName : role= ID ;
def roleName(self, ):
role = None
try:
try:
# src/SavedFSM/BuildFSM.g:220:9: (role= ID )
# src/SavedFSM/BuildFSM.g:220:11: role= ID
pass
role=self.match(self.input, ID, self.FOLLOW_ID_in_roleName505)
#action start
if not(role.text in self.roles):
self.roles.append(role.text)
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "roleName"
# $ANTLR start "labelName"
# src/SavedFSM/BuildFSM.g:223:1: labelName : ID ;
def labelName(self, ):
try:
try:
# src/SavedFSM/BuildFSM.g:223:10: ( ID )
# src/SavedFSM/BuildFSM.g:223:12: ID
pass
self.match(self.input, ID, self.FOLLOW_ID_in_labelName513)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "labelName"
# $ANTLR start "roleDef"
# src/SavedFSM/BuildFSM.g:224:1: roleDef : ID ;
def roleDef(self, ):
try:
try:
# src/SavedFSM/BuildFSM.g:224:8: ( ID )
# src/SavedFSM/BuildFSM.g:224:10: ID
pass
self.match(self.input, ID, self.FOLLOW_ID_in_roleDef519)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "roleDef"
# $ANTLR start "primitivetype"
# src/SavedFSM/BuildFSM.g:225:1: primitivetype : INT ;
def primitivetype(self, ):
try:
try:
# src/SavedFSM/BuildFSM.g:225:15: ( INT )
# src/SavedFSM/BuildFSM.g:225:16: INT
pass
self.match(self.input, INT, self.FOLLOW_INT_in_primitivetype525)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "primitivetype"
# Delegated rules
FOLLOW_PROTOCOL_in_description52 = frozenset([2])
FOLLOW_roleName_in_description54 = frozenset([24])
FOLLOW_parameterDefs_in_description56 = frozenset([12, 13, 18, 19, 22, 49, 51, 52])
FOLLOW_activityDef_in_description58 = frozenset([3, 12, 13, 18, 19, 22, 49, 51, 52])
FOLLOW_ROLES_in_parameterDefs71 = frozenset([2])
FOLLOW_roleName_in_parameterDefs73 = frozenset([3, 26])
FOLLOW_RESV_in_activityDef85 = frozenset([2])
FOLLOW_ID_in_activityDef98 = frozenset([15])
FOLLOW_VALUE_in_activityDef110 = frozenset([2])
FOLLOW_ID_in_activityDef116 = frozenset([3, 5, 6, 26])
FOLLOW_set_in_activityDef120 = frozenset([3, 26])
FOLLOW_ID_in_activityDef141 = frozenset([21])
FOLLOW_ASSERT_in_activityDef151 = frozenset([2])
FOLLOW_ASSERTION_in_activityDef156 = frozenset([3])
FOLLOW_SEND_in_activityDef169 = frozenset([2])
FOLLOW_ID_in_activityDef182 = frozenset([15])
FOLLOW_VALUE_in_activityDef201 = frozenset([2])
FOLLOW_ID_in_activityDef207 = frozenset([3, 5, 6, 26])
FOLLOW_set_in_activityDef212 = frozenset([3, 26])
FOLLOW_ID_in_activityDef236 = frozenset([21])
FOLLOW_ASSERT_in_activityDef246 = frozenset([2])
FOLLOW_ASSERTION_in_activityDef251 = frozenset([3])
FOLLOW_49_in_activityDef270 = frozenset([2])
FOLLOW_BRANCH_in_activityDef280 = frozenset([2])
FOLLOW_activityDef_in_activityDef286 = frozenset([3, 12, 13, 18, 19, 22, 49, 51, 52])
FOLLOW_PARALLEL_in_activityDef305 = frozenset([2])
FOLLOW_BRANCH_in_activityDef322 = frozenset([2])
FOLLOW_activityDef_in_activityDef331 = frozenset([3, 12, 13, 18, 19, 22, 49, 51, 52])
FOLLOW_51_in_activityDef352 = frozenset([2])
FOLLOW_BRANCH_in_activityDef361 = frozenset([2])
FOLLOW_activityDef_in_activityDef364 = frozenset([3, 12, 13, 18, 19, 22, 49, 51, 52])
FOLLOW_52_in_activityDef388 = frozenset([2])
FOLLOW_ID_in_activityDef394 = frozenset([16])
FOLLOW_BRANCH_in_activityDef410 = frozenset([2])
FOLLOW_activityDef_in_activityDef413 = frozenset([3, 12, 13, 18, 19, 22, 49, 51, 52])
FOLLOW_RECLABEL_in_activityDef431 = frozenset([2])
FOLLOW_ID_in_activityDef438 = frozenset([3])
FOLLOW_GLOBAL_ESCAPE_in_activityDef452 = frozenset([2])
FOLLOW_58_in_activityDef461 = frozenset([2])
FOLLOW_activityDef_in_activityDef464 = frozenset([3, 12, 13, 18, 19, 22, 49, 51, 52])
FOLLOW_59_in_activityDef477 = frozenset([2])
FOLLOW_roleName_in_activityDef479 = frozenset([12, 13, 18, 19, 22, 49, 51, 52])
FOLLOW_activityDef_in_activityDef488 = frozenset([3, 12, 13, 18, 19, 22, 49, 51, 52])
FOLLOW_ID_in_roleName505 = frozenset([1])
FOLLOW_ID_in_labelName513 = frozenset([1])
FOLLOW_ID_in_roleDef519 = frozenset([1])
FOLLOW_INT_in_primitivetype525 = frozenset([1])
class GrocParser(Parser):
grammarFileName = "borg/borgcron/py/Groc.g"
antlr_version = version_str_to_tuple("3.1.1")
antlr_version_str = "3.1.1"
tokenNames = tokenNames
def __init__(self, input, state=None):
if state is None:
state = RecognizerSharedState()
Parser.__init__(self, input, state)
self.dfa4 = self.DFA4(self,
4,
eot=self.DFA4_eot,
eof=self.DFA4_eof,
min=self.DFA4_min,
max=self.DFA4_max,
accept=self.DFA4_accept,
special=self.DFA4_special,
transition=self.DFA4_transition)
self.ordinal_set = set()
self.weekday_set = set()
self.month_set = set()
self.monthday_set = set()
self.time_string = ''
self.interval_mins = 0
self.period_string = ''
self.synchronized = False
self.start_time_string = ''
self.end_time_string = ''
valuesDict = {
SUNDAY: 0,
FIRST: 1,
MONDAY: 1,
JANUARY: 1,
TUESDAY: 2,
SECOND: 2,
FEBRUARY: 2,
WEDNESDAY: 3,
THIRD: 3,
MARCH: 3,
THURSDAY: 4,
FOURTH: 4,
APRIL: 4,
FRIDAY: 5,
FIFTH: 5,
MAY: 5,
SATURDAY: 6,
JUNE: 6,
JULY: 7,
AUGUST: 8,
SEPTEMBER: 9,
OCTOBER: 10,
NOVEMBER: 11,
DECEMBER: 12,
}
# Convert date tokens to int representations of properties.
def ValueOf(self, token_type):
return self.valuesDict.get(token_type, -1)
# $ANTLR start "timespec"
# borg/borgcron/py/Groc.g:92:1: timespec : ( specifictime | interval ) EOF ;
def timespec(self, ):
try:
try:
# borg/borgcron/py/Groc.g:93:3: ( ( specifictime | interval ) EOF )
# borg/borgcron/py/Groc.g:93:5: ( specifictime | interval ) EOF
pass
# borg/borgcron/py/Groc.g:93:5: ( specifictime | interval )
alt1 = 2
LA1_0 = self.input.LA(1)
if (LA1_0 == EVERY):
LA1_1 = self.input.LA(2)
if ((DIGIT <= LA1_1 <= DIGITS)):
alt1 = 2
elif ((DAY <= LA1_1 <= SUNDAY)):
alt1 = 1
else:
nvae = NoViableAltException("", 1, 1, self.input)
raise nvae
elif ((DIGIT <= LA1_0 <= DIGITS)
or (FIRST <= LA1_0 <= FOURTH_OR_FIFTH)):
alt1 = 1
else:
nvae = NoViableAltException("", 1, 0, self.input)
raise nvae
if alt1 == 1:
# borg/borgcron/py/Groc.g:93:7: specifictime
pass
self._state.following.append(
self.FOLLOW_specifictime_in_timespec44)
self.specifictime()
self._state.following.pop()
elif alt1 == 2:
# borg/borgcron/py/Groc.g:93:22: interval
pass
self._state.following.append(
self.FOLLOW_interval_in_timespec48)
self.interval()
self._state.following.pop()
self.match(self.input, EOF, self.FOLLOW_EOF_in_timespec52)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "timespec"
# $ANTLR start "specifictime"
# borg/borgcron/py/Groc.g:96:1: specifictime : ( ( ( ( ( ordinals weekdays ) | monthdays ) OF ( monthspec | quarterspec ) ) | ( ordinals weekdays ) ) TIME ) ;
def specifictime(self, ):
TIME1 = None
try:
try:
# borg/borgcron/py/Groc.g:97:3: ( ( ( ( ( ( ordinals weekdays ) | monthdays ) OF ( monthspec | quarterspec ) ) | ( ordinals weekdays ) ) TIME ) )
# borg/borgcron/py/Groc.g:97:5: ( ( ( ( ( ordinals weekdays ) | monthdays ) OF ( monthspec | quarterspec ) ) | ( ordinals weekdays ) ) TIME )
pass
# borg/borgcron/py/Groc.g:97:5: ( ( ( ( ( ordinals weekdays ) | monthdays ) OF ( monthspec | quarterspec ) ) | ( ordinals weekdays ) ) TIME )
# borg/borgcron/py/Groc.g:97:7: ( ( ( ( ordinals weekdays ) | monthdays ) OF ( monthspec | quarterspec ) ) | ( ordinals weekdays ) ) TIME
pass
# borg/borgcron/py/Groc.g:97:7: ( ( ( ( ordinals weekdays ) | monthdays ) OF ( monthspec | quarterspec ) ) | ( ordinals weekdays ) )
alt4 = 2
alt4 = self.dfa4.predict(self.input)
if alt4 == 1:
# borg/borgcron/py/Groc.g:97:8: ( ( ( ordinals weekdays ) | monthdays ) OF ( monthspec | quarterspec ) )
pass
# borg/borgcron/py/Groc.g:97:8: ( ( ( ordinals weekdays ) | monthdays ) OF ( monthspec | quarterspec ) )
# borg/borgcron/py/Groc.g:97:10: ( ( ordinals weekdays ) | monthdays ) OF ( monthspec | quarterspec )
pass
# borg/borgcron/py/Groc.g:97:10: ( ( ordinals weekdays ) | monthdays )
alt2 = 2
LA2_0 = self.input.LA(1)
if (LA2_0 == EVERY or (FIRST <= LA2_0 <= FOURTH_OR_FIFTH)):
alt2 = 1
elif ((DIGIT <= LA2_0 <= DIGITS)):
alt2 = 2
else:
nvae = NoViableAltException("", 2, 0, self.input)
raise nvae
if alt2 == 1:
# borg/borgcron/py/Groc.g:97:11: ( ordinals weekdays )
pass
# borg/borgcron/py/Groc.g:97:11: ( ordinals weekdays )
# borg/borgcron/py/Groc.g:97:12: ordinals weekdays
pass
self._state.following.append(
self.FOLLOW_ordinals_in_specifictime72)
self.ordinals()
self._state.following.pop()
self._state.following.append(
self.FOLLOW_weekdays_in_specifictime74)
self.weekdays()
self._state.following.pop()
elif alt2 == 2:
# borg/borgcron/py/Groc.g:97:31: monthdays
pass
self._state.following.append(
self.FOLLOW_monthdays_in_specifictime77)
self.monthdays()
self._state.following.pop()
self.match(self.input, OF,
self.FOLLOW_OF_in_specifictime80)
# borg/borgcron/py/Groc.g:97:45: ( monthspec | quarterspec )
alt3 = 2
LA3_0 = self.input.LA(1)
if ((MONTH <= LA3_0 <= DECEMBER)):
alt3 = 1
elif ((FIRST <= LA3_0 <= THIRD) or LA3_0 == QUARTER):
alt3 = 2
else:
nvae = NoViableAltException("", 3, 0, self.input)
raise nvae
if alt3 == 1:
# borg/borgcron/py/Groc.g:97:46: monthspec
pass
self._state.following.append(
self.FOLLOW_monthspec_in_specifictime83)
self.monthspec()
self._state.following.pop()
elif alt3 == 2:
# borg/borgcron/py/Groc.g:97:56: quarterspec
pass
self._state.following.append(
self.FOLLOW_quarterspec_in_specifictime85)
self.quarterspec()
self._state.following.pop()
elif alt4 == 2:
# borg/borgcron/py/Groc.g:98:11: ( ordinals weekdays )
pass
# borg/borgcron/py/Groc.g:98:11: ( ordinals weekdays )
# borg/borgcron/py/Groc.g:98:12: ordinals weekdays
pass
self._state.following.append(
self.FOLLOW_ordinals_in_specifictime101)
self.ordinals()
self._state.following.pop()
self._state.following.append(
self.FOLLOW_weekdays_in_specifictime103)
self.weekdays()
self._state.following.pop()
#action start
self.month_set = set(range(1, 13))
#action end
TIME1 = self.match(self.input, TIME,
self.FOLLOW_TIME_in_specifictime117)
#action start
self.time_string = TIME1.text
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "specifictime"
# $ANTLR start "interval"
# borg/borgcron/py/Groc.g:102:1: interval : ( EVERY intervalnum= ( DIGIT | DIGITS ) period ( time_range | ( SYNCHRONIZED ) )? ) ;
def interval(self, ):
intervalnum = None
period2 = None
try:
try:
# borg/borgcron/py/Groc.g:103:3: ( ( EVERY intervalnum= ( DIGIT | DIGITS ) period ( time_range | ( SYNCHRONIZED ) )? ) )
# borg/borgcron/py/Groc.g:103:5: ( EVERY intervalnum= ( DIGIT | DIGITS ) period ( time_range | ( SYNCHRONIZED ) )? )
pass
# borg/borgcron/py/Groc.g:103:5: ( EVERY intervalnum= ( DIGIT | DIGITS ) period ( time_range | ( SYNCHRONIZED ) )? )
# borg/borgcron/py/Groc.g:103:7: EVERY intervalnum= ( DIGIT | DIGITS ) period ( time_range | ( SYNCHRONIZED ) )?
pass
self.match(self.input, EVERY, self.FOLLOW_EVERY_in_interval136)
intervalnum = self.input.LT(1)
if (DIGIT <= self.input.LA(1) <= DIGITS):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
#action start
self.interval_mins = int(intervalnum.text)
#action end
self._state.following.append(self.FOLLOW_period_in_interval164)
period2 = self.period()
self._state.following.pop()
#action start
if ((period2 is not None)
and [self.input.toString(period2.start, period2.stop)]
or [None])[0] == "hours":
self.period_string = "hours"
else:
self.period_string = "minutes"
#action end
# borg/borgcron/py/Groc.g:113:7: ( time_range | ( SYNCHRONIZED ) )?
alt5 = 3
LA5_0 = self.input.LA(1)
if (LA5_0 == FROM):
alt5 = 1
elif (LA5_0 == SYNCHRONIZED):
alt5 = 2
if alt5 == 1:
# borg/borgcron/py/Groc.g:113:9: time_range
pass
self._state.following.append(
self.FOLLOW_time_range_in_interval176)
self.time_range()
self._state.following.pop()
elif alt5 == 2:
# borg/borgcron/py/Groc.g:114:9: ( SYNCHRONIZED )
pass
# borg/borgcron/py/Groc.g:114:9: ( SYNCHRONIZED )
# borg/borgcron/py/Groc.g:114:10: SYNCHRONIZED
pass
self.match(self.input, SYNCHRONIZED,
self.FOLLOW_SYNCHRONIZED_in_interval189)
#action start
self.synchronized = True
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "interval"
# $ANTLR start "ordinals"
# borg/borgcron/py/Groc.g:118:1: ordinals : ( EVERY | ( ordinal ( COMMA ordinal )* ) ) ;
def ordinals(self, ):
try:
try:
# borg/borgcron/py/Groc.g:119:3: ( ( EVERY | ( ordinal ( COMMA ordinal )* ) ) )
# borg/borgcron/py/Groc.g:119:5: ( EVERY | ( ordinal ( COMMA ordinal )* ) )
pass
# borg/borgcron/py/Groc.g:119:5: ( EVERY | ( ordinal ( COMMA ordinal )* ) )
alt7 = 2
LA7_0 = self.input.LA(1)
if (LA7_0 == EVERY):
alt7 = 1
elif ((FIRST <= LA7_0 <= FOURTH_OR_FIFTH)):
alt7 = 2
else:
nvae = NoViableAltException("", 7, 0, self.input)
raise nvae
if alt7 == 1:
# borg/borgcron/py/Groc.g:119:7: EVERY
pass
self.match(self.input, EVERY,
self.FOLLOW_EVERY_in_ordinals218)
elif alt7 == 2:
# borg/borgcron/py/Groc.g:120:5: ( ordinal ( COMMA ordinal )* )
pass
# borg/borgcron/py/Groc.g:120:5: ( ordinal ( COMMA ordinal )* )
# borg/borgcron/py/Groc.g:120:7: ordinal ( COMMA ordinal )*
pass
self._state.following.append(
self.FOLLOW_ordinal_in_ordinals226)
self.ordinal()
self._state.following.pop()
# borg/borgcron/py/Groc.g:120:15: ( COMMA ordinal )*
while True: #loop6
alt6 = 2
LA6_0 = self.input.LA(1)
if (LA6_0 == COMMA):
alt6 = 1
if alt6 == 1:
# borg/borgcron/py/Groc.g:120:16: COMMA ordinal
pass
self.match(self.input, COMMA,
self.FOLLOW_COMMA_in_ordinals229)
self._state.following.append(
self.FOLLOW_ordinal_in_ordinals231)
self.ordinal()
self._state.following.pop()
else:
break #loop6
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "ordinals"
# $ANTLR start "ordinal"
# borg/borgcron/py/Groc.g:123:1: ordinal : ord= ( FIRST | SECOND | THIRD | FOURTH | FIFTH | FOURTH_OR_FIFTH ) ;
def ordinal(self, ):
ord = None
try:
try:
# borg/borgcron/py/Groc.g:124:3: (ord= ( FIRST | SECOND | THIRD | FOURTH | FIFTH | FOURTH_OR_FIFTH ) )
# borg/borgcron/py/Groc.g:124:5: ord= ( FIRST | SECOND | THIRD | FOURTH | FIFTH | FOURTH_OR_FIFTH )
pass
ord = self.input.LT(1)
if (FIRST <= self.input.LA(1) <= FOURTH_OR_FIFTH):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
#action start
self.ordinal_set.add(self.ValueOf(ord.type))
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "ordinal"
class period_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
# $ANTLR start "period"
# borg/borgcron/py/Groc.g:129:1: period : ( HOURS | MINUTES ) ;
def period(self, ):
retval = self.period_return()
retval.start = self.input.LT(1)
try:
try:
# borg/borgcron/py/Groc.g:130:3: ( ( HOURS | MINUTES ) )
# borg/borgcron/py/Groc.g:130:5: ( HOURS | MINUTES )
pass
if (HOURS <= self.input.LA(1) <= MINUTES):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
retval.stop = self.input.LT(-1)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end "period"
# $ANTLR start "monthdays"
# borg/borgcron/py/Groc.g:133:1: monthdays : ( monthday ( COMMA monthday )* ) ;
def monthdays(self, ):
try:
try:
# borg/borgcron/py/Groc.g:134:3: ( ( monthday ( COMMA monthday )* ) )
# borg/borgcron/py/Groc.g:134:5: ( monthday ( COMMA monthday )* )
pass
# borg/borgcron/py/Groc.g:134:5: ( monthday ( COMMA monthday )* )
# borg/borgcron/py/Groc.g:134:7: monthday ( COMMA monthday )*
pass
self._state.following.append(
self.FOLLOW_monthday_in_monthdays314)
self.monthday()
self._state.following.pop()
# borg/borgcron/py/Groc.g:134:16: ( COMMA monthday )*
while True: #loop8
alt8 = 2
LA8_0 = self.input.LA(1)
if (LA8_0 == COMMA):
alt8 = 1
if alt8 == 1:
# borg/borgcron/py/Groc.g:134:18: COMMA monthday
pass
self.match(self.input, COMMA,
self.FOLLOW_COMMA_in_monthdays318)
self._state.following.append(
self.FOLLOW_monthday_in_monthdays320)
self.monthday()
self._state.following.pop()
else:
break #loop8
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "monthdays"
# $ANTLR start "monthday"
# borg/borgcron/py/Groc.g:137:1: monthday : day= ( DIGIT | DIGITS ) ;
def monthday(self, ):
day = None
try:
try:
# borg/borgcron/py/Groc.g:138:3: (day= ( DIGIT | DIGITS ) )
# borg/borgcron/py/Groc.g:138:5: day= ( DIGIT | DIGITS )
pass
day = self.input.LT(1)
if (DIGIT <= self.input.LA(1) <= DIGITS):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
#action start
self.monthday_set.add(int(day.text))
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "monthday"
# $ANTLR start "weekdays"
# borg/borgcron/py/Groc.g:142:1: weekdays : ( DAY | ( weekday ( COMMA weekday )* ) ) ;
def weekdays(self, ):
try:
try:
# borg/borgcron/py/Groc.g:143:3: ( ( DAY | ( weekday ( COMMA weekday )* ) ) )
# borg/borgcron/py/Groc.g:143:5: ( DAY | ( weekday ( COMMA weekday )* ) )
pass
# borg/borgcron/py/Groc.g:143:5: ( DAY | ( weekday ( COMMA weekday )* ) )
alt10 = 2
LA10_0 = self.input.LA(1)
if (LA10_0 == DAY):
alt10 = 1
elif ((MONDAY <= LA10_0 <= SUNDAY)):
alt10 = 2
else:
nvae = NoViableAltException("", 10, 0, self.input)
raise nvae
if alt10 == 1:
# borg/borgcron/py/Groc.g:143:7: DAY
pass
self.match(self.input, DAY, self.FOLLOW_DAY_in_weekdays365)
#action start
if self.ordinal_set:
# <ordinal> day means <ordinal> day of the month,
# not every day of the <ordinal> week.
self.monthday_set = self.ordinal_set
self.ordinal_set = set()
else:
self.ordinal_set = self.ordinal_set.union(allOrdinals)
self.weekday_set = set([
self.ValueOf(SUNDAY),
self.ValueOf(MONDAY),
self.ValueOf(TUESDAY),
self.ValueOf(WEDNESDAY),
self.ValueOf(THURSDAY),
self.ValueOf(FRIDAY),
self.ValueOf(SATURDAY),
self.ValueOf(SUNDAY)
])
#action end
elif alt10 == 2:
# borg/borgcron/py/Groc.g:155:11: ( weekday ( COMMA weekday )* )
pass
# borg/borgcron/py/Groc.g:155:11: ( weekday ( COMMA weekday )* )
# borg/borgcron/py/Groc.g:155:13: weekday ( COMMA weekday )*
pass
self._state.following.append(
self.FOLLOW_weekday_in_weekdays373)
self.weekday()
self._state.following.pop()
# borg/borgcron/py/Groc.g:155:21: ( COMMA weekday )*
while True: #loop9
alt9 = 2
LA9_0 = self.input.LA(1)
if (LA9_0 == COMMA):
alt9 = 1
if alt9 == 1:
# borg/borgcron/py/Groc.g:155:22: COMMA weekday
pass
self.match(self.input, COMMA,
self.FOLLOW_COMMA_in_weekdays376)
self._state.following.append(
self.FOLLOW_weekday_in_weekdays378)
self.weekday()
self._state.following.pop()
else:
break #loop9
#action start
if not self.ordinal_set:
self.ordinal_set = self.ordinal_set.union(allOrdinals)
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "weekdays"
# $ANTLR start "weekday"
# borg/borgcron/py/Groc.g:161:1: weekday : dayname= ( MONDAY | TUESDAY | WEDNESDAY | THURSDAY | FRIDAY | SATURDAY | SUNDAY ) ;
def weekday(self, ):
dayname = None
try:
try:
# borg/borgcron/py/Groc.g:162:3: (dayname= ( MONDAY | TUESDAY | WEDNESDAY | THURSDAY | FRIDAY | SATURDAY | SUNDAY ) )
# borg/borgcron/py/Groc.g:162:5: dayname= ( MONDAY | TUESDAY | WEDNESDAY | THURSDAY | FRIDAY | SATURDAY | SUNDAY )
pass
dayname = self.input.LT(1)
if (MONDAY <= self.input.LA(1) <= SUNDAY):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
#action start
self.weekday_set.add(self.ValueOf(dayname.type))
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "weekday"
# $ANTLR start "monthspec"
# borg/borgcron/py/Groc.g:168:1: monthspec : ( MONTH | months ) ;
def monthspec(self, ):
try:
try:
# borg/borgcron/py/Groc.g:169:3: ( ( MONTH | months ) )
# borg/borgcron/py/Groc.g:169:5: ( MONTH | months )
pass
# borg/borgcron/py/Groc.g:169:5: ( MONTH | months )
alt11 = 2
LA11_0 = self.input.LA(1)
if (LA11_0 == MONTH):
alt11 = 1
elif ((JANUARY <= LA11_0 <= DECEMBER)):
alt11 = 2
else:
nvae = NoViableAltException("", 11, 0, self.input)
raise nvae
if alt11 == 1:
# borg/borgcron/py/Groc.g:169:7: MONTH
pass
self.match(self.input, MONTH,
self.FOLLOW_MONTH_in_monthspec459)
#action start
self.month_set = self.month_set.union(
set([
self.ValueOf(JANUARY),
self.ValueOf(FEBRUARY),
self.ValueOf(MARCH),
self.ValueOf(APRIL),
self.ValueOf(MAY),
self.ValueOf(JUNE),
self.ValueOf(JULY),
self.ValueOf(AUGUST),
self.ValueOf(SEPTEMBER),
self.ValueOf(OCTOBER),
self.ValueOf(NOVEMBER),
self.ValueOf(DECEMBER)
]))
#action end
elif alt11 == 2:
# borg/borgcron/py/Groc.g:177:7: months
pass
self._state.following.append(
self.FOLLOW_months_in_monthspec469)
self.months()
self._state.following.pop()
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "monthspec"
# $ANTLR start "months"
# borg/borgcron/py/Groc.g:180:1: months : ( month ( COMMA month )* ) ;
def months(self, ):
try:
try:
# borg/borgcron/py/Groc.g:181:3: ( ( month ( COMMA month )* ) )
# borg/borgcron/py/Groc.g:181:5: ( month ( COMMA month )* )
pass
# borg/borgcron/py/Groc.g:181:5: ( month ( COMMA month )* )
# borg/borgcron/py/Groc.g:181:7: month ( COMMA month )*
pass
self._state.following.append(self.FOLLOW_month_in_months486)
self.month()
self._state.following.pop()
# borg/borgcron/py/Groc.g:181:13: ( COMMA month )*
while True: #loop12
alt12 = 2
LA12_0 = self.input.LA(1)
if (LA12_0 == COMMA):
alt12 = 1
if alt12 == 1:
# borg/borgcron/py/Groc.g:181:14: COMMA month
pass
self.match(self.input, COMMA,
self.FOLLOW_COMMA_in_months489)
self._state.following.append(
self.FOLLOW_month_in_months491)
self.month()
self._state.following.pop()
else:
break #loop12
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "months"
# $ANTLR start "month"
# borg/borgcron/py/Groc.g:184:1: month : monthname= ( JANUARY | FEBRUARY | MARCH | APRIL | MAY | JUNE | JULY | AUGUST | SEPTEMBER | OCTOBER | NOVEMBER | DECEMBER ) ;
def month(self, ):
monthname = None
try:
try:
# borg/borgcron/py/Groc.g:185:3: (monthname= ( JANUARY | FEBRUARY | MARCH | APRIL | MAY | JUNE | JULY | AUGUST | SEPTEMBER | OCTOBER | NOVEMBER | DECEMBER ) )
# borg/borgcron/py/Groc.g:185:5: monthname= ( JANUARY | FEBRUARY | MARCH | APRIL | MAY | JUNE | JULY | AUGUST | SEPTEMBER | OCTOBER | NOVEMBER | DECEMBER )
pass
monthname = self.input.LT(1)
if (JANUARY <= self.input.LA(1) <= DECEMBER):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
#action start
self.month_set.add(self.ValueOf(monthname.type))
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "month"
# $ANTLR start "quarterspec"
# borg/borgcron/py/Groc.g:190:1: quarterspec : ( QUARTER | ( quarter_ordinals MONTH OF QUARTER ) ) ;
def quarterspec(self, ):
try:
try:
# borg/borgcron/py/Groc.g:191:3: ( ( QUARTER | ( quarter_ordinals MONTH OF QUARTER ) ) )
# borg/borgcron/py/Groc.g:191:5: ( QUARTER | ( quarter_ordinals MONTH OF QUARTER ) )
pass
# borg/borgcron/py/Groc.g:191:5: ( QUARTER | ( quarter_ordinals MONTH OF QUARTER ) )
alt13 = 2
LA13_0 = self.input.LA(1)
if (LA13_0 == QUARTER):
alt13 = 1
elif ((FIRST <= LA13_0 <= THIRD)):
alt13 = 2
else:
nvae = NoViableAltException("", 13, 0, self.input)
raise nvae
if alt13 == 1:
# borg/borgcron/py/Groc.g:191:7: QUARTER
pass
self.match(self.input, QUARTER,
self.FOLLOW_QUARTER_in_quarterspec583)
#action start
self.month_set = self.month_set.union(
set([
self.ValueOf(JANUARY),
self.ValueOf(APRIL),
self.ValueOf(JULY),
self.ValueOf(OCTOBER)
]))
#action end
elif alt13 == 2:
# borg/borgcron/py/Groc.g:195:7: ( quarter_ordinals MONTH OF QUARTER )
pass
# borg/borgcron/py/Groc.g:195:7: ( quarter_ordinals MONTH OF QUARTER )
# borg/borgcron/py/Groc.g:195:9: quarter_ordinals MONTH OF QUARTER
pass
self._state.following.append(
self.FOLLOW_quarter_ordinals_in_quarterspec595)
self.quarter_ordinals()
self._state.following.pop()
self.match(self.input, MONTH,
self.FOLLOW_MONTH_in_quarterspec597)
self.match(self.input, OF,
self.FOLLOW_OF_in_quarterspec599)
self.match(self.input, QUARTER,
self.FOLLOW_QUARTER_in_quarterspec601)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "quarterspec"
# $ANTLR start "quarter_ordinals"
# borg/borgcron/py/Groc.g:198:1: quarter_ordinals : ( month_of_quarter_ordinal ( COMMA month_of_quarter_ordinal )* ) ;
def quarter_ordinals(self, ):
try:
try:
# borg/borgcron/py/Groc.g:199:3: ( ( month_of_quarter_ordinal ( COMMA month_of_quarter_ordinal )* ) )
# borg/borgcron/py/Groc.g:199:5: ( month_of_quarter_ordinal ( COMMA month_of_quarter_ordinal )* )
pass
# borg/borgcron/py/Groc.g:199:5: ( month_of_quarter_ordinal ( COMMA month_of_quarter_ordinal )* )
# borg/borgcron/py/Groc.g:199:7: month_of_quarter_ordinal ( COMMA month_of_quarter_ordinal )*
pass
self._state.following.append(
self.FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals620
)
self.month_of_quarter_ordinal()
self._state.following.pop()
# borg/borgcron/py/Groc.g:199:32: ( COMMA month_of_quarter_ordinal )*
while True: #loop14
alt14 = 2
LA14_0 = self.input.LA(1)
if (LA14_0 == COMMA):
alt14 = 1
if alt14 == 1:
# borg/borgcron/py/Groc.g:199:33: COMMA month_of_quarter_ordinal
pass
self.match(self.input, COMMA,
self.FOLLOW_COMMA_in_quarter_ordinals623)
self._state.following.append(
self.
FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals625
)
self.month_of_quarter_ordinal()
self._state.following.pop()
else:
break #loop14
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "quarter_ordinals"
# $ANTLR start "month_of_quarter_ordinal"
# borg/borgcron/py/Groc.g:202:1: month_of_quarter_ordinal : offset= ( FIRST | SECOND | THIRD ) ;
def month_of_quarter_ordinal(self, ):
offset = None
try:
try:
# borg/borgcron/py/Groc.g:203:3: (offset= ( FIRST | SECOND | THIRD ) )
# borg/borgcron/py/Groc.g:203:5: offset= ( FIRST | SECOND | THIRD )
pass
offset = self.input.LT(1)
if (FIRST <= self.input.LA(1) <= THIRD):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
#action start
jOffset = self.ValueOf(offset.type) - 1
self.month_set = self.month_set.union(
set([
jOffset + self.ValueOf(JANUARY),
jOffset + self.ValueOf(APRIL),
jOffset + self.ValueOf(JULY),
jOffset + self.ValueOf(OCTOBER)
]))
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "month_of_quarter_ordinal"
# $ANTLR start "time_range"
# borg/borgcron/py/Groc.g:210:1: time_range : ( FROM (start_time= TIME ) TO (end_time= TIME ) ) ;
def time_range(self, ):
start_time = None
end_time = None
try:
try:
# borg/borgcron/py/Groc.g:211:3: ( ( FROM (start_time= TIME ) TO (end_time= TIME ) ) )
# borg/borgcron/py/Groc.g:211:5: ( FROM (start_time= TIME ) TO (end_time= TIME ) )
pass
# borg/borgcron/py/Groc.g:211:5: ( FROM (start_time= TIME ) TO (end_time= TIME ) )
# borg/borgcron/py/Groc.g:211:7: FROM (start_time= TIME ) TO (end_time= TIME )
pass
self.match(self.input, FROM, self.FOLLOW_FROM_in_time_range673)
# borg/borgcron/py/Groc.g:211:12: (start_time= TIME )
# borg/borgcron/py/Groc.g:211:13: start_time= TIME
pass
start_time = self.match(self.input, TIME,
self.FOLLOW_TIME_in_time_range680)
#action start
self.start_time_string = start_time.text
#action end
self.match(self.input, TO, self.FOLLOW_TO_in_time_range691)
# borg/borgcron/py/Groc.g:212:10: (end_time= TIME )
# borg/borgcron/py/Groc.g:212:11: end_time= TIME
pass
end_time = self.match(self.input, TIME,
self.FOLLOW_TIME_in_time_range698)
#action start
self.end_time_string = end_time.text
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "time_range"
# Delegated rules
# lookup tables for DFA #4
DFA4_eot = DFA.unpack(u"\13\uffff")
DFA4_eof = DFA.unpack(u"\13\uffff")
DFA4_min = DFA.unpack(
u"\1\6\1\23\1\12\1\uffff\2\4\1\13\1\uffff\1\24\1\12\1\4")
DFA4_max = DFA.unpack(
u"\1\20\2\32\1\uffff\1\5\1\12\1\20\1\uffff\2\32\1\12")
DFA4_accept = DFA.unpack(u"\3\uffff\1\1\3\uffff\1\2\3\uffff")
DFA4_special = DFA.unpack(u"\13\uffff")
DFA4_transition = [
DFA.unpack(u"\1\1\2\3\2\uffff\6\2"),
DFA.unpack(u"\1\4\7\5"),
DFA.unpack(u"\1\6\10\uffff\1\4\7\5"),
DFA.unpack(u""),
DFA.unpack(u"\1\3\1\7"),
DFA.unpack(u"\1\3\1\7\4\uffff\1\10"),
DFA.unpack(u"\6\11"),
DFA.unpack(u""),
DFA.unpack(u"\7\12"),
DFA.unpack(u"\1\6\10\uffff\1\4\7\5"),
DFA.unpack(u"\1\3\1\7\4\uffff\1\10")
]
# class definition for DFA #4
DFA4 = DFA
FOLLOW_specifictime_in_timespec44 = frozenset([])
FOLLOW_interval_in_timespec48 = frozenset([])
FOLLOW_EOF_in_timespec52 = frozenset([1])
FOLLOW_ordinals_in_specifictime72 = frozenset(
[19, 20, 21, 22, 23, 24, 25, 26])
FOLLOW_weekdays_in_specifictime74 = frozenset([4])
FOLLOW_monthdays_in_specifictime77 = frozenset([4])
FOLLOW_OF_in_specifictime80 = frozenset(
[11, 12, 13, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40])
FOLLOW_monthspec_in_specifictime83 = frozenset([5])
FOLLOW_quarterspec_in_specifictime85 = frozenset([5])
FOLLOW_ordinals_in_specifictime101 = frozenset(
[19, 20, 21, 22, 23, 24, 25, 26])
FOLLOW_weekdays_in_specifictime103 = frozenset([5])
FOLLOW_TIME_in_specifictime117 = frozenset([1])
FOLLOW_EVERY_in_interval136 = frozenset([7, 8])
FOLLOW_set_in_interval146 = frozenset([17, 18])
FOLLOW_period_in_interval164 = frozenset([1, 9, 41])
FOLLOW_time_range_in_interval176 = frozenset([1])
FOLLOW_SYNCHRONIZED_in_interval189 = frozenset([1])
FOLLOW_EVERY_in_ordinals218 = frozenset([1])
FOLLOW_ordinal_in_ordinals226 = frozenset([1, 10])
FOLLOW_COMMA_in_ordinals229 = frozenset([11, 12, 13, 14, 15, 16])
FOLLOW_ordinal_in_ordinals231 = frozenset([1, 10])
FOLLOW_set_in_ordinal252 = frozenset([1])
FOLLOW_set_in_period291 = frozenset([1])
FOLLOW_monthday_in_monthdays314 = frozenset([1, 10])
FOLLOW_COMMA_in_monthdays318 = frozenset([7, 8])
FOLLOW_monthday_in_monthdays320 = frozenset([1, 10])
FOLLOW_set_in_monthday340 = frozenset([1])
FOLLOW_DAY_in_weekdays365 = frozenset([1])
FOLLOW_weekday_in_weekdays373 = frozenset([1, 10])
FOLLOW_COMMA_in_weekdays376 = frozenset([19, 20, 21, 22, 23, 24, 25, 26])
FOLLOW_weekday_in_weekdays378 = frozenset([1, 10])
FOLLOW_set_in_weekday400 = frozenset([1])
FOLLOW_MONTH_in_monthspec459 = frozenset([1])
FOLLOW_months_in_monthspec469 = frozenset([1])
FOLLOW_month_in_months486 = frozenset([1, 10])
FOLLOW_COMMA_in_months489 = frozenset(
[27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39])
FOLLOW_month_in_months491 = frozenset([1, 10])
FOLLOW_set_in_month510 = frozenset([1])
FOLLOW_QUARTER_in_quarterspec583 = frozenset([1])
FOLLOW_quarter_ordinals_in_quarterspec595 = frozenset([27])
FOLLOW_MONTH_in_quarterspec597 = frozenset([4])
FOLLOW_OF_in_quarterspec599 = frozenset([40])
FOLLOW_QUARTER_in_quarterspec601 = frozenset([1])
FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals620 = frozenset([1, 10])
FOLLOW_COMMA_in_quarter_ordinals623 = frozenset(
[11, 12, 13, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40])
FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals625 = frozenset([1, 10])
FOLLOW_set_in_month_of_quarter_ordinal644 = frozenset([1])
FOLLOW_FROM_in_time_range673 = frozenset([5])
FOLLOW_TIME_in_time_range680 = frozenset([42])
FOLLOW_TO_in_time_range691 = frozenset([5])
FOLLOW_TIME_in_time_range698 = frozenset([1])
class BuildFSM(TreeParser):
grammarFileName = "src\\SavedFSM\\BuildFSM.g"
antlr_version = version_str_to_tuple("3.1.3 Mar 18, 2009 10:09:25")
antlr_version_str = "3.1.3 Mar 18, 2009 10:09:25"
tokenNames = tokenNames
def __init__(self, input, state=None, *args, **kwargs):
if state is None:
state = RecognizerSharedState()
super(BuildFSM, self).__init__(input, state, *args, **kwargs)
# memory here is used only for logging and debugging purposes.
# We append bebugging information to memory so we can print it later.
self.memory = []
self.main_fsm = FSMBuilderState()
self.current_fsm = self.main_fsm
# $ANTLR start "description"
# src\\SavedFSM\\BuildFSM.g:107:1: description : ^( PROTOCOL ( activityDef )+ ) ;
def description(self, ):
try:
try:
# src\\SavedFSM\\BuildFSM.g:107:12: ( ^( PROTOCOL ( activityDef )+ ) )
# src\\SavedFSM\\BuildFSM.g:107:14: ^( PROTOCOL ( activityDef )+ )
pass
self.match(self.input, PROTOCOL, self.FOLLOW_PROTOCOL_in_description52)
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:107:25: ( activityDef )+
cnt1 = 0
while True: #loop1
alt1 = 2
LA1_0 = self.input.LA(1)
if ((RESV <= LA1_0 <= SEND) or (RECLABEL <= LA1_0 <= PARALLEL) or LA1_0 == GLOBAL_ESCAPE or LA1_0 == 47 or (49 <= LA1_0 <= 50)) :
alt1 = 1
if alt1 == 1:
# src\\SavedFSM\\BuildFSM.g:107:25: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_description54)
self.activityDef()
self._state.following.pop()
else:
if cnt1 >= 1:
break #loop1
eee = EarlyExitException(1, self.input)
raise eee
cnt1 += 1
self.match(self.input, UP, None)
#action start
print "ProtocolDefinition"
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "description"
# $ANTLR start "activityDef"
# src\\SavedFSM\\BuildFSM.g:108:1: activityDef : ( ^( RESV ( ^( VALUE ( (val= ID vtype= ( INT | STRING ) ) )* ) ) rlabel= ID (rtype= ID )* role= ID ( ^( ASSERT (assertion= ASSERTION )? ) ) ) | ^( SEND ( ^( VALUE ( (val= ID vtype= ( INT | STRING ) ) )* ) ) slabel= ID (stype= ID )* role= ID ( ^( ASSERT (assertion= ASSERTION )? ) ) ) | ^( 'choice' ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( PARALLEL ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( 'repeat' ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'rec' label= ID ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'RECLABEL' labelID= ID ) | ^( GLOBAL_ESCAPE ( ^( 'do' ( ( activityDef )+ ) ) ) ( ^( 'interrupt' roleName ( ( activityDef )+ ) ) ) ) );
def activityDef(self, ):
val = None
vtype = None
rlabel = None
rtype = None
role = None
assertion = None
slabel = None
stype = None
label = None
labelID = None
try:
try:
# src\\SavedFSM\\BuildFSM.g:108:12: ( ^( RESV ( ^( VALUE ( (val= ID vtype= ( INT | STRING ) ) )* ) ) rlabel= ID (rtype= ID )* role= ID ( ^( ASSERT (assertion= ASSERTION )? ) ) ) | ^( SEND ( ^( VALUE ( (val= ID vtype= ( INT | STRING ) ) )* ) ) slabel= ID (stype= ID )* role= ID ( ^( ASSERT (assertion= ASSERTION )? ) ) ) | ^( 'choice' ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( PARALLEL ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( 'repeat' ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'rec' label= ID ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'RECLABEL' labelID= ID ) | ^( GLOBAL_ESCAPE ( ^( 'do' ( ( activityDef )+ ) ) ) ( ^( 'interrupt' roleName ( ( activityDef )+ ) ) ) ) )
alt16 = 8
LA16 = self.input.LA(1)
if LA16 == RESV:
alt16 = 1
elif LA16 == SEND:
alt16 = 2
elif LA16 == 47:
alt16 = 3
elif LA16 == PARALLEL:
alt16 = 4
elif LA16 == 49:
alt16 = 5
elif LA16 == 50:
alt16 = 6
elif LA16 == RECLABEL:
alt16 = 7
elif LA16 == GLOBAL_ESCAPE:
alt16 = 8
else:
nvae = NoViableAltException("", 16, 0, self.input)
raise nvae
if alt16 == 1:
# src\\SavedFSM\\BuildFSM.g:109:2: ^( RESV ( ^( VALUE ( (val= ID vtype= ( INT | STRING ) ) )* ) ) rlabel= ID (rtype= ID )* role= ID ( ^( ASSERT (assertion= ASSERTION )? ) ) )
pass
self.match(self.input, RESV, self.FOLLOW_RESV_in_activityDef66)
#action start
local_context = []
#action end
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:110:5: ( ^( VALUE ( (val= ID vtype= ( INT | STRING ) ) )* ) )
# src\\SavedFSM\\BuildFSM.g:110:6: ^( VALUE ( (val= ID vtype= ( INT | STRING ) ) )* )
pass
self.match(self.input, VALUE, self.FOLLOW_VALUE_in_activityDef76)
if self.input.LA(1) == DOWN:
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:110:14: ( (val= ID vtype= ( INT | STRING ) ) )*
while True: #loop2
alt2 = 2
LA2_0 = self.input.LA(1)
if (LA2_0 == ID) :
alt2 = 1
if alt2 == 1:
# src\\SavedFSM\\BuildFSM.g:110:15: (val= ID vtype= ( INT | STRING ) )
pass
# src\\SavedFSM\\BuildFSM.g:110:15: (val= ID vtype= ( INT | STRING ) )
# src\\SavedFSM\\BuildFSM.g:110:16: val= ID vtype= ( INT | STRING )
pass
val=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef82)
vtype = self.input.LT(1)
if (INT <= self.input.LA(1) <= STRING):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
#action start
if ((val is not None) and (vtype is not None)): local_context.append((val.text, vtype.text))
#action end
else:
break #loop2
self.match(self.input, UP, None)
rlabel=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef107)
#action start
#INFO: This is the way to write comments in actions self.memory.append('resv' + rlabel.text)
#action end
# src\\SavedFSM\\BuildFSM.g:112:5: (rtype= ID )*
while True: #loop3
alt3 = 2
LA3_0 = self.input.LA(1)
if (LA3_0 == ID) :
LA3_1 = self.input.LA(2)
if (LA3_1 == ID) :
alt3 = 1
if alt3 == 1:
# src\\SavedFSM\\BuildFSM.g:112:6: rtype= ID
pass
rtype=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef121)
#action start
self.memory.append(rtype.text)
#action end
else:
break #loop3
role=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef131)
# src\\SavedFSM\\BuildFSM.g:113:5: ( ^( ASSERT (assertion= ASSERTION )? ) )
# src\\SavedFSM\\BuildFSM.g:113:6: ^( ASSERT (assertion= ASSERTION )? )
pass
self.match(self.input, ASSERT, self.FOLLOW_ASSERT_in_activityDef139)
if self.input.LA(1) == DOWN:
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:113:15: (assertion= ASSERTION )?
alt4 = 2
LA4_0 = self.input.LA(1)
if (LA4_0 == ASSERTION) :
alt4 = 1
if alt4 == 1:
# src\\SavedFSM\\BuildFSM.g:113:16: assertion= ASSERTION
pass
assertion=self.match(self.input, ASSERTION, self.FOLLOW_ASSERTION_in_activityDef144)
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
self.current_fsm.add_transition(TransitionFactory.create(LocalType.RESV,rlabel, role), assertion, local_context)
#action end
elif alt16 == 2:
# src\\SavedFSM\\BuildFSM.g:119:3: ^( SEND ( ^( VALUE ( (val= ID vtype= ( INT | STRING ) ) )* ) ) slabel= ID (stype= ID )* role= ID ( ^( ASSERT (assertion= ASSERTION )? ) ) )
pass
self.match(self.input, SEND, self.FOLLOW_SEND_in_activityDef163)
#action start
local_context = []
#action end
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:120:12: ( ^( VALUE ( (val= ID vtype= ( INT | STRING ) ) )* ) )
# src\\SavedFSM\\BuildFSM.g:120:13: ^( VALUE ( (val= ID vtype= ( INT | STRING ) ) )* )
pass
self.match(self.input, VALUE, self.FOLLOW_VALUE_in_activityDef180)
if self.input.LA(1) == DOWN:
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:120:21: ( (val= ID vtype= ( INT | STRING ) ) )*
while True: #loop5
alt5 = 2
LA5_0 = self.input.LA(1)
if (LA5_0 == ID) :
alt5 = 1
if alt5 == 1:
# src\\SavedFSM\\BuildFSM.g:120:22: (val= ID vtype= ( INT | STRING ) )
pass
# src\\SavedFSM\\BuildFSM.g:120:22: (val= ID vtype= ( INT | STRING ) )
# src\\SavedFSM\\BuildFSM.g:120:23: val= ID vtype= ( INT | STRING )
pass
val=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef186)
vtype = self.input.LT(1)
if (INT <= self.input.LA(1) <= STRING):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
#action start
if ((val is not None) and (vtype is not None)): local_context.append((val.text, vtype.text))
#action end
else:
break #loop5
self.match(self.input, UP, None)
slabel=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef212)
#action start
self.memory.append('send' + slabel.text)
#action end
# src\\SavedFSM\\BuildFSM.g:121:61: (stype= ID )*
while True: #loop6
alt6 = 2
LA6_0 = self.input.LA(1)
if (LA6_0 == ID) :
LA6_1 = self.input.LA(2)
if (LA6_1 == ID) :
alt6 = 1
if alt6 == 1:
# src\\SavedFSM\\BuildFSM.g:121:63: stype= ID
pass
stype=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef222)
#action start
self.memory.append(stype.text)
#action end
else:
break #loop6
role=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef232)
# src\\SavedFSM\\BuildFSM.g:122:5: ( ^( ASSERT (assertion= ASSERTION )? ) )
# src\\SavedFSM\\BuildFSM.g:122:6: ^( ASSERT (assertion= ASSERTION )? )
pass
self.match(self.input, ASSERT, self.FOLLOW_ASSERT_in_activityDef240)
if self.input.LA(1) == DOWN:
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:122:15: (assertion= ASSERTION )?
alt7 = 2
LA7_0 = self.input.LA(1)
if (LA7_0 == ASSERTION) :
alt7 = 1
if alt7 == 1:
# src\\SavedFSM\\BuildFSM.g:122:16: assertion= ASSERTION
pass
assertion=self.match(self.input, ASSERTION, self.FOLLOW_ASSERTION_in_activityDef245)
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
self.memory.append('In SEND assertion')
#action end
#action start
self.current_fsm.add_transition(TransitionFactory.create(LocalType.SEND,slabel, role), assertion, local_context)
#action end
elif alt16 == 3:
# src\\SavedFSM\\BuildFSM.g:127:3: ^( 'choice' ( ^( BRANCH ( activityDef )+ ) )+ )
pass
self.match(self.input, 47, self.FOLLOW_47_in_activityDef264)
#action start
self.memory.append('enter choice state')
self.current_fsm.choice_start_state.append(self.current_fsm.get_current_state())
self.current_fsm.choice_end_state.append(self.current_fsm.state_gen.next())
#action end
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:132:2: ( ^( BRANCH ( activityDef )+ ) )+
cnt9 = 0
while True: #loop9
alt9 = 2
LA9_0 = self.input.LA(1)
if (LA9_0 == BRANCH) :
alt9 = 1
if alt9 == 1:
# src\\SavedFSM\\BuildFSM.g:132:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef274)
#action start
self.memory.append('enter choice branch and save the current state')
self.current_fsm.move_current_state(self.current_fsm.choice_start_state[-1])
#action end
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:137:4: ( activityDef )+
cnt8 = 0
while True: #loop8
alt8 = 2
LA8_0 = self.input.LA(1)
if ((RESV <= LA8_0 <= SEND) or (RECLABEL <= LA8_0 <= PARALLEL) or LA8_0 == GLOBAL_ESCAPE or LA8_0 == 47 or (49 <= LA8_0 <= 50)) :
alt8 = 1
if alt8 == 1:
# src\\SavedFSM\\BuildFSM.g:137:4: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef280)
self.activityDef()
self._state.following.pop()
else:
if cnt8 >= 1:
break #loop8
eee = EarlyExitException(8, self.input)
raise eee
cnt8 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('exit choice branch and set the current state to the end state for the choice')
self.current_fsm.fsm.add_transition(self.current_fsm.fsm.EMPTY_TRANSITION, self.current_fsm.get_current_state(), self.current_fsm.choice_end_state[-1])
#action end
else:
if cnt9 >= 1:
break #loop9
eee = EarlyExitException(9, self.input)
raise eee
cnt9 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('set the current state to be equal to the end state for the choice')
self.current_fsm.move_current_state(self.current_fsm.choice_end_state[-1])
self.current_fsm.choice_end_state.pop()
self.current_fsm.choice_start_state.pop()
#action end
elif alt16 == 4:
# src\\SavedFSM\\BuildFSM.g:149:4: ^( PARALLEL ( ^( BRANCH ( activityDef )+ ) )+ )
pass
self.match(self.input, PARALLEL, self.FOLLOW_PARALLEL_in_activityDef299)
#action start
self.memory.append('enter parallel state')
self.parallel_root = self.current_fsm
#action end
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:154:2: ( ^( BRANCH ( activityDef )+ ) )+
cnt11 = 0
while True: #loop11
alt11 = 2
LA11_0 = self.input.LA(1)
if (LA11_0 == BRANCH) :
alt11 = 1
if alt11 == 1:
# src\\SavedFSM\\BuildFSM.g:154:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef316)
#action start
self.memory.append('enter parallel branch')
nested_fsm = FSMBuilderState(self.parallel_root)
self.parallel_root.fsm.add_fsm_to_memory(self.parallel_root.get_current_state(), nested_fsm.fsm)
self.current_fsm = nested_fsm
#action end
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:161:2: ( activityDef )+
cnt10 = 0
while True: #loop10
alt10 = 2
LA10_0 = self.input.LA(1)
if ((RESV <= LA10_0 <= SEND) or (RECLABEL <= LA10_0 <= PARALLEL) or LA10_0 == GLOBAL_ESCAPE or LA10_0 == 47 or (49 <= LA10_0 <= 50)) :
alt10 = 1
if alt10 == 1:
# src\\SavedFSM\\BuildFSM.g:161:3: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef325)
self.activityDef()
self._state.following.pop()
else:
if cnt10 >= 1:
break #loop10
eee = EarlyExitException(10, self.input)
raise eee
cnt10 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('exit parallel branch')
self.current_fsm.add_transition(self.current_fsm.fsm.END_PAR_TRANSITION)
#action end
else:
if cnt11 >= 1:
break #loop11
eee = EarlyExitException(11, self.input)
raise eee
cnt11 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('exit parallel state')
self.current_fsm = self.current_fsm.parent
self.current_fsm.fsm.add_transition(self.current_fsm.fsm.EMPTY_TRANSITION, self.current_fsm.get_current_state(), self.current_fsm.move_current_state())
#action end
elif alt16 == 5:
# src\\SavedFSM\\BuildFSM.g:171:3: ^( 'repeat' ( ^( BRANCH ( activityDef )+ ) ) )
pass
self.match(self.input, 49, self.FOLLOW_49_in_activityDef346)
#action start
self.memory.append('enter repeat state')
#action end
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:173:2: ( ^( BRANCH ( activityDef )+ ) )
# src\\SavedFSM\\BuildFSM.g:173:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef355)
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:173:12: ( activityDef )+
cnt12 = 0
while True: #loop12
alt12 = 2
LA12_0 = self.input.LA(1)
if ((RESV <= LA12_0 <= SEND) or (RECLABEL <= LA12_0 <= PARALLEL) or LA12_0 == GLOBAL_ESCAPE or LA12_0 == 47 or (49 <= LA12_0 <= 50)) :
alt12 = 1
if alt12 == 1:
# src\\SavedFSM\\BuildFSM.g:173:13: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef358)
self.activityDef()
self._state.following.pop()
#action start
self.memory.append('repeat statement')
#action end
else:
if cnt12 >= 1:
break #loop12
eee = EarlyExitException(12, self.input)
raise eee
cnt12 += 1
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
self.memory.append('exit repeat state')
#action end
elif alt16 == 6:
# src\\SavedFSM\\BuildFSM.g:176:10: ^( 'rec' label= ID ( ^( BRANCH ( activityDef )+ ) ) )
pass
self.match(self.input, 50, self.FOLLOW_50_in_activityDef382)
self.match(self.input, DOWN, None)
label=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef388)
#action start
self.memory.append('enter rec state ' + label.text + str(self.current_fsm.get_current_state()))
self.current_fsm.recursions_states.setdefault(label.text, (self.current_fsm.format_state_name(self.current_fsm.get_current_state()), True))
#action end
# src\\SavedFSM\\BuildFSM.g:180:2: ( ^( BRANCH ( activityDef )+ ) )
# src\\SavedFSM\\BuildFSM.g:180:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef404)
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:180:12: ( activityDef )+
cnt13 = 0
while True: #loop13
alt13 = 2
LA13_0 = self.input.LA(1)
if ((RESV <= LA13_0 <= SEND) or (RECLABEL <= LA13_0 <= PARALLEL) or LA13_0 == GLOBAL_ESCAPE or LA13_0 == 47 or (49 <= LA13_0 <= 50)) :
alt13 = 1
if alt13 == 1:
# src\\SavedFSM\\BuildFSM.g:180:13: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef407)
self.activityDef()
self._state.following.pop()
#action start
self.memory.append('rec statement')
#action end
else:
if cnt13 >= 1:
break #loop13
eee = EarlyExitException(13, self.input)
raise eee
cnt13 += 1
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
(start_state, isActive) = self.current_fsm.recursions_states.get(label.text)
self.memory.append('exit rec state ' + label.text + 'start_state' + str(start_state))
self.current_fsm.recursions_states[label.text] = (start_state, False)
#action end
elif alt16 == 7:
# src\\SavedFSM\\BuildFSM.g:187:3: ^( 'RECLABEL' labelID= ID )
pass
self.match(self.input, RECLABEL, self.FOLLOW_RECLABEL_in_activityDef425)
self.match(self.input, DOWN, None)
labelID=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef432)
#action start
(start_rec_state, isActive) = self.current_fsm.recursions_states.get(labelID.text)
self.memory.append('rec label:' + labelID.text + 'starts from state:' + str(start_rec_state))
if isActive:
self.current_fsm.fsm.add_transition(self.current_fsm.fsm.EMPTY_TRANSITION,
self.current_fsm.format_state_name(self.current_fsm.get_current_state()),
start_rec_state)
# Generate unreachable state for the choice construct
self.current_fsm.move_current_state()
else: raise ExceptionFSM('Calling a recusrion label from a recursion that is not valid')
#action end
self.match(self.input, UP, None)
#action start
# Do not need it for no
#self.current_fsm.fsm.copy_transitions(self.current_fsm.recursions_states[labelID.text], self.current_fsm.get_current_state())
#action end
elif alt16 == 8:
# src\\SavedFSM\\BuildFSM.g:204:3: ^( GLOBAL_ESCAPE ( ^( 'do' ( ( activityDef )+ ) ) ) ( ^( 'interrupt' roleName ( ( activityDef )+ ) ) ) )
pass
self.match(self.input, GLOBAL_ESCAPE, self.FOLLOW_GLOBAL_ESCAPE_in_activityDef446)
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:205:5: ( ^( 'do' ( ( activityDef )+ ) ) )
# src\\SavedFSM\\BuildFSM.g:205:6: ^( 'do' ( ( activityDef )+ ) )
pass
self.match(self.input, 56, self.FOLLOW_56_in_activityDef455)
self.match(self.input, DOWN, None)
# src\\SavedFSM\\BuildFSM.g:205:13: ( ( activityDef )+ )
# src\\SavedFSM\\BuildFSM.g:205:14: ( activityDef )+
pass
# src\\SavedFSM\\BuildFSM.g:205:14: ( activityDef )+
cnt14 = 0
while True: #loop14
alt14 = 2
LA14_0 = self.input.LA(1)
if ((RESV <= LA14_0 <= SEND) or (RECLABEL <= LA14_0 <= PARALLEL) or LA14_0 == GLOBAL_ESCAPE or LA14_0 == 47 or (49 <= LA14_0 <= 50)) :
alt14 = 1
if alt14 == 1:
# src\\SavedFSM\\BuildFSM.g:205:14: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef458)
self.activityDef()
self._state.following.pop()
else:
if cnt14 >= 1:
break #loop14
eee = EarlyExitException(14, self.input)
raise eee
cnt14 += 1
#action start
self.current_fsm.fsm.final_state = self.current_fsm.get_current_state()
#action end
self.match(self.input, UP, None)
# src\\SavedFSM\\BuildFSM.g:206:5: ( ^( 'interrupt' roleName ( ( activityDef )+ ) ) )
# src\\SavedFSM\\BuildFSM.g:206:6: ^( 'interrupt' roleName ( ( activityDef )+ ) )
pass
self.match(self.input, 57, self.FOLLOW_57_in_activityDef471)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_roleName_in_activityDef473)
self.roleName()
self._state.following.pop()
#action start
self.memory.append('before setting interrupt_transition to True')
self.current_fsm.interrupt_start_state = self.current_fsm.move_current_state()
self.current_fsm.set_interrupt_transition = True
#action end
# src\\SavedFSM\\BuildFSM.g:209:56: ( ( activityDef )+ )
# src\\SavedFSM\\BuildFSM.g:209:57: ( activityDef )+
pass
# src\\SavedFSM\\BuildFSM.g:209:57: ( activityDef )+
cnt15 = 0
while True: #loop15
alt15 = 2
LA15_0 = self.input.LA(1)
if ((RESV <= LA15_0 <= SEND) or (RECLABEL <= LA15_0 <= PARALLEL) or LA15_0 == GLOBAL_ESCAPE or LA15_0 == 47 or (49 <= LA15_0 <= 50)) :
alt15 = 1
if alt15 == 1:
# src\\SavedFSM\\BuildFSM.g:209:57: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef482)
self.activityDef()
self._state.following.pop()
else:
if cnt15 >= 1:
break #loop15
eee = EarlyExitException(15, self.input)
raise eee
cnt15 += 1
self.match(self.input, UP, None)
self.match(self.input, UP, None)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "activityDef"
# $ANTLR start "roleName"
# src\\SavedFSM\\BuildFSM.g:211:1: roleName : ID ;
def roleName(self, ):
try:
try:
# src\\SavedFSM\\BuildFSM.g:211:9: ( ID )
# src\\SavedFSM\\BuildFSM.g:211:11: ID
pass
self.match(self.input, ID, self.FOLLOW_ID_in_roleName495)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "roleName"
# $ANTLR start "labelName"
# src\\SavedFSM\\BuildFSM.g:212:1: labelName : ID ;
def labelName(self, ):
try:
try:
# src\\SavedFSM\\BuildFSM.g:212:10: ( ID )
# src\\SavedFSM\\BuildFSM.g:212:12: ID
pass
self.match(self.input, ID, self.FOLLOW_ID_in_labelName501)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "labelName"
# $ANTLR start "roleDef"
# src\\SavedFSM\\BuildFSM.g:213:1: roleDef : ID ;
def roleDef(self, ):
try:
try:
# src\\SavedFSM\\BuildFSM.g:213:8: ( ID )
# src\\SavedFSM\\BuildFSM.g:213:10: ID
pass
self.match(self.input, ID, self.FOLLOW_ID_in_roleDef507)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "roleDef"
# $ANTLR start "primitivetype"
# src\\SavedFSM\\BuildFSM.g:214:1: primitivetype : INT ;
def primitivetype(self, ):
try:
try:
# src\\SavedFSM\\BuildFSM.g:214:15: ( INT )
# src\\SavedFSM\\BuildFSM.g:214:16: INT
pass
self.match(self.input, INT, self.FOLLOW_INT_in_primitivetype513)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "primitivetype"
# Delegated rules
FOLLOW_PROTOCOL_in_description52 = frozenset([2])
FOLLOW_activityDef_in_description54 = frozenset([3, 12, 13, 18, 19, 22, 47, 49, 50])
FOLLOW_RESV_in_activityDef66 = frozenset([2])
FOLLOW_VALUE_in_activityDef76 = frozenset([2])
FOLLOW_ID_in_activityDef82 = frozenset([5, 6])
FOLLOW_set_in_activityDef86 = frozenset([3, 24])
FOLLOW_ID_in_activityDef107 = frozenset([24])
FOLLOW_ID_in_activityDef121 = frozenset([24])
FOLLOW_ID_in_activityDef131 = frozenset([21])
FOLLOW_ASSERT_in_activityDef139 = frozenset([2])
FOLLOW_ASSERTION_in_activityDef144 = frozenset([3])
FOLLOW_SEND_in_activityDef163 = frozenset([2])
FOLLOW_VALUE_in_activityDef180 = frozenset([2])
FOLLOW_ID_in_activityDef186 = frozenset([5, 6])
FOLLOW_set_in_activityDef191 = frozenset([3, 24])
FOLLOW_ID_in_activityDef212 = frozenset([24])
FOLLOW_ID_in_activityDef222 = frozenset([24])
FOLLOW_ID_in_activityDef232 = frozenset([21])
FOLLOW_ASSERT_in_activityDef240 = frozenset([2])
FOLLOW_ASSERTION_in_activityDef245 = frozenset([3])
FOLLOW_47_in_activityDef264 = frozenset([2])
FOLLOW_BRANCH_in_activityDef274 = frozenset([2])
FOLLOW_activityDef_in_activityDef280 = frozenset([3, 12, 13, 18, 19, 22, 47, 49, 50])
FOLLOW_PARALLEL_in_activityDef299 = frozenset([2])
FOLLOW_BRANCH_in_activityDef316 = frozenset([2])
FOLLOW_activityDef_in_activityDef325 = frozenset([3, 12, 13, 18, 19, 22, 47, 49, 50])
FOLLOW_49_in_activityDef346 = frozenset([2])
FOLLOW_BRANCH_in_activityDef355 = frozenset([2])
FOLLOW_activityDef_in_activityDef358 = frozenset([3, 12, 13, 18, 19, 22, 47, 49, 50])
FOLLOW_50_in_activityDef382 = frozenset([2])
FOLLOW_ID_in_activityDef388 = frozenset([16])
FOLLOW_BRANCH_in_activityDef404 = frozenset([2])
FOLLOW_activityDef_in_activityDef407 = frozenset([3, 12, 13, 18, 19, 22, 47, 49, 50])
FOLLOW_RECLABEL_in_activityDef425 = frozenset([2])
FOLLOW_ID_in_activityDef432 = frozenset([3])
FOLLOW_GLOBAL_ESCAPE_in_activityDef446 = frozenset([2])
FOLLOW_56_in_activityDef455 = frozenset([2])
FOLLOW_activityDef_in_activityDef458 = frozenset([3, 12, 13, 18, 19, 22, 47, 49, 50])
FOLLOW_57_in_activityDef471 = frozenset([2])
FOLLOW_roleName_in_activityDef473 = frozenset([3, 12, 13, 18, 19, 22, 47, 49, 50])
FOLLOW_activityDef_in_activityDef482 = frozenset([3, 12, 13, 18, 19, 22, 47, 49, 50])
FOLLOW_ID_in_roleName495 = frozenset([1])
FOLLOW_ID_in_labelName501 = frozenset([1])
FOLLOW_ID_in_roleDef507 = frozenset([1])
FOLLOW_INT_in_primitivetype513 = frozenset([1])
class ExpParser(Parser):
grammarFileName = "Exp.g"
tokenNames = tokenNames
def __init__(self, input):
Parser.__init__(self, input)
self.adaptor = CommonTreeAdaptor()
class low_prededence_op_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start low_prededence_op
# Exp.g:20:1: low_prededence_op : ( OP_PLUS | OP_MINUS );
def low_prededence_op(self, ):
retval = self.low_prededence_op_return()
retval.start = self.input.LT(1)
root_0 = None
set1 = None
set1_tree = None
try:
try:
# Exp.g:20:18: ( OP_PLUS | OP_MINUS )
# Exp.g:
root_0 = self.adaptor.nil()
set1 = self.input.LT(1)
if (OP_PLUS <= self.input.LA(1) <= OP_MINUS):
self.input.consume()
self.adaptor.addChild(root_0,
self.adaptor.createWithPayload(set1))
self.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
self.recoverFromMismatchedSet(
self.input, mse, self.FOLLOW_set_in_low_prededence_op0)
raise mse
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end low_prededence_op
class high_prededence_op_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start high_prededence_op
# Exp.g:21:1: high_prededence_op : ( OP_MULT | OP_DIV );
def high_prededence_op(self, ):
retval = self.high_prededence_op_return()
retval.start = self.input.LT(1)
root_0 = None
set2 = None
set2_tree = None
try:
try:
# Exp.g:21:19: ( OP_MULT | OP_DIV )
# Exp.g:
root_0 = self.adaptor.nil()
set2 = self.input.LT(1)
if (OP_MULT <= self.input.LA(1) <= OP_DIV):
self.input.consume()
self.adaptor.addChild(root_0,
self.adaptor.createWithPayload(set2))
self.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
self.recoverFromMismatchedSet(
self.input, mse,
self.FOLLOW_set_in_high_prededence_op0)
raise mse
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end high_prededence_op
class low_precedence_exp_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start low_precedence_exp
# Exp.g:23:1: low_precedence_exp : high_precedence_exp ( low_prededence_op high_precedence_exp )* ;
def low_precedence_exp(self, ):
retval = self.low_precedence_exp_return()
retval.start = self.input.LT(1)
root_0 = None
high_precedence_exp3 = None
low_prededence_op4 = None
high_precedence_exp5 = None
try:
try:
# Exp.g:23:19: ( high_precedence_exp ( low_prededence_op high_precedence_exp )* )
# Exp.g:23:21: high_precedence_exp ( low_prededence_op high_precedence_exp )*
root_0 = self.adaptor.nil()
self.following.append(
self.FOLLOW_high_precedence_exp_in_low_precedence_exp126)
high_precedence_exp3 = self.high_precedence_exp()
self.following.pop()
self.adaptor.addChild(root_0, high_precedence_exp3.tree)
# Exp.g:23:41: ( low_prededence_op high_precedence_exp )*
while True: #loop1
alt1 = 2
LA1_0 = self.input.LA(1)
if ((OP_PLUS <= LA1_0 <= OP_MINUS)):
alt1 = 1
if alt1 == 1:
# Exp.g:23:42: low_prededence_op high_precedence_exp
self.following.append(
self.
FOLLOW_low_prededence_op_in_low_precedence_exp129)
low_prededence_op4 = self.low_prededence_op()
self.following.pop()
root_0 = self.adaptor.becomeRoot(
low_prededence_op4.tree, root_0)
self.following.append(
self.
FOLLOW_high_precedence_exp_in_low_precedence_exp132
)
high_precedence_exp5 = self.high_precedence_exp()
self.following.pop()
self.adaptor.addChild(root_0,
high_precedence_exp5.tree)
else:
break #loop1
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end low_precedence_exp
class high_precedence_exp_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start high_precedence_exp
# Exp.g:24:1: high_precedence_exp : atom ( high_prededence_op atom )* ;
def high_precedence_exp(self, ):
retval = self.high_precedence_exp_return()
retval.start = self.input.LT(1)
root_0 = None
atom6 = None
high_prededence_op7 = None
atom8 = None
try:
try:
# Exp.g:24:20: ( atom ( high_prededence_op atom )* )
# Exp.g:24:22: atom ( high_prededence_op atom )*
root_0 = self.adaptor.nil()
self.following.append(
self.FOLLOW_atom_in_high_precedence_exp140)
atom6 = self.atom()
self.following.pop()
self.adaptor.addChild(root_0, atom6.tree)
# Exp.g:24:27: ( high_prededence_op atom )*
while True: #loop2
alt2 = 2
LA2_0 = self.input.LA(1)
if ((OP_MULT <= LA2_0 <= OP_DIV)):
alt2 = 1
if alt2 == 1:
# Exp.g:24:28: high_prededence_op atom
self.following.append(
self.
FOLLOW_high_prededence_op_in_high_precedence_exp143
)
high_prededence_op7 = self.high_prededence_op()
self.following.pop()
root_0 = self.adaptor.becomeRoot(
high_prededence_op7.tree, root_0)
self.following.append(
self.FOLLOW_atom_in_high_precedence_exp146)
atom8 = self.atom()
self.following.pop()
self.adaptor.addChild(root_0, atom8.tree)
else:
break #loop2
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end high_precedence_exp
class atom_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start atom
# Exp.g:25:1: atom : ( OPERAND | LEFT_PAREN low_precedence_exp RIGHT_PAREN );
def atom(self, ):
retval = self.atom_return()
retval.start = self.input.LT(1)
root_0 = None
OPERAND9 = None
LEFT_PAREN10 = None
RIGHT_PAREN12 = None
low_precedence_exp11 = None
OPERAND9_tree = None
LEFT_PAREN10_tree = None
RIGHT_PAREN12_tree = None
try:
try:
# Exp.g:25:5: ( OPERAND | LEFT_PAREN low_precedence_exp RIGHT_PAREN )
alt3 = 2
LA3_0 = self.input.LA(1)
if (LA3_0 == OPERAND):
alt3 = 1
elif (LA3_0 == LEFT_PAREN):
alt3 = 2
else:
nvae = NoViableAltException(
"25:1: atom : ( OPERAND | LEFT_PAREN low_precedence_exp RIGHT_PAREN );",
3, 0, self.input)
raise nvae
if alt3 == 1:
# Exp.g:25:7: OPERAND
root_0 = self.adaptor.nil()
OPERAND9 = self.input.LT(1)
self.match(self.input, OPERAND,
self.FOLLOW_OPERAND_in_atom154)
OPERAND9_tree = self.adaptor.createWithPayload(OPERAND9)
self.adaptor.addChild(root_0, OPERAND9_tree)
elif alt3 == 2:
# Exp.g:25:16: LEFT_PAREN low_precedence_exp RIGHT_PAREN
root_0 = self.adaptor.nil()
LEFT_PAREN10 = self.input.LT(1)
self.match(self.input, LEFT_PAREN,
self.FOLLOW_LEFT_PAREN_in_atom157)
self.following.append(
self.FOLLOW_low_precedence_exp_in_atom160)
low_precedence_exp11 = self.low_precedence_exp()
self.following.pop()
self.adaptor.addChild(root_0, low_precedence_exp11.tree)
RIGHT_PAREN12 = self.input.LT(1)
self.match(self.input, RIGHT_PAREN,
self.FOLLOW_RIGHT_PAREN_in_atom162)
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end atom
FOLLOW_set_in_low_prededence_op0 = frozenset([1])
FOLLOW_set_in_high_prededence_op0 = frozenset([1])
FOLLOW_high_precedence_exp_in_low_precedence_exp126 = frozenset([1, 7, 8])
FOLLOW_low_prededence_op_in_low_precedence_exp129 = frozenset([4, 5])
FOLLOW_high_precedence_exp_in_low_precedence_exp132 = frozenset([1, 7, 8])
FOLLOW_atom_in_high_precedence_exp140 = frozenset([1, 9, 10])
FOLLOW_high_prededence_op_in_high_precedence_exp143 = frozenset([4, 5])
FOLLOW_atom_in_high_precedence_exp146 = frozenset([1, 9, 10])
FOLLOW_OPERAND_in_atom154 = frozenset([1])
FOLLOW_LEFT_PAREN_in_atom157 = frozenset([4, 5])
FOLLOW_low_precedence_exp_in_atom160 = frozenset([6])
FOLLOW_RIGHT_PAREN_in_atom162 = frozenset([1])
class BuildFSM(TreeParser):
grammarFileName = "BuildFSM.g"
antlr_version = version_str_to_tuple("3.1.3 Mar 18, 2009 10:09:25")
antlr_version_str = "3.1.3 Mar 18, 2009 10:09:25"
tokenNames = tokenNames
def __init__(self, input, state=None, *args, **kwargs):
if state is None:
state = RecognizerSharedState()
super(BuildFSM, self).__init__(input, state, *args, **kwargs)
# memory here is used only for logging and debugging purposes.
# We append bebugging information to memory so we can print it later.
self.memory = []
self.main_fsm = FSMBuilderState()
self.current_fsm = main_fsm
# $ANTLR start "description"
# BuildFSM.g:68:1: description : ^( PROTOCOL ( activityDef )+ ) ;
def description(self, ):
try:
try:
# BuildFSM.g:68:12: ( ^( PROTOCOL ( activityDef )+ ) )
# BuildFSM.g:68:14: ^( PROTOCOL ( activityDef )+ )
pass
self.match(self.input, PROTOCOL, self.FOLLOW_PROTOCOL_in_description52)
self.match(self.input, DOWN, None)
# BuildFSM.g:68:25: ( activityDef )+
cnt1 = 0
while True: #loop1
alt1 = 2
LA1_0 = self.input.LA(1)
if ((RESV <= LA1_0 <= SEND) or (RECLABEL <= LA1_0 <= PARALLEL) or LA1_0 == 39 or (42 <= LA1_0 <= 43)) :
alt1 = 1
if alt1 == 1:
# BuildFSM.g:68:25: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_description54)
self.activityDef()
self._state.following.pop()
else:
if cnt1 >= 1:
break #loop1
eee = EarlyExitException(1, self.input)
raise eee
cnt1 += 1
self.match(self.input, UP, None)
#action start
print "ProtocolDefinition"
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "description"
# $ANTLR start "activityDef"
# BuildFSM.g:69:1: activityDef : ( ^( RESV ^( VALUE (val= ID type= ID )* ) rlabel= ID (rtype= ID )* role= ID ^( ASSERT (assertion= ASSERTION )? ) ) | ^( SEND ^( VALUE (val= ID type= ID )* ) slabel= ID (stype= ID )* role= ID ^( ASSERT (assertion= ASSERTION )? ) ) | ^( 'choice' ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( PARALLEL ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( 'repeat' ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'rec' label= ID ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'RECLABEL' labelID= ID ) );
def activityDef(self, ):
val = None
type = None
rlabel = None
rtype = None
role = None
assertion = None
slabel = None
stype = None
label = None
labelID = None
try:
try:
# BuildFSM.g:69:12: ( ^( RESV ^( VALUE (val= ID type= ID )* ) rlabel= ID (rtype= ID )* role= ID ^( ASSERT (assertion= ASSERTION )? ) ) | ^( SEND ^( VALUE (val= ID type= ID )* ) slabel= ID (stype= ID )* role= ID ^( ASSERT (assertion= ASSERTION )? ) ) | ^( 'choice' ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( PARALLEL ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( 'repeat' ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'rec' label= ID ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'RECLABEL' labelID= ID ) )
alt14 = 7
LA14 = self.input.LA(1)
if LA14 == RESV:
alt14 = 1
elif LA14 == SEND:
alt14 = 2
elif LA14 == 39:
alt14 = 3
elif LA14 == PARALLEL:
alt14 = 4
elif LA14 == 42:
alt14 = 5
elif LA14 == 43:
alt14 = 6
elif LA14 == RECLABEL:
alt14 = 7
else:
nvae = NoViableAltException("", 14, 0, self.input)
raise nvae
if alt14 == 1:
# BuildFSM.g:70:4: ^( RESV ^( VALUE (val= ID type= ID )* ) rlabel= ID (rtype= ID )* role= ID ^( ASSERT (assertion= ASSERTION )? ) )
pass
self.match(self.input, RESV, self.FOLLOW_RESV_in_activityDef68)
self.match(self.input, DOWN, None)
self.match(self.input, VALUE, self.FOLLOW_VALUE_in_activityDef75)
if self.input.LA(1) == DOWN:
self.match(self.input, DOWN, None)
# BuildFSM.g:71:12: (val= ID type= ID )*
while True: #loop2
alt2 = 2
LA2_0 = self.input.LA(1)
if (LA2_0 == ID) :
alt2 = 1
if alt2 == 1:
# BuildFSM.g:71:13: val= ID type= ID
pass
val=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef80)
type=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef85)
else:
break #loop2
self.match(self.input, UP, None)
#action start
self.memory.append('In RESV value')
#action end
rlabel=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef99)
#action start
#INFO: This is the way to write comments in actions self.memory.append('resv' + rlabel.text)
#action end
# BuildFSM.g:74:4: (rtype= ID )*
while True: #loop3
alt3 = 2
LA3_0 = self.input.LA(1)
if (LA3_0 == ID) :
LA3_1 = self.input.LA(2)
if (LA3_1 == ID) :
alt3 = 1
if alt3 == 1:
# BuildFSM.g:74:6: rtype= ID
pass
rtype=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef117)
#action start
self.memory.append(rtype.text)
#action end
else:
break #loop3
role=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef127)
#action start
self.current_fsm.add_transition(TransitionFactory.create(LocalType.RESV,rlabel, role))
#action end
self.match(self.input, ASSERT, self.FOLLOW_ASSERT_in_activityDef138)
if self.input.LA(1) == DOWN:
self.match(self.input, DOWN, None)
# BuildFSM.g:76:13: (assertion= ASSERTION )?
alt4 = 2
LA4_0 = self.input.LA(1)
if (LA4_0 == ASSERTION) :
alt4 = 1
if alt4 == 1:
# BuildFSM.g:76:14: assertion= ASSERTION
pass
assertion=self.match(self.input, ASSERTION, self.FOLLOW_ASSERTION_in_activityDef143)
self.match(self.input, UP, None)
#action start
self.memory.append('In RESV assertion')
#action end
self.match(self.input, UP, None)
elif alt14 == 2:
# BuildFSM.g:78:4: ^( SEND ^( VALUE (val= ID type= ID )* ) slabel= ID (stype= ID )* role= ID ^( ASSERT (assertion= ASSERTION )? ) )
pass
self.match(self.input, SEND, self.FOLLOW_SEND_in_activityDef159)
self.match(self.input, DOWN, None)
self.match(self.input, VALUE, self.FOLLOW_VALUE_in_activityDef164)
if self.input.LA(1) == DOWN:
self.match(self.input, DOWN, None)
# BuildFSM.g:79:10: (val= ID type= ID )*
while True: #loop5
alt5 = 2
LA5_0 = self.input.LA(1)
if (LA5_0 == ID) :
alt5 = 1
if alt5 == 1:
# BuildFSM.g:79:11: val= ID type= ID
pass
val=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef169)
type=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef174)
else:
break #loop5
self.match(self.input, UP, None)
#action start
self.memory.append('In SEND value')
#action end
slabel=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef187)
#action start
self.memory.append('send' + slabel.text)
#action end
# BuildFSM.g:80:58: (stype= ID )*
while True: #loop6
alt6 = 2
LA6_0 = self.input.LA(1)
if (LA6_0 == ID) :
LA6_1 = self.input.LA(2)
if (LA6_1 == ID) :
alt6 = 1
if alt6 == 1:
# BuildFSM.g:80:60: stype= ID
pass
stype=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef197)
#action start
self.memory.append(stype.text)
#action end
else:
break #loop6
role=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef207)
#action start
self.current_fsm.add_transition(TransitionFactory.create(LocalType.SEND,slabel, role))
#action end
self.match(self.input, ASSERT, self.FOLLOW_ASSERT_in_activityDef215)
if self.input.LA(1) == DOWN:
self.match(self.input, DOWN, None)
# BuildFSM.g:82:11: (assertion= ASSERTION )?
alt7 = 2
LA7_0 = self.input.LA(1)
if (LA7_0 == ASSERTION) :
alt7 = 1
if alt7 == 1:
# BuildFSM.g:82:12: assertion= ASSERTION
pass
assertion=self.match(self.input, ASSERTION, self.FOLLOW_ASSERTION_in_activityDef220)
self.match(self.input, UP, None)
#action start
self.memory.append('In SEND assertion')
#action end
self.match(self.input, UP, None)
elif alt14 == 3:
# BuildFSM.g:84:3: ^( 'choice' ( ^( BRANCH ( activityDef )+ ) )+ )
pass
self.match(self.input, 39, self.FOLLOW_39_in_activityDef234)
#action start
self.memory.append('enter choice state')
self.current_fsm.choice_start_stat. = self.current_fsm.get_current_state()
self.current_fsm.choice_end_state = self.current_fsm.state_gen.next()
#action end
self.match(self.input, DOWN, None)
# BuildFSM.g:89:2: ( ^( BRANCH ( activityDef )+ ) )+
cnt9 = 0
while True: #loop9
alt9 = 2
LA9_0 = self.input.LA(1)
if (LA9_0 == BRANCH) :
alt9 = 1
if alt9 == 1:
# BuildFSM.g:89:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef244)
#action start
self.memory.append('enter choice branch and save the current state')
self.current_fsm.move_current_state(self.current_fsm.choice_start_state)
#action end
self.match(self.input, DOWN, None)
# BuildFSM.g:93:4: ( activityDef )+
cnt8 = 0
while True: #loop8
alt8 = 2
LA8_0 = self.input.LA(1)
if ((RESV <= LA8_0 <= SEND) or (RECLABEL <= LA8_0 <= PARALLEL) or LA8_0 == 39 or (42 <= LA8_0 <= 43)) :
alt8 = 1
if alt8 == 1:
# BuildFSM.g:93:4: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef250)
self.activityDef()
self._state.following.pop()
else:
if cnt8 >= 1:
break #loop8
eee = EarlyExitException(8, self.input)
raise eee
cnt8 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('exit choice branch and set the current state to the end state for the choice')
self.current_fsm.add_transition(self.fsm.EMPTY_TRANSITION, self.current_fsm.get_current_state(), nothing, self.current_fsm.choice_end_state)
#action end
else:
if cnt9 >= 1:
break #loop9
eee = EarlyExitException(9, self.input)
raise eee
cnt9 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('set the current state to be equal to the end state for the choice')
self.current_fsm.move_current_state(self.choice_end_state)
#action end
elif alt14 == 4:
# BuildFSM.g:103:4: ^( PARALLEL ( ^( BRANCH ( activityDef )+ ) )+ )
pass
self.match(self.input, PARALLEL, self.FOLLOW_PARALLEL_in_activityDef269)
#action start
self.memory.append('enter parallel state')
self.current_fsm.processing_par_state = True
#action end
self.match(self.input, DOWN, None)
# BuildFSM.g:108:2: ( ^( BRANCH ( activityDef )+ ) )+
cnt11 = 0
while True: #loop11
alt11 = 2
LA11_0 = self.input.LA(1)
if (LA11_0 == BRANCH) :
alt11 = 1
if alt11 == 1:
# BuildFSM.g:108:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef286)
#action start
self.memory.append('enter parallel branch')
self.current_fsm.start_new_par_branch = True
nested_fsm = FSMBuilderState(self.fsm)
self.current_fsm.add_fsm_to_memory(self.current_fsm.get_current_state(), nested_fsm)
self.current_fsm = nested_fsm
#action end
self.match(self.input, DOWN, None)
# BuildFSM.g:117:2: ( activityDef )+
cnt10 = 0
while True: #loop10
alt10 = 2
LA10_0 = self.input.LA(1)
if ((RESV <= LA10_0 <= SEND) or (RECLABEL <= LA10_0 <= PARALLEL) or LA10_0 == 39 or (42 <= LA10_0 <= 43)) :
alt10 = 1
if alt10 == 1:
# BuildFSM.g:117:3: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef295)
self.activityDef()
self._state.following.pop()
#action start
self.start_new_branch = False
#action end
else:
if cnt10 >= 1:
break #loop10
eee = EarlyExitException(10, self.input)
raise eee
cnt10 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('exit parallel branch')
self.current_fsm.start_new_par_branch = True
#action end
else:
if cnt11 >= 1:
break #loop11
eee = EarlyExitException(11, self.input)
raise eee
cnt11 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('exit parallel state')
self.current_fsm.processing_par_state = False
self.current_fsm = self.current_fsm.parent
self.current_fsm.add_transition(self.fsm.EMPTY_TRANSITION, self.current_fsm.get_current_state(), nothing, self.current_fsm.move_current_state())
#action end
elif alt14 == 5:
# BuildFSM.g:127:3: ^( 'repeat' ( ^( BRANCH ( activityDef )+ ) ) )
pass
self.match(self.input, 42, self.FOLLOW_42_in_activityDef318)
#action start
self.memory.append('enter repeat state')
#action end
self.match(self.input, DOWN, None)
# BuildFSM.g:129:2: ( ^( BRANCH ( activityDef )+ ) )
# BuildFSM.g:129:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef327)
self.match(self.input, DOWN, None)
# BuildFSM.g:129:12: ( activityDef )+
cnt12 = 0
while True: #loop12
alt12 = 2
LA12_0 = self.input.LA(1)
if ((RESV <= LA12_0 <= SEND) or (RECLABEL <= LA12_0 <= PARALLEL) or LA12_0 == 39 or (42 <= LA12_0 <= 43)) :
alt12 = 1
if alt12 == 1:
# BuildFSM.g:129:13: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef330)
self.activityDef()
self._state.following.pop()
#action start
self.memory.append('repeat statement')
#action end
else:
if cnt12 >= 1:
break #loop12
eee = EarlyExitException(12, self.input)
raise eee
cnt12 += 1
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
self.memory.append('exit repeat state')
#action end
elif alt14 == 6:
# BuildFSM.g:132:10: ^( 'rec' label= ID ( ^( BRANCH ( activityDef )+ ) ) )
pass
self.match(self.input, 43, self.FOLLOW_43_in_activityDef354)
self.match(self.input, DOWN, None)
label=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef360)
#action start
self.memory.append('enter rec state ' + label.text)
self.current_fsm.recursions_states.setdefault(label.text, self.current_fsm.get_current_state())
#action end
# BuildFSM.g:136:2: ( ^( BRANCH ( activityDef )+ ) )
# BuildFSM.g:136:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef376)
self.match(self.input, DOWN, None)
# BuildFSM.g:136:12: ( activityDef )+
cnt13 = 0
while True: #loop13
alt13 = 2
LA13_0 = self.input.LA(1)
if ((RESV <= LA13_0 <= SEND) or (RECLABEL <= LA13_0 <= PARALLEL) or LA13_0 == 39 or (42 <= LA13_0 <= 43)) :
alt13 = 1
if alt13 == 1:
# BuildFSM.g:136:13: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef379)
self.activityDef()
self._state.following.pop()
#action start
self.memory.append('rec statement')
#action end
else:
if cnt13 >= 1:
break #loop13
eee = EarlyExitException(13, self.input)
raise eee
cnt13 += 1
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
self.memory.append('exit rec state ' + label.text)
#action end
elif alt14 == 7:
# BuildFSM.g:139:3: ^( 'RECLABEL' labelID= ID )
pass
self.match(self.input, RECLABEL, self.FOLLOW_RECLABEL_in_activityDef397)
self.match(self.input, DOWN, None)
labelID=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef404)
#action start
self.memory.append('repeat rec again ' + labelID.text)
self.current_fsm.copy_transitions(self.current_fsm.recursions_states[labelID.text], self.current_fsm.get_current_state())
#action end
self.match(self.input, UP, None)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "activityDef"
# $ANTLR start "roleName"
# BuildFSM.g:144:1: roleName : ID ;
def roleName(self, ):
try:
try:
# BuildFSM.g:144:9: ( ID )
# BuildFSM.g:144:11: ID
pass
self.match(self.input, ID, self.FOLLOW_ID_in_roleName415)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "roleName"
# $ANTLR start "labelName"
# BuildFSM.g:145:1: labelName : ID ;
def labelName(self, ):
try:
try:
# BuildFSM.g:145:10: ( ID )
# BuildFSM.g:145:12: ID
pass
self.match(self.input, ID, self.FOLLOW_ID_in_labelName421)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "labelName"
# $ANTLR start "roleDef"
# BuildFSM.g:146:1: roleDef : ID ;
def roleDef(self, ):
try:
try:
# BuildFSM.g:146:8: ( ID )
# BuildFSM.g:146:10: ID
pass
self.match(self.input, ID, self.FOLLOW_ID_in_roleDef427)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "roleDef"
# Delegated rules
FOLLOW_PROTOCOL_in_description52 = frozenset([2])
FOLLOW_activityDef_in_description54 = frozenset([3, 10, 11, 14, 15, 39, 42, 43])
FOLLOW_RESV_in_activityDef68 = frozenset([2])
FOLLOW_VALUE_in_activityDef75 = frozenset([2])
FOLLOW_ID_in_activityDef80 = frozenset([18])
FOLLOW_ID_in_activityDef85 = frozenset([3, 18])
FOLLOW_ID_in_activityDef99 = frozenset([18])
FOLLOW_ID_in_activityDef117 = frozenset([18])
FOLLOW_ID_in_activityDef127 = frozenset([53])
FOLLOW_ASSERT_in_activityDef138 = frozenset([2])
FOLLOW_ASSERTION_in_activityDef143 = frozenset([3])
FOLLOW_SEND_in_activityDef159 = frozenset([2])
FOLLOW_VALUE_in_activityDef164 = frozenset([2])
FOLLOW_ID_in_activityDef169 = frozenset([18])
FOLLOW_ID_in_activityDef174 = frozenset([3, 18])
FOLLOW_ID_in_activityDef187 = frozenset([18])
FOLLOW_ID_in_activityDef197 = frozenset([18])
FOLLOW_ID_in_activityDef207 = frozenset([53])
FOLLOW_ASSERT_in_activityDef215 = frozenset([2])
FOLLOW_ASSERTION_in_activityDef220 = frozenset([3])
FOLLOW_39_in_activityDef234 = frozenset([2])
FOLLOW_BRANCH_in_activityDef244 = frozenset([2])
FOLLOW_activityDef_in_activityDef250 = frozenset([3, 10, 11, 14, 15, 39, 42, 43])
FOLLOW_PARALLEL_in_activityDef269 = frozenset([2])
FOLLOW_BRANCH_in_activityDef286 = frozenset([2])
FOLLOW_activityDef_in_activityDef295 = frozenset([3, 10, 11, 14, 15, 39, 42, 43])
FOLLOW_42_in_activityDef318 = frozenset([2])
FOLLOW_BRANCH_in_activityDef327 = frozenset([2])
FOLLOW_activityDef_in_activityDef330 = frozenset([3, 10, 11, 14, 15, 39, 42, 43])
FOLLOW_43_in_activityDef354 = frozenset([2])
FOLLOW_ID_in_activityDef360 = frozenset([12])
FOLLOW_BRANCH_in_activityDef376 = frozenset([2])
FOLLOW_activityDef_in_activityDef379 = frozenset([3, 10, 11, 14, 15, 39, 42, 43])
FOLLOW_RECLABEL_in_activityDef397 = frozenset([2])
FOLLOW_ID_in_activityDef404 = frozenset([3])
FOLLOW_ID_in_roleName415 = frozenset([1])
FOLLOW_ID_in_labelName421 = frozenset([1])
FOLLOW_ID_in_roleDef427 = frozenset([1])
class ExpTreeParser(TreeParser):
grammarFileName = "ExpTreeParser.g"
tokenNames = tokenNames
def __init__(self, input):
TreeParser.__init__(self, input)
# $ANTLR start exp
# ExpTreeParser.g:11:1: exp returns [node] : (theNode= plus | theNode= minus | theNode= div | theNode= mult | theNode= leaf ) ;
def exp(self, ):
node = None
theNode = None
try:
try:
# ExpTreeParser.g:11:19: ( (theNode= plus | theNode= minus | theNode= div | theNode= mult | theNode= leaf ) )
# ExpTreeParser.g:11:20: (theNode= plus | theNode= minus | theNode= div | theNode= mult | theNode= leaf )
# ExpTreeParser.g:11:20: (theNode= plus | theNode= minus | theNode= div | theNode= mult | theNode= leaf )
alt1 = 5
LA1 = self.input.LA(1)
if LA1 == OP_PLUS:
alt1 = 1
elif LA1 == OP_MINUS:
alt1 = 2
elif LA1 == OP_DIV:
alt1 = 3
elif LA1 == OP_MULT:
alt1 = 4
elif LA1 == OPERAND:
alt1 = 5
else:
nvae = NoViableAltException("11:20: (theNode= plus | theNode= minus | theNode= div | theNode= mult | theNode= leaf )", 1, 0, self.input)
raise nvae
if alt1 == 1:
# ExpTreeParser.g:11:21: theNode= plus
self.following.append(self.FOLLOW_plus_in_exp45)
theNode = self.plus()
self.following.pop()
elif alt1 == 2:
# ExpTreeParser.g:11:34: theNode= minus
self.following.append(self.FOLLOW_minus_in_exp49)
theNode = self.minus()
self.following.pop()
elif alt1 == 3:
# ExpTreeParser.g:11:48: theNode= div
self.following.append(self.FOLLOW_div_in_exp53)
theNode = self.div()
self.following.pop()
elif alt1 == 4:
# ExpTreeParser.g:11:60: theNode= mult
self.following.append(self.FOLLOW_mult_in_exp57)
theNode = self.mult()
self.following.pop()
elif alt1 == 5:
# ExpTreeParser.g:11:73: theNode= leaf
self.following.append(self.FOLLOW_leaf_in_exp61)
theNode = self.leaf()
self.following.pop()
#action start
node=theNode
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return node
# $ANTLR end exp
# $ANTLR start plus
# ExpTreeParser.g:15:1: plus returns [node] : ^( OP_PLUS lhs= exp rhs= exp ) ;
def plus(self, ):
node = None
lhs = None
rhs = None
try:
try:
# ExpTreeParser.g:15:20: ( ^( OP_PLUS lhs= exp rhs= exp ) )
# ExpTreeParser.g:15:21: ^( OP_PLUS lhs= exp rhs= exp )
self.match(self.input, OP_PLUS, self.FOLLOW_OP_PLUS_in_plus74)
self.match(self.input, DOWN, None)
self.following.append(self.FOLLOW_exp_in_plus78)
lhs = self.exp()
self.following.pop()
self.following.append(self.FOLLOW_exp_in_plus82)
rhs = self.exp()
self.following.pop()
self.match(self.input, UP, None)
#action start
node = AddOperator(lhs,rhs)
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return node
# $ANTLR end plus
# $ANTLR start minus
# ExpTreeParser.g:19:1: minus returns [node] : ^( OP_MINUS lhs= exp rhs= exp ) ;
def minus(self, ):
node = None
lhs = None
rhs = None
try:
try:
# ExpTreeParser.g:19:21: ( ^( OP_MINUS lhs= exp rhs= exp ) )
# ExpTreeParser.g:19:23: ^( OP_MINUS lhs= exp rhs= exp )
self.match(self.input, OP_MINUS, self.FOLLOW_OP_MINUS_in_minus96)
self.match(self.input, DOWN, None)
self.following.append(self.FOLLOW_exp_in_minus100)
lhs = self.exp()
self.following.pop()
self.following.append(self.FOLLOW_exp_in_minus104)
rhs = self.exp()
self.following.pop()
self.match(self.input, UP, None)
#action start
node = SubstractOperator(lhs,rhs)
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return node
# $ANTLR end minus
# $ANTLR start mult
# ExpTreeParser.g:23:1: mult returns [node] : ^( OP_MULT lhs= exp rhs= exp ) ;
def mult(self, ):
node = None
lhs = None
rhs = None
try:
try:
# ExpTreeParser.g:23:20: ( ^( OP_MULT lhs= exp rhs= exp ) )
# ExpTreeParser.g:23:22: ^( OP_MULT lhs= exp rhs= exp )
self.match(self.input, OP_MULT, self.FOLLOW_OP_MULT_in_mult118)
self.match(self.input, DOWN, None)
self.following.append(self.FOLLOW_exp_in_mult122)
lhs = self.exp()
self.following.pop()
self.following.append(self.FOLLOW_exp_in_mult126)
rhs = self.exp()
self.following.pop()
self.match(self.input, UP, None)
#action start
node = MultiplyOperator(lhs,rhs)
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return node
# $ANTLR end mult
# $ANTLR start div
# ExpTreeParser.g:27:1: div returns [node] : ^( OP_DIV lhs= exp rhs= exp ) ;
def div(self, ):
node = None
lhs = None
rhs = None
try:
try:
# ExpTreeParser.g:27:19: ( ^( OP_DIV lhs= exp rhs= exp ) )
# ExpTreeParser.g:27:21: ^( OP_DIV lhs= exp rhs= exp )
self.match(self.input, OP_DIV, self.FOLLOW_OP_DIV_in_div140)
self.match(self.input, DOWN, None)
self.following.append(self.FOLLOW_exp_in_div144)
lhs = self.exp()
self.following.pop()
self.following.append(self.FOLLOW_exp_in_div148)
rhs = self.exp()
self.following.pop()
self.match(self.input, UP, None)
#action start
node = DivideOperator(lhs,rhs)
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return node
# $ANTLR end div
# $ANTLR start leaf
# ExpTreeParser.g:31:1: leaf returns [node] : OPERAND ;
def leaf(self, ):
node = None
OPERAND1 = None
try:
try:
# ExpTreeParser.g:31:20: ( OPERAND )
# ExpTreeParser.g:31:22: OPERAND
OPERAND1 = self.input.LT(1)
self.match(self.input, OPERAND, self.FOLLOW_OPERAND_in_leaf161)
#action start
node = Operand(OPERAND1.getText())
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return node
# $ANTLR end leaf
FOLLOW_plus_in_exp45 = frozenset([1])
FOLLOW_minus_in_exp49 = frozenset([1])
FOLLOW_div_in_exp53 = frozenset([1])
FOLLOW_mult_in_exp57 = frozenset([1])
FOLLOW_leaf_in_exp61 = frozenset([1])
FOLLOW_OP_PLUS_in_plus74 = frozenset([2])
FOLLOW_exp_in_plus78 = frozenset([4, 7, 8, 9, 10])
FOLLOW_exp_in_plus82 = frozenset([3])
FOLLOW_OP_MINUS_in_minus96 = frozenset([2])
FOLLOW_exp_in_minus100 = frozenset([4, 7, 8, 9, 10])
FOLLOW_exp_in_minus104 = frozenset([3])
FOLLOW_OP_MULT_in_mult118 = frozenset([2])
FOLLOW_exp_in_mult122 = frozenset([4, 7, 8, 9, 10])
FOLLOW_exp_in_mult126 = frozenset([3])
FOLLOW_OP_DIV_in_div140 = frozenset([2])
FOLLOW_exp_in_div144 = frozenset([4, 7, 8, 9, 10])
FOLLOW_exp_in_div148 = frozenset([3])
FOLLOW_OPERAND_in_leaf161 = frozenset([1])
class GrocParser(Parser):
grammarFileName = "Groc.g"
antlr_version = version_str_to_tuple("3.1.1")
antlr_version_str = "3.1.1"
tokenNames = tokenNames
def __init__(self, input, state=None):
if state is None:
state = RecognizerSharedState()
Parser.__init__(self, input, state)
self.dfa3 = self.DFA3(self,
3,
eot=self.DFA3_eot,
eof=self.DFA3_eof,
min=self.DFA3_min,
max=self.DFA3_max,
accept=self.DFA3_accept,
special=self.DFA3_special,
transition=self.DFA3_transition)
self.ordinal_set = set()
self.weekday_set = set()
self.month_set = set()
self.time_string = ''
self.interval_mins = 0
self.period_string = ''
valuesDict = {
SUNDAY: 0,
FIRST: 1,
MONDAY: 1,
JANUARY: 1,
TUESDAY: 2,
SECOND: 2,
FEBRUARY: 2,
WEDNESDAY: 3,
THIRD: 3,
MARCH: 3,
THURSDAY: 4,
FOURTH: 4,
APRIL: 4,
FRIDAY: 5,
FIFTH: 5,
MAY: 5,
SATURDAY: 6,
JUNE: 6,
JULY: 7,
AUGUST: 8,
SEPTEMBER: 9,
OCTOBER: 10,
NOVEMBER: 11,
DECEMBER: 12,
}
def ValueOf(self, token_type):
return self.valuesDict.get(token_type, -1)
def timespec(self, ):
try:
try:
pass
alt1 = 2
LA1_0 = self.input.LA(1)
if (LA1_0 == EVERY):
LA1_1 = self.input.LA(2)
if ((DIGIT <= LA1_1 <= DIGITS)):
alt1 = 2
elif ((DAY <= LA1_1 <= SUNDAY)):
alt1 = 1
else:
nvae = NoViableAltException("", 1, 1, self.input)
raise nvae
elif ((FIRST <= LA1_0 <= FOURTH_OR_FIFTH)):
alt1 = 1
else:
nvae = NoViableAltException("", 1, 0, self.input)
raise nvae
if alt1 == 1:
pass
self._state.following.append(
self.FOLLOW_specifictime_in_timespec44)
self.specifictime()
self._state.following.pop()
elif alt1 == 2:
pass
self._state.following.append(
self.FOLLOW_interval_in_timespec48)
self.interval()
self._state.following.pop()
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def specifictime(self, ):
TIME1 = None
try:
try:
pass
pass
alt3 = 2
alt3 = self.dfa3.predict(self.input)
if alt3 == 1:
pass
pass
pass
self._state.following.append(
self.FOLLOW_ordinals_in_specifictime69)
self.ordinals()
self._state.following.pop()
self._state.following.append(
self.FOLLOW_weekdays_in_specifictime71)
self.weekdays()
self._state.following.pop()
self.match(self.input, OF,
self.FOLLOW_OF_in_specifictime74)
alt2 = 2
LA2_0 = self.input.LA(1)
if ((MONTH <= LA2_0 <= DECEMBER)):
alt2 = 1
elif ((FIRST <= LA2_0 <= THIRD) or LA2_0 == QUARTER):
alt2 = 2
else:
nvae = NoViableAltException("", 2, 0, self.input)
raise nvae
if alt2 == 1:
pass
self._state.following.append(
self.FOLLOW_monthspec_in_specifictime77)
self.monthspec()
self._state.following.pop()
elif alt2 == 2:
pass
self._state.following.append(
self.FOLLOW_quarterspec_in_specifictime79)
self.quarterspec()
self._state.following.pop()
elif alt3 == 2:
pass
pass
self._state.following.append(
self.FOLLOW_ordinals_in_specifictime96)
self.ordinals()
self._state.following.pop()
self._state.following.append(
self.FOLLOW_weekdays_in_specifictime98)
self.weekdays()
self._state.following.pop()
self.month_set = set(range(1, 13))
TIME1 = self.match(self.input, TIME,
self.FOLLOW_TIME_in_specifictime112)
self.time_string = TIME1.text
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def interval(self, ):
intervalnum = None
period2 = None
try:
try:
pass
pass
self.match(self.input, EVERY, self.FOLLOW_EVERY_in_interval131)
intervalnum = self.input.LT(1)
if (DIGIT <= self.input.LA(1) <= DIGITS):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self.interval_mins = int(intervalnum.text)
self._state.following.append(self.FOLLOW_period_in_interval157)
period2 = self.period()
self._state.following.pop()
if ((period2 is not None)
and [self.input.toString(period2.start, period2.stop)]
or [None])[0] == "hours":
self.period_string = "hours"
else:
self.period_string = "minutes"
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def ordinals(self, ):
try:
try:
pass
alt5 = 2
LA5_0 = self.input.LA(1)
if (LA5_0 == EVERY):
alt5 = 1
elif ((FIRST <= LA5_0 <= FOURTH_OR_FIFTH)):
alt5 = 2
else:
nvae = NoViableAltException("", 5, 0, self.input)
raise nvae
if alt5 == 1:
pass
self.match(self.input, EVERY,
self.FOLLOW_EVERY_in_ordinals176)
self.ordinal_set = self.ordinal_set.union(allOrdinals)
elif alt5 == 2:
pass
pass
self._state.following.append(
self.FOLLOW_ordinal_in_ordinals192)
self.ordinal()
self._state.following.pop()
while True:
alt4 = 2
LA4_0 = self.input.LA(1)
if (LA4_0 == COMMA):
alt4 = 1
if alt4 == 1:
pass
self.match(self.input, COMMA,
self.FOLLOW_COMMA_in_ordinals195)
self._state.following.append(
self.FOLLOW_ordinal_in_ordinals197)
self.ordinal()
self._state.following.pop()
else:
break
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def ordinal(self, ):
ord = None
try:
try:
pass
ord = self.input.LT(1)
if (FIRST <= self.input.LA(1) <= FOURTH_OR_FIFTH):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self.ordinal_set.add(self.ValueOf(ord.type))
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
class period_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
def period(self, ):
retval = self.period_return()
retval.start = self.input.LT(1)
try:
try:
pass
if (HOURS <= self.input.LA(1) <= MINUTES):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
retval.stop = self.input.LT(-1)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
def weekdays(self, ):
try:
try:
pass
alt7 = 2
LA7_0 = self.input.LA(1)
if (LA7_0 == DAY):
alt7 = 1
elif ((MONDAY <= LA7_0 <= SUNDAY)):
alt7 = 2
else:
nvae = NoViableAltException("", 7, 0, self.input)
raise nvae
if alt7 == 1:
pass
self.match(self.input, DAY, self.FOLLOW_DAY_in_weekdays280)
self.weekday_set = set([
self.ValueOf(SUNDAY),
self.ValueOf(MONDAY),
self.ValueOf(TUESDAY),
self.ValueOf(WEDNESDAY),
self.ValueOf(THURSDAY),
self.ValueOf(FRIDAY),
self.ValueOf(SATURDAY),
self.ValueOf(SUNDAY)
])
elif alt7 == 2:
pass
pass
self._state.following.append(
self.FOLLOW_weekday_in_weekdays288)
self.weekday()
self._state.following.pop()
while True:
alt6 = 2
LA6_0 = self.input.LA(1)
if (LA6_0 == COMMA):
alt6 = 1
if alt6 == 1:
pass
self.match(self.input, COMMA,
self.FOLLOW_COMMA_in_weekdays291)
self._state.following.append(
self.FOLLOW_weekday_in_weekdays293)
self.weekday()
self._state.following.pop()
else:
break
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def weekday(self, ):
dayname = None
try:
try:
pass
dayname = self.input.LT(1)
if (MONDAY <= self.input.LA(1) <= SUNDAY):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self.weekday_set.add(self.ValueOf(dayname.type))
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def monthspec(self, ):
try:
try:
pass
alt8 = 2
LA8_0 = self.input.LA(1)
if (LA8_0 == MONTH):
alt8 = 1
elif ((JANUARY <= LA8_0 <= DECEMBER)):
alt8 = 2
else:
nvae = NoViableAltException("", 8, 0, self.input)
raise nvae
if alt8 == 1:
pass
self.match(self.input, MONTH,
self.FOLLOW_MONTH_in_monthspec373)
self.month_set = self.month_set.union(
set([
self.ValueOf(JANUARY),
self.ValueOf(FEBRUARY),
self.ValueOf(MARCH),
self.ValueOf(APRIL),
self.ValueOf(MAY),
self.ValueOf(JUNE),
self.ValueOf(JULY),
self.ValueOf(AUGUST),
self.ValueOf(SEPTEMBER),
self.ValueOf(OCTOBER),
self.ValueOf(NOVEMBER),
self.ValueOf(DECEMBER)
]))
elif alt8 == 2:
pass
self._state.following.append(
self.FOLLOW_months_in_monthspec383)
self.months()
self._state.following.pop()
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def months(self, ):
try:
try:
pass
pass
self._state.following.append(self.FOLLOW_month_in_months400)
self.month()
self._state.following.pop()
while True:
alt9 = 2
LA9_0 = self.input.LA(1)
if (LA9_0 == COMMA):
alt9 = 1
if alt9 == 1:
pass
self.match(self.input, COMMA,
self.FOLLOW_COMMA_in_months403)
self._state.following.append(
self.FOLLOW_month_in_months405)
self.month()
self._state.following.pop()
else:
break
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def month(self, ):
monthname = None
try:
try:
pass
monthname = self.input.LT(1)
if (JANUARY <= self.input.LA(1) <= DECEMBER):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self.month_set.add(self.ValueOf(monthname.type))
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def quarterspec(self, ):
try:
try:
pass
alt10 = 2
LA10_0 = self.input.LA(1)
if (LA10_0 == QUARTER):
alt10 = 1
elif ((FIRST <= LA10_0 <= THIRD)):
alt10 = 2
else:
nvae = NoViableAltException("", 10, 0, self.input)
raise nvae
if alt10 == 1:
pass
self.match(self.input, QUARTER,
self.FOLLOW_QUARTER_in_quarterspec497)
self.month_set = self.month_set.union(
set([
self.ValueOf(JANUARY),
self.ValueOf(APRIL),
self.ValueOf(JULY),
self.ValueOf(OCTOBER)
]))
elif alt10 == 2:
pass
pass
self._state.following.append(
self.FOLLOW_quarter_ordinals_in_quarterspec509)
self.quarter_ordinals()
self._state.following.pop()
self.match(self.input, MONTH,
self.FOLLOW_MONTH_in_quarterspec511)
self.match(self.input, OF,
self.FOLLOW_OF_in_quarterspec513)
self.match(self.input, QUARTER,
self.FOLLOW_QUARTER_in_quarterspec515)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def quarter_ordinals(self, ):
try:
try:
pass
pass
self._state.following.append(
self.FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals534
)
self.month_of_quarter_ordinal()
self._state.following.pop()
while True:
alt11 = 2
LA11_0 = self.input.LA(1)
if (LA11_0 == COMMA):
alt11 = 1
if alt11 == 1:
pass
self.match(self.input, COMMA,
self.FOLLOW_COMMA_in_quarter_ordinals537)
self._state.following.append(
self.
FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals539
)
self.month_of_quarter_ordinal()
self._state.following.pop()
else:
break
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def month_of_quarter_ordinal(self, ):
offset = None
try:
try:
pass
offset = self.input.LT(1)
if (FIRST <= self.input.LA(1) <= THIRD):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
jOffset = self.ValueOf(offset.type) - 1
self.month_set = self.month_set.union(
set([
jOffset + self.ValueOf(JANUARY),
jOffset + self.ValueOf(APRIL),
jOffset + self.ValueOf(JULY),
jOffset + self.ValueOf(OCTOBER)
]))
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
DFA3_eot = DFA.unpack(u"\13\uffff")
DFA3_eof = DFA.unpack(u"\13\uffff")
DFA3_min = DFA.unpack(u"\1\6\1\22\1\11\2\4\1\12\2\uffff\1\23\1\11\1\4")
DFA3_max = DFA.unpack(u"\1\17\2\31\1\5\1\11\1\17\2\uffff\2\31\1\11")
DFA3_accept = DFA.unpack(u"\6\uffff\1\1\1\2\3\uffff")
DFA3_special = DFA.unpack(u"\13\uffff")
DFA3_transition = [
DFA.unpack(u"\1\1\3\uffff\6\2"),
DFA.unpack(u"\1\3\7\4"),
DFA.unpack(u"\1\5\10\uffff\1\3\7\4"),
DFA.unpack(u"\1\6\1\7"),
DFA.unpack(u"\1\6\1\7\3\uffff\1\10"),
DFA.unpack(u"\6\11"),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u"\7\12"),
DFA.unpack(u"\1\5\10\uffff\1\3\7\4"),
DFA.unpack(u"\1\6\1\7\3\uffff\1\10")
]
DFA3 = DFA
FOLLOW_specifictime_in_timespec44 = frozenset([1])
FOLLOW_interval_in_timespec48 = frozenset([1])
FOLLOW_ordinals_in_specifictime69 = frozenset(
[18, 19, 20, 21, 22, 23, 24, 25])
FOLLOW_weekdays_in_specifictime71 = frozenset([4])
FOLLOW_OF_in_specifictime74 = frozenset(
[10, 11, 12, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39])
FOLLOW_monthspec_in_specifictime77 = frozenset([5])
FOLLOW_quarterspec_in_specifictime79 = frozenset([5])
FOLLOW_ordinals_in_specifictime96 = frozenset(
[18, 19, 20, 21, 22, 23, 24, 25])
FOLLOW_weekdays_in_specifictime98 = frozenset([5])
FOLLOW_TIME_in_specifictime112 = frozenset([1])
FOLLOW_EVERY_in_interval131 = frozenset([7, 8])
FOLLOW_set_in_interval141 = frozenset([16, 17])
FOLLOW_period_in_interval157 = frozenset([1])
FOLLOW_EVERY_in_ordinals176 = frozenset([1])
FOLLOW_ordinal_in_ordinals192 = frozenset([1, 9])
FOLLOW_COMMA_in_ordinals195 = frozenset([10, 11, 12, 13, 14, 15])
FOLLOW_ordinal_in_ordinals197 = frozenset([1, 9])
FOLLOW_set_in_ordinal218 = frozenset([1])
FOLLOW_set_in_period257 = frozenset([1])
FOLLOW_DAY_in_weekdays280 = frozenset([1])
FOLLOW_weekday_in_weekdays288 = frozenset([1, 9])
FOLLOW_COMMA_in_weekdays291 = frozenset([18, 19, 20, 21, 22, 23, 24, 25])
FOLLOW_weekday_in_weekdays293 = frozenset([1, 9])
FOLLOW_set_in_weekday314 = frozenset([1])
FOLLOW_MONTH_in_monthspec373 = frozenset([1])
FOLLOW_months_in_monthspec383 = frozenset([1])
FOLLOW_month_in_months400 = frozenset([1, 9])
FOLLOW_COMMA_in_months403 = frozenset(
[26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38])
FOLLOW_month_in_months405 = frozenset([1, 9])
FOLLOW_set_in_month424 = frozenset([1])
FOLLOW_QUARTER_in_quarterspec497 = frozenset([1])
FOLLOW_quarter_ordinals_in_quarterspec509 = frozenset([26])
FOLLOW_MONTH_in_quarterspec511 = frozenset([4])
FOLLOW_OF_in_quarterspec513 = frozenset([39])
FOLLOW_QUARTER_in_quarterspec515 = frozenset([1])
FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals534 = frozenset([1, 9])
FOLLOW_COMMA_in_quarter_ordinals537 = frozenset(
[10, 11, 12, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39])
FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals539 = frozenset([1, 9])
FOLLOW_set_in_month_of_quarter_ordinal558 = frozenset([1])
class jedParser(Parser):
grammarFileName = "jed.g"
antlr_version = version_str_to_tuple("3.1")
antlr_version_str = "3.1"
tokenNames = tokenNames
def __init__(self, input, state=None):
if state is None:
state = RecognizerSharedState()
Parser.__init__(self, input, state)
self.dfa5 = self.DFA5(self,
5,
eot=self.DFA5_eot,
eof=self.DFA5_eof,
min=self.DFA5_min,
max=self.DFA5_max,
accept=self.DFA5_accept,
special=self.DFA5_special,
transition=self.DFA5_transition)
self._fuse_count = 0
self._fuses = bitarray()
self._fuse_default = False
self._pin_count = 0
# $ANTLR start "eval"
# jed.g:26:1: eval returns [value] : ( otherstar | NL )* ( entity ) ( otherstar | NL )* EOF ;
def eval(self, ):
value = None
entity1 = None
try:
try:
# jed.g:27:5: ( ( otherstar | NL )* ( entity ) ( otherstar | NL )* EOF )
# jed.g:27:7: ( otherstar | NL )* ( entity ) ( otherstar | NL )* EOF
pass
# jed.g:27:7: ( otherstar | NL )*
while True: #loop1
alt1 = 3
LA1_0 = self.input.LA(1)
if ((OTHER <= LA1_0 <= STAR)):
alt1 = 1
elif (LA1_0 == NL):
alt1 = 2
if alt1 == 1:
# jed.g:27:8: otherstar
pass
self._state.following.append(
self.FOLLOW_otherstar_in_eval61)
self.otherstar()
self._state.following.pop()
elif alt1 == 2:
# jed.g:27:18: NL
pass
self.match(self.input, NL, self.FOLLOW_NL_in_eval63)
else:
break #loop1
# jed.g:28:9: ( entity )
# jed.g:28:10: entity
pass
self._state.following.append(self.FOLLOW_entity_in_eval76)
entity1 = self.entity()
self._state.following.pop()
#action start
value = entity1
#action end
# jed.g:29:9: ( otherstar | NL )*
while True: #loop2
alt2 = 3
LA2_0 = self.input.LA(1)
if ((OTHER <= LA2_0 <= STAR)):
alt2 = 1
elif (LA2_0 == NL):
alt2 = 2
if alt2 == 1:
# jed.g:29:10: otherstar
pass
self._state.following.append(
self.FOLLOW_otherstar_in_eval90)
self.otherstar()
self._state.following.pop()
elif alt2 == 2:
# jed.g:29:20: NL
pass
self.match(self.input, NL, self.FOLLOW_NL_in_eval92)
else:
break #loop2
self.match(self.input, EOF, self.FOLLOW_EOF_in_eval104)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return value
# $ANTLR end "eval"
# $ANTLR start "other"
# jed.g:32:1: other : ( OTHER | ZERO | ONE | DIG01 | F | J | L | N | P | Q | V | X | WS | C ) ;
def other(self, ):
try:
try:
# jed.g:33:5: ( ( OTHER | ZERO | ONE | DIG01 | F | J | L | N | P | Q | V | X | WS | C ) )
# jed.g:33:7: ( OTHER | ZERO | ONE | DIG01 | F | J | L | N | P | Q | V | X | WS | C )
pass
if (OTHER <= self.input.LA(1) <= C):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "other"
# $ANTLR start "otherstar"
# jed.g:36:1: otherstar : ( other | STAR ) ;
def otherstar(self, ):
try:
try:
# jed.g:37:5: ( ( other | STAR ) )
# jed.g:37:7: ( other | STAR )
pass
# jed.g:37:7: ( other | STAR )
alt3 = 2
LA3_0 = self.input.LA(1)
if ((OTHER <= LA3_0 <= C)):
alt3 = 1
elif (LA3_0 == STAR):
alt3 = 2
else:
nvae = NoViableAltException("", 3, 0, self.input)
raise nvae
if alt3 == 1:
# jed.g:37:8: other
pass
self._state.following.append(
self.FOLLOW_other_in_otherstar162)
self.other()
self._state.following.pop()
elif alt3 == 2:
# jed.g:37:14: STAR
pass
self.match(self.input, STAR,
self.FOLLOW_STAR_in_otherstar164)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "otherstar"
class string_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
# $ANTLR start "string"
# jed.g:40:1: string : ( other )+ ;
def string(self, ):
retval = self.string_return()
retval.start = self.input.LT(1)
try:
try:
# jed.g:41:5: ( ( other )+ )
# jed.g:41:7: ( other )+
pass
# jed.g:41:7: ( other )+
cnt4 = 0
while True: #loop4
alt4 = 2
LA4_0 = self.input.LA(1)
if ((OTHER <= LA4_0 <= C)):
alt4 = 1
if alt4 == 1:
# jed.g:41:7: other
pass
self._state.following.append(
self.FOLLOW_other_in_string183)
self.other()
self._state.following.pop()
else:
if cnt4 >= 1:
break #loop4
eee = EarlyExitException(4, self.input)
raise eee
cnt4 += 1
retval.stop = self.input.LT(-1)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end "string"
# $ANTLR start "entity"
# jed.g:44:1: entity returns [value] : STX lines ETX ;
def entity(self, ):
value = None
lines2 = None
try:
try:
# jed.g:45:5: ( STX lines ETX )
# jed.g:45:7: STX lines ETX
pass
self.match(self.input, STX, self.FOLLOW_STX_in_entity205)
self._state.following.append(self.FOLLOW_lines_in_entity207)
lines2 = self.lines()
self._state.following.pop()
self.match(self.input, ETX, self.FOLLOW_ETX_in_entity209)
#action start
value = lines2
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return value
# $ANTLR end "entity"
# $ANTLR start "lines"
# jed.g:48:1: lines returns [value] : ( fuse_count | pin_count | default_fuse | default_test | test_vec_max | fuses | note | dev_id | checksum )+ ;
def lines(self, ):
value = None
fuse_count3 = None
pin_count4 = None
checksum5 = None
try:
try:
# jed.g:49:5: ( ( fuse_count | pin_count | default_fuse | default_test | test_vec_max | fuses | note | dev_id | checksum )+ )
# jed.g:49:7: ( fuse_count | pin_count | default_fuse | default_test | test_vec_max | fuses | note | dev_id | checksum )+
pass
# jed.g:49:7: ( fuse_count | pin_count | default_fuse | default_test | test_vec_max | fuses | note | dev_id | checksum )+
cnt5 = 0
while True: #loop5
alt5 = 10
alt5 = self.dfa5.predict(self.input)
if alt5 == 1:
# jed.g:49:10: fuse_count
pass
self._state.following.append(
self.FOLLOW_fuse_count_in_lines235)
fuse_count3 = self.fuse_count()
self._state.following.pop()
#action start
self._fuse_count = fuse_count3
#action end
elif alt5 == 2:
# jed.g:50:10: pin_count
pass
self._state.following.append(
self.FOLLOW_pin_count_in_lines252)
pin_count4 = self.pin_count()
self._state.following.pop()
#action start
self._pin_count = pin_count4
#action end
elif alt5 == 3:
# jed.g:51:10: default_fuse
pass
self._state.following.append(
self.FOLLOW_default_fuse_in_lines270)
self.default_fuse()
self._state.following.pop()
elif alt5 == 4:
# jed.g:52:10: default_test
pass
self._state.following.append(
self.FOLLOW_default_test_in_lines281)
self.default_test()
self._state.following.pop()
elif alt5 == 5:
# jed.g:53:10: test_vec_max
pass
self._state.following.append(
self.FOLLOW_test_vec_max_in_lines292)
self.test_vec_max()
self._state.following.pop()
elif alt5 == 6:
# jed.g:54:10: fuses
pass
self._state.following.append(
self.FOLLOW_fuses_in_lines303)
self.fuses()
self._state.following.pop()
elif alt5 == 7:
# jed.g:55:10: note
pass
self._state.following.append(
self.FOLLOW_note_in_lines314)
self.note()
self._state.following.pop()
elif alt5 == 8:
# jed.g:56:10: dev_id
pass
self._state.following.append(
self.FOLLOW_dev_id_in_lines325)
self.dev_id()
self._state.following.pop()
elif alt5 == 9:
# jed.g:57:10: checksum
pass
self._state.following.append(
self.FOLLOW_checksum_in_lines336)
checksum5 = self.checksum()
self._state.following.pop()
#action start
self._checksum = checksum5
#action end
else:
if cnt5 >= 1:
break #loop5
eee = EarlyExitException(5, self.input)
raise eee
cnt5 += 1
#action start
addr_diff = self._fuse_count - len(self._fuses)
if addr_diff < 0:
raise Exception("JEDEC File has more bits than the F field specifies. Actual: %s; F: %s."%\
(len(self._fuses), self._fuse_count))
if addr_diff:
buff = bitarray(addr_diff)
buff.setall(self._fuse_default)
self._fuses += buff
value = {
'fuses': self._fuses,
'checksum': self._checksum,
'fusecount': self._fuse_count,
'pincount': self._pin_count
}
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return value
# $ANTLR end "lines"
class fuses_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
self.address = None
self.length = None
# $ANTLR start "fuses"
# jed.g:74:1: fuses returns [address, length] : L digits ( WS )+ bit_field STAR NL ;
def fuses(self, ):
retval = self.fuses_return()
retval.start = self.input.LT(1)
digits6 = None
bit_field7 = None
try:
try:
# jed.g:75:5: ( L digits ( WS )+ bit_field STAR NL )
# jed.g:75:7: L digits ( WS )+ bit_field STAR NL
pass
self.match(self.input, L, self.FOLLOW_L_in_fuses382)
self._state.following.append(self.FOLLOW_digits_in_fuses384)
digits6 = self.digits()
self._state.following.pop()
# jed.g:75:16: ( WS )+
cnt6 = 0
while True: #loop6
alt6 = 2
LA6_0 = self.input.LA(1)
if (LA6_0 == WS):
alt6 = 1
if alt6 == 1:
# jed.g:75:16: WS
pass
self.match(self.input, WS, self.FOLLOW_WS_in_fuses386)
else:
if cnt6 >= 1:
break #loop6
eee = EarlyExitException(6, self.input)
raise eee
cnt6 += 1
self._state.following.append(self.FOLLOW_bit_field_in_fuses389)
bit_field7 = self.bit_field()
self._state.following.pop()
self.match(self.input, STAR, self.FOLLOW_STAR_in_fuses391)
self.match(self.input, NL, self.FOLLOW_NL_in_fuses393)
#action start
retval.address = ((digits6 is not None) and [digits6.value]
or [None])[0]
#action end
#action start
retval.length = len(
((bit_field7 is not None) and
[self.input.toString(bit_field7.start, bit_field7.stop)]
or [None])[0])
#action end
#action start
addr_diff = retval.address - len(self._fuses)
if addr_diff < 0:
raise Exception(
"JED FILE CAN NOT HAVE OUT OF ORDER ADDRESSES!")
if addr_diff:
buff = bitarray(addr_diff)
buff.setall(self._fuse_default)
self._fuses += buff
self._fuses += ((bit_field7 is not None)
and [bit_field7.value] or [None])[0]
#action end
retval.stop = self.input.LT(-1)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end "fuses"
class bit_field_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
self.value = None
# $ANTLR start "bit_field"
# jed.g:88:1: bit_field returns [value] : ( ZERO | ONE )+ ;
def bit_field(self, ):
retval = self.bit_field_return()
retval.start = self.input.LT(1)
try:
try:
# jed.g:89:5: ( ( ZERO | ONE )+ )
# jed.g:89:7: ( ZERO | ONE )+
pass
# jed.g:89:7: ( ZERO | ONE )+
cnt7 = 0
while True: #loop7
alt7 = 2
LA7_0 = self.input.LA(1)
if ((ZERO <= LA7_0 <= ONE)):
alt7 = 1
if alt7 == 1:
# jed.g:
pass
if (ZERO <= self.input.LA(1) <= ONE):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
else:
if cnt7 >= 1:
break #loop7
eee = EarlyExitException(7, self.input)
raise eee
cnt7 += 1
#action start
retval.value = bitarray(
str(self.input.toString(retval.start, self.input.LT(-1))))
#action end
retval.stop = self.input.LT(-1)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end "bit_field"
# $ANTLR start "note"
# jed.g:92:1: note returns [value] : N string STAR NL ;
def note(self, ):
value = None
string8 = None
try:
try:
# jed.g:93:5: ( N string STAR NL )
# jed.g:93:7: N string STAR NL
pass
self.match(self.input, N, self.FOLLOW_N_in_note455)
self._state.following.append(self.FOLLOW_string_in_note457)
string8 = self.string()
self._state.following.pop()
self.match(self.input, STAR, self.FOLLOW_STAR_in_note459)
self.match(self.input, NL, self.FOLLOW_NL_in_note461)
#action start
value = ((string8 is not None) and
[self.input.toString(string8.start, string8.stop)]
or [None])[0]
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return value
# $ANTLR end "note"
# $ANTLR start "checksum"
# jed.g:97:1: checksum returns [value] : C string STAR NL ;
def checksum(self, ):
value = None
string9 = None
try:
try:
# jed.g:98:5: ( C string STAR NL )
# jed.g:98:7: C string STAR NL
pass
self.match(self.input, C, self.FOLLOW_C_in_checksum492)
self._state.following.append(self.FOLLOW_string_in_checksum494)
string9 = self.string()
self._state.following.pop()
self.match(self.input, STAR, self.FOLLOW_STAR_in_checksum496)
self.match(self.input, NL, self.FOLLOW_NL_in_checksum498)
#action start
value = ((string9 is not None) and
[self.input.toString(string9.start, string9.stop)]
or [None])[0]
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return value
# $ANTLR end "checksum"
# $ANTLR start "dev_id"
# jed.g:102:1: dev_id returns [value] : J string STAR NL ;
def dev_id(self, ):
value = None
string10 = None
try:
try:
# jed.g:103:5: ( J string STAR NL )
# jed.g:103:7: J string STAR NL
pass
self.match(self.input, J, self.FOLLOW_J_in_dev_id529)
self._state.following.append(self.FOLLOW_string_in_dev_id531)
string10 = self.string()
self._state.following.pop()
self.match(self.input, STAR, self.FOLLOW_STAR_in_dev_id533)
self.match(self.input, NL, self.FOLLOW_NL_in_dev_id535)
#action start
value = ((string10 is not None) and
[self.input.toString(string10.start, string10.stop)]
or [None])[0]
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return value
# $ANTLR end "dev_id"
# $ANTLR start "fuse_count"
# jed.g:107:1: fuse_count returns [value] : Q F digits STAR NL ;
def fuse_count(self, ):
value = None
digits11 = None
try:
try:
# jed.g:108:5: ( Q F digits STAR NL )
# jed.g:108:7: Q F digits STAR NL
pass
self.match(self.input, Q, self.FOLLOW_Q_in_fuse_count567)
self.match(self.input, F, self.FOLLOW_F_in_fuse_count569)
self._state.following.append(
self.FOLLOW_digits_in_fuse_count571)
digits11 = self.digits()
self._state.following.pop()
self.match(self.input, STAR, self.FOLLOW_STAR_in_fuse_count573)
self.match(self.input, NL, self.FOLLOW_NL_in_fuse_count575)
#action start
value = ((digits11 is not None) and [digits11.value]
or [None])[0]
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return value
# $ANTLR end "fuse_count"
# $ANTLR start "pin_count"
# jed.g:111:1: pin_count returns [value] : Q P digits STAR NL ;
def pin_count(self, ):
value = None
digits12 = None
try:
try:
# jed.g:112:5: ( Q P digits STAR NL )
# jed.g:112:7: Q P digits STAR NL
pass
self.match(self.input, Q, self.FOLLOW_Q_in_pin_count598)
self.match(self.input, P, self.FOLLOW_P_in_pin_count600)
self._state.following.append(
self.FOLLOW_digits_in_pin_count602)
digits12 = self.digits()
self._state.following.pop()
self.match(self.input, STAR, self.FOLLOW_STAR_in_pin_count604)
self.match(self.input, NL, self.FOLLOW_NL_in_pin_count606)
#action start
value = ((digits12 is not None) and [digits12.value]
or [None])[0]
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return value
# $ANTLR end "pin_count"
# $ANTLR start "default_fuse"
# jed.g:115:1: default_fuse returns [value] : F bool STAR NL ;
def default_fuse(self, ):
value = None
bool13 = None
try:
try:
# jed.g:116:5: ( F bool STAR NL )
# jed.g:116:7: F bool STAR NL
pass
self.match(self.input, F, self.FOLLOW_F_in_default_fuse629)
self._state.following.append(
self.FOLLOW_bool_in_default_fuse631)
bool13 = self.bool()
self._state.following.pop()
self.match(self.input, STAR,
self.FOLLOW_STAR_in_default_fuse633)
self.match(self.input, NL, self.FOLLOW_NL_in_default_fuse635)
#action start
value = bool13
#action end
#action start
self._fuse_default = bool13
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return value
# $ANTLR end "default_fuse"
# $ANTLR start "default_test"
# jed.g:120:1: default_test returns [value] : X bool STAR NL ;
def default_test(self, ):
value = None
bool14 = None
try:
try:
# jed.g:121:5: ( X bool STAR NL )
# jed.g:121:7: X bool STAR NL
pass
self.match(self.input, X, self.FOLLOW_X_in_default_test668)
self._state.following.append(
self.FOLLOW_bool_in_default_test670)
bool14 = self.bool()
self._state.following.pop()
self.match(self.input, STAR,
self.FOLLOW_STAR_in_default_test672)
self.match(self.input, NL, self.FOLLOW_NL_in_default_test674)
#action start
value = bool14
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return value
# $ANTLR end "default_test"
# $ANTLR start "test_vec_max"
# jed.g:124:1: test_vec_max returns [value] : Q V bool STAR NL ;
def test_vec_max(self, ):
value = None
bool15 = None
try:
try:
# jed.g:125:5: ( Q V bool STAR NL )
# jed.g:125:7: Q V bool STAR NL
pass
self.match(self.input, Q, self.FOLLOW_Q_in_test_vec_max697)
self.match(self.input, V, self.FOLLOW_V_in_test_vec_max699)
self._state.following.append(
self.FOLLOW_bool_in_test_vec_max701)
bool15 = self.bool()
self._state.following.pop()
self.match(self.input, STAR,
self.FOLLOW_STAR_in_test_vec_max703)
self.match(self.input, NL, self.FOLLOW_NL_in_test_vec_max705)
#action start
value = bool15
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return value
# $ANTLR end "test_vec_max"
# $ANTLR start "bool"
# jed.g:128:1: bool returns [value] : ( ZERO | ONE ) ;
def bool(self, ):
value = None
try:
try:
# jed.g:129:5: ( ( ZERO | ONE ) )
# jed.g:129:7: ( ZERO | ONE )
pass
# jed.g:129:7: ( ZERO | ONE )
alt8 = 2
LA8_0 = self.input.LA(1)
if (LA8_0 == ZERO):
alt8 = 1
elif (LA8_0 == ONE):
alt8 = 2
else:
nvae = NoViableAltException("", 8, 0, self.input)
raise nvae
if alt8 == 1:
# jed.g:129:8: ZERO
pass
self.match(self.input, ZERO, self.FOLLOW_ZERO_in_bool729)
#action start
value = False
#action end
elif alt8 == 2:
# jed.g:129:28: ONE
pass
self.match(self.input, ONE, self.FOLLOW_ONE_in_bool733)
#action start
value = True
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return value
# $ANTLR end "bool"
class digits_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
self.value = None
# $ANTLR start "digits"
# jed.g:132:1: digits returns [value] : ( digit )+ ;
def digits(self, ):
retval = self.digits_return()
retval.start = self.input.LT(1)
try:
try:
# jed.g:133:5: ( ( digit )+ )
# jed.g:133:7: ( digit )+
pass
# jed.g:133:7: ( digit )+
cnt9 = 0
while True: #loop9
alt9 = 2
LA9_0 = self.input.LA(1)
if ((ZERO <= LA9_0 <= DIG01)):
alt9 = 1
if alt9 == 1:
# jed.g:133:7: digit
pass
self._state.following.append(
self.FOLLOW_digit_in_digits757)
self.digit()
self._state.following.pop()
else:
if cnt9 >= 1:
break #loop9
eee = EarlyExitException(9, self.input)
raise eee
cnt9 += 1
#action start
retval.value = int(
self.input.toString(retval.start, self.input.LT(-1)))
#action end
retval.stop = self.input.LT(-1)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end "digits"
# $ANTLR start "digit"
# jed.g:136:1: digit : ( ZERO | ONE | DIG01 );
def digit(self, ):
try:
try:
# jed.g:137:5: ( ZERO | ONE | DIG01 )
# jed.g:
pass
if (ZERO <= self.input.LA(1) <= DIG01):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "digit"
# Delegated rules
# lookup tables for DFA #5
DFA5_eot = DFA.unpack(u"\14\uffff")
DFA5_eof = DFA.unpack(u"\14\uffff")
DFA5_min = DFA.unpack(u"\1\11\1\uffff\1\11\11\uffff")
DFA5_max = DFA.unpack(u"\1\25\1\uffff\1\17\11\uffff")
DFA5_accept = DFA.unpack(
u"\1\uffff\1\12\1\uffff\1\3\1\4\1\6\1\7\1\10\1\11\1\1\1\2\1\5")
DFA5_special = DFA.unpack(u"\14\uffff")
DFA5_transition = [
DFA.unpack(u"\1\3\1\7\1\5\1\6\1\uffff\1\2\1\uffff\1\4\1\uffff\1\10"
u"\2\uffff\1\1"),
DFA.unpack(u""),
DFA.unpack(u"\1\11\3\uffff\1\12\1\uffff\1\13"),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u"")
]
# class definition for DFA #5
DFA5 = DFA
FOLLOW_otherstar_in_eval61 = frozenset(
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])
FOLLOW_NL_in_eval63 = frozenset(
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])
FOLLOW_entity_in_eval76 = frozenset(
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
FOLLOW_otherstar_in_eval90 = frozenset(
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
FOLLOW_NL_in_eval92 = frozenset(
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
FOLLOW_EOF_in_eval104 = frozenset([1])
FOLLOW_set_in_other116 = frozenset([1])
FOLLOW_other_in_otherstar162 = frozenset([1])
FOLLOW_STAR_in_otherstar164 = frozenset([1])
FOLLOW_other_in_string183 = frozenset(
[1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18])
FOLLOW_STX_in_entity205 = frozenset([9, 10, 11, 12, 14, 16, 18])
FOLLOW_lines_in_entity207 = frozenset([21])
FOLLOW_ETX_in_entity209 = frozenset([1])
FOLLOW_fuse_count_in_lines235 = frozenset([1, 9, 10, 11, 12, 14, 16, 18])
FOLLOW_pin_count_in_lines252 = frozenset([1, 9, 10, 11, 12, 14, 16, 18])
FOLLOW_default_fuse_in_lines270 = frozenset([1, 9, 10, 11, 12, 14, 16, 18])
FOLLOW_default_test_in_lines281 = frozenset([1, 9, 10, 11, 12, 14, 16, 18])
FOLLOW_test_vec_max_in_lines292 = frozenset([1, 9, 10, 11, 12, 14, 16, 18])
FOLLOW_fuses_in_lines303 = frozenset([1, 9, 10, 11, 12, 14, 16, 18])
FOLLOW_note_in_lines314 = frozenset([1, 9, 10, 11, 12, 14, 16, 18])
FOLLOW_dev_id_in_lines325 = frozenset([1, 9, 10, 11, 12, 14, 16, 18])
FOLLOW_checksum_in_lines336 = frozenset([1, 9, 10, 11, 12, 14, 16, 18])
FOLLOW_L_in_fuses382 = frozenset([6, 7, 8])
FOLLOW_digits_in_fuses384 = frozenset([17])
FOLLOW_WS_in_fuses386 = frozenset([6, 7, 17])
FOLLOW_bit_field_in_fuses389 = frozenset([19])
FOLLOW_STAR_in_fuses391 = frozenset([4])
FOLLOW_NL_in_fuses393 = frozenset([1])
FOLLOW_set_in_bit_field427 = frozenset([1, 6, 7])
FOLLOW_N_in_note455 = frozenset(
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18])
FOLLOW_string_in_note457 = frozenset([19])
FOLLOW_STAR_in_note459 = frozenset([4])
FOLLOW_NL_in_note461 = frozenset([1])
FOLLOW_C_in_checksum492 = frozenset(
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18])
FOLLOW_string_in_checksum494 = frozenset([19])
FOLLOW_STAR_in_checksum496 = frozenset([4])
FOLLOW_NL_in_checksum498 = frozenset([1])
FOLLOW_J_in_dev_id529 = frozenset(
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18])
FOLLOW_string_in_dev_id531 = frozenset([19])
FOLLOW_STAR_in_dev_id533 = frozenset([4])
FOLLOW_NL_in_dev_id535 = frozenset([1])
FOLLOW_Q_in_fuse_count567 = frozenset([9])
FOLLOW_F_in_fuse_count569 = frozenset([6, 7, 8])
FOLLOW_digits_in_fuse_count571 = frozenset([19])
FOLLOW_STAR_in_fuse_count573 = frozenset([4])
FOLLOW_NL_in_fuse_count575 = frozenset([1])
FOLLOW_Q_in_pin_count598 = frozenset([13])
FOLLOW_P_in_pin_count600 = frozenset([6, 7, 8])
FOLLOW_digits_in_pin_count602 = frozenset([19])
FOLLOW_STAR_in_pin_count604 = frozenset([4])
FOLLOW_NL_in_pin_count606 = frozenset([1])
FOLLOW_F_in_default_fuse629 = frozenset([6, 7])
FOLLOW_bool_in_default_fuse631 = frozenset([19])
FOLLOW_STAR_in_default_fuse633 = frozenset([4])
FOLLOW_NL_in_default_fuse635 = frozenset([1])
FOLLOW_X_in_default_test668 = frozenset([6, 7])
FOLLOW_bool_in_default_test670 = frozenset([19])
FOLLOW_STAR_in_default_test672 = frozenset([4])
FOLLOW_NL_in_default_test674 = frozenset([1])
FOLLOW_Q_in_test_vec_max697 = frozenset([15])
FOLLOW_V_in_test_vec_max699 = frozenset([6, 7])
FOLLOW_bool_in_test_vec_max701 = frozenset([19])
FOLLOW_STAR_in_test_vec_max703 = frozenset([4])
FOLLOW_NL_in_test_vec_max705 = frozenset([1])
FOLLOW_ZERO_in_bool729 = frozenset([1])
FOLLOW_ONE_in_bool733 = frozenset([1])
FOLLOW_digit_in_digits757 = frozenset([1, 6, 7, 8])
FOLLOW_set_in_digit0 = frozenset([1])
class BuildFSM(TreeParser):
grammarFileName = "src/BuildFSM.g"
antlr_version = version_str_to_tuple("3.1.3 Mar 18, 2009 10:09:25")
antlr_version_str = "3.1.3 Mar 18, 2009 10:09:25"
tokenNames = tokenNames
def __init__(self, input, state=None, *args, **kwargs):
if state is None:
state = RecognizerSharedState()
super(BuildFSM, self).__init__(input, state, *args, **kwargs)
self.memory = []
self.current_state = 1
self.fsm = FSM(self.current_state)
self.processing_par_state = False
self.start_new_par_branch = False
self.state_gen = generate_ints()
# Choice States
self.choice_start_state = -1
self.choice_end_state = -1
# Recursion states
self.recursions_states = {}
def move_current_state(self, value=None):
if value is None:
self.current_state = self.state_gen.next()
else:
self.current_state = value
return self.current_state
def get_current_state(self):
return self.current_state
def add_transition(self, transition):
if self.processing_par_state:
self.fsm.add_transition_to_memory(transition,
self.get_current_state(),
self.start_new_par_branch,
checkMessages)
else:
self.fsm.add_transition(transition, self.get_current_state(),
checkMessages, self.move_current_state())
# $ANTLR start "description"
# src/BuildFSM.g:62:1: description : ^( PROTOCOL ( activityDef )+ ) ;
def description(self, ):
try:
try:
# src/BuildFSM.g:62:12: ( ^( PROTOCOL ( activityDef )+ ) )
# src/BuildFSM.g:62:14: ^( PROTOCOL ( activityDef )+ )
pass
self.match(self.input, PROTOCOL,
self.FOLLOW_PROTOCOL_in_description57)
self.match(self.input, DOWN, None)
# src/BuildFSM.g:62:25: ( activityDef )+
cnt1 = 0
while True: #loop1
alt1 = 2
LA1_0 = self.input.LA(1)
if ((RESV <= LA1_0 <= SEND)
or (RECLABEL <= LA1_0 <= PARALLEL) or LA1_0 == 39
or (42 <= LA1_0 <= 43)):
alt1 = 1
if alt1 == 1:
# src/BuildFSM.g:62:25: activityDef
pass
self._state.following.append(
self.FOLLOW_activityDef_in_description59)
self.activityDef()
self._state.following.pop()
else:
if cnt1 >= 1:
break #loop1
eee = EarlyExitException(1, self.input)
raise eee
cnt1 += 1
self.match(self.input, UP, None)
#action start
print "ProtocolDefinition"
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "description"
# $ANTLR start "activityDef"
# src/BuildFSM.g:63:1: activityDef : ( ^( RESV rlabel= ID (rtype= ID )* role= ID ) | ^( SEND slabel= ID (stype= ID )* role= ID ) | ^( 'choice' ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( PARALLEL ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( 'repeat' ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'rec' label= ID ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'RECLABEL' labelID= ID ) );
def activityDef(self, ):
rlabel = None
rtype = None
role = None
slabel = None
stype = None
label = None
labelID = None
try:
try:
# src/BuildFSM.g:63:12: ( ^( RESV rlabel= ID (rtype= ID )* role= ID ) | ^( SEND slabel= ID (stype= ID )* role= ID ) | ^( 'choice' ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( PARALLEL ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( 'repeat' ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'rec' label= ID ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'RECLABEL' labelID= ID ) )
alt10 = 7
LA10 = self.input.LA(1)
if LA10 == RESV:
alt10 = 1
elif LA10 == SEND:
alt10 = 2
elif LA10 == 39:
alt10 = 3
elif LA10 == PARALLEL:
alt10 = 4
elif LA10 == 42:
alt10 = 5
elif LA10 == 43:
alt10 = 6
elif LA10 == RECLABEL:
alt10 = 7
else:
nvae = NoViableAltException("", 10, 0, self.input)
raise nvae
if alt10 == 1:
# src/BuildFSM.g:64:4: ^( RESV rlabel= ID (rtype= ID )* role= ID )
pass
self.match(self.input, RESV,
self.FOLLOW_RESV_in_activityDef73)
self.match(self.input, DOWN, None)
rlabel = self.match(self.input, ID,
self.FOLLOW_ID_in_activityDef79)
#action start
#check this comments
self.memory.append('resv' + rlabel.text)
#action end
# src/BuildFSM.g:66:48: (rtype= ID )*
while True: #loop2
alt2 = 2
LA2_0 = self.input.LA(1)
if (LA2_0 == ID):
LA2_1 = self.input.LA(2)
if (LA2_1 == ID):
alt2 = 1
if alt2 == 1:
# src/BuildFSM.g:66:50: rtype= ID
pass
rtype = self.match(self.input, ID,
self.FOLLOW_ID_in_activityDef93)
#action start
self.memory.append(rtype.text)
#action end
else:
break #loop2
role = self.match(self.input, ID,
self.FOLLOW_ID_in_activityDef103)
self.match(self.input, UP, None)
#action start
self.add_transition(
TransitionFactory.create(LocalType.RESV, rlabel, role))
#action end
elif alt10 == 2:
# src/BuildFSM.g:69:4: ^( SEND slabel= ID (stype= ID )* role= ID )
pass
self.match(self.input, SEND,
self.FOLLOW_SEND_in_activityDef117)
self.match(self.input, DOWN, None)
slabel = self.match(self.input, ID,
self.FOLLOW_ID_in_activityDef123)
#action start
self.memory.append('send' + slabel.text)
#action end
# src/BuildFSM.g:69:67: (stype= ID )*
while True: #loop3
alt3 = 2
LA3_0 = self.input.LA(1)
if (LA3_0 == ID):
LA3_1 = self.input.LA(2)
if (LA3_1 == ID):
alt3 = 1
if alt3 == 1:
# src/BuildFSM.g:69:69: stype= ID
pass
stype = self.match(
self.input, ID,
self.FOLLOW_ID_in_activityDef133)
#action start
self.memory.append(stype.text)
#action end
else:
break #loop3
role = self.match(self.input, ID,
self.FOLLOW_ID_in_activityDef143)
self.match(self.input, UP, None)
#action start
self.add_transition(
TransitionFactory.create(LocalType.SEND, slabel, role))
#action end
elif alt10 == 3:
# src/BuildFSM.g:72:3: ^( 'choice' ( ^( BRANCH ( activityDef )+ ) )+ )
pass
self.match(self.input, 39,
self.FOLLOW_39_in_activityDef158)
#action start
self.memory.append('enter choice state')
self.choice_start_state = self.get_current_state()
self.choice_end_state = self.state_gen.next()
#action end
self.match(self.input, DOWN, None)
# src/BuildFSM.g:77:2: ( ^( BRANCH ( activityDef )+ ) )+
cnt5 = 0
while True: #loop5
alt5 = 2
LA5_0 = self.input.LA(1)
if (LA5_0 == BRANCH):
alt5 = 1
if alt5 == 1:
# src/BuildFSM.g:77:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH,
self.FOLLOW_BRANCH_in_activityDef168)
#action start
self.memory.append(
'enter choice branch and save the current state'
)
self.move_current_state(self.choice_start_state)
#action end
self.match(self.input, DOWN, None)
# src/BuildFSM.g:81:4: ( activityDef )+
cnt4 = 0
while True: #loop4
alt4 = 2
LA4_0 = self.input.LA(1)
if ((RESV <= LA4_0 <= SEND)
or (RECLABEL <= LA4_0 <= PARALLEL)
or LA4_0 == 39 or (42 <= LA4_0 <= 43)):
alt4 = 1
if alt4 == 1:
# src/BuildFSM.g:81:4: activityDef
pass
self._state.following.append(
self.
FOLLOW_activityDef_in_activityDef174)
self.activityDef()
self._state.following.pop()
else:
if cnt4 >= 1:
break #loop4
eee = EarlyExitException(4, self.input)
raise eee
cnt4 += 1
self.match(self.input, UP, None)
#action start
self.memory.append(
'exit choice branch and set the current state to the end state for the choice'
)
self.fsm.add_transition(self.fsm.EMPTY_TRANSITION,
self.get_current_state(),
nothing,
self.choice_end_state)
#action end
else:
if cnt5 >= 1:
break #loop5
eee = EarlyExitException(5, self.input)
raise eee
cnt5 += 1
self.match(self.input, UP, None)
#action start
self.memory.append(
'set the current state to be equal to the end state for the choice'
)
self.move_current_state(self.choice_end_state)
#action end
elif alt10 == 4:
# src/BuildFSM.g:91:4: ^( PARALLEL ( ^( BRANCH ( activityDef )+ ) )+ )
pass
self.match(self.input, PARALLEL,
self.FOLLOW_PARALLEL_in_activityDef193)
#action start
self.memory.append('enter parallel state')
self.processing_par_state = True
#action end
self.match(self.input, DOWN, None)
# src/BuildFSM.g:96:2: ( ^( BRANCH ( activityDef )+ ) )+
cnt7 = 0
while True: #loop7
alt7 = 2
LA7_0 = self.input.LA(1)
if (LA7_0 == BRANCH):
alt7 = 1
if alt7 == 1:
# src/BuildFSM.g:96:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH,
self.FOLLOW_BRANCH_in_activityDef210)
#action start
self.memory.append('enter parallel branch')
self.start_new_par_branch = True
#action end
self.match(self.input, DOWN, None)
# src/BuildFSM.g:101:2: ( activityDef )+
cnt6 = 0
while True: #loop6
alt6 = 2
LA6_0 = self.input.LA(1)
if ((RESV <= LA6_0 <= SEND)
or (RECLABEL <= LA6_0 <= PARALLEL)
or LA6_0 == 39 or (42 <= LA6_0 <= 43)):
alt6 = 1
if alt6 == 1:
# src/BuildFSM.g:101:3: activityDef
pass
self._state.following.append(
self.
FOLLOW_activityDef_in_activityDef219)
self.activityDef()
self._state.following.pop()
#action start
self.start_new_branch = False
#action end
else:
if cnt6 >= 1:
break #loop6
eee = EarlyExitException(6, self.input)
raise eee
cnt6 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('exit parallel branch')
self.start_new_par_branch = True
#action end
else:
if cnt7 >= 1:
break #loop7
eee = EarlyExitException(7, self.input)
raise eee
cnt7 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('exit parallel state')
self.processing_par_state = False
self.fsm.add_transition(self.fsm.EMPTY_TRANSITION,
self.get_current_state(), nothing,
self.move_current_state())
#action end
elif alt10 == 5:
# src/BuildFSM.g:110:3: ^( 'repeat' ( ^( BRANCH ( activityDef )+ ) ) )
pass
self.match(self.input, 42,
self.FOLLOW_42_in_activityDef242)
#action start
self.memory.append('enter repeat state')
#action end
self.match(self.input, DOWN, None)
# src/BuildFSM.g:112:2: ( ^( BRANCH ( activityDef )+ ) )
# src/BuildFSM.g:112:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH,
self.FOLLOW_BRANCH_in_activityDef251)
self.match(self.input, DOWN, None)
# src/BuildFSM.g:112:12: ( activityDef )+
cnt8 = 0
while True: #loop8
alt8 = 2
LA8_0 = self.input.LA(1)
if ((RESV <= LA8_0 <= SEND)
or (RECLABEL <= LA8_0 <= PARALLEL)
or LA8_0 == 39 or (42 <= LA8_0 <= 43)):
alt8 = 1
if alt8 == 1:
# src/BuildFSM.g:112:13: activityDef
pass
self._state.following.append(
self.FOLLOW_activityDef_in_activityDef254)
self.activityDef()
self._state.following.pop()
#action start
self.memory.append('repeat statement')
#action end
else:
if cnt8 >= 1:
break #loop8
eee = EarlyExitException(8, self.input)
raise eee
cnt8 += 1
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
self.memory.append('exit repeat state')
#action end
elif alt10 == 6:
# src/BuildFSM.g:115:10: ^( 'rec' label= ID ( ^( BRANCH ( activityDef )+ ) ) )
pass
self.match(self.input, 43,
self.FOLLOW_43_in_activityDef278)
self.match(self.input, DOWN, None)
label = self.match(self.input, ID,
self.FOLLOW_ID_in_activityDef284)
#action start
self.memory.append('enter rec state ' + label.text)
self.recursions_states.setdefault(label.text,
self.get_current_state())
#action end
# src/BuildFSM.g:119:2: ( ^( BRANCH ( activityDef )+ ) )
# src/BuildFSM.g:119:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH,
self.FOLLOW_BRANCH_in_activityDef300)
self.match(self.input, DOWN, None)
# src/BuildFSM.g:119:12: ( activityDef )+
cnt9 = 0
while True: #loop9
alt9 = 2
LA9_0 = self.input.LA(1)
if ((RESV <= LA9_0 <= SEND)
or (RECLABEL <= LA9_0 <= PARALLEL)
or LA9_0 == 39 or (42 <= LA9_0 <= 43)):
alt9 = 1
if alt9 == 1:
# src/BuildFSM.g:119:13: activityDef
pass
self._state.following.append(
self.FOLLOW_activityDef_in_activityDef303)
self.activityDef()
self._state.following.pop()
#action start
self.memory.append('rec statement')
#action end
else:
if cnt9 >= 1:
break #loop9
eee = EarlyExitException(9, self.input)
raise eee
cnt9 += 1
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
self.memory.append('exit rec state ' + label.text)
#action end
elif alt10 == 7:
# src/BuildFSM.g:122:3: ^( 'RECLABEL' labelID= ID )
pass
self.match(self.input, RECLABEL,
self.FOLLOW_RECLABEL_in_activityDef321)
self.match(self.input, DOWN, None)
labelID = self.match(self.input, ID,
self.FOLLOW_ID_in_activityDef328)
#action start
self.memory.append('repeat rec again ' + labelID.text)
self.fsm.copy_transitions(
self.recursions_states[labelID.text],
self.get_current_state())
#action end
self.match(self.input, UP, None)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "activityDef"
# $ANTLR start "roleName"
# src/BuildFSM.g:127:1: roleName : ID ;
def roleName(self, ):
try:
try:
# src/BuildFSM.g:127:9: ( ID )
# src/BuildFSM.g:127:11: ID
pass
self.match(self.input, ID, self.FOLLOW_ID_in_roleName339)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "roleName"
# $ANTLR start "labelName"
# src/BuildFSM.g:128:1: labelName : ID ;
def labelName(self, ):
try:
try:
# src/BuildFSM.g:128:10: ( ID )
# src/BuildFSM.g:128:12: ID
pass
self.match(self.input, ID, self.FOLLOW_ID_in_labelName345)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "labelName"
# $ANTLR start "roleDef"
# src/BuildFSM.g:129:1: roleDef : ID ;
def roleDef(self, ):
try:
try:
# src/BuildFSM.g:129:8: ( ID )
# src/BuildFSM.g:129:10: ID
pass
self.match(self.input, ID, self.FOLLOW_ID_in_roleDef351)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "roleDef"
# Delegated rules
FOLLOW_PROTOCOL_in_description57 = frozenset([2])
FOLLOW_activityDef_in_description59 = frozenset(
[3, 10, 11, 14, 15, 39, 42, 43])
FOLLOW_RESV_in_activityDef73 = frozenset([2])
FOLLOW_ID_in_activityDef79 = frozenset([18])
FOLLOW_ID_in_activityDef93 = frozenset([18])
FOLLOW_ID_in_activityDef103 = frozenset([3])
FOLLOW_SEND_in_activityDef117 = frozenset([2])
FOLLOW_ID_in_activityDef123 = frozenset([18])
FOLLOW_ID_in_activityDef133 = frozenset([18])
FOLLOW_ID_in_activityDef143 = frozenset([3])
FOLLOW_39_in_activityDef158 = frozenset([2])
FOLLOW_BRANCH_in_activityDef168 = frozenset([2])
FOLLOW_activityDef_in_activityDef174 = frozenset(
[3, 10, 11, 14, 15, 39, 42, 43])
FOLLOW_PARALLEL_in_activityDef193 = frozenset([2])
FOLLOW_BRANCH_in_activityDef210 = frozenset([2])
FOLLOW_activityDef_in_activityDef219 = frozenset(
[3, 10, 11, 14, 15, 39, 42, 43])
FOLLOW_42_in_activityDef242 = frozenset([2])
FOLLOW_BRANCH_in_activityDef251 = frozenset([2])
FOLLOW_activityDef_in_activityDef254 = frozenset(
[3, 10, 11, 14, 15, 39, 42, 43])
FOLLOW_43_in_activityDef278 = frozenset([2])
FOLLOW_ID_in_activityDef284 = frozenset([12])
FOLLOW_BRANCH_in_activityDef300 = frozenset([2])
FOLLOW_activityDef_in_activityDef303 = frozenset(
[3, 10, 11, 14, 15, 39, 42, 43])
FOLLOW_RECLABEL_in_activityDef321 = frozenset([2])
FOLLOW_ID_in_activityDef328 = frozenset([3])
FOLLOW_ID_in_roleName339 = frozenset([1])
FOLLOW_ID_in_labelName345 = frozenset([1])
FOLLOW_ID_in_roleDef351 = frozenset([1])
class logic_gramParser(Parser):
grammarFileName = "logic_gram.g"
antlr_version = version_str_to_tuple("3.1.3 Mar 18, 2009 10:09:25")
antlr_version_str = "3.1.3 Mar 18, 2009 10:09:25"
tokenNames = tokenNames
def __init__(self, input, state=None, *args, **kwargs):
if state is None:
state = RecognizerSharedState()
super(logic_gramParser, self).__init__(input, state, *args, **kwargs)
self.nodeList = []
kernel=core.Kernel.getSingleton()
self.session = kernel.session()
self.segment = kernel.segment()
# $ANTLR start "formula"
# logic_gram.g:18:1: formula : expression ;
def formula(self, ):
try:
try:
# logic_gram.g:19:2: ( expression )
# logic_gram.g:19:3: expression
pass
self._state.following.append(self.FOLLOW_expression_in_formula32)
self.expression()
self._state.following.pop()
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "formula"
# $ANTLR start "expression"
# logic_gram.g:22:1: expression returns [node] : a= atom ( '^' | '&' | ( '->' | '<-' ) | '<->' ) b= atom ;
def expression(self, ):
node = None
a = None
b = None
try:
try:
# logic_gram.g:23:2: (a= atom ( '^' | '&' | ( '->' | '<-' ) | '<->' ) b= atom )
# logic_gram.g:23:3: a= atom ( '^' | '&' | ( '->' | '<-' ) | '<->' ) b= atom
pass
#action start
revers=None
relation=None
#action end
self._state.following.append(self.FOLLOW_atom_in_expression49)
a = self.atom()
self._state.following.pop()
# logic_gram.g:26:10: ( '^' | '&' | ( '->' | '<-' ) | '<->' )
alt2 = 4
LA2 = self.input.LA(1)
if LA2 == 6:
alt2 = 1
elif LA2 == 7:
alt2 = 2
elif LA2 == 8 or LA2 == 9:
alt2 = 3
elif LA2 == 10:
alt2 = 4
else:
nvae = NoViableAltException("", 2, 0, self.input)
raise nvae
if alt2 == 1:
# logic_gram.g:26:11: '^'
pass
self.match(self.input, 6, self.FOLLOW_6_in_expression52)
#action start
relation=logic_keynodes.Relation.nrel_disjunction
#action end
elif alt2 == 2:
# logic_gram.g:27:3: '&'
pass
self.match(self.input, 7, self.FOLLOW_7_in_expression57)
#action start
relation=logic_keynodes.Relation.nrel_conjunction
#action end
elif alt2 == 3:
# logic_gram.g:28:3: ( '->' | '<-' )
pass
# logic_gram.g:28:3: ( '->' | '<-' )
alt1 = 2
LA1_0 = self.input.LA(1)
if (LA1_0 == 8) :
alt1 = 1
elif (LA1_0 == 9) :
alt1 = 2
else:
nvae = NoViableAltException("", 1, 0, self.input)
raise nvae
if alt1 == 1:
# logic_gram.g:28:4: '->'
pass
self.match(self.input, 8, self.FOLLOW_8_in_expression64)
elif alt1 == 2:
# logic_gram.g:28:9: '<-'
pass
self.match(self.input, 9, self.FOLLOW_9_in_expression66)
#action start
revers=True
#action end
#action start
relation=logic_keynodes.Relation.nrel_implication
#action end
elif alt2 == 4:
# logic_gram.g:29:3: '<->'
pass
self.match(self.input, 10, self.FOLLOW_10_in_expression75)
#action start
relation=logic_keynodes.Relation.nrel_equivalence
#action end
self._state.following.append(self.FOLLOW_atom_in_expression84)
b = self.atom()
self._state.following.pop()
#action start
if relation==logic_keynodes.Relation.nrel_implication:
if revers:
a,b=b,a
node=sc_utils.createPairBinaryOrient(self.session, self.segment, a ,b, sc.SC_CONST)
else:
node=sc_utils.createPairBinaryNoOrient(self.session, self.segment, a ,b, sc.SC_CONST)
self.nodeList.append(node)
self.nodeList.append(sc_utils.createPairPosPerm(self.session, self.segment,relation, node, sc.SC_CONST))
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return node
# $ANTLR end "expression"
# $ANTLR start "brekets"
# logic_gram.g:43:1: brekets returns [node] : '(' expression ')' ;
def brekets(self, ):
node = None
expression1 = None
try:
try:
# logic_gram.g:44:2: ( '(' expression ')' )
# logic_gram.g:44:3: '(' expression ')'
pass
self.match(self.input, 11, self.FOLLOW_11_in_brekets102)
self._state.following.append(self.FOLLOW_expression_in_brekets104)
expression1 = self.expression()
self._state.following.pop()
#action start
node = expression1
#action end
self.match(self.input, 12, self.FOLLOW_12_in_brekets108)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return node
# $ANTLR end "brekets"
# $ANTLR start "negation"
# logic_gram.g:46:1: negation returns [node] : '!' atom ;
def negation(self, ):
node = None
atom2 = None
try:
try:
# logic_gram.g:47:2: ( '!' atom )
# logic_gram.g:47:3: '!' atom
pass
self.match(self.input, 13, self.FOLLOW_13_in_negation121)
self._state.following.append(self.FOLLOW_atom_in_negation123)
atom2 = self.atom()
self._state.following.pop()
#action start
node= self.session.create_el(self.segment, sc.SC_CONST)
atomNode=atom2
self.nodeList.append(sc_utils.createPairPosPerm(self.session, self.segment, logic_keynodes.Relation.nrel_negation, node, sc.SC_CONST))
self.nodeList.append(sc_utils.createPairPosPerm(self.session, self.segment, node, atomNode, sc.SC_CONST))
self.nodeList.append(node)
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return node
# $ANTLR end "negation"
# $ANTLR start "atom"
# logic_gram.g:55:1: atom returns [node] : ( | brekets | ID | negation );
def atom(self, ):
node = None
ID4 = None
brekets3 = None
negation5 = None
try:
try:
# logic_gram.g:55:20: ( | brekets | ID | negation )
alt3 = 4
LA3 = self.input.LA(1)
if LA3 == EOF or LA3 == 6 or LA3 == 7 or LA3 == 8 or LA3 == 9 or LA3 == 10 or LA3 == 12:
alt3 = 1
elif LA3 == 11:
alt3 = 2
elif LA3 == ID:
alt3 = 3
elif LA3 == 13:
alt3 = 4
else:
nvae = NoViableAltException("", 3, 0, self.input)
raise nvae
if alt3 == 1:
# logic_gram.g:56:2:
pass
elif alt3 == 2:
# logic_gram.g:56:4: brekets
pass
self._state.following.append(self.FOLLOW_brekets_in_atom140)
brekets3 = self.brekets()
self._state.following.pop()
#action start
node = brekets3
#action end
elif alt3 == 3:
# logic_gram.g:57:4: ID
pass
ID4=self.match(self.input, ID, self.FOLLOW_ID_in_atom147)
#action start
node = self.session.create_el_idtf(self.segment,sc.SC_CONST,ID4.text)[1]
self.nodeList.append(node)
#action end
elif alt3 == 4:
# logic_gram.g:60:4: negation
pass
self._state.following.append(self.FOLLOW_negation_in_atom154)
negation5 = self.negation()
self._state.following.pop()
#action start
node = negation5
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return node
# $ANTLR end "atom"
# Delegated rules
FOLLOW_expression_in_formula32 = frozenset([1])
FOLLOW_atom_in_expression49 = frozenset([6, 7, 8, 9, 10])
FOLLOW_6_in_expression52 = frozenset([4, 11, 13])
FOLLOW_7_in_expression57 = frozenset([4, 11, 13])
FOLLOW_8_in_expression64 = frozenset([4, 11, 13])
FOLLOW_9_in_expression66 = frozenset([4, 11, 13])
FOLLOW_10_in_expression75 = frozenset([4, 11, 13])
FOLLOW_atom_in_expression84 = frozenset([1])
FOLLOW_11_in_brekets102 = frozenset([4, 6, 7, 8, 9, 10, 11, 13])
FOLLOW_expression_in_brekets104 = frozenset([12])
FOLLOW_12_in_brekets108 = frozenset([1])
FOLLOW_13_in_negation121 = frozenset([4, 11, 13])
FOLLOW_atom_in_negation123 = frozenset([1])
FOLLOW_brekets_in_atom140 = frozenset([1])
FOLLOW_ID_in_atom147 = frozenset([1])
FOLLOW_negation_in_atom154 = frozenset([1])
class BuildFSM(TreeParser):
grammarFileName = "src/BuildFSM.g"
antlr_version = version_str_to_tuple("3.1.3 Mar 18, 2009 10:09:25")
antlr_version_str = "3.1.3 Mar 18, 2009 10:09:25"
tokenNames = tokenNames
def __init__(self, input, state=None, *args, **kwargs):
if state is None:
state = RecognizerSharedState()
super(BuildFSM, self).__init__(input, state, *args, **kwargs)
self.memory = []
self.isInSpecialState = False;
# $ANTLR start "description"
# src/BuildFSM.g:15:1: description : ^( PROTOCOL ( activityDef )+ ) ;
def description(self, ):
try:
try:
# src/BuildFSM.g:15:12: ( ^( PROTOCOL ( activityDef )+ ) )
# src/BuildFSM.g:15:14: ^( PROTOCOL ( activityDef )+ )
pass
self.match(self.input, PROTOCOL, self.FOLLOW_PROTOCOL_in_description47)
self.match(self.input, DOWN, None)
# src/BuildFSM.g:15:25: ( activityDef )+
cnt1 = 0
while True: #loop1
alt1 = 2
LA1_0 = self.input.LA(1)
if ((RESV <= LA1_0 <= SEND) or (UNORDERED <= LA1_0 <= PARALLEL) or LA1_0 == 39 or (42 <= LA1_0 <= 43)) :
alt1 = 1
if alt1 == 1:
# src/BuildFSM.g:15:25: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_description49)
self.activityDef()
self._state.following.pop()
else:
if cnt1 >= 1:
break #loop1
eee = EarlyExitException(1, self.input)
raise eee
cnt1 += 1
self.match(self.input, UP, None)
#action start
print "ProtocolDefinition"
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "description"
# $ANTLR start "activityDef"
# src/BuildFSM.g:16:1: activityDef : ( ^( RESV rlabel= ID (rtype= ID )* roleName ) | ^( SEND slabel= ID (stype= ID )* roleName ) | ^( 'choice' ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( PARALLEL ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( UNORDERED ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'repeat' ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'rec' label= ID ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'RECLABEL' labelID= ID ) );
def activityDef(self, ):
rlabel = None
rtype = None
slabel = None
stype = None
label = None
labelID = None
try:
try:
# src/BuildFSM.g:16:12: ( ^( RESV rlabel= ID (rtype= ID )* roleName ) | ^( SEND slabel= ID (stype= ID )* roleName ) | ^( 'choice' ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( PARALLEL ( ^( BRANCH ( activityDef )+ ) )+ ) | ^( UNORDERED ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'repeat' ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'rec' label= ID ( ^( BRANCH ( activityDef )+ ) ) ) | ^( 'RECLABEL' labelID= ID ) )
alt11 = 8
LA11 = self.input.LA(1)
if LA11 == RESV:
alt11 = 1
elif LA11 == SEND:
alt11 = 2
elif LA11 == 39:
alt11 = 3
elif LA11 == PARALLEL:
alt11 = 4
elif LA11 == UNORDERED:
alt11 = 5
elif LA11 == 42:
alt11 = 6
elif LA11 == 43:
alt11 = 7
elif LA11 == RECLABEL:
alt11 = 8
else:
nvae = NoViableAltException("", 11, 0, self.input)
raise nvae
if alt11 == 1:
# src/BuildFSM.g:17:4: ^( RESV rlabel= ID (rtype= ID )* roleName )
pass
self.match(self.input, RESV, self.FOLLOW_RESV_in_activityDef63)
self.match(self.input, DOWN, None)
rlabel=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef69)
#action start
self.memory.append('resv' + rlabel.text)
#action end
# src/BuildFSM.g:17:67: (rtype= ID )*
while True: #loop2
alt2 = 2
LA2_0 = self.input.LA(1)
if (LA2_0 == ID) :
LA2_1 = self.input.LA(2)
if (LA2_1 == ID) :
alt2 = 1
if alt2 == 1:
# src/BuildFSM.g:17:69: rtype= ID
pass
rtype=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef79)
#action start
self.memory.append(rtype.text)
#action end
else:
break #loop2
self._state.following.append(self.FOLLOW_roleName_in_activityDef85)
self.roleName()
self._state.following.pop()
self.match(self.input, UP, None)
elif alt11 == 2:
# src/BuildFSM.g:19:4: ^( SEND slabel= ID (stype= ID )* roleName )
pass
self.match(self.input, SEND, self.FOLLOW_SEND_in_activityDef93)
self.match(self.input, DOWN, None)
slabel=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef99)
#action start
self.memory.append('send' + slabel.text)
#action end
# src/BuildFSM.g:19:67: (stype= ID )*
while True: #loop3
alt3 = 2
LA3_0 = self.input.LA(1)
if (LA3_0 == ID) :
LA3_1 = self.input.LA(2)
if (LA3_1 == ID) :
alt3 = 1
if alt3 == 1:
# src/BuildFSM.g:19:69: stype= ID
pass
stype=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef109)
#action start
self.memory.append(stype.text)
#action end
else:
break #loop3
self._state.following.append(self.FOLLOW_roleName_in_activityDef115)
self.roleName()
self._state.following.pop()
self.match(self.input, UP, None)
elif alt11 == 3:
# src/BuildFSM.g:21:3: ^( 'choice' ( ^( BRANCH ( activityDef )+ ) )+ )
pass
self.match(self.input, 39, self.FOLLOW_39_in_activityDef122)
#action start
self.memory.append('enter choice state')
#action end
self.match(self.input, DOWN, None)
# src/BuildFSM.g:23:2: ( ^( BRANCH ( activityDef )+ ) )+
cnt5 = 0
while True: #loop5
alt5 = 2
LA5_0 = self.input.LA(1)
if (LA5_0 == BRANCH) :
alt5 = 1
if alt5 == 1:
# src/BuildFSM.g:23:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef132)
#action start
self.memory.append('enter choice branch')
#action end
self.match(self.input, DOWN, None)
# src/BuildFSM.g:23:56: ( activityDef )+
cnt4 = 0
while True: #loop4
alt4 = 2
LA4_0 = self.input.LA(1)
if ((RESV <= LA4_0 <= SEND) or (UNORDERED <= LA4_0 <= PARALLEL) or LA4_0 == 39 or (42 <= LA4_0 <= 43)) :
alt4 = 1
if alt4 == 1:
# src/BuildFSM.g:23:56: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef136)
self.activityDef()
self._state.following.pop()
else:
if cnt4 >= 1:
break #loop4
eee = EarlyExitException(4, self.input)
raise eee
cnt4 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('exit choice branch')
#action end
else:
if cnt5 >= 1:
break #loop5
eee = EarlyExitException(5, self.input)
raise eee
cnt5 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('exit choice state')
#action end
elif alt11 == 4:
# src/BuildFSM.g:26:4: ^( PARALLEL ( ^( BRANCH ( activityDef )+ ) )+ )
pass
self.match(self.input, PARALLEL, self.FOLLOW_PARALLEL_in_activityDef154)
#action start
self.memory.append('enter parallel state')
#action end
self.match(self.input, DOWN, None)
# src/BuildFSM.g:28:2: ( ^( BRANCH ( activityDef )+ ) )+
cnt7 = 0
while True: #loop7
alt7 = 2
LA7_0 = self.input.LA(1)
if (LA7_0 == BRANCH) :
alt7 = 1
if alt7 == 1:
# src/BuildFSM.g:28:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef171)
#action start
self.memory.append('enter parallel branch')
#action end
self.match(self.input, DOWN, None)
# src/BuildFSM.g:28:58: ( activityDef )+
cnt6 = 0
while True: #loop6
alt6 = 2
LA6_0 = self.input.LA(1)
if ((RESV <= LA6_0 <= SEND) or (UNORDERED <= LA6_0 <= PARALLEL) or LA6_0 == 39 or (42 <= LA6_0 <= 43)) :
alt6 = 1
if alt6 == 1:
# src/BuildFSM.g:28:58: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef175)
self.activityDef()
self._state.following.pop()
else:
if cnt6 >= 1:
break #loop6
eee = EarlyExitException(6, self.input)
raise eee
cnt6 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('exit parallel branch')
#action end
else:
if cnt7 >= 1:
break #loop7
eee = EarlyExitException(7, self.input)
raise eee
cnt7 += 1
self.match(self.input, UP, None)
#action start
self.memory.append('exit parallel state')
#action end
elif alt11 == 5:
# src/BuildFSM.g:31:3: ^( UNORDERED ( ^( BRANCH ( activityDef )+ ) ) )
pass
self.match(self.input, UNORDERED, self.FOLLOW_UNORDERED_in_activityDef192)
#action start
self.memory.append('enter unordered state')
#action end
self.match(self.input, DOWN, None)
# src/BuildFSM.g:33:2: ( ^( BRANCH ( activityDef )+ ) )
# src/BuildFSM.g:33:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef201)
self.match(self.input, DOWN, None)
# src/BuildFSM.g:33:12: ( activityDef )+
cnt8 = 0
while True: #loop8
alt8 = 2
LA8_0 = self.input.LA(1)
if ((RESV <= LA8_0 <= SEND) or (UNORDERED <= LA8_0 <= PARALLEL) or LA8_0 == 39 or (42 <= LA8_0 <= 43)) :
alt8 = 1
if alt8 == 1:
# src/BuildFSM.g:33:13: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef204)
self.activityDef()
self._state.following.pop()
#action start
self.memory.append('unordered statement')
#action end
else:
if cnt8 >= 1:
break #loop8
eee = EarlyExitException(8, self.input)
raise eee
cnt8 += 1
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
self.memory.append('exit unordered state')
#action end
elif alt11 == 6:
# src/BuildFSM.g:36:3: ^( 'repeat' ( ^( BRANCH ( activityDef )+ ) ) )
pass
self.match(self.input, 42, self.FOLLOW_42_in_activityDef221)
#action start
self.memory.append('enter repeat state')
#action end
self.match(self.input, DOWN, None)
# src/BuildFSM.g:38:2: ( ^( BRANCH ( activityDef )+ ) )
# src/BuildFSM.g:38:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef230)
self.match(self.input, DOWN, None)
# src/BuildFSM.g:38:12: ( activityDef )+
cnt9 = 0
while True: #loop9
alt9 = 2
LA9_0 = self.input.LA(1)
if ((RESV <= LA9_0 <= SEND) or (UNORDERED <= LA9_0 <= PARALLEL) or LA9_0 == 39 or (42 <= LA9_0 <= 43)) :
alt9 = 1
if alt9 == 1:
# src/BuildFSM.g:38:13: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef233)
self.activityDef()
self._state.following.pop()
#action start
self.memory.append('repeat statement')
#action end
else:
if cnt9 >= 1:
break #loop9
eee = EarlyExitException(9, self.input)
raise eee
cnt9 += 1
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
self.memory.append('exit repeat state')
#action end
elif alt11 == 7:
# src/BuildFSM.g:41:10: ^( 'rec' label= ID ( ^( BRANCH ( activityDef )+ ) ) )
pass
self.match(self.input, 43, self.FOLLOW_43_in_activityDef257)
self.match(self.input, DOWN, None)
label=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef263)
#action start
self.memory.append('enter rec state ' + label.text)
#action end
# src/BuildFSM.g:43:2: ( ^( BRANCH ( activityDef )+ ) )
# src/BuildFSM.g:43:3: ^( BRANCH ( activityDef )+ )
pass
self.match(self.input, BRANCH, self.FOLLOW_BRANCH_in_activityDef279)
self.match(self.input, DOWN, None)
# src/BuildFSM.g:43:12: ( activityDef )+
cnt10 = 0
while True: #loop10
alt10 = 2
LA10_0 = self.input.LA(1)
if ((RESV <= LA10_0 <= SEND) or (UNORDERED <= LA10_0 <= PARALLEL) or LA10_0 == 39 or (42 <= LA10_0 <= 43)) :
alt10 = 1
if alt10 == 1:
# src/BuildFSM.g:43:13: activityDef
pass
self._state.following.append(self.FOLLOW_activityDef_in_activityDef282)
self.activityDef()
self._state.following.pop()
#action start
self.memory.append('rec statement')
#action end
else:
if cnt10 >= 1:
break #loop10
eee = EarlyExitException(10, self.input)
raise eee
cnt10 += 1
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
self.memory.append('exit rec state ' + label.text)
#action end
elif alt11 == 8:
# src/BuildFSM.g:46:3: ^( 'RECLABEL' labelID= ID )
pass
self.match(self.input, RECLABEL, self.FOLLOW_RECLABEL_in_activityDef300)
self.match(self.input, DOWN, None)
labelID=self.match(self.input, ID, self.FOLLOW_ID_in_activityDef307)
#action start
self.memory.append('repeat rec again ' + labelID.text)
#action end
self.match(self.input, UP, None)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "activityDef"
# $ANTLR start "roleName"
# src/BuildFSM.g:48:1: roleName : ID ;
def roleName(self, ):
try:
try:
# src/BuildFSM.g:48:9: ( ID )
# src/BuildFSM.g:48:11: ID
pass
self.match(self.input, ID, self.FOLLOW_ID_in_roleName318)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "roleName"
# $ANTLR start "labelName"
# src/BuildFSM.g:49:1: labelName : ID ;
def labelName(self, ):
try:
try:
# src/BuildFSM.g:49:10: ( ID )
# src/BuildFSM.g:49:12: ID
pass
self.match(self.input, ID, self.FOLLOW_ID_in_labelName324)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "labelName"
# $ANTLR start "roleDef"
# src/BuildFSM.g:50:1: roleDef : ID ;
def roleDef(self, ):
try:
try:
# src/BuildFSM.g:50:8: ( ID )
# src/BuildFSM.g:50:10: ID
pass
self.match(self.input, ID, self.FOLLOW_ID_in_roleDef330)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "roleDef"
# Delegated rules
FOLLOW_PROTOCOL_in_description47 = frozenset([2])
FOLLOW_activityDef_in_description49 = frozenset([3, 10, 11, 13, 14, 15, 39, 42, 43])
FOLLOW_RESV_in_activityDef63 = frozenset([2])
FOLLOW_ID_in_activityDef69 = frozenset([18])
FOLLOW_ID_in_activityDef79 = frozenset([18])
FOLLOW_roleName_in_activityDef85 = frozenset([3])
FOLLOW_SEND_in_activityDef93 = frozenset([2])
FOLLOW_ID_in_activityDef99 = frozenset([18])
FOLLOW_ID_in_activityDef109 = frozenset([18])
FOLLOW_roleName_in_activityDef115 = frozenset([3])
FOLLOW_39_in_activityDef122 = frozenset([2])
FOLLOW_BRANCH_in_activityDef132 = frozenset([2])
FOLLOW_activityDef_in_activityDef136 = frozenset([3, 10, 11, 13, 14, 15, 39, 42, 43])
FOLLOW_PARALLEL_in_activityDef154 = frozenset([2])
FOLLOW_BRANCH_in_activityDef171 = frozenset([2])
FOLLOW_activityDef_in_activityDef175 = frozenset([3, 10, 11, 13, 14, 15, 39, 42, 43])
FOLLOW_UNORDERED_in_activityDef192 = frozenset([2])
FOLLOW_BRANCH_in_activityDef201 = frozenset([2])
FOLLOW_activityDef_in_activityDef204 = frozenset([3, 10, 11, 13, 14, 15, 39, 42, 43])
FOLLOW_42_in_activityDef221 = frozenset([2])
FOLLOW_BRANCH_in_activityDef230 = frozenset([2])
FOLLOW_activityDef_in_activityDef233 = frozenset([3, 10, 11, 13, 14, 15, 39, 42, 43])
FOLLOW_43_in_activityDef257 = frozenset([2])
FOLLOW_ID_in_activityDef263 = frozenset([12])
FOLLOW_BRANCH_in_activityDef279 = frozenset([2])
FOLLOW_activityDef_in_activityDef282 = frozenset([3, 10, 11, 13, 14, 15, 39, 42, 43])
FOLLOW_RECLABEL_in_activityDef300 = frozenset([2])
FOLLOW_ID_in_activityDef307 = frozenset([3])
FOLLOW_ID_in_roleName318 = frozenset([1])
FOLLOW_ID_in_labelName324 = frozenset([1])
FOLLOW_ID_in_roleDef330 = frozenset([1])
class bound(TreeParser):
grammarFileName = "C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g"
antlr_version = version_str_to_tuple("3.1.3 Mar 18, 2009 10:09:25")
antlr_version_str = "3.1.3 Mar 18, 2009 10:09:25"
tokenNames = tokenNames
def __init__(self, input, state=None, *args, **kwargs):
if state is None:
state = RecognizerSharedState()
super(bound, self).__init__(input, state, *args, **kwargs)
self.dfa1 = self.DFA1(
self, 1,
eot = self.DFA1_eot,
eof = self.DFA1_eof,
min = self.DFA1_min,
max = self.DFA1_max,
accept = self.DFA1_accept,
special = self.DFA1_special,
transition = self.DFA1_transition
)
bound = 0
def getBound(self):
return self.bound
# $ANTLR start "eval"
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g:58:1: eval : formula ;
def eval(self, ):
formula1 = None
try:
try:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g:58:5: ( formula )
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g:58:9: formula
pass
self._state.following.append(self.FOLLOW_formula_in_eval62)
formula1 = self.formula()
self._state.following.pop()
#action start
self.bound = formula1;
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "eval"
# $ANTLR start "formula"
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g:61:1: formula returns [value] : ( ^( OR a= formula b= formula ) | ^( AND a= formula b= formula ) | ^( NOT a= formula ) | ^( CONCAT a= formula b= formula ) | ^( HOLD INT PROP ) | ^( HOLD INT ^( NOT PROP ) ) | ^( WITHIN phi= formula low= INT high= INT ) | PROP | TRUE | FALSE );
def formula(self, ):
value = None
low = None
high = None
INT2 = None
INT3 = None
a = None
b = None
phi = None
try:
try:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g:62:5: ( ^( OR a= formula b= formula ) | ^( AND a= formula b= formula ) | ^( NOT a= formula ) | ^( CONCAT a= formula b= formula ) | ^( HOLD INT PROP ) | ^( HOLD INT ^( NOT PROP ) ) | ^( WITHIN phi= formula low= INT high= INT ) | PROP | TRUE | FALSE )
alt1 = 10
alt1 = self.dfa1.predict(self.input)
if alt1 == 1:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g:62:9: ^( OR a= formula b= formula )
pass
self.match(self.input, OR, self.FOLLOW_OR_in_formula88)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_formula_in_formula93)
a = self.formula()
self._state.following.pop()
self._state.following.append(self.FOLLOW_formula_in_formula97)
b = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
value = (min(a[0], b[0]), max(a[1], b[1]))
#action end
elif alt1 == 2:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g:63:9: ^( AND a= formula b= formula )
pass
self.match(self.input, AND, self.FOLLOW_AND_in_formula111)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_formula_in_formula115)
a = self.formula()
self._state.following.pop()
self._state.following.append(self.FOLLOW_formula_in_formula119)
b = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
value = (max(a[0], b[0]), max(a[1], b[1]))
#action end
elif alt1 == 3:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g:64:9: ^( NOT a= formula )
pass
self.match(self.input, NOT, self.FOLLOW_NOT_in_formula133)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_formula_in_formula137)
a = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
value = a
#action end
elif alt1 == 4:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g:65:9: ^( CONCAT a= formula b= formula )
pass
self.match(self.input, CONCAT, self.FOLLOW_CONCAT_in_formula161)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_formula_in_formula165)
a = self.formula()
self._state.following.pop()
self._state.following.append(self.FOLLOW_formula_in_formula169)
b = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
value = [x+y+1 for x, y in zip(a, b)]
#action end
elif alt1 == 5:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g:66:9: ^( HOLD INT PROP )
pass
self.match(self.input, HOLD, self.FOLLOW_HOLD_in_formula183)
self.match(self.input, DOWN, None)
INT2=self.match(self.input, INT, self.FOLLOW_INT_in_formula185)
self.match(self.input, PROP, self.FOLLOW_PROP_in_formula187)
self.match(self.input, UP, None)
#action start
value = (int(INT2.text), int(INT2.text))
#action end
elif alt1 == 6:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g:67:9: ^( HOLD INT ^( NOT PROP ) )
pass
self.match(self.input, HOLD, self.FOLLOW_HOLD_in_formula208)
self.match(self.input, DOWN, None)
INT3=self.match(self.input, INT, self.FOLLOW_INT_in_formula210)
self.match(self.input, NOT, self.FOLLOW_NOT_in_formula213)
self.match(self.input, DOWN, None)
self.match(self.input, PROP, self.FOLLOW_PROP_in_formula215)
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
value = (int(INT3.text), int(INT3.text))
#action end
elif alt1 == 7:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g:68:9: ^( WITHIN phi= formula low= INT high= INT )
pass
self.match(self.input, WITHIN, self.FOLLOW_WITHIN_in_formula230)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_formula_in_formula234)
phi = self.formula()
self._state.following.pop()
low=self.match(self.input, INT, self.FOLLOW_INT_in_formula238)
high=self.match(self.input, INT, self.FOLLOW_INT_in_formula242)
self.match(self.input, UP, None)
#action start
value = (int(low.text)+phi[0], int(high.text)) # - int(low.text)
if phi[1] > int(high.text) - int(low.text):
raise ValueError("Within operator deadline is invalid!")
#action end
elif alt1 == 8:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g:73:9: PROP
pass
self.match(self.input, PROP, self.FOLLOW_PROP_in_formula255)
#action start
value = (0, 0)
#action end
elif alt1 == 9:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g:74:9: TRUE
pass
self.match(self.input, TRUE, self.FOLLOW_TRUE_in_formula290)
#action start
value = (0, 0)
#action end
elif alt1 == 10:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\bound.g:75:9: FALSE
pass
self.match(self.input, FALSE, self.FOLLOW_FALSE_in_formula325)
#action start
value = (0, 0)
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return value
# $ANTLR end "formula"
# Delegated rules
# lookup tables for DFA #1
DFA1_eot = DFA.unpack(
u"\16\uffff"
)
DFA1_eof = DFA.unpack(
u"\16\uffff"
)
DFA1_min = DFA.unpack(
u"\1\4\4\uffff\1\2\4\uffff\1\12\1\6\2\uffff"
)
DFA1_max = DFA.unpack(
u"\1\15\4\uffff\1\2\4\uffff\1\12\1\13\2\uffff"
)
DFA1_accept = DFA.unpack(
u"\1\uffff\1\1\1\2\1\3\1\4\1\uffff\1\7\1\10\1\11\1\12\2\uffff\1"
u"\5\1\6"
)
DFA1_special = DFA.unpack(
u"\16\uffff"
)
DFA1_transition = [
DFA.unpack(u"\1\2\1\1\1\3\1\5\1\6\1\4\1\uffff\1\7\1\10\1\11"),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u"\1\12"),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u"\1\13"),
DFA.unpack(u"\1\15\4\uffff\1\14"),
DFA.unpack(u""),
DFA.unpack(u"")
]
# class definition for DFA #1
class DFA1(DFA):
pass
FOLLOW_formula_in_eval62 = frozenset([1])
FOLLOW_OR_in_formula88 = frozenset([2])
FOLLOW_formula_in_formula93 = frozenset([4, 5, 6, 7, 8, 9, 11, 12, 13])
FOLLOW_formula_in_formula97 = frozenset([3])
FOLLOW_AND_in_formula111 = frozenset([2])
FOLLOW_formula_in_formula115 = frozenset([4, 5, 6, 7, 8, 9, 11, 12, 13])
FOLLOW_formula_in_formula119 = frozenset([3])
FOLLOW_NOT_in_formula133 = frozenset([2])
FOLLOW_formula_in_formula137 = frozenset([3])
FOLLOW_CONCAT_in_formula161 = frozenset([2])
FOLLOW_formula_in_formula165 = frozenset([4, 5, 6, 7, 8, 9, 11, 12, 13])
FOLLOW_formula_in_formula169 = frozenset([3])
FOLLOW_HOLD_in_formula183 = frozenset([2])
FOLLOW_INT_in_formula185 = frozenset([11])
FOLLOW_PROP_in_formula187 = frozenset([3])
FOLLOW_HOLD_in_formula208 = frozenset([2])
FOLLOW_INT_in_formula210 = frozenset([6])
FOLLOW_NOT_in_formula213 = frozenset([2])
FOLLOW_PROP_in_formula215 = frozenset([3])
FOLLOW_WITHIN_in_formula230 = frozenset([2])
FOLLOW_formula_in_formula234 = frozenset([10])
FOLLOW_INT_in_formula238 = frozenset([10])
FOLLOW_INT_in_formula242 = frozenset([3])
FOLLOW_PROP_in_formula255 = frozenset([1])
FOLLOW_TRUE_in_formula290 = frozenset([1])
FOLLOW_FALSE_in_formula325 = frozenset([1])
class FiziksGramrParser(DebugParser):
grammarFileName = "C:\\Users\\James\\Documents\\FiziksGramr.g"
antlr_version = version_str_to_tuple("3.2 Sep 23, 2009 12:02:23")
antlr_version_str = "3.2 Sep 23, 2009 12:02:23"
tokenNames = tokenNames
def __init__(self, input, state=None, *args, **kwargs):
if state is None:
state = RecognizerSharedState()
debug_socket = kwargs.pop('debug_socket', None)
port = kwargs.pop('port', None)
super(FiziksGramrParser, self).__init__(input, state, *args, **kwargs)
self._state.ruleMemo = {}
self.ruleLevel = 0
if self._dbg is None:
proxy = DebugEventSocketProxy(self, debug=debug_socket, port=port)
self.setDebugListener(proxy)
proxy.handshake()
ruleNames = [
"invalidRule", "synpred6_FiziksGramr", "val", "statement",
"expression", "iimport", "synpred3_FiziksGramr",
"synpred4_FiziksGramr", "hippy", "theymustalldie", "start",
"synpred5_FiziksGramr", "synpred8_FiziksGramr", "synpred1_FiziksGramr",
"synpred7_FiziksGramr", "synpred2_FiziksGramr"
]
def getRuleLevel(self):
return self.ruleLevel
def incRuleLevel(self):
self.ruleLevel += 1
def decRuleLevel(self):
self.ruleLevel -= 1
def evalPredicate(self, result, predicate):
self._dbg.semanticPredicate(result, predicate)
return result
# $ANTLR start "start"
# C:\\Users\\James\\Documents\\FiziksGramr.g:74:1: start : ( statement '#' ']' )* ;
def start(self, ):
start_StartIndex = self.input.index()
try:
self._dbg.enterRule(self.getGrammarFileName(), "start")
if self.getRuleLevel() == 0:
self._dbg.commence()
self.incRuleLevel()
self._dbg.location(74, 1)
success = False
try:
try:
if self._state.backtracking > 0 and self.alreadyParsedRule(
self.input, 1):
# for cached failed rules, alreadyParsedRule will raise an exception
success = True
return
# C:\\Users\\James\\Documents\\FiziksGramr.g:74:7: ( ( statement '#' ']' )* )
self._dbg.enterAlt(1)
# C:\\Users\\James\\Documents\\FiziksGramr.g:74:9: ( statement '#' ']' )*
pass
self._dbg.location(74, 9)
# C:\\Users\\James\\Documents\\FiziksGramr.g:74:9: ( statement '#' ']' )*
try:
self._dbg.enterSubRule(1)
while True: #loop1
alt1 = 2
try:
self._dbg.enterDecision(1)
LA1_0 = self.input.LA(1)
if ((18 <= LA1_0 <= 20)):
alt1 = 1
finally:
self._dbg.exitDecision(1)
if alt1 == 1:
self._dbg.enterAlt(1)
# C:\\Users\\James\\Documents\\FiziksGramr.g:74:10: statement '#' ']'
pass
self._dbg.location(74, 10)
self._state.following.append(
self.FOLLOW_statement_in_start625)
self.statement()
self._state.following.pop()
self._dbg.location(74, 20)
self.match(self.input, 16,
self.FOLLOW_16_in_start627)
self._dbg.location(74, 24)
self.match(self.input, 17,
self.FOLLOW_17_in_start629)
else:
break #loop1
finally:
self._dbg.exitSubRule(1)
success = True
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
if self._state.backtracking > 0:
self.memoize(self.input, 1, start_StartIndex, success)
pass
self._dbg.location(74, 29)
finally:
self._dbg.exitRule(self.getGrammarFileName(), "start")
self.decRuleLevel()
if self.getRuleLevel() == 0:
self._dbg.terminate()
return
# $ANTLR end "start"
# $ANTLR start "statement"
# C:\\Users\\James\\Documents\\FiziksGramr.g:76:1: statement : ( iimport | hippy | theymustalldie );
def statement(self, ):
statement_StartIndex = self.input.index()
try:
self._dbg.enterRule(self.getGrammarFileName(), "statement")
if self.getRuleLevel() == 0:
self._dbg.commence()
self.incRuleLevel()
self._dbg.location(76, 1)
success = False
try:
try:
if self._state.backtracking > 0 and self.alreadyParsedRule(
self.input, 2):
# for cached failed rules, alreadyParsedRule will raise an exception
success = True
return
# C:\\Users\\James\\Documents\\FiziksGramr.g:77:2: ( iimport | hippy | theymustalldie )
alt2 = 3
try:
self._dbg.enterDecision(2)
LA2 = self.input.LA(1)
if LA2 == 18:
alt2 = 1
elif LA2 == 19:
alt2 = 2
elif LA2 == 20:
alt2 = 3
else:
if self._state.backtracking > 0:
raise BacktrackingFailed
nvae = NoViableAltException("", 2, 0, self.input)
self._dbg.recognitionException(nvae)
raise nvae
finally:
self._dbg.exitDecision(2)
if alt2 == 1:
self._dbg.enterAlt(1)
# C:\\Users\\James\\Documents\\FiziksGramr.g:77:4: iimport
pass
self._dbg.location(77, 4)
self._state.following.append(
self.FOLLOW_iimport_in_statement640)
self.iimport()
self._state.following.pop()
elif alt2 == 2:
self._dbg.enterAlt(2)
# C:\\Users\\James\\Documents\\FiziksGramr.g:77:12: hippy
pass
self._dbg.location(77, 12)
self._state.following.append(
self.FOLLOW_hippy_in_statement642)
self.hippy()
self._state.following.pop()
elif alt2 == 3:
self._dbg.enterAlt(3)
# C:\\Users\\James\\Documents\\FiziksGramr.g:77:18: theymustalldie
pass
self._dbg.location(77, 18)
self._state.following.append(
self.FOLLOW_theymustalldie_in_statement644)
self.theymustalldie()
self._state.following.pop()
success = True
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
if self._state.backtracking > 0:
self.memoize(self.input, 2, statement_StartIndex, success)
pass
self._dbg.location(77, 32)
finally:
self._dbg.exitRule(self.getGrammarFileName(), "statement")
self.decRuleLevel()
if self.getRuleLevel() == 0:
self._dbg.terminate()
return
# $ANTLR end "statement"
# $ANTLR start "iimport"
# C:\\Users\\James\\Documents\\FiziksGramr.g:79:1: iimport : 'import' val ;
def iimport(self, ):
iimport_StartIndex = self.input.index()
try:
self._dbg.enterRule(self.getGrammarFileName(), "iimport")
if self.getRuleLevel() == 0:
self._dbg.commence()
self.incRuleLevel()
self._dbg.location(79, 1)
success = False
try:
try:
if self._state.backtracking > 0 and self.alreadyParsedRule(
self.input, 3):
# for cached failed rules, alreadyParsedRule will raise an exception
success = True
return
# C:\\Users\\James\\Documents\\FiziksGramr.g:79:9: ( 'import' val )
self._dbg.enterAlt(1)
# C:\\Users\\James\\Documents\\FiziksGramr.g:79:11: 'import' val
pass
self._dbg.location(79, 11)
self.match(self.input, 18, self.FOLLOW_18_in_iimport653)
self._dbg.location(79, 20)
self._state.following.append(self.FOLLOW_val_in_iimport655)
self.val()
self._state.following.pop()
success = True
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
if self._state.backtracking > 0:
self.memoize(self.input, 3, iimport_StartIndex, success)
pass
self._dbg.location(79, 23)
finally:
self._dbg.exitRule(self.getGrammarFileName(), "iimport")
self.decRuleLevel()
if self.getRuleLevel() == 0:
self._dbg.terminate()
return
# $ANTLR end "iimport"
# $ANTLR start "hippy"
# C:\\Users\\James\\Documents\\FiziksGramr.g:81:1: hippy : 'hippy' expression ;
def hippy(self, ):
hippy_StartIndex = self.input.index()
try:
self._dbg.enterRule(self.getGrammarFileName(), "hippy")
if self.getRuleLevel() == 0:
self._dbg.commence()
self.incRuleLevel()
self._dbg.location(81, 1)
success = False
try:
try:
if self._state.backtracking > 0 and self.alreadyParsedRule(
self.input, 4):
# for cached failed rules, alreadyParsedRule will raise an exception
success = True
return
# C:\\Users\\James\\Documents\\FiziksGramr.g:81:7: ( 'hippy' expression )
self._dbg.enterAlt(1)
# C:\\Users\\James\\Documents\\FiziksGramr.g:81:9: 'hippy' expression
pass
self._dbg.location(81, 9)
self.match(self.input, 19, self.FOLLOW_19_in_hippy663)
self._dbg.location(81, 17)
self._state.following.append(
self.FOLLOW_expression_in_hippy665)
self.expression()
self._state.following.pop()
success = True
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
if self._state.backtracking > 0:
self.memoize(self.input, 4, hippy_StartIndex, success)
pass
self._dbg.location(81, 27)
finally:
self._dbg.exitRule(self.getGrammarFileName(), "hippy")
self.decRuleLevel()
if self.getRuleLevel() == 0:
self._dbg.terminate()
return
# $ANTLR end "hippy"
# $ANTLR start "theymustalldie"
# C:\\Users\\James\\Documents\\FiziksGramr.g:83:1: theymustalldie : 'all' 'the' 'hippies' 'must' 'die' ;
def theymustalldie(self, ):
theymustalldie_StartIndex = self.input.index()
try:
self._dbg.enterRule(self.getGrammarFileName(), "theymustalldie")
if self.getRuleLevel() == 0:
self._dbg.commence()
self.incRuleLevel()
self._dbg.location(83, 1)
success = False
try:
try:
if self._state.backtracking > 0 and self.alreadyParsedRule(
self.input, 5):
# for cached failed rules, alreadyParsedRule will raise an exception
success = True
return
# C:\\Users\\James\\Documents\\FiziksGramr.g:84:2: ( 'all' 'the' 'hippies' 'must' 'die' )
self._dbg.enterAlt(1)
# C:\\Users\\James\\Documents\\FiziksGramr.g:84:4: 'all' 'the' 'hippies' 'must' 'die'
pass
self._dbg.location(84, 4)
self.match(self.input, 20,
self.FOLLOW_20_in_theymustalldie674)
self._dbg.location(84, 10)
self.match(self.input, 21,
self.FOLLOW_21_in_theymustalldie676)
self._dbg.location(84, 16)
self.match(self.input, 22,
self.FOLLOW_22_in_theymustalldie678)
self._dbg.location(84, 26)
self.match(self.input, 23,
self.FOLLOW_23_in_theymustalldie680)
self._dbg.location(84, 33)
self.match(self.input, 24,
self.FOLLOW_24_in_theymustalldie682)
success = True
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
if self._state.backtracking > 0:
self.memoize(self.input, 5, theymustalldie_StartIndex,
success)
pass
self._dbg.location(84, 38)
finally:
self._dbg.exitRule(self.getGrammarFileName(), "theymustalldie")
self.decRuleLevel()
if self.getRuleLevel() == 0:
self._dbg.terminate()
return
# $ANTLR end "theymustalldie"
# $ANTLR start "expression"
# C:\\Users\\James\\Documents\\FiziksGramr.g:86:1: expression : val ( '-' val )* ;
def expression(self, ):
expression_StartIndex = self.input.index()
try:
self._dbg.enterRule(self.getGrammarFileName(), "expression")
if self.getRuleLevel() == 0:
self._dbg.commence()
self.incRuleLevel()
self._dbg.location(86, 1)
success = False
try:
try:
if self._state.backtracking > 0 and self.alreadyParsedRule(
self.input, 6):
# for cached failed rules, alreadyParsedRule will raise an exception
success = True
return
# C:\\Users\\James\\Documents\\FiziksGramr.g:87:2: ( val ( '-' val )* )
self._dbg.enterAlt(1)
# C:\\Users\\James\\Documents\\FiziksGramr.g:87:4: val ( '-' val )*
pass
self._dbg.location(87, 4)
self._state.following.append(
self.FOLLOW_val_in_expression692)
self.val()
self._state.following.pop()
self._dbg.location(87, 8)
# C:\\Users\\James\\Documents\\FiziksGramr.g:87:8: ( '-' val )*
try:
self._dbg.enterSubRule(3)
while True: #loop3
alt3 = 2
try:
self._dbg.enterDecision(3)
LA3_0 = self.input.LA(1)
if (LA3_0 == 25):
alt3 = 1
finally:
self._dbg.exitDecision(3)
if alt3 == 1:
self._dbg.enterAlt(1)
# C:\\Users\\James\\Documents\\FiziksGramr.g:87:9: '-' val
pass
self._dbg.location(87, 9)
self.match(self.input, 25,
self.FOLLOW_25_in_expression695)
self._dbg.location(87, 13)
self._state.following.append(
self.FOLLOW_val_in_expression697)
self.val()
self._state.following.pop()
else:
break #loop3
finally:
self._dbg.exitSubRule(3)
success = True
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
if self._state.backtracking > 0:
self.memoize(self.input, 6, expression_StartIndex, success)
pass
self._dbg.location(87, 18)
finally:
self._dbg.exitRule(self.getGrammarFileName(), "expression")
self.decRuleLevel()
if self.getRuleLevel() == 0:
self._dbg.terminate()
return
# $ANTLR end "expression"
# $ANTLR start "val"
# C:\\Users\\James\\Documents\\FiziksGramr.g:89:1: val : ( ID | INT | FLOAT | STRING | CHAR );
def val(self, ):
val_StartIndex = self.input.index()
try:
self._dbg.enterRule(self.getGrammarFileName(), "val")
if self.getRuleLevel() == 0:
self._dbg.commence()
self.incRuleLevel()
self._dbg.location(89, 1)
success = False
try:
try:
if self._state.backtracking > 0 and self.alreadyParsedRule(
self.input, 7):
# for cached failed rules, alreadyParsedRule will raise an exception
success = True
return
# C:\\Users\\James\\Documents\\FiziksGramr.g:89:6: ( ID | INT | FLOAT | STRING | CHAR )
self._dbg.enterAlt(1)
# C:\\Users\\James\\Documents\\FiziksGramr.g:
pass
self._dbg.location(89, 6)
if (ID <= self.input.LA(1) <= CHAR):
self.input.consume()
self._state.errorRecovery = False
else:
if self._state.backtracking > 0:
raise BacktrackingFailed
mse = MismatchedSetException(None, self.input)
self._dbg.recognitionException(mse)
raise mse
success = True
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
if self._state.backtracking > 0:
self.memoize(self.input, 7, val_StartIndex, success)
pass
self._dbg.location(89, 32)
finally:
self._dbg.exitRule(self.getGrammarFileName(), "val")
self.decRuleLevel()
if self.getRuleLevel() == 0:
self._dbg.terminate()
return
# $ANTLR end "val"
# Delegated rules
FOLLOW_statement_in_start625 = frozenset([16])
FOLLOW_16_in_start627 = frozenset([17])
FOLLOW_17_in_start629 = frozenset([1, 18, 19, 20])
FOLLOW_iimport_in_statement640 = frozenset([1])
FOLLOW_hippy_in_statement642 = frozenset([1])
FOLLOW_theymustalldie_in_statement644 = frozenset([1])
FOLLOW_18_in_iimport653 = frozenset([4, 5, 6, 7, 8])
FOLLOW_val_in_iimport655 = frozenset([1])
FOLLOW_19_in_hippy663 = frozenset([4, 5, 6, 7, 8])
FOLLOW_expression_in_hippy665 = frozenset([1])
FOLLOW_20_in_theymustalldie674 = frozenset([21])
FOLLOW_21_in_theymustalldie676 = frozenset([22])
FOLLOW_22_in_theymustalldie678 = frozenset([23])
FOLLOW_23_in_theymustalldie680 = frozenset([24])
FOLLOW_24_in_theymustalldie682 = frozenset([1])
FOLLOW_val_in_expression692 = frozenset([1, 25])
FOLLOW_25_in_expression695 = frozenset([4, 5, 6, 7, 8])
FOLLOW_val_in_expression697 = frozenset([1, 25])
FOLLOW_set_in_val0 = frozenset([1])
class psfParser(Parser):
grammarFileName = "psf.g"
tokenNames = tokenNames
def __init__(self, input):
Parser.__init__(self, input)
self.dfa2 = self.DFA2(self,
2,
eot=self.DFA2_eot,
eof=self.DFA2_eof,
min=self.DFA2_min,
max=self.DFA2_max,
accept=self.DFA2_accept,
special=self.DFA2_special,
transition=self.DFA2_transition)
self.adaptor = CommonTreeAdaptor()
class annotate_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start annotate
# psf.g:8:1: annotate : ( line | NEWLINE )* ;
def annotate(self, ):
retval = self.annotate_return()
retval.start = self.input.LT(1)
root_0 = None
NEWLINE2 = None
line1 = None
NEWLINE2_tree = None
try:
try:
# psf.g:8:9: ( ( line | NEWLINE )* )
# psf.g:8:11: ( line | NEWLINE )*
root_0 = self.adaptor.nil()
# psf.g:8:11: ( line | NEWLINE )*
while True: #loop1
alt1 = 3
LA1_0 = self.input.LA(1)
if (LA1_0 == DOLLARTOKEN or LA1_0 == LRB
or (TOKEN <= LA1_0 <= LCB) or LA1_0 == LSB):
alt1 = 1
elif (LA1_0 == NEWLINE):
alt1 = 2
if alt1 == 1:
# psf.g:8:12: line
self.following.append(self.FOLLOW_line_in_annotate35)
line1 = self.line()
self.following.pop()
self.adaptor.addChild(root_0, line1.tree)
elif alt1 == 2:
# psf.g:8:19: NEWLINE
NEWLINE2 = self.input.LT(1)
self.match(self.input, NEWLINE,
self.FOLLOW_NEWLINE_in_annotate39)
NEWLINE2_tree = self.adaptor.createWithPayload(
NEWLINE2)
self.adaptor.addChild(root_0, NEWLINE2_tree)
else:
break #loop1
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end annotate
class line_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start line
# psf.g:11:1: line : ( tagexpr | expr | conjexpr | corefexpr );
def line(self, ):
retval = self.line_return()
retval.start = self.input.LT(1)
root_0 = None
tagexpr3 = None
expr4 = None
conjexpr5 = None
corefexpr6 = None
try:
try:
# psf.g:11:6: ( tagexpr | expr | conjexpr | corefexpr )
alt2 = 4
alt2 = self.dfa2.predict(self.input)
if alt2 == 1:
# psf.g:11:8: tagexpr
root_0 = self.adaptor.nil()
self.following.append(self.FOLLOW_tagexpr_in_line51)
tagexpr3 = self.tagexpr()
self.following.pop()
self.adaptor.addChild(root_0, tagexpr3.tree)
elif alt2 == 2:
# psf.g:12:5: expr
root_0 = self.adaptor.nil()
self.following.append(self.FOLLOW_expr_in_line57)
expr4 = self.expr()
self.following.pop()
self.adaptor.addChild(root_0, expr4.tree)
elif alt2 == 3:
# psf.g:13:4: conjexpr
root_0 = self.adaptor.nil()
self.following.append(self.FOLLOW_conjexpr_in_line62)
conjexpr5 = self.conjexpr()
self.following.pop()
self.adaptor.addChild(root_0, conjexpr5.tree)
elif alt2 == 4:
# psf.g:14:4: corefexpr
root_0 = self.adaptor.nil()
self.following.append(self.FOLLOW_corefexpr_in_line67)
corefexpr6 = self.corefexpr()
self.following.pop()
self.adaptor.addChild(root_0, corefexpr6.tree)
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end line
class corefexpr_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start corefexpr
# psf.g:17:1: corefexpr : narrow EQ narrow ;
def corefexpr(self, ):
retval = self.corefexpr_return()
retval.start = self.input.LT(1)
root_0 = None
EQ8 = None
narrow7 = None
narrow9 = None
EQ8_tree = None
try:
try:
# psf.g:17:10: ( narrow EQ narrow )
# psf.g:18:3: narrow EQ narrow
root_0 = self.adaptor.nil()
self.following.append(self.FOLLOW_narrow_in_corefexpr78)
narrow7 = self.narrow()
self.following.pop()
self.adaptor.addChild(root_0, narrow7.tree)
EQ8 = self.input.LT(1)
self.match(self.input, EQ, self.FOLLOW_EQ_in_corefexpr80)
EQ8_tree = self.adaptor.createWithPayload(EQ8)
root_0 = self.adaptor.becomeRoot(EQ8_tree, root_0)
self.following.append(self.FOLLOW_narrow_in_corefexpr83)
narrow9 = self.narrow()
self.following.pop()
self.adaptor.addChild(root_0, narrow9.tree)
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end corefexpr
class expr_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start expr
# psf.g:24:1: expr : lc ;
def expr(self, ):
retval = self.expr_return()
retval.start = self.input.LT(1)
root_0 = None
lc10 = None
try:
try:
# psf.g:24:6: ( lc )
# psf.g:24:8: lc
root_0 = self.adaptor.nil()
self.following.append(self.FOLLOW_lc_in_expr96)
lc10 = self.lc()
self.following.pop()
self.adaptor.addChild(root_0, lc10.tree)
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end expr
class lc_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start lc
# psf.g:27:1: lc : rc ( LARROW lc )? ;
def lc(self, ):
retval = self.lc_return()
retval.start = self.input.LT(1)
root_0 = None
LARROW12 = None
rc11 = None
lc13 = None
LARROW12_tree = None
try:
try:
# psf.g:27:4: ( rc ( LARROW lc )? )
# psf.g:27:6: rc ( LARROW lc )?
root_0 = self.adaptor.nil()
self.following.append(self.FOLLOW_rc_in_lc106)
rc11 = self.rc()
self.following.pop()
self.adaptor.addChild(root_0, rc11.tree)
# psf.g:27:9: ( LARROW lc )?
alt3 = 2
LA3_0 = self.input.LA(1)
if (LA3_0 == LARROW):
alt3 = 1
if alt3 == 1:
# psf.g:27:10: LARROW lc
LARROW12 = self.input.LT(1)
self.match(self.input, LARROW, self.FOLLOW_LARROW_in_lc109)
LARROW12_tree = self.adaptor.createWithPayload(LARROW12)
root_0 = self.adaptor.becomeRoot(LARROW12_tree, root_0)
self.following.append(self.FOLLOW_lc_in_lc112)
lc13 = self.lc()
self.following.pop()
self.adaptor.addChild(root_0, lc13.tree)
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end lc
class rc_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start rc
# psf.g:30:1: rc : atom ( RARROW atom )* ;
def rc(self, ):
retval = self.rc_return()
retval.start = self.input.LT(1)
root_0 = None
RARROW15 = None
atom14 = None
atom16 = None
RARROW15_tree = None
try:
try:
# psf.g:30:4: ( atom ( RARROW atom )* )
# psf.g:30:6: atom ( RARROW atom )*
root_0 = self.adaptor.nil()
self.following.append(self.FOLLOW_atom_in_rc124)
atom14 = self.atom()
self.following.pop()
self.adaptor.addChild(root_0, atom14.tree)
# psf.g:30:11: ( RARROW atom )*
while True: #loop4
alt4 = 2
LA4_0 = self.input.LA(1)
if (LA4_0 == RARROW):
alt4 = 1
if alt4 == 1:
# psf.g:30:12: RARROW atom
RARROW15 = self.input.LT(1)
self.match(self.input, RARROW,
self.FOLLOW_RARROW_in_rc127)
RARROW15_tree = self.adaptor.createWithPayload(
RARROW15)
root_0 = self.adaptor.becomeRoot(RARROW15_tree, root_0)
self.following.append(self.FOLLOW_atom_in_rc130)
atom16 = self.atom()
self.following.pop()
self.adaptor.addChild(root_0, atom16.tree)
else:
break #loop4
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end rc
class conjexpr_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start conjexpr
# psf.g:33:1: conjexpr : DOLLARTOKEN DCOLON atom ( DCOLON atom )? ;
def conjexpr(self, ):
retval = self.conjexpr_return()
retval.start = self.input.LT(1)
root_0 = None
DOLLARTOKEN17 = None
DCOLON18 = None
DCOLON20 = None
atom19 = None
atom21 = None
DOLLARTOKEN17_tree = None
DCOLON18_tree = None
DCOLON20_tree = None
try:
try:
# psf.g:33:9: ( DOLLARTOKEN DCOLON atom ( DCOLON atom )? )
# psf.g:33:11: DOLLARTOKEN DCOLON atom ( DCOLON atom )?
root_0 = self.adaptor.nil()
DOLLARTOKEN17 = self.input.LT(1)
self.match(self.input, DOLLARTOKEN,
self.FOLLOW_DOLLARTOKEN_in_conjexpr141)
DOLLARTOKEN17_tree = self.adaptor.createWithPayload(
DOLLARTOKEN17)
self.adaptor.addChild(root_0, DOLLARTOKEN17_tree)
DCOLON18 = self.input.LT(1)
self.match(self.input, DCOLON,
self.FOLLOW_DCOLON_in_conjexpr143)
DCOLON18_tree = self.adaptor.createWithPayload(DCOLON18)
root_0 = self.adaptor.becomeRoot(DCOLON18_tree, root_0)
self.following.append(self.FOLLOW_atom_in_conjexpr146)
atom19 = self.atom()
self.following.pop()
self.adaptor.addChild(root_0, atom19.tree)
# psf.g:33:36: ( DCOLON atom )?
alt5 = 2
LA5_0 = self.input.LA(1)
if (LA5_0 == DCOLON):
alt5 = 1
if alt5 == 1:
# psf.g:33:37: DCOLON atom
DCOLON20 = self.input.LT(1)
self.match(self.input, DCOLON,
self.FOLLOW_DCOLON_in_conjexpr149)
self.following.append(self.FOLLOW_atom_in_conjexpr152)
atom21 = self.atom()
self.following.pop()
self.adaptor.addChild(root_0, atom21.tree)
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end conjexpr
class atom_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start atom
# psf.g:39:1: atom : ( narrow | curlyset | LRB ( expr )+ ( HEAD ( expr )* )? RRB );
def atom(self, ):
retval = self.atom_return()
retval.start = self.input.LT(1)
root_0 = None
LRB24 = None
HEAD26 = None
RRB28 = None
narrow22 = None
curlyset23 = None
expr25 = None
expr27 = None
LRB24_tree = None
HEAD26_tree = None
RRB28_tree = None
try:
try:
# psf.g:39:6: ( narrow | curlyset | LRB ( expr )+ ( HEAD ( expr )* )? RRB )
alt9 = 3
LA9 = self.input.LA(1)
if LA9 == DOLLARTOKEN or LA9 == TOKEN or LA9 == LSB:
alt9 = 1
elif LA9 == LCB:
alt9 = 2
elif LA9 == LRB:
alt9 = 3
else:
nvae = NoViableAltException(
"39:1: atom : ( narrow | curlyset | LRB ( expr )+ ( HEAD ( expr )* )? RRB );",
9, 0, self.input)
raise nvae
if alt9 == 1:
# psf.g:39:8: narrow
root_0 = self.adaptor.nil()
self.following.append(self.FOLLOW_narrow_in_atom167)
narrow22 = self.narrow()
self.following.pop()
self.adaptor.addChild(root_0, narrow22.tree)
elif alt9 == 2:
# psf.g:40:4: curlyset
root_0 = self.adaptor.nil()
self.following.append(self.FOLLOW_curlyset_in_atom172)
curlyset23 = self.curlyset()
self.following.pop()
self.adaptor.addChild(root_0, curlyset23.tree)
elif alt9 == 3:
# psf.g:41:4: LRB ( expr )+ ( HEAD ( expr )* )? RRB
root_0 = self.adaptor.nil()
LRB24 = self.input.LT(1)
self.match(self.input, LRB, self.FOLLOW_LRB_in_atom177)
LRB24_tree = self.adaptor.createWithPayload(LRB24)
root_0 = self.adaptor.becomeRoot(LRB24_tree, root_0)
# psf.g:41:9: ( expr )+
cnt6 = 0
while True: #loop6
alt6 = 2
LA6_0 = self.input.LA(1)
if (LA6_0 == DOLLARTOKEN or LA6_0 == LRB
or (TOKEN <= LA6_0 <= LCB) or LA6_0 == LSB):
alt6 = 1
if alt6 == 1:
# psf.g:41:9: expr
self.following.append(self.FOLLOW_expr_in_atom180)
expr25 = self.expr()
self.following.pop()
self.adaptor.addChild(root_0, expr25.tree)
else:
if cnt6 >= 1:
break #loop6
eee = EarlyExitException(6, self.input)
raise eee
cnt6 += 1
# psf.g:41:15: ( HEAD ( expr )* )?
alt8 = 2
LA8_0 = self.input.LA(1)
if (LA8_0 == HEAD):
alt8 = 1
if alt8 == 1:
# psf.g:41:16: HEAD ( expr )*
HEAD26 = self.input.LT(1)
self.match(self.input, HEAD,
self.FOLLOW_HEAD_in_atom184)
HEAD26_tree = self.adaptor.createWithPayload(HEAD26)
self.adaptor.addChild(root_0, HEAD26_tree)
# psf.g:41:21: ( expr )*
while True: #loop7
alt7 = 2
LA7_0 = self.input.LA(1)
if (LA7_0 == DOLLARTOKEN or LA7_0 == LRB
or (TOKEN <= LA7_0 <= LCB)
or LA7_0 == LSB):
alt7 = 1
if alt7 == 1:
# psf.g:41:21: expr
self.following.append(
self.FOLLOW_expr_in_atom186)
expr27 = self.expr()
self.following.pop()
self.adaptor.addChild(root_0, expr27.tree)
else:
break #loop7
RRB28 = self.input.LT(1)
self.match(self.input, RRB, self.FOLLOW_RRB_in_atom191)
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end atom
class narrow_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start narrow
# psf.g:44:1: narrow : ( TOKEN | DOLLARTOKEN | phrase );
def narrow(self, ):
retval = self.narrow_return()
retval.start = self.input.LT(1)
root_0 = None
TOKEN29 = None
DOLLARTOKEN30 = None
phrase31 = None
TOKEN29_tree = None
DOLLARTOKEN30_tree = None
try:
try:
# psf.g:44:8: ( TOKEN | DOLLARTOKEN | phrase )
alt10 = 3
LA10 = self.input.LA(1)
if LA10 == TOKEN:
alt10 = 1
elif LA10 == DOLLARTOKEN:
alt10 = 2
elif LA10 == LSB:
alt10 = 3
else:
nvae = NoViableAltException(
"44:1: narrow : ( TOKEN | DOLLARTOKEN | phrase );", 10,
0, self.input)
raise nvae
if alt10 == 1:
# psf.g:44:10: TOKEN
root_0 = self.adaptor.nil()
TOKEN29 = self.input.LT(1)
self.match(self.input, TOKEN,
self.FOLLOW_TOKEN_in_narrow202)
TOKEN29_tree = self.adaptor.createWithPayload(TOKEN29)
self.adaptor.addChild(root_0, TOKEN29_tree)
elif alt10 == 2:
# psf.g:45:4: DOLLARTOKEN
root_0 = self.adaptor.nil()
DOLLARTOKEN30 = self.input.LT(1)
self.match(self.input, DOLLARTOKEN,
self.FOLLOW_DOLLARTOKEN_in_narrow207)
DOLLARTOKEN30_tree = self.adaptor.createWithPayload(
DOLLARTOKEN30)
self.adaptor.addChild(root_0, DOLLARTOKEN30_tree)
elif alt10 == 3:
# psf.g:46:4: phrase
root_0 = self.adaptor.nil()
self.following.append(self.FOLLOW_phrase_in_narrow212)
phrase31 = self.phrase()
self.following.pop()
self.adaptor.addChild(root_0, phrase31.tree)
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end narrow
class curlyset_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start curlyset
# psf.g:49:1: curlyset : LCB ( atom )* RCB ;
def curlyset(self, ):
retval = self.curlyset_return()
retval.start = self.input.LT(1)
root_0 = None
LCB32 = None
RCB34 = None
atom33 = None
LCB32_tree = None
RCB34_tree = None
try:
try:
# psf.g:49:9: ( LCB ( atom )* RCB )
# psf.g:49:11: LCB ( atom )* RCB
root_0 = self.adaptor.nil()
LCB32 = self.input.LT(1)
self.match(self.input, LCB, self.FOLLOW_LCB_in_curlyset221)
LCB32_tree = self.adaptor.createWithPayload(LCB32)
root_0 = self.adaptor.becomeRoot(LCB32_tree, root_0)
# psf.g:49:16: ( atom )*
while True: #loop11
alt11 = 2
LA11_0 = self.input.LA(1)
if (LA11_0 == DOLLARTOKEN or LA11_0 == LRB
or (TOKEN <= LA11_0 <= LCB) or LA11_0 == LSB):
alt11 = 1
if alt11 == 1:
# psf.g:49:16: atom
self.following.append(self.FOLLOW_atom_in_curlyset224)
atom33 = self.atom()
self.following.pop()
self.adaptor.addChild(root_0, atom33.tree)
else:
break #loop11
RCB34 = self.input.LT(1)
self.match(self.input, RCB, self.FOLLOW_RCB_in_curlyset227)
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end curlyset
class phrase_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start phrase
# psf.g:52:1: phrase : LSB TOKEN ( TOKEN )+ RSB ;
def phrase(self, ):
retval = self.phrase_return()
retval.start = self.input.LT(1)
root_0 = None
LSB35 = None
TOKEN36 = None
TOKEN37 = None
RSB38 = None
LSB35_tree = None
TOKEN36_tree = None
TOKEN37_tree = None
RSB38_tree = None
try:
try:
# psf.g:52:8: ( LSB TOKEN ( TOKEN )+ RSB )
# psf.g:52:10: LSB TOKEN ( TOKEN )+ RSB
root_0 = self.adaptor.nil()
LSB35 = self.input.LT(1)
self.match(self.input, LSB, self.FOLLOW_LSB_in_phrase238)
LSB35_tree = self.adaptor.createWithPayload(LSB35)
root_0 = self.adaptor.becomeRoot(LSB35_tree, root_0)
TOKEN36 = self.input.LT(1)
self.match(self.input, TOKEN, self.FOLLOW_TOKEN_in_phrase241)
TOKEN36_tree = self.adaptor.createWithPayload(TOKEN36)
self.adaptor.addChild(root_0, TOKEN36_tree)
# psf.g:52:21: ( TOKEN )+
cnt12 = 0
while True: #loop12
alt12 = 2
LA12_0 = self.input.LA(1)
if (LA12_0 == TOKEN):
alt12 = 1
if alt12 == 1:
# psf.g:52:22: TOKEN
TOKEN37 = self.input.LT(1)
self.match(self.input, TOKEN,
self.FOLLOW_TOKEN_in_phrase244)
TOKEN37_tree = self.adaptor.createWithPayload(TOKEN37)
self.adaptor.addChild(root_0, TOKEN37_tree)
else:
if cnt12 >= 1:
break #loop12
eee = EarlyExitException(12, self.input)
raise eee
cnt12 += 1
RSB38 = self.input.LT(1)
self.match(self.input, RSB, self.FOLLOW_RSB_in_phrase248)
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end phrase
class tagexpr_return(object):
def __init__(self):
self.start = None
self.stop = None
self.tree = None
# $ANTLR start tagexpr
# psf.g:55:1: tagexpr : TOKEN ( VOCTAG | INTTAG ) ;
def tagexpr(self, ):
retval = self.tagexpr_return()
retval.start = self.input.LT(1)
root_0 = None
TOKEN39 = None
set40 = None
TOKEN39_tree = None
set40_tree = None
try:
try:
# psf.g:55:9: ( TOKEN ( VOCTAG | INTTAG ) )
# psf.g:55:11: TOKEN ( VOCTAG | INTTAG )
root_0 = self.adaptor.nil()
TOKEN39 = self.input.LT(1)
self.match(self.input, TOKEN, self.FOLLOW_TOKEN_in_tagexpr259)
TOKEN39_tree = self.adaptor.createWithPayload(TOKEN39)
self.adaptor.addChild(root_0, TOKEN39_tree)
set40 = self.input.LT(1)
if (VOCTAG <= self.input.LA(1) <= INTTAG):
self.input.consume()
root_0 = self.adaptor.becomeRoot(
self.adaptor.createWithPayload(set40), root_0)
self.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
self.recoverFromMismatchedSet(
self.input, mse, self.FOLLOW_set_in_tagexpr261)
raise mse
retval.stop = self.input.LT(-1)
retval.tree = self.adaptor.rulePostProcessing(root_0)
self.adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
# $ANTLR end tagexpr
# lookup tables for DFA #2
DFA2_eot = DFA.unpack(u"\13\uffff")
DFA2_eof = DFA.unpack(u"\1\uffff\2\4\7\uffff\1\4")
DFA2_min = DFA.unpack(u"\1\10\2\4\1\15\4\uffff\2\15\1\4")
DFA2_max = DFA.unpack(u"\1\20\1\23\1\20\1\15\4\uffff\1\15\1\21\1\20")
DFA2_accept = DFA.unpack(u"\4\uffff\1\2\1\1\1\4\1\3\3\uffff")
DFA2_special = DFA.unpack(u"\13\uffff")
DFA2_transition = [
DFA.unpack(u"\1\2\1\uffff\1\4\2\uffff\1\1\1\4\1\uffff\1\3"),
DFA.unpack(u"\1\4\1\6\3\4\1\uffff\1\4\2\uffff\2\4\1\uffff\1\4\1"
u"\uffff\2\5"),
DFA.unpack(u"\1\4\1\6\3\4\1\7\1\4\2\uffff\2\4\1\uffff\1\4"),
DFA.unpack(u"\1\10"),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u"\1\11"),
DFA.unpack(u"\1\11\3\uffff\1\12"),
DFA.unpack(u"\1\4\1\6\3\4\1\uffff\1\4\2\uffff\2\4\1\uffff\1\4")
]
# class definition for DFA #2
DFA2 = DFA
FOLLOW_line_in_annotate35 = frozenset([1, 4, 8, 10, 13, 14, 16])
FOLLOW_NEWLINE_in_annotate39 = frozenset([1, 4, 8, 10, 13, 14, 16])
FOLLOW_tagexpr_in_line51 = frozenset([1])
FOLLOW_expr_in_line57 = frozenset([1])
FOLLOW_conjexpr_in_line62 = frozenset([1])
FOLLOW_corefexpr_in_line67 = frozenset([1])
FOLLOW_narrow_in_corefexpr78 = frozenset([5])
FOLLOW_EQ_in_corefexpr80 = frozenset([8, 13, 16])
FOLLOW_narrow_in_corefexpr83 = frozenset([1])
FOLLOW_lc_in_expr96 = frozenset([1])
FOLLOW_rc_in_lc106 = frozenset([1, 6])
FOLLOW_LARROW_in_lc109 = frozenset([8, 10, 13, 14, 16])
FOLLOW_lc_in_lc112 = frozenset([1])
FOLLOW_atom_in_rc124 = frozenset([1, 7])
FOLLOW_RARROW_in_rc127 = frozenset([8, 10, 13, 14, 16])
FOLLOW_atom_in_rc130 = frozenset([1, 7])
FOLLOW_DOLLARTOKEN_in_conjexpr141 = frozenset([9])
FOLLOW_DCOLON_in_conjexpr143 = frozenset([8, 10, 13, 14, 16])
FOLLOW_atom_in_conjexpr146 = frozenset([1, 9])
FOLLOW_DCOLON_in_conjexpr149 = frozenset([8, 10, 13, 14, 16])
FOLLOW_atom_in_conjexpr152 = frozenset([1])
FOLLOW_narrow_in_atom167 = frozenset([1])
FOLLOW_curlyset_in_atom172 = frozenset([1])
FOLLOW_LRB_in_atom177 = frozenset([8, 10, 13, 14, 16])
FOLLOW_expr_in_atom180 = frozenset([8, 10, 11, 12, 13, 14, 16])
FOLLOW_HEAD_in_atom184 = frozenset([8, 10, 12, 13, 14, 16])
FOLLOW_expr_in_atom186 = frozenset([8, 10, 12, 13, 14, 16])
FOLLOW_RRB_in_atom191 = frozenset([1])
FOLLOW_TOKEN_in_narrow202 = frozenset([1])
FOLLOW_DOLLARTOKEN_in_narrow207 = frozenset([1])
FOLLOW_phrase_in_narrow212 = frozenset([1])
FOLLOW_LCB_in_curlyset221 = frozenset([8, 10, 13, 14, 15, 16])
FOLLOW_atom_in_curlyset224 = frozenset([8, 10, 13, 14, 15, 16])
FOLLOW_RCB_in_curlyset227 = frozenset([1])
FOLLOW_LSB_in_phrase238 = frozenset([13])
FOLLOW_TOKEN_in_phrase241 = frozenset([13])
FOLLOW_TOKEN_in_phrase244 = frozenset([13, 17])
FOLLOW_RSB_in_phrase248 = frozenset([1])
FOLLOW_TOKEN_in_tagexpr259 = frozenset([18, 19])
FOLLOW_set_in_tagexpr261 = frozenset([1])
class GrocParser(Parser):
grammarFileName = "Groc.g"
antlr_version = version_str_to_tuple("3.1.1")
antlr_version_str = "3.1.1"
tokenNames = tokenNames
def __init__(self, input, state=None):
if state is None:
state = RecognizerSharedState()
Parser.__init__(self, input, state)
self.ordinal_set = set()
self.weekday_set = set()
self.month_set = set()
self.time_string = '';
self.interval_mins = 0;
self.period_string = '';
valuesDict = {
SUNDAY: 0,
FIRST: 1,
MONDAY: 1,
JANUARY: 1,
TUESDAY: 2,
SECOND: 2,
FEBRUARY: 2,
WEDNESDAY: 3,
THIRD: 3,
MARCH: 3,
THURSDAY: 4,
FOURTH: 4,
APRIL: 4,
FRIDAY: 5,
FIFTH: 5,
MAY: 5,
SATURDAY: 6,
JUNE: 6,
JULY: 7,
AUGUST: 8,
SEPTEMBER: 9,
OCTOBER: 10,
NOVEMBER: 11,
DECEMBER: 12,
}
def ValueOf(self, token_type):
return self.valuesDict.get(token_type, -1)
def timespec(self, ):
try:
try:
pass
alt1 = 2
LA1_0 = self.input.LA(1)
if (LA1_0 == EVERY) :
LA1_1 = self.input.LA(2)
if ((DIGIT <= LA1_1 <= DIGITS)) :
alt1 = 2
elif ((MONDAY <= LA1_1 <= SUNDAY)) :
alt1 = 1
else:
nvae = NoViableAltException("", 1, 1, self.input)
raise nvae
elif ((FIRST <= LA1_0 <= FOURTH_OR_FIFTH)) :
alt1 = 1
else:
nvae = NoViableAltException("", 1, 0, self.input)
raise nvae
if alt1 == 1:
pass
self._state.following.append(self.FOLLOW_specifictime_in_timespec44)
self.specifictime()
self._state.following.pop()
elif alt1 == 2:
pass
self._state.following.append(self.FOLLOW_interval_in_timespec48)
self.interval()
self._state.following.pop()
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def specifictime(self, ):
TIME1 = None
try:
try:
pass
pass
pass
pass
pass
self._state.following.append(self.FOLLOW_ordinals_in_specifictime69)
self.ordinals()
self._state.following.pop()
self._state.following.append(self.FOLLOW_weekdays_in_specifictime71)
self.weekdays()
self._state.following.pop()
self.match(self.input, OF, self.FOLLOW_OF_in_specifictime75)
alt2 = 2
LA2_0 = self.input.LA(1)
if ((MONTH <= LA2_0 <= DECEMBER)) :
alt2 = 1
elif ((FIRST <= LA2_0 <= THIRD) or LA2_0 == QUARTER) :
alt2 = 2
else:
nvae = NoViableAltException("", 2, 0, self.input)
raise nvae
if alt2 == 1:
pass
self._state.following.append(self.FOLLOW_monthspec_in_specifictime78)
self.monthspec()
self._state.following.pop()
elif alt2 == 2:
pass
self._state.following.append(self.FOLLOW_quarterspec_in_specifictime80)
self.quarterspec()
self._state.following.pop()
TIME1=self.match(self.input, TIME, self.FOLLOW_TIME_in_specifictime93)
self.time_string = TIME1.text
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def interval(self, ):
intervalnum = None
period2 = None
try:
try:
pass
pass
self.match(self.input, EVERY, self.FOLLOW_EVERY_in_interval112)
intervalnum = self.input.LT(1)
if (DIGIT <= self.input.LA(1) <= DIGITS):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self.interval_mins = int(intervalnum.text)
self._state.following.append(self.FOLLOW_period_in_interval138)
period2 = self.period()
self._state.following.pop()
if ((period2 is not None) and [self.input.toString(period2.start,period2.stop)] or [None])[0] == "hours":
self.period_string = "hours"
else:
self.period_string = "minutes"
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def ordinals(self, ):
try:
try:
pass
alt4 = 2
LA4_0 = self.input.LA(1)
if (LA4_0 == EVERY) :
alt4 = 1
elif ((FIRST <= LA4_0 <= FOURTH_OR_FIFTH)) :
alt4 = 2
else:
nvae = NoViableAltException("", 4, 0, self.input)
raise nvae
if alt4 == 1:
pass
self.match(self.input, EVERY, self.FOLLOW_EVERY_in_ordinals157)
self.ordinal_set = self.ordinal_set.union(allOrdinals)
elif alt4 == 2:
pass
pass
self._state.following.append(self.FOLLOW_ordinal_in_ordinals173)
self.ordinal()
self._state.following.pop()
while True:
alt3 = 2
LA3_0 = self.input.LA(1)
if (LA3_0 == COMMA) :
alt3 = 1
if alt3 == 1:
pass
self.match(self.input, COMMA, self.FOLLOW_COMMA_in_ordinals176)
self._state.following.append(self.FOLLOW_ordinal_in_ordinals178)
self.ordinal()
self._state.following.pop()
else:
break
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def ordinal(self, ):
ord = None
try:
try:
pass
ord = self.input.LT(1)
if (FIRST <= self.input.LA(1) <= FOURTH_OR_FIFTH):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self.ordinal_set.add(self.ValueOf(ord.type));
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
class period_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
def period(self, ):
retval = self.period_return()
retval.start = self.input.LT(1)
try:
try:
pass
if (HOURS <= self.input.LA(1) <= MINUTES):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
retval.stop = self.input.LT(-1)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
def weekdays(self, ):
try:
try:
pass
pass
self._state.following.append(self.FOLLOW_weekday_in_weekdays261)
self.weekday()
self._state.following.pop()
while True:
alt5 = 2
LA5_0 = self.input.LA(1)
if (LA5_0 == COMMA) :
alt5 = 1
if alt5 == 1:
pass
self.match(self.input, COMMA, self.FOLLOW_COMMA_in_weekdays264)
self._state.following.append(self.FOLLOW_weekday_in_weekdays266)
self.weekday()
self._state.following.pop()
else:
break
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def weekday(self, ):
dayname = None
try:
try:
pass
dayname = self.input.LT(1)
if (MONDAY <= self.input.LA(1) <= SUNDAY):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self.weekday_set.add(self.ValueOf(dayname.type))
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def monthspec(self, ):
try:
try:
pass
alt6 = 2
LA6_0 = self.input.LA(1)
if (LA6_0 == MONTH) :
alt6 = 1
elif ((JANUARY <= LA6_0 <= DECEMBER)) :
alt6 = 2
else:
nvae = NoViableAltException("", 6, 0, self.input)
raise nvae
if alt6 == 1:
pass
self.match(self.input, MONTH, self.FOLLOW_MONTH_in_monthspec344)
self.month_set = self.month_set.union(set([
self.ValueOf(JANUARY), self.ValueOf(FEBRUARY), self.ValueOf(MARCH),
self.ValueOf(APRIL), self.ValueOf(MAY), self.ValueOf(JUNE),
self.ValueOf(JULY), self.ValueOf(AUGUST), self.ValueOf(SEPTEMBER),
self.ValueOf(OCTOBER), self.ValueOf(NOVEMBER),
self.ValueOf(DECEMBER)]))
elif alt6 == 2:
pass
self._state.following.append(self.FOLLOW_months_in_monthspec354)
self.months()
self._state.following.pop()
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def months(self, ):
try:
try:
pass
pass
self._state.following.append(self.FOLLOW_month_in_months371)
self.month()
self._state.following.pop()
while True:
alt7 = 2
LA7_0 = self.input.LA(1)
if (LA7_0 == COMMA) :
alt7 = 1
if alt7 == 1:
pass
self.match(self.input, COMMA, self.FOLLOW_COMMA_in_months374)
self._state.following.append(self.FOLLOW_month_in_months376)
self.month()
self._state.following.pop()
else:
break
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def month(self, ):
monthname = None
try:
try:
pass
monthname = self.input.LT(1)
if (JANUARY <= self.input.LA(1) <= DECEMBER):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self.month_set.add(self.ValueOf(monthname.type));
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def quarterspec(self, ):
try:
try:
pass
alt8 = 2
LA8_0 = self.input.LA(1)
if (LA8_0 == QUARTER) :
alt8 = 1
elif ((FIRST <= LA8_0 <= THIRD)) :
alt8 = 2
else:
nvae = NoViableAltException("", 8, 0, self.input)
raise nvae
if alt8 == 1:
pass
self.match(self.input, QUARTER, self.FOLLOW_QUARTER_in_quarterspec468)
self.month_set = self.month_set.union(set([
self.ValueOf(JANUARY), self.ValueOf(APRIL), self.ValueOf(JULY),
self.ValueOf(OCTOBER)]))
elif alt8 == 2:
pass
pass
self._state.following.append(self.FOLLOW_quarter_ordinals_in_quarterspec480)
self.quarter_ordinals()
self._state.following.pop()
self.match(self.input, MONTH, self.FOLLOW_MONTH_in_quarterspec482)
self.match(self.input, OF, self.FOLLOW_OF_in_quarterspec484)
self.match(self.input, QUARTER, self.FOLLOW_QUARTER_in_quarterspec486)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def quarter_ordinals(self, ):
try:
try:
pass
pass
self._state.following.append(self.FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals505)
self.month_of_quarter_ordinal()
self._state.following.pop()
while True:
alt9 = 2
LA9_0 = self.input.LA(1)
if (LA9_0 == COMMA) :
alt9 = 1
if alt9 == 1:
pass
self.match(self.input, COMMA, self.FOLLOW_COMMA_in_quarter_ordinals508)
self._state.following.append(self.FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals510)
self.month_of_quarter_ordinal()
self._state.following.pop()
else:
break
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def month_of_quarter_ordinal(self, ):
offset = None
try:
try:
pass
offset = self.input.LT(1)
if (FIRST <= self.input.LA(1) <= THIRD):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
jOffset = self.ValueOf(offset.type) - 1
self.month_set = self.month_set.union(set([
jOffset + self.ValueOf(JANUARY), jOffset + self.ValueOf(APRIL),
jOffset + self.ValueOf(JULY), jOffset + self.ValueOf(OCTOBER)]))
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
FOLLOW_specifictime_in_timespec44 = frozenset([1])
FOLLOW_interval_in_timespec48 = frozenset([1])
FOLLOW_ordinals_in_specifictime69 = frozenset([18, 19, 20, 21, 22, 23, 24])
FOLLOW_weekdays_in_specifictime71 = frozenset([4])
FOLLOW_OF_in_specifictime75 = frozenset([10, 11, 12, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38])
FOLLOW_monthspec_in_specifictime78 = frozenset([5])
FOLLOW_quarterspec_in_specifictime80 = frozenset([5])
FOLLOW_TIME_in_specifictime93 = frozenset([1])
FOLLOW_EVERY_in_interval112 = frozenset([7, 8])
FOLLOW_set_in_interval122 = frozenset([16, 17])
FOLLOW_period_in_interval138 = frozenset([1])
FOLLOW_EVERY_in_ordinals157 = frozenset([1])
FOLLOW_ordinal_in_ordinals173 = frozenset([1, 9])
FOLLOW_COMMA_in_ordinals176 = frozenset([10, 11, 12, 13, 14, 15])
FOLLOW_ordinal_in_ordinals178 = frozenset([1, 9])
FOLLOW_set_in_ordinal199 = frozenset([1])
FOLLOW_set_in_period238 = frozenset([1])
FOLLOW_weekday_in_weekdays261 = frozenset([1, 9])
FOLLOW_COMMA_in_weekdays264 = frozenset([18, 19, 20, 21, 22, 23, 24])
FOLLOW_weekday_in_weekdays266 = frozenset([1, 9])
FOLLOW_set_in_weekday285 = frozenset([1])
FOLLOW_MONTH_in_monthspec344 = frozenset([1])
FOLLOW_months_in_monthspec354 = frozenset([1])
FOLLOW_month_in_months371 = frozenset([1, 9])
FOLLOW_COMMA_in_months374 = frozenset([25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37])
FOLLOW_month_in_months376 = frozenset([1, 9])
FOLLOW_set_in_month395 = frozenset([1])
FOLLOW_QUARTER_in_quarterspec468 = frozenset([1])
FOLLOW_quarter_ordinals_in_quarterspec480 = frozenset([25])
FOLLOW_MONTH_in_quarterspec482 = frozenset([4])
FOLLOW_OF_in_quarterspec484 = frozenset([38])
FOLLOW_QUARTER_in_quarterspec486 = frozenset([1])
FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals505 = frozenset([1, 9])
FOLLOW_COMMA_in_quarter_ordinals508 = frozenset([10, 11, 12, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38])
FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals510 = frozenset([1, 9])
FOLLOW_set_in_month_of_quarter_ordinal529 = frozenset([1])
class twtl2dfa(TreeParser):
grammarFileName = "C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g"
antlr_version = version_str_to_tuple("3.1.3 Mar 18, 2009 10:09:25")
antlr_version_str = "3.1.3 Mar 18, 2009 10:09:25"
tokenNames = tokenNames
def __init__(self, input, state=None, *args, **kwargs):
if state is None:
state = RecognizerSharedState()
super(twtl2dfa, self).__init__(input, state, *args, **kwargs)
self.dfa1 = self.DFA1(self,
1,
eot=self.DFA1_eot,
eof=self.DFA1_eof,
min=self.DFA1_min,
max=self.DFA1_max,
accept=self.DFA1_accept,
special=self.DFA1_special,
transition=self.DFA1_transition)
dfa = None
props = None
def getDFA(self):
return self.dfa
# $ANTLR start "eval"
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g:61:1: eval : formula ;
def eval(self, ):
formula1 = None
try:
try:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g:61:5: ( formula )
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g:61:9: formula
pass
self._state.following.append(self.FOLLOW_formula_in_eval62)
formula1 = self.formula()
self._state.following.pop()
#action start
self.dfa = formula1
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "eval"
# $ANTLR start "formula"
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g:64:1: formula returns [dfa] : ( ^( OR a= formula b= formula ) | ^( AND a= formula b= formula ) | ^( NOT a= formula ) | ^( CONCAT a= formula b= formula ) | ^( HOLD INT p= PROP ) | ^( HOLD INT ^( NOT p= PROP ) ) | ^( WITHIN phi= formula low= INT high= INT ) | PROP | TRUE | FALSE );
def formula(self, ):
dfa = None
p = None
low = None
high = None
INT2 = None
INT3 = None
PROP4 = None
a = None
b = None
phi = None
try:
try:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g:65:5: ( ^( OR a= formula b= formula ) | ^( AND a= formula b= formula ) | ^( NOT a= formula ) | ^( CONCAT a= formula b= formula ) | ^( HOLD INT p= PROP ) | ^( HOLD INT ^( NOT p= PROP ) ) | ^( WITHIN phi= formula low= INT high= INT ) | PROP | TRUE | FALSE )
alt1 = 10
alt1 = self.dfa1.predict(self.input)
if alt1 == 1:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g:65:9: ^( OR a= formula b= formula )
pass
self.match(self.input, OR, self.FOLLOW_OR_in_formula88)
self.match(self.input, DOWN, None)
self._state.following.append(
self.FOLLOW_formula_in_formula93)
a = self.formula()
self._state.following.pop()
self._state.following.append(
self.FOLLOW_formula_in_formula97)
b = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
dfa = union(a, b)
#action end
elif alt1 == 2:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g:66:9: ^( AND a= formula b= formula )
pass
self.match(self.input, AND, self.FOLLOW_AND_in_formula112)
self.match(self.input, DOWN, None)
self._state.following.append(
self.FOLLOW_formula_in_formula116)
a = self.formula()
self._state.following.pop()
self._state.following.append(
self.FOLLOW_formula_in_formula120)
b = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
dfa = intersection(a, b)
#action end
elif alt1 == 3:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g:67:9: ^( NOT a= formula )
pass
self.match(self.input, NOT, self.FOLLOW_NOT_in_formula135)
self.match(self.input, DOWN, None)
self._state.following.append(
self.FOLLOW_formula_in_formula139)
a = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
dfa = complement(a)
#action end
elif alt1 == 4:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g:68:9: ^( CONCAT a= formula b= formula )
pass
self.match(self.input, CONCAT,
self.FOLLOW_CONCAT_in_formula164)
self.match(self.input, DOWN, None)
self._state.following.append(
self.FOLLOW_formula_in_formula168)
a = self.formula()
self._state.following.pop()
self._state.following.append(
self.FOLLOW_formula_in_formula172)
b = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
dfa = concatenation(a, b)
#action end
elif alt1 == 5:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g:69:9: ^( HOLD INT p= PROP )
pass
self.match(self.input, HOLD,
self.FOLLOW_HOLD_in_formula187)
self.match(self.input, DOWN, None)
INT2 = self.match(self.input, INT,
self.FOLLOW_INT_in_formula189)
p = self.match(self.input, PROP,
self.FOLLOW_PROP_in_formula193)
self.match(self.input, UP, None)
#action start
dfa = hold(self.props,
p.text,
int(INT2.text),
negation=False)
#action end
elif alt1 == 6:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g:72:9: ^( HOLD INT ^( NOT p= PROP ) )
pass
self.match(self.input, HOLD,
self.FOLLOW_HOLD_in_formula207)
self.match(self.input, DOWN, None)
INT3 = self.match(self.input, INT,
self.FOLLOW_INT_in_formula209)
self.match(self.input, NOT, self.FOLLOW_NOT_in_formula212)
self.match(self.input, DOWN, None)
p = self.match(self.input, PROP,
self.FOLLOW_PROP_in_formula216)
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
dfa = hold(self.props,
p.text,
int(INT3.text),
negation=True)
#action end
elif alt1 == 7:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g:75:9: ^( WITHIN phi= formula low= INT high= INT )
pass
self.match(self.input, WITHIN,
self.FOLLOW_WITHIN_in_formula231)
self.match(self.input, DOWN, None)
self._state.following.append(
self.FOLLOW_formula_in_formula235)
phi = self.formula()
self._state.following.pop()
low = self.match(self.input, INT,
self.FOLLOW_INT_in_formula239)
high = self.match(self.input, INT,
self.FOLLOW_INT_in_formula243)
self.match(self.input, UP, None)
#action start
dfa = within(phi, int(low.text), int(high.text))
#action end
elif alt1 == 8:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g:78:9: PROP
pass
PROP4 = self.match(self.input, PROP,
self.FOLLOW_PROP_in_formula256)
#action start
dfa = accept_prop(self.props, prop=PROP4)
#action end
elif alt1 == 9:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g:79:9: TRUE
pass
self.match(self.input, TRUE,
self.FOLLOW_TRUE_in_formula291)
#action start
dfa = accept_prop(self.props, boolean=True)
#action end
elif alt1 == 10:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl2dfa.g:80:9: FALSE
pass
self.match(self.input, FALSE,
self.FOLLOW_FALSE_in_formula326)
#action start
dfa = accept_prop(self.props, boolean=False)
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return dfa
# $ANTLR end "formula"
# Delegated rules
# lookup tables for DFA #1
DFA1_eot = DFA.unpack(u"\16\uffff")
DFA1_eof = DFA.unpack(u"\16\uffff")
DFA1_min = DFA.unpack(u"\1\4\4\uffff\1\2\4\uffff\1\12\1\6\2\uffff")
DFA1_max = DFA.unpack(u"\1\15\4\uffff\1\2\4\uffff\1\12\1\13\2\uffff")
DFA1_accept = DFA.unpack(
u"\1\uffff\1\1\1\2\1\3\1\4\1\uffff\1\7\1\10\1\11\1\12\2\uffff\1"
u"\5\1\6")
DFA1_special = DFA.unpack(u"\16\uffff")
DFA1_transition = [
DFA.unpack(u"\1\2\1\1\1\3\1\5\1\6\1\4\1\uffff\1\7\1\10\1\11"),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u"\1\12"),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u""),
DFA.unpack(u"\1\13"),
DFA.unpack(u"\1\15\4\uffff\1\14"),
DFA.unpack(u""),
DFA.unpack(u"")
]
# class definition for DFA #1
class DFA1(DFA):
pass
FOLLOW_formula_in_eval62 = frozenset([1])
FOLLOW_OR_in_formula88 = frozenset([2])
FOLLOW_formula_in_formula93 = frozenset([4, 5, 6, 7, 8, 9, 11, 12, 13])
FOLLOW_formula_in_formula97 = frozenset([3])
FOLLOW_AND_in_formula112 = frozenset([2])
FOLLOW_formula_in_formula116 = frozenset([4, 5, 6, 7, 8, 9, 11, 12, 13])
FOLLOW_formula_in_formula120 = frozenset([3])
FOLLOW_NOT_in_formula135 = frozenset([2])
FOLLOW_formula_in_formula139 = frozenset([3])
FOLLOW_CONCAT_in_formula164 = frozenset([2])
FOLLOW_formula_in_formula168 = frozenset([4, 5, 6, 7, 8, 9, 11, 12, 13])
FOLLOW_formula_in_formula172 = frozenset([3])
FOLLOW_HOLD_in_formula187 = frozenset([2])
FOLLOW_INT_in_formula189 = frozenset([11])
FOLLOW_PROP_in_formula193 = frozenset([3])
FOLLOW_HOLD_in_formula207 = frozenset([2])
FOLLOW_INT_in_formula209 = frozenset([6])
FOLLOW_NOT_in_formula212 = frozenset([2])
FOLLOW_PROP_in_formula216 = frozenset([3])
FOLLOW_WITHIN_in_formula231 = frozenset([2])
FOLLOW_formula_in_formula235 = frozenset([10])
FOLLOW_INT_in_formula239 = frozenset([10])
FOLLOW_INT_in_formula243 = frozenset([3])
FOLLOW_PROP_in_formula256 = frozenset([1])
FOLLOW_TRUE_in_formula291 = frozenset([1])
FOLLOW_FALSE_in_formula326 = frozenset([1])
class twtl2dfa(TreeParser):
grammarFileName = "twtl2dfa.g"
api_version = 1
tokenNames = tokenNames
def __init__(self, input, state=None, *args, **kwargs):
if state is None:
state = RecognizerSharedState()
super(twtl2dfa, self).__init__(input, state, *args, **kwargs)
self.delegates = []
dfa=None
props = None
def getDFA(self):
return self.dfa
# $ANTLR start "eval"
# twtl2dfa.g:62:1: eval : formula ;
def eval(self, ):
formula1 = None
try:
try:
# twtl2dfa.g:62:5: ( formula )
# twtl2dfa.g:62:9: formula
pass
self._state.following.append(self.FOLLOW_formula_in_eval62)
formula1 = self.formula()
self._state.following.pop()
#action start
self.dfa = formula1;
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "eval"
# $ANTLR start "formula"
# twtl2dfa.g:65:1: formula returns [dfa] : ( ^( OR a= formula b= formula ) | ^( AND a= formula b= formula ) | ^( NOT a= formula ) | ^( CONCAT a= formula b= formula ) | ^( HOLD INT p= PROP ) | ^( HOLD INT ^( NOT p= PROP ) ) | ^( WITHIN phi= formula low= INT high= INT ) | PROP | TRUE | FALSE );
def formula(self, ):
dfa = None
p = None
low = None
high = None
INT2 = None
INT3 = None
PROP4 = None
a = None
b = None
phi = None
try:
try:
# twtl2dfa.g:66:5: ( ^( OR a= formula b= formula ) | ^( AND a= formula b= formula ) | ^( NOT a= formula ) | ^( CONCAT a= formula b= formula ) | ^( HOLD INT p= PROP ) | ^( HOLD INT ^( NOT p= PROP ) ) | ^( WITHIN phi= formula low= INT high= INT ) | PROP | TRUE | FALSE )
alt1 = 10
LA1 = self.input.LA(1)
if LA1 == OR:
alt1 = 1
elif LA1 == AND:
alt1 = 2
elif LA1 == NOT:
alt1 = 3
elif LA1 == CONCAT:
alt1 = 4
elif LA1 == HOLD:
LA1_5 = self.input.LA(2)
if (LA1_5 == 2) :
LA1_10 = self.input.LA(3)
if (LA1_10 == INT) :
LA1_11 = self.input.LA(4)
if (LA1_11 == PROP) :
alt1 = 5
elif (LA1_11 == NOT) :
alt1 = 6
else:
nvae = NoViableAltException("", 1, 11, self.input)
raise nvae
else:
nvae = NoViableAltException("", 1, 10, self.input)
raise nvae
else:
nvae = NoViableAltException("", 1, 5, self.input)
raise nvae
elif LA1 == WITHIN:
alt1 = 7
elif LA1 == PROP:
alt1 = 8
elif LA1 == TRUE:
alt1 = 9
elif LA1 == FALSE:
alt1 = 10
else:
nvae = NoViableAltException("", 1, 0, self.input)
raise nvae
if alt1 == 1:
# twtl2dfa.g:66:9: ^( OR a= formula b= formula )
pass
self.match(self.input, OR, self.FOLLOW_OR_in_formula88)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_formula_in_formula93)
a = self.formula()
self._state.following.pop()
self._state.following.append(self.FOLLOW_formula_in_formula97)
b = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
dfa = union(a, b)
#action end
elif alt1 == 2:
# twtl2dfa.g:67:9: ^( AND a= formula b= formula )
pass
self.match(self.input, AND, self.FOLLOW_AND_in_formula112)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_formula_in_formula116)
a = self.formula()
self._state.following.pop()
self._state.following.append(self.FOLLOW_formula_in_formula120)
b = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
dfa = intersection(a, b)
#action end
elif alt1 == 3:
# twtl2dfa.g:68:9: ^( NOT a= formula )
pass
self.match(self.input, NOT, self.FOLLOW_NOT_in_formula135)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_formula_in_formula139)
a = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
dfa = complement(a)
#action end
elif alt1 == 4:
# twtl2dfa.g:69:9: ^( CONCAT a= formula b= formula )
pass
self.match(self.input, CONCAT, self.FOLLOW_CONCAT_in_formula164)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_formula_in_formula168)
a = self.formula()
self._state.following.pop()
self._state.following.append(self.FOLLOW_formula_in_formula172)
b = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
dfa = concatenation(a, b)
#action end
elif alt1 == 5:
# twtl2dfa.g:70:9: ^( HOLD INT p= PROP )
pass
self.match(self.input, HOLD, self.FOLLOW_HOLD_in_formula187)
self.match(self.input, DOWN, None)
INT2 = self.match(self.input, INT, self.FOLLOW_INT_in_formula189)
p = self.match(self.input, PROP, self.FOLLOW_PROP_in_formula193)
self.match(self.input, UP, None)
#action start
dfa = hold(self.props, p.text, int(INT2.text), negation=False)
#action end
elif alt1 == 6:
# twtl2dfa.g:73:9: ^( HOLD INT ^( NOT p= PROP ) )
pass
self.match(self.input, HOLD, self.FOLLOW_HOLD_in_formula207)
self.match(self.input, DOWN, None)
INT3 = self.match(self.input, INT, self.FOLLOW_INT_in_formula209)
self.match(self.input, NOT, self.FOLLOW_NOT_in_formula212)
self.match(self.input, DOWN, None)
p = self.match(self.input, PROP, self.FOLLOW_PROP_in_formula216)
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
dfa = hold(self.props, p.text, int(INT3.text), negation=True)
#action end
elif alt1 == 7:
# twtl2dfa.g:76:9: ^( WITHIN phi= formula low= INT high= INT )
pass
self.match(self.input, WITHIN, self.FOLLOW_WITHIN_in_formula231)
self.match(self.input, DOWN, None)
self._state.following.append(self.FOLLOW_formula_in_formula235)
phi = self.formula()
self._state.following.pop()
low = self.match(self.input, INT, self.FOLLOW_INT_in_formula239)
high = self.match(self.input, INT, self.FOLLOW_INT_in_formula243)
self.match(self.input, UP, None)
#action start
dfa = within(phi, int(low.text), int(high.text))
#action end
elif alt1 == 8:
# twtl2dfa.g:79:9: PROP
pass
PROP4 = self.match(self.input, PROP, self.FOLLOW_PROP_in_formula256)
#action start
dfa = accept_prop(self.props, prop=PROP4)
#action end
elif alt1 == 9:
# twtl2dfa.g:80:9: TRUE
pass
self.match(self.input, TRUE, self.FOLLOW_TRUE_in_formula291)
#action start
dfa = accept_prop(self.props, boolean=True)
#action end
elif alt1 == 10:
# twtl2dfa.g:81:9: FALSE
pass
self.match(self.input, FALSE, self.FOLLOW_FALSE_in_formula326)
#action start
dfa = accept_prop(self.props, boolean=False)
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return dfa
# $ANTLR end "formula"
FOLLOW_formula_in_eval62 = frozenset([1])
FOLLOW_OR_in_formula88 = frozenset([2])
FOLLOW_formula_in_formula93 = frozenset([4, 5, 7, 10, 15, 16, 17, 18, 19])
FOLLOW_formula_in_formula97 = frozenset([3])
FOLLOW_AND_in_formula112 = frozenset([2])
FOLLOW_formula_in_formula116 = frozenset([4, 5, 7, 10, 15, 16, 17, 18, 19])
FOLLOW_formula_in_formula120 = frozenset([3])
FOLLOW_NOT_in_formula135 = frozenset([2])
FOLLOW_formula_in_formula139 = frozenset([3])
FOLLOW_CONCAT_in_formula164 = frozenset([2])
FOLLOW_formula_in_formula168 = frozenset([4, 5, 7, 10, 15, 16, 17, 18, 19])
FOLLOW_formula_in_formula172 = frozenset([3])
FOLLOW_HOLD_in_formula187 = frozenset([2])
FOLLOW_INT_in_formula189 = frozenset([17])
FOLLOW_PROP_in_formula193 = frozenset([3])
FOLLOW_HOLD_in_formula207 = frozenset([2])
FOLLOW_INT_in_formula209 = frozenset([15])
FOLLOW_NOT_in_formula212 = frozenset([2])
FOLLOW_PROP_in_formula216 = frozenset([3])
FOLLOW_WITHIN_in_formula231 = frozenset([2])
FOLLOW_formula_in_formula235 = frozenset([11])
FOLLOW_INT_in_formula239 = frozenset([11])
FOLLOW_INT_in_formula243 = frozenset([3])
FOLLOW_PROP_in_formula256 = frozenset([1])
FOLLOW_TRUE_in_formula291 = frozenset([1])
FOLLOW_FALSE_in_formula326 = frozenset([1])
class twtlParser(Parser):
grammarFileName = "C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g"
antlr_version = version_str_to_tuple("3.1.3 Mar 18, 2009 10:09:25")
antlr_version_str = "3.1.3 Mar 18, 2009 10:09:25"
tokenNames = tokenNames
def __init__(self, input, state=None, *args, **kwargs):
if state is None:
state = RecognizerSharedState()
super(twtlParser, self).__init__(input, state, *args, **kwargs)
self._adaptor = None
self.adaptor = CommonTreeAdaptor()
def getTreeAdaptor(self):
return self._adaptor
def setTreeAdaptor(self, adaptor):
self._adaptor = adaptor
adaptor = property(getTreeAdaptor, setTreeAdaptor)
class prog_return(ParserRuleReturnScope):
def __init__(self):
super(twtlParser.prog_return, self).__init__()
self.tree = None
# $ANTLR start "prog"
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:96:1: prog : formula ;
def prog(self, ):
retval = self.prog_return()
retval.start = self.input.LT(1)
root_0 = None
formula1 = None
try:
try:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:96:5: ( formula )
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:96:9: formula
pass
root_0 = self._adaptor.nil()
self._state.following.append(self.FOLLOW_formula_in_prog171)
formula1 = self.formula()
self._state.following.pop()
self._adaptor.addChild(root_0, formula1.tree)
retval.stop = self.input.LT(-1)
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "prog"
class formula_return(ParserRuleReturnScope):
def __init__(self):
super(twtlParser.formula_return, self).__init__()
self.tree = None
# $ANTLR start "formula"
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:98:1: formula : disjunction ;
def formula(self, ):
retval = self.formula_return()
retval.start = self.input.LT(1)
root_0 = None
disjunction2 = None
try:
try:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:98:9: ( disjunction )
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:98:13: disjunction
pass
root_0 = self._adaptor.nil()
self._state.following.append(self.FOLLOW_disjunction_in_formula182)
disjunction2 = self.disjunction()
self._state.following.pop()
self._adaptor.addChild(root_0, disjunction2.tree)
retval.stop = self.input.LT(-1)
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "formula"
class disjunction_return(ParserRuleReturnScope):
def __init__(self):
super(twtlParser.disjunction_return, self).__init__()
self.tree = None
# $ANTLR start "disjunction"
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:100:1: disjunction : conjunction ( OR conjunction )* ;
def disjunction(self, ):
retval = self.disjunction_return()
retval.start = self.input.LT(1)
root_0 = None
OR4 = None
conjunction3 = None
conjunction5 = None
OR4_tree = None
try:
try:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:101:5: ( conjunction ( OR conjunction )* )
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:101:7: conjunction ( OR conjunction )*
pass
root_0 = self._adaptor.nil()
self._state.following.append(self.FOLLOW_conjunction_in_disjunction195)
conjunction3 = self.conjunction()
self._state.following.pop()
self._adaptor.addChild(root_0, conjunction3.tree)
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:101:19: ( OR conjunction )*
while True: #loop1
alt1 = 2
LA1_0 = self.input.LA(1)
if (LA1_0 == OR) :
alt1 = 1
if alt1 == 1:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:101:20: OR conjunction
pass
OR4=self.match(self.input, OR, self.FOLLOW_OR_in_disjunction198)
OR4_tree = self._adaptor.createWithPayload(OR4)
root_0 = self._adaptor.becomeRoot(OR4_tree, root_0)
self._state.following.append(self.FOLLOW_conjunction_in_disjunction201)
conjunction5 = self.conjunction()
self._state.following.pop()
self._adaptor.addChild(root_0, conjunction5.tree)
else:
break #loop1
retval.stop = self.input.LT(-1)
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "disjunction"
class conjunction_return(ParserRuleReturnScope):
def __init__(self):
super(twtlParser.conjunction_return, self).__init__()
self.tree = None
# $ANTLR start "conjunction"
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:104:1: conjunction : concatenation ( AND concatenation )* ;
def conjunction(self, ):
retval = self.conjunction_return()
retval.start = self.input.LT(1)
root_0 = None
AND7 = None
concatenation6 = None
concatenation8 = None
AND7_tree = None
try:
try:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:105:5: ( concatenation ( AND concatenation )* )
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:105:9: concatenation ( AND concatenation )*
pass
root_0 = self._adaptor.nil()
self._state.following.append(self.FOLLOW_concatenation_in_conjunction224)
concatenation6 = self.concatenation()
self._state.following.pop()
self._adaptor.addChild(root_0, concatenation6.tree)
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:105:23: ( AND concatenation )*
while True: #loop2
alt2 = 2
LA2_0 = self.input.LA(1)
if (LA2_0 == AND) :
alt2 = 1
if alt2 == 1:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:105:24: AND concatenation
pass
AND7=self.match(self.input, AND, self.FOLLOW_AND_in_conjunction227)
AND7_tree = self._adaptor.createWithPayload(AND7)
root_0 = self._adaptor.becomeRoot(AND7_tree, root_0)
self._state.following.append(self.FOLLOW_concatenation_in_conjunction230)
concatenation8 = self.concatenation()
self._state.following.pop()
self._adaptor.addChild(root_0, concatenation8.tree)
else:
break #loop2
retval.stop = self.input.LT(-1)
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "conjunction"
class concatenation_return(ParserRuleReturnScope):
def __init__(self):
super(twtlParser.concatenation_return, self).__init__()
self.tree = None
# $ANTLR start "concatenation"
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:108:1: concatenation : temporal ( CONCAT temporal )* ;
def concatenation(self, ):
retval = self.concatenation_return()
retval.start = self.input.LT(1)
root_0 = None
CONCAT10 = None
temporal9 = None
temporal11 = None
CONCAT10_tree = None
try:
try:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:109:5: ( temporal ( CONCAT temporal )* )
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:109:9: temporal ( CONCAT temporal )*
pass
root_0 = self._adaptor.nil()
self._state.following.append(self.FOLLOW_temporal_in_concatenation252)
temporal9 = self.temporal()
self._state.following.pop()
self._adaptor.addChild(root_0, temporal9.tree)
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:109:18: ( CONCAT temporal )*
while True: #loop3
alt3 = 2
LA3_0 = self.input.LA(1)
if (LA3_0 == CONCAT) :
alt3 = 1
if alt3 == 1:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:109:19: CONCAT temporal
pass
CONCAT10=self.match(self.input, CONCAT, self.FOLLOW_CONCAT_in_concatenation255)
CONCAT10_tree = self._adaptor.createWithPayload(CONCAT10)
root_0 = self._adaptor.becomeRoot(CONCAT10_tree, root_0)
self._state.following.append(self.FOLLOW_temporal_in_concatenation258)
temporal11 = self.temporal()
self._state.following.pop()
self._adaptor.addChild(root_0, temporal11.tree)
else:
break #loop3
retval.stop = self.input.LT(-1)
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "concatenation"
class temporal_return(ParserRuleReturnScope):
def __init__(self):
super(twtlParser.temporal_return, self).__init__()
self.tree = None
# $ANTLR start "temporal"
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:112:1: temporal : ( HOLD '^' duration= INT PROP | HOLD '^' duration= INT NOT p= PROP -> ^( HOLD $duration ^( NOT $p) ) | ( '[' phi= formula ']' '^' '[' low= INT ',' high= INT ']' ) -> ^( WITHIN['W'] $phi $low $high) | negation );
def temporal(self, ):
retval = self.temporal_return()
retval.start = self.input.LT(1)
root_0 = None
duration = None
p = None
low = None
high = None
HOLD12 = None
char_literal13 = None
PROP14 = None
HOLD15 = None
char_literal16 = None
NOT17 = None
char_literal18 = None
char_literal19 = None
char_literal20 = None
char_literal21 = None
char_literal22 = None
char_literal23 = None
phi = None
negation24 = None
duration_tree = None
p_tree = None
low_tree = None
high_tree = None
HOLD12_tree = None
char_literal13_tree = None
PROP14_tree = None
HOLD15_tree = None
char_literal16_tree = None
NOT17_tree = None
char_literal18_tree = None
char_literal19_tree = None
char_literal20_tree = None
char_literal21_tree = None
char_literal22_tree = None
char_literal23_tree = None
stream_22 = RewriteRuleTokenStream(self._adaptor, "token 22")
stream_23 = RewriteRuleTokenStream(self._adaptor, "token 23")
stream_NOT = RewriteRuleTokenStream(self._adaptor, "token NOT")
stream_24 = RewriteRuleTokenStream(self._adaptor, "token 24")
stream_PROP = RewriteRuleTokenStream(self._adaptor, "token PROP")
stream_HOLD = RewriteRuleTokenStream(self._adaptor, "token HOLD")
stream_INT = RewriteRuleTokenStream(self._adaptor, "token INT")
stream_21 = RewriteRuleTokenStream(self._adaptor, "token 21")
stream_formula = RewriteRuleSubtreeStream(self._adaptor, "rule formula")
try:
try:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:113:5: ( HOLD '^' duration= INT PROP | HOLD '^' duration= INT NOT p= PROP -> ^( HOLD $duration ^( NOT $p) ) | ( '[' phi= formula ']' '^' '[' low= INT ',' high= INT ']' ) -> ^( WITHIN['W'] $phi $low $high) | negation )
alt4 = 4
LA4 = self.input.LA(1)
if LA4 == HOLD:
LA4_1 = self.input.LA(2)
if (LA4_1 == 21) :
LA4_4 = self.input.LA(3)
if (LA4_4 == INT) :
LA4_5 = self.input.LA(4)
if (LA4_5 == PROP) :
alt4 = 1
elif (LA4_5 == NOT) :
alt4 = 2
else:
nvae = NoViableAltException("", 4, 5, self.input)
raise nvae
else:
nvae = NoViableAltException("", 4, 4, self.input)
raise nvae
else:
nvae = NoViableAltException("", 4, 1, self.input)
raise nvae
elif LA4 == 22:
alt4 = 3
elif LA4 == NOT or LA4 == PROP or LA4 == TRUE or LA4 == FALSE or LA4 == 25:
alt4 = 4
else:
nvae = NoViableAltException("", 4, 0, self.input)
raise nvae
if alt4 == 1:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:113:7: HOLD '^' duration= INT PROP
pass
root_0 = self._adaptor.nil()
HOLD12=self.match(self.input, HOLD, self.FOLLOW_HOLD_in_temporal278)
HOLD12_tree = self._adaptor.createWithPayload(HOLD12)
root_0 = self._adaptor.becomeRoot(HOLD12_tree, root_0)
char_literal13=self.match(self.input, 21, self.FOLLOW_21_in_temporal281)
duration=self.match(self.input, INT, self.FOLLOW_INT_in_temporal286)
duration_tree = self._adaptor.createWithPayload(duration)
self._adaptor.addChild(root_0, duration_tree)
PROP14=self.match(self.input, PROP, self.FOLLOW_PROP_in_temporal288)
PROP14_tree = self._adaptor.createWithPayload(PROP14)
self._adaptor.addChild(root_0, PROP14_tree)
elif alt4 == 2:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:114:7: HOLD '^' duration= INT NOT p= PROP
pass
HOLD15=self.match(self.input, HOLD, self.FOLLOW_HOLD_in_temporal296)
stream_HOLD.add(HOLD15)
char_literal16=self.match(self.input, 21, self.FOLLOW_21_in_temporal298)
stream_21.add(char_literal16)
duration=self.match(self.input, INT, self.FOLLOW_INT_in_temporal302)
stream_INT.add(duration)
NOT17=self.match(self.input, NOT, self.FOLLOW_NOT_in_temporal304)
stream_NOT.add(NOT17)
p=self.match(self.input, PROP, self.FOLLOW_PROP_in_temporal308)
stream_PROP.add(p)
# AST Rewrite
# elements: HOLD, p, duration, NOT
# token labels: p, duration
# rule labels: retval
# token list labels:
# rule list labels:
# wildcard labels:
retval.tree = root_0
stream_p = RewriteRuleTokenStream(self._adaptor, "token p", p)
stream_duration = RewriteRuleTokenStream(self._adaptor, "token duration", duration)
if retval is not None:
stream_retval = RewriteRuleSubtreeStream(self._adaptor, "rule retval", retval.tree)
else:
stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)
root_0 = self._adaptor.nil()
# 114:40: -> ^( HOLD $duration ^( NOT $p) )
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:114:43: ^( HOLD $duration ^( NOT $p) )
root_1 = self._adaptor.nil()
root_1 = self._adaptor.becomeRoot(stream_HOLD.nextNode(), root_1)
self._adaptor.addChild(root_1, stream_duration.nextNode())
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:114:60: ^( NOT $p)
root_2 = self._adaptor.nil()
root_2 = self._adaptor.becomeRoot(stream_NOT.nextNode(), root_2)
self._adaptor.addChild(root_2, stream_p.nextNode())
self._adaptor.addChild(root_1, root_2)
self._adaptor.addChild(root_0, root_1)
retval.tree = root_0
elif alt4 == 3:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:115:7: ( '[' phi= formula ']' '^' '[' low= INT ',' high= INT ']' )
pass
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:115:7: ( '[' phi= formula ']' '^' '[' low= INT ',' high= INT ']' )
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:115:8: '[' phi= formula ']' '^' '[' low= INT ',' high= INT ']'
pass
char_literal18=self.match(self.input, 22, self.FOLLOW_22_in_temporal333)
stream_22.add(char_literal18)
self._state.following.append(self.FOLLOW_formula_in_temporal337)
phi = self.formula()
self._state.following.pop()
stream_formula.add(phi.tree)
char_literal19=self.match(self.input, 23, self.FOLLOW_23_in_temporal339)
stream_23.add(char_literal19)
char_literal20=self.match(self.input, 21, self.FOLLOW_21_in_temporal341)
stream_21.add(char_literal20)
char_literal21=self.match(self.input, 22, self.FOLLOW_22_in_temporal343)
stream_22.add(char_literal21)
low=self.match(self.input, INT, self.FOLLOW_INT_in_temporal347)
stream_INT.add(low)
char_literal22=self.match(self.input, 24, self.FOLLOW_24_in_temporal349)
stream_24.add(char_literal22)
high=self.match(self.input, INT, self.FOLLOW_INT_in_temporal353)
stream_INT.add(high)
char_literal23=self.match(self.input, 23, self.FOLLOW_23_in_temporal355)
stream_23.add(char_literal23)
# AST Rewrite
# elements: phi, high, low
# token labels: high, low
# rule labels: phi, retval
# token list labels:
# rule list labels:
# wildcard labels:
retval.tree = root_0
stream_high = RewriteRuleTokenStream(self._adaptor, "token high", high)
stream_low = RewriteRuleTokenStream(self._adaptor, "token low", low)
if phi is not None:
stream_phi = RewriteRuleSubtreeStream(self._adaptor, "rule phi", phi.tree)
else:
stream_phi = RewriteRuleSubtreeStream(self._adaptor, "token phi", None)
if retval is not None:
stream_retval = RewriteRuleSubtreeStream(self._adaptor, "rule retval", retval.tree)
else:
stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)
root_0 = self._adaptor.nil()
# 115:62: -> ^( WITHIN['W'] $phi $low $high)
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:115:65: ^( WITHIN['W'] $phi $low $high)
root_1 = self._adaptor.nil()
root_1 = self._adaptor.becomeRoot(self._adaptor.create(WITHIN, 'W'), root_1)
self._adaptor.addChild(root_1, stream_phi.nextTree())
self._adaptor.addChild(root_1, stream_low.nextNode())
self._adaptor.addChild(root_1, stream_high.nextNode())
self._adaptor.addChild(root_0, root_1)
retval.tree = root_0
elif alt4 == 4:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:116:7: negation
pass
root_0 = self._adaptor.nil()
self._state.following.append(self.FOLLOW_negation_in_temporal380)
negation24 = self.negation()
self._state.following.pop()
self._adaptor.addChild(root_0, negation24.tree)
retval.stop = self.input.LT(-1)
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "temporal"
class negation_return(ParserRuleReturnScope):
def __init__(self):
super(twtlParser.negation_return, self).__init__()
self.tree = None
# $ANTLR start "negation"
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:119:1: negation : ( NOT )? atom ;
def negation(self, ):
retval = self.negation_return()
retval.start = self.input.LT(1)
root_0 = None
NOT25 = None
atom26 = None
NOT25_tree = None
try:
try:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:120:5: ( ( NOT )? atom )
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:120:7: ( NOT )? atom
pass
root_0 = self._adaptor.nil()
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:120:7: ( NOT )?
alt5 = 2
LA5_0 = self.input.LA(1)
if (LA5_0 == NOT) :
alt5 = 1
if alt5 == 1:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:120:8: NOT
pass
NOT25=self.match(self.input, NOT, self.FOLLOW_NOT_in_negation399)
NOT25_tree = self._adaptor.createWithPayload(NOT25)
root_0 = self._adaptor.becomeRoot(NOT25_tree, root_0)
self._state.following.append(self.FOLLOW_atom_in_negation404)
atom26 = self.atom()
self._state.following.pop()
self._adaptor.addChild(root_0, atom26.tree)
retval.stop = self.input.LT(-1)
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "negation"
class atom_return(ParserRuleReturnScope):
def __init__(self):
super(twtlParser.atom_return, self).__init__()
self.tree = None
# $ANTLR start "atom"
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:123:1: atom : ( TRUE | FALSE | PROP | '(' formula ')' );
def atom(self, ):
retval = self.atom_return()
retval.start = self.input.LT(1)
root_0 = None
TRUE27 = None
FALSE28 = None
PROP29 = None
char_literal30 = None
char_literal32 = None
formula31 = None
TRUE27_tree = None
FALSE28_tree = None
PROP29_tree = None
char_literal30_tree = None
char_literal32_tree = None
try:
try:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:124:5: ( TRUE | FALSE | PROP | '(' formula ')' )
alt6 = 4
LA6 = self.input.LA(1)
if LA6 == TRUE:
alt6 = 1
elif LA6 == FALSE:
alt6 = 2
elif LA6 == PROP:
alt6 = 3
elif LA6 == 25:
alt6 = 4
else:
nvae = NoViableAltException("", 6, 0, self.input)
raise nvae
if alt6 == 1:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:124:7: TRUE
pass
root_0 = self._adaptor.nil()
TRUE27=self.match(self.input, TRUE, self.FOLLOW_TRUE_in_atom422)
TRUE27_tree = self._adaptor.createWithPayload(TRUE27)
self._adaptor.addChild(root_0, TRUE27_tree)
elif alt6 == 2:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:125:7: FALSE
pass
root_0 = self._adaptor.nil()
FALSE28=self.match(self.input, FALSE, self.FOLLOW_FALSE_in_atom431)
FALSE28_tree = self._adaptor.createWithPayload(FALSE28)
self._adaptor.addChild(root_0, FALSE28_tree)
elif alt6 == 3:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:126:7: PROP
pass
root_0 = self._adaptor.nil()
PROP29=self.match(self.input, PROP, self.FOLLOW_PROP_in_atom440)
PROP29_tree = self._adaptor.createWithPayload(PROP29)
self._adaptor.addChild(root_0, PROP29_tree)
elif alt6 == 4:
# C:\\Users\\Cristian\\Dropbox\\work\\workspace\\TWTL\\src\\twtl.g:127:7: '(' formula ')'
pass
root_0 = self._adaptor.nil()
char_literal30=self.match(self.input, 25, self.FOLLOW_25_in_atom449)
self._state.following.append(self.FOLLOW_formula_in_atom452)
formula31 = self.formula()
self._state.following.pop()
self._adaptor.addChild(root_0, formula31.tree)
char_literal32=self.match(self.input, 26, self.FOLLOW_26_in_atom454)
retval.stop = self.input.LT(-1)
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "atom"
# Delegated rules
FOLLOW_formula_in_prog171 = frozenset([1])
FOLLOW_disjunction_in_formula182 = frozenset([1])
FOLLOW_conjunction_in_disjunction195 = frozenset([1, 5])
FOLLOW_OR_in_disjunction198 = frozenset([6, 7, 11, 12, 13, 22, 25])
FOLLOW_conjunction_in_disjunction201 = frozenset([1, 5])
FOLLOW_concatenation_in_conjunction224 = frozenset([1, 4])
FOLLOW_AND_in_conjunction227 = frozenset([6, 7, 11, 12, 13, 22, 25])
FOLLOW_concatenation_in_conjunction230 = frozenset([1, 4])
FOLLOW_temporal_in_concatenation252 = frozenset([1, 9])
FOLLOW_CONCAT_in_concatenation255 = frozenset([6, 7, 11, 12, 13, 22, 25])
FOLLOW_temporal_in_concatenation258 = frozenset([1, 9])
FOLLOW_HOLD_in_temporal278 = frozenset([21])
FOLLOW_21_in_temporal281 = frozenset([10])
FOLLOW_INT_in_temporal286 = frozenset([11])
FOLLOW_PROP_in_temporal288 = frozenset([1])
FOLLOW_HOLD_in_temporal296 = frozenset([21])
FOLLOW_21_in_temporal298 = frozenset([10])
FOLLOW_INT_in_temporal302 = frozenset([6])
FOLLOW_NOT_in_temporal304 = frozenset([11])
FOLLOW_PROP_in_temporal308 = frozenset([1])
FOLLOW_22_in_temporal333 = frozenset([6, 7, 11, 12, 13, 22, 25])
FOLLOW_formula_in_temporal337 = frozenset([23])
FOLLOW_23_in_temporal339 = frozenset([21])
FOLLOW_21_in_temporal341 = frozenset([22])
FOLLOW_22_in_temporal343 = frozenset([10])
FOLLOW_INT_in_temporal347 = frozenset([24])
FOLLOW_24_in_temporal349 = frozenset([10])
FOLLOW_INT_in_temporal353 = frozenset([23])
FOLLOW_23_in_temporal355 = frozenset([1])
FOLLOW_negation_in_temporal380 = frozenset([1])
FOLLOW_NOT_in_negation399 = frozenset([6, 7, 11, 12, 13, 22, 25])
FOLLOW_atom_in_negation404 = frozenset([1])
FOLLOW_TRUE_in_atom422 = frozenset([1])
FOLLOW_FALSE_in_atom431 = frozenset([1])
FOLLOW_PROP_in_atom440 = frozenset([1])
FOLLOW_25_in_atom449 = frozenset([6, 7, 11, 12, 13, 22, 25])
FOLLOW_formula_in_atom452 = frozenset([26])
FOLLOW_26_in_atom454 = frozenset([1])
class GuardParser(Parser):
grammarFileName = "grammars/Guard.g"
antlr_version = version_str_to_tuple("3.1.1")
antlr_version_str = "3.1.1"
tokenNames = tokenNames
def __init__(self, input, state=None):
if state is None:
state = RecognizerSharedState()
Parser.__init__(self, input, state)
self.or_expr_stack = []
self.and_expr_stack = []
self.sum_stack = []
# $ANTLR start "guard"
# grammars/Guard.g:102:1: guard returns [r] : op= or_expr EOF ;
def guard(self, ):
r = None
op = None
try:
try:
# grammars/Guard.g:102:19: (op= or_expr EOF )
# grammars/Guard.g:103:2: op= or_expr EOF
pass
self._state.following.append(self.FOLLOW_or_expr_in_guard53)
op = self.or_expr()
self._state.following.pop()
#action start
r = op
#action end
self.match(self.input, EOF, self.FOLLOW_EOF_in_guard57)
except RecognitionException, e:
raise
finally:
pass
return r
# $ANTLR end "guard"
# $ANTLR start "or_expr"
# grammars/Guard.g:105:1: or_expr returns [a] : op1= and_expr ( '||' op2= and_expr )* ;
def or_expr(self, ):
self.or_expr_stack.append(or_expr_scope())
a = None
op1 = None
op2 = None
try:
try:
# grammars/Guard.g:105:30: (op1= and_expr ( '||' op2= and_expr )* )
# grammars/Guard.g:106:2: op1= and_expr ( '||' op2= and_expr )*
pass
self._state.following.append(self.FOLLOW_and_expr_in_or_expr76)
op1 = self.and_expr()
self._state.following.pop()
#action start
self.or_expr_stack[-1].l = [op1]
#action end
# grammars/Guard.g:106:37: ( '||' op2= and_expr )*
while True: #loop1
alt1 = 2
LA1_0 = self.input.LA(1)
if (LA1_0 == 8):
alt1 = 1
if alt1 == 1:
# grammars/Guard.g:106:38: '||' op2= and_expr
pass
self.match(self.input, 8, self.FOLLOW_8_in_or_expr81)
self._state.following.append(
self.FOLLOW_and_expr_in_or_expr85)
op2 = self.and_expr()
self._state.following.pop()
#action start
self.or_expr_stack[-1].l.append(op2)
#action end
else:
break #loop1
#action start
a = OrAtom(self.or_expr_stack[-1].l)
#action end
except RecognitionException, e:
raise
finally:
self.or_expr_stack.pop()
pass
return a
# $ANTLR end "or_expr"
# $ANTLR start "and_expr"
# grammars/Guard.g:108:1: and_expr returns [a] : op1= disj ( '&&' op2= disj )* ;
def and_expr(self, ):
self.and_expr_stack.append(and_expr_scope())
a = None
op1 = None
op2 = None
try:
try:
# grammars/Guard.g:108:31: (op1= disj ( '&&' op2= disj )* )
# grammars/Guard.g:109:2: op1= disj ( '&&' op2= disj )*
pass
self._state.following.append(self.FOLLOW_disj_in_and_expr110)
op1 = self.disj()
self._state.following.pop()
#action start
self.and_expr_stack[-1].l = [op1]
#action end
# grammars/Guard.g:109:34: ( '&&' op2= disj )*
while True: #loop2
alt2 = 2
LA2_0 = self.input.LA(1)
if (LA2_0 == 9):
alt2 = 1
if alt2 == 1:
# grammars/Guard.g:109:35: '&&' op2= disj
pass
self.match(self.input, 9, self.FOLLOW_9_in_and_expr115)
self._state.following.append(
self.FOLLOW_disj_in_and_expr119)
op2 = self.disj()
self._state.following.pop()
#action start
self.and_expr_stack[-1].l.append(op2)
#action end
else:
break #loop2
#action start
a = AndAtom(self.and_expr_stack[-1].l)
#action end
except RecognitionException, e:
raise
finally:
self.and_expr_stack.pop()
pass
return a
# $ANTLR end "and_expr"
# $ANTLR start "disj"
# grammars/Guard.g:111:1: disj returns [a] : ( '(' op= or_expr ')' | op= in_atom | op= negative_expr | op= expr );
def disj(self, ):
a = None
op = None
try:
try:
# grammars/Guard.g:111:18: ( '(' op= or_expr ')' | op= in_atom | op= negative_expr | op= expr )
alt3 = 4
LA3 = self.input.LA(1)
if LA3 == 10:
alt3 = 1
elif LA3 == 19:
alt3 = 2
elif LA3 == 21:
alt3 = 3
elif LA3 == ID or LA3 == INT or LA3 == BOOLCONST:
alt3 = 4
else:
nvae = NoViableAltException("", 3, 0, self.input)
raise nvae
if alt3 == 1:
# grammars/Guard.g:112:2: '(' op= or_expr ')'
pass
self.match(self.input, 10, self.FOLLOW_10_in_disj140)
self._state.following.append(
self.FOLLOW_or_expr_in_disj144)
op = self.or_expr()
self._state.following.pop()
self.match(self.input, 11, self.FOLLOW_11_in_disj146)
#action start
a = op
#action end
elif alt3 == 2:
# grammars/Guard.g:113:2: op= in_atom
pass
self._state.following.append(
self.FOLLOW_in_atom_in_disj155)
op = self.in_atom()
self._state.following.pop()
#action start
a = op
#action end
elif alt3 == 3:
# grammars/Guard.g:114:2: op= negative_expr
pass
self._state.following.append(
self.FOLLOW_negative_expr_in_disj165)
op = self.negative_expr()
self._state.following.pop()
#action start
a = op
#action end
elif alt3 == 4:
# grammars/Guard.g:115:2: op= expr
pass
self._state.following.append(self.FOLLOW_expr_in_disj175)
op = self.expr()
self._state.following.pop()
#action start
a = op
#action end
except RecognitionException, e:
raise
finally:
pass
return a
# $ANTLR end "disj"
# $ANTLR start "expr"
# grammars/Guard.g:117:1: expr returns [a] : (op= comp_atom | op= positive_bool );
def expr(self, ):
a = None
op = None
try:
try:
# grammars/Guard.g:117:18: (op= comp_atom | op= positive_bool )
alt4 = 2
LA4_0 = self.input.LA(1)
if (LA4_0 == ID):
LA4_1 = self.input.LA(2)
if (LA4_1 == EOF or (8 <= LA4_1 <= 9) or LA4_1 == 11):
alt4 = 2
elif ((12 <= LA4_1 <= 18)):
alt4 = 1
else:
nvae = NoViableAltException("", 4, 1, self.input)
raise nvae
elif ((INT <= LA4_0 <= BOOLCONST)):
alt4 = 1
else:
nvae = NoViableAltException("", 4, 0, self.input)
raise nvae
if alt4 == 1:
# grammars/Guard.g:117:20: op= comp_atom
pass
self._state.following.append(
self.FOLLOW_comp_atom_in_expr193)
op = self.comp_atom()
self._state.following.pop()
#action start
a = op
#action end
elif alt4 == 2:
# grammars/Guard.g:118:2: op= positive_bool
pass
self._state.following.append(
self.FOLLOW_positive_bool_in_expr205)
op = self.positive_bool()
self._state.following.pop()
#action start
a = op
#action end
except RecognitionException, e:
raise
finally:
pass
return a
# $ANTLR end "expr"
# $ANTLR start "comp_atom"
# grammars/Guard.g:120:1: comp_atom returns [a] : arg1= sum op= ( '==' | '!=' | '<' | '>' | '<=' | '>=' ) arg2= sum ;
def comp_atom(self, ):
a = None
op = None
arg1 = None
arg2 = None
try:
try:
# grammars/Guard.g:120:23: (arg1= sum op= ( '==' | '!=' | '<' | '>' | '<=' | '>=' ) arg2= sum )
# grammars/Guard.g:120:25: arg1= sum op= ( '==' | '!=' | '<' | '>' | '<=' | '>=' ) arg2= sum
pass
self._state.following.append(self.FOLLOW_sum_in_comp_atom221)
arg1 = self.sum()
self._state.following.pop()
op = self.input.LT(1)
if (12 <= self.input.LA(1) <= 17):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self._state.following.append(self.FOLLOW_sum_in_comp_atom241)
arg2 = self.sum()
self._state.following.pop()
#action start
a = CompAtom(arg1, op.text, arg2)
#action end
except RecognitionException, e:
raise
finally:
pass
return a
# $ANTLR end "comp_atom"
# $ANTLR start "sum"
# grammars/Guard.g:122:1: sum returns [a] : o= var ( '+' o= var )* ;
def sum(self, ):
self.sum_stack.append(sum_scope())
a = None
o = None
try:
try:
# grammars/Guard.g:122:26: (o= var ( '+' o= var )* )
# grammars/Guard.g:123:2: o= var ( '+' o= var )*
pass
self._state.following.append(self.FOLLOW_var_in_sum261)
o = self.var()
self._state.following.pop()
#action start
self.sum_stack[-1].l = [o]
#action end
# grammars/Guard.g:123:22: ( '+' o= var )*
while True: #loop5
alt5 = 2
LA5_0 = self.input.LA(1)
if (LA5_0 == 18):
alt5 = 1
if alt5 == 1:
# grammars/Guard.g:123:23: '+' o= var
pass
self.match(self.input, 18, self.FOLLOW_18_in_sum266)
self._state.following.append(self.FOLLOW_var_in_sum270)
o = self.var()
self._state.following.pop()
#action start
self.sum_stack[-1].l.append(o)
#action end
else:
break #loop5
#action start
a = SumAtom(self.sum_stack[-1].l)
#action end
except RecognitionException, e:
raise
finally:
self.sum_stack.pop()
pass
return a
# $ANTLR end "sum"
# $ANTLR start "var"
# grammars/Guard.g:125:1: var returns [a] : (arg= ID | arg= INT | arg= BOOLCONST );
def var(self, ):
a = None
arg = None
try:
try:
# grammars/Guard.g:125:17: (arg= ID | arg= INT | arg= BOOLCONST )
alt6 = 3
LA6 = self.input.LA(1)
if LA6 == ID:
alt6 = 1
elif LA6 == INT:
alt6 = 2
elif LA6 == BOOLCONST:
alt6 = 3
else:
nvae = NoViableAltException("", 6, 0, self.input)
raise nvae
if alt6 == 1:
# grammars/Guard.g:125:19: arg= ID
pass
arg = self.match(self.input, ID, self.FOLLOW_ID_in_var290)
#action start
a = arg.text
#action end
elif alt6 == 2:
# grammars/Guard.g:125:43: arg= INT
pass
arg = self.match(self.input, INT,
self.FOLLOW_INT_in_var298)
#action start
a = int(arg.text)
#action end
elif alt6 == 3:
# grammars/Guard.g:125:73: arg= BOOLCONST
pass
arg = self.match(self.input, BOOLCONST,
self.FOLLOW_BOOLCONST_in_var306)
#action start
a = BoolConst(arg.text == "true")
#action end
except RecognitionException, e:
raise
finally:
pass
return a
# $ANTLR end "var"
# $ANTLR start "in_atom"
# grammars/Guard.g:127:1: in_atom returns [a] : 'in' '(' s= state ( '.' s= state )* ')' ;
def in_atom(self, ):
a = None
s = None
try:
try:
# grammars/Guard.g:127:21: ( 'in' '(' s= state ( '.' s= state )* ')' )
# grammars/Guard.g:127:23: 'in' '(' s= state ( '.' s= state )* ')'
pass
self.match(self.input, 19, self.FOLLOW_19_in_in_atom320)
self.match(self.input, 10, self.FOLLOW_10_in_in_atom322)
#action start
path = []
#action end
self._state.following.append(self.FOLLOW_state_in_in_atom328)
s = self.state()
self._state.following.pop()
#action start
path.append(s)
#action end
# grammars/Guard.g:127:69: ( '.' s= state )*
while True: #loop7
alt7 = 2
LA7_0 = self.input.LA(1)
if (LA7_0 == 20):
alt7 = 1
if alt7 == 1:
# grammars/Guard.g:127:70: '.' s= state
pass
self.match(self.input, 20,
self.FOLLOW_20_in_in_atom333)
self._state.following.append(
self.FOLLOW_state_in_in_atom337)
s = self.state()
self._state.following.pop()
#action start
path.append(s)
#action end
else:
break #loop7
self.match(self.input, 11, self.FOLLOW_11_in_in_atom343)
#action start
a = InAtom(path)
#action end
except RecognitionException, e:
raise
finally:
pass
return a
# $ANTLR end "in_atom"
# $ANTLR start "positive_bool"
# grammars/Guard.g:129:1: positive_bool returns [a] : arg= ID ;
def positive_bool(self, ):
a = None
arg = None
try:
try:
# grammars/Guard.g:129:27: (arg= ID )
# grammars/Guard.g:129:29: arg= ID
pass
arg = self.match(self.input, ID,
self.FOLLOW_ID_in_positive_bool359)
#action start
a = CompAtom(SumAtom([arg.text]), "==",
SumAtom([BoolConst(True)]))
#action end
except RecognitionException, e:
raise
finally:
pass
return a
# $ANTLR end "positive_bool"
# $ANTLR start "negative_expr"
# grammars/Guard.g:131:1: negative_expr returns [a] : '!' (arg1= positive_bool | '(' arg2= or_expr ')' ) ;
def negative_expr(self, ):
a = None
arg1 = None
arg2 = None
try:
try:
# grammars/Guard.g:131:27: ( '!' (arg1= positive_bool | '(' arg2= or_expr ')' ) )
# grammars/Guard.g:131:29: '!' (arg1= positive_bool | '(' arg2= or_expr ')' )
pass
self.match(self.input, 21, self.FOLLOW_21_in_negative_expr373)
# grammars/Guard.g:131:33: (arg1= positive_bool | '(' arg2= or_expr ')' )
alt8 = 2
LA8_0 = self.input.LA(1)
if (LA8_0 == ID):
alt8 = 1
elif (LA8_0 == 10):
alt8 = 2
else:
nvae = NoViableAltException("", 8, 0, self.input)
raise nvae
if alt8 == 1:
# grammars/Guard.g:131:34: arg1= positive_bool
pass
self._state.following.append(
self.FOLLOW_positive_bool_in_negative_expr378)
arg1 = self.positive_bool()
self._state.following.pop()
#action start
a = Negation(arg1)
#action end
elif alt8 == 2:
# grammars/Guard.g:131:76: '(' arg2= or_expr ')'
pass
self.match(self.input, 10,
self.FOLLOW_10_in_negative_expr384)
self._state.following.append(
self.FOLLOW_or_expr_in_negative_expr388)
arg2 = self.or_expr()
self._state.following.pop()
self.match(self.input, 11,
self.FOLLOW_11_in_negative_expr390)
#action start
a = Negation(arg2)
#action end
except RecognitionException, e:
raise
finally:
pass
return a
# $ANTLR end "negative_expr"
# $ANTLR start "state"
# grammars/Guard.g:133:1: state returns [state_name] : (s= ID | s= INT ) ;
def state(self, ):
state_name = None
s = None
try:
try:
# grammars/Guard.g:133:28: ( (s= ID | s= INT ) )
# grammars/Guard.g:133:30: (s= ID | s= INT )
pass
# grammars/Guard.g:133:30: (s= ID | s= INT )
alt9 = 2
LA9_0 = self.input.LA(1)
if (LA9_0 == ID):
alt9 = 1
elif (LA9_0 == INT):
alt9 = 2
else:
nvae = NoViableAltException("", 9, 0, self.input)
raise nvae
if alt9 == 1:
# grammars/Guard.g:133:31: s= ID
pass
s = self.match(self.input, ID, self.FOLLOW_ID_in_state408)
elif alt9 == 2:
# grammars/Guard.g:133:38: s= INT
pass
s = self.match(self.input, INT,
self.FOLLOW_INT_in_state414)
#action start
state_name = s.text
#action end
except RecognitionException, e:
raise
finally:
pass
return state_name
# $ANTLR end "state"
# Delegated rules
FOLLOW_or_expr_in_guard53 = frozenset([])
FOLLOW_EOF_in_guard57 = frozenset([1])
FOLLOW_and_expr_in_or_expr76 = frozenset([1, 8])
FOLLOW_8_in_or_expr81 = frozenset([4, 5, 6, 10, 19, 21])
FOLLOW_and_expr_in_or_expr85 = frozenset([1, 8])
FOLLOW_disj_in_and_expr110 = frozenset([1, 9])
FOLLOW_9_in_and_expr115 = frozenset([4, 5, 6, 10, 19, 21])
FOLLOW_disj_in_and_expr119 = frozenset([1, 9])
FOLLOW_10_in_disj140 = frozenset([4, 5, 6, 10, 19, 21])
FOLLOW_or_expr_in_disj144 = frozenset([11])
FOLLOW_11_in_disj146 = frozenset([1])
FOLLOW_in_atom_in_disj155 = frozenset([1])
FOLLOW_negative_expr_in_disj165 = frozenset([1])
FOLLOW_expr_in_disj175 = frozenset([1])
FOLLOW_comp_atom_in_expr193 = frozenset([1])
FOLLOW_positive_bool_in_expr205 = frozenset([1])
FOLLOW_sum_in_comp_atom221 = frozenset([12, 13, 14, 15, 16, 17])
FOLLOW_set_in_comp_atom225 = frozenset([4, 5, 6])
FOLLOW_sum_in_comp_atom241 = frozenset([1])
FOLLOW_var_in_sum261 = frozenset([1, 18])
FOLLOW_18_in_sum266 = frozenset([4, 5, 6])
FOLLOW_var_in_sum270 = frozenset([1, 18])
FOLLOW_ID_in_var290 = frozenset([1])
FOLLOW_INT_in_var298 = frozenset([1])
FOLLOW_BOOLCONST_in_var306 = frozenset([1])
FOLLOW_19_in_in_atom320 = frozenset([10])
FOLLOW_10_in_in_atom322 = frozenset([4, 5])
FOLLOW_state_in_in_atom328 = frozenset([11, 20])
FOLLOW_20_in_in_atom333 = frozenset([4, 5])
FOLLOW_state_in_in_atom337 = frozenset([11, 20])
FOLLOW_11_in_in_atom343 = frozenset([1])
FOLLOW_ID_in_positive_bool359 = frozenset([1])
FOLLOW_21_in_negative_expr373 = frozenset([4, 5, 6, 10, 19, 21])
FOLLOW_positive_bool_in_negative_expr378 = frozenset([1])
FOLLOW_10_in_negative_expr384 = frozenset([4, 5, 6, 10, 19, 21])
FOLLOW_or_expr_in_negative_expr388 = frozenset([11])
FOLLOW_11_in_negative_expr390 = frozenset([1])
FOLLOW_ID_in_state408 = frozenset([1])
FOLLOW_INT_in_state414 = frozenset([1])
class GrocParser(Parser):
grammarFileName = "Groc.g"
antlr_version = version_str_to_tuple("3.1.1")
antlr_version_str = "3.1.1"
tokenNames = tokenNames
def __init__(self, input, state=None):
if state is None:
state = RecognizerSharedState()
Parser.__init__(self, input, state)
self.dfa4 = self.DFA4(self,
4,
eot=self.DFA4_eot,
eof=self.DFA4_eof,
min=self.DFA4_min,
max=self.DFA4_max,
accept=self.DFA4_accept,
special=self.DFA4_special,
transition=self.DFA4_transition)
self.ordinal_set = set()
self.weekday_set = set()
self.month_set = set()
self.monthday_set = set()
self.time_string = ''
self.interval_mins = 0
self.period_string = ''
self.synchronized = False
self.start_time_string = ''
self.end_time_string = ''
valuesDict = {
SUNDAY: 0,
FIRST: 1,
MONDAY: 1,
JANUARY: 1,
TUESDAY: 2,
SECOND: 2,
FEBRUARY: 2,
WEDNESDAY: 3,
THIRD: 3,
MARCH: 3,
THURSDAY: 4,
FOURTH: 4,
APRIL: 4,
FRIDAY: 5,
FIFTH: 5,
MAY: 5,
SATURDAY: 6,
JUNE: 6,
JULY: 7,
AUGUST: 8,
SEPTEMBER: 9,
OCTOBER: 10,
NOVEMBER: 11,
DECEMBER: 12,
}
def ValueOf(self, token_type):
return self.valuesDict.get(token_type, -1)
def timespec(self, ):
try:
try:
pass
alt1 = 2
LA1_0 = self.input.LA(1)
if (LA1_0 == EVERY):
LA1_1 = self.input.LA(2)
if ((DIGIT <= LA1_1 <= DIGITS)):
alt1 = 2
elif ((DAY <= LA1_1 <= SUNDAY)):
alt1 = 1
else:
nvae = NoViableAltException("", 1, 1, self.input)
raise nvae
elif ((DIGIT <= LA1_0 <= DIGITS)
or (FIRST <= LA1_0 <= FOURTH_OR_FIFTH)):
alt1 = 1
else:
nvae = NoViableAltException("", 1, 0, self.input)
raise nvae
if alt1 == 1:
pass
self._state.following.append(
self.FOLLOW_specifictime_in_timespec44)
self.specifictime()
self._state.following.pop()
elif alt1 == 2:
pass
self._state.following.append(
self.FOLLOW_interval_in_timespec48)
self.interval()
self._state.following.pop()
self.match(self.input, EOF, self.FOLLOW_EOF_in_timespec52)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def specifictime(self, ):
TIME1 = None
try:
try:
pass
pass
alt4 = 2
alt4 = self.dfa4.predict(self.input)
if alt4 == 1:
pass
pass
alt2 = 2
LA2_0 = self.input.LA(1)
if (LA2_0 == EVERY or (FIRST <= LA2_0 <= FOURTH_OR_FIFTH)):
alt2 = 1
elif ((DIGIT <= LA2_0 <= DIGITS)):
alt2 = 2
else:
nvae = NoViableAltException("", 2, 0, self.input)
raise nvae
if alt2 == 1:
pass
pass
self._state.following.append(
self.FOLLOW_ordinals_in_specifictime72)
self.ordinals()
self._state.following.pop()
self._state.following.append(
self.FOLLOW_weekdays_in_specifictime74)
self.weekdays()
self._state.following.pop()
elif alt2 == 2:
pass
self._state.following.append(
self.FOLLOW_monthdays_in_specifictime77)
self.monthdays()
self._state.following.pop()
self.match(self.input, OF,
self.FOLLOW_OF_in_specifictime80)
alt3 = 2
LA3_0 = self.input.LA(1)
if ((MONTH <= LA3_0 <= DECEMBER)):
alt3 = 1
elif ((FIRST <= LA3_0 <= THIRD) or LA3_0 == QUARTER):
alt3 = 2
else:
nvae = NoViableAltException("", 3, 0, self.input)
raise nvae
if alt3 == 1:
pass
self._state.following.append(
self.FOLLOW_monthspec_in_specifictime83)
self.monthspec()
self._state.following.pop()
elif alt3 == 2:
pass
self._state.following.append(
self.FOLLOW_quarterspec_in_specifictime85)
self.quarterspec()
self._state.following.pop()
elif alt4 == 2:
pass
pass
self._state.following.append(
self.FOLLOW_ordinals_in_specifictime101)
self.ordinals()
self._state.following.pop()
self._state.following.append(
self.FOLLOW_weekdays_in_specifictime103)
self.weekdays()
self._state.following.pop()
self.month_set = set(range(1, 13))
TIME1 = self.match(self.input, TIME,
self.FOLLOW_TIME_in_specifictime117)
self.time_string = TIME1.text
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def interval(self, ):
intervalnum = None
period2 = None
try:
try:
pass
pass
self.match(self.input, EVERY, self.FOLLOW_EVERY_in_interval136)
intervalnum = self.input.LT(1)
if (DIGIT <= self.input.LA(1) <= DIGITS):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self.interval_mins = int(intervalnum.text)
self._state.following.append(self.FOLLOW_period_in_interval164)
period2 = self.period()
self._state.following.pop()
if ((period2 is not None)
and [self.input.toString(period2.start, period2.stop)]
or [None])[0] == "hours":
self.period_string = "hours"
else:
self.period_string = "minutes"
alt5 = 3
LA5_0 = self.input.LA(1)
if (LA5_0 == FROM):
alt5 = 1
elif (LA5_0 == SYNCHRONIZED):
alt5 = 2
if alt5 == 1:
pass
self._state.following.append(
self.FOLLOW_time_range_in_interval176)
self.time_range()
self._state.following.pop()
elif alt5 == 2:
pass
pass
self.match(self.input, SYNCHRONIZED,
self.FOLLOW_SYNCHRONIZED_in_interval189)
self.synchronized = True
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def ordinals(self, ):
try:
try:
pass
alt7 = 2
LA7_0 = self.input.LA(1)
if (LA7_0 == EVERY):
alt7 = 1
elif ((FIRST <= LA7_0 <= FOURTH_OR_FIFTH)):
alt7 = 2
else:
nvae = NoViableAltException("", 7, 0, self.input)
raise nvae
if alt7 == 1:
pass
self.match(self.input, EVERY,
self.FOLLOW_EVERY_in_ordinals218)
elif alt7 == 2:
pass
pass
self._state.following.append(
self.FOLLOW_ordinal_in_ordinals226)
self.ordinal()
self._state.following.pop()
while True:
alt6 = 2
LA6_0 = self.input.LA(1)
if (LA6_0 == COMMA):
alt6 = 1
if alt6 == 1:
pass
self.match(self.input, COMMA,
self.FOLLOW_COMMA_in_ordinals229)
self._state.following.append(
self.FOLLOW_ordinal_in_ordinals231)
self.ordinal()
self._state.following.pop()
else:
break
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def ordinal(self, ):
ord = None
try:
try:
pass
ord = self.input.LT(1)
if (FIRST <= self.input.LA(1) <= FOURTH_OR_FIFTH):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self.ordinal_set.add(self.ValueOf(ord.type))
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
class period_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
def period(self, ):
retval = self.period_return()
retval.start = self.input.LT(1)
try:
try:
pass
if (HOURS <= self.input.LA(1) <= MINUTES):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
retval.stop = self.input.LT(-1)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return retval
def monthdays(self, ):
try:
try:
pass
pass
self._state.following.append(
self.FOLLOW_monthday_in_monthdays314)
self.monthday()
self._state.following.pop()
while True:
alt8 = 2
LA8_0 = self.input.LA(1)
if (LA8_0 == COMMA):
alt8 = 1
if alt8 == 1:
pass
self.match(self.input, COMMA,
self.FOLLOW_COMMA_in_monthdays318)
self._state.following.append(
self.FOLLOW_monthday_in_monthdays320)
self.monthday()
self._state.following.pop()
else:
break
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def monthday(self, ):
day = None
try:
try:
pass
day = self.input.LT(1)
if (DIGIT <= self.input.LA(1) <= DIGITS):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self.monthday_set.add(int(day.text))
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def weekdays(self, ):
try:
try:
pass
alt10 = 2
LA10_0 = self.input.LA(1)
if (LA10_0 == DAY):
alt10 = 1
elif ((MONDAY <= LA10_0 <= SUNDAY)):
alt10 = 2
else:
nvae = NoViableAltException("", 10, 0, self.input)
raise nvae
if alt10 == 1:
pass
self.match(self.input, DAY, self.FOLLOW_DAY_in_weekdays365)
if self.ordinal_set:
self.monthday_set = self.ordinal_set
self.ordinal_set = set()
else:
self.ordinal_set = self.ordinal_set.union(allOrdinals)
self.weekday_set = set([
self.ValueOf(SUNDAY),
self.ValueOf(MONDAY),
self.ValueOf(TUESDAY),
self.ValueOf(WEDNESDAY),
self.ValueOf(THURSDAY),
self.ValueOf(FRIDAY),
self.ValueOf(SATURDAY),
self.ValueOf(SUNDAY)
])
elif alt10 == 2:
pass
pass
self._state.following.append(
self.FOLLOW_weekday_in_weekdays373)
self.weekday()
self._state.following.pop()
while True:
alt9 = 2
LA9_0 = self.input.LA(1)
if (LA9_0 == COMMA):
alt9 = 1
if alt9 == 1:
pass
self.match(self.input, COMMA,
self.FOLLOW_COMMA_in_weekdays376)
self._state.following.append(
self.FOLLOW_weekday_in_weekdays378)
self.weekday()
self._state.following.pop()
else:
break
if not self.ordinal_set:
self.ordinal_set = self.ordinal_set.union(allOrdinals)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def weekday(self, ):
dayname = None
try:
try:
pass
dayname = self.input.LT(1)
if (MONDAY <= self.input.LA(1) <= SUNDAY):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self.weekday_set.add(self.ValueOf(dayname.type))
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def monthspec(self, ):
try:
try:
pass
alt11 = 2
LA11_0 = self.input.LA(1)
if (LA11_0 == MONTH):
alt11 = 1
elif ((JANUARY <= LA11_0 <= DECEMBER)):
alt11 = 2
else:
nvae = NoViableAltException("", 11, 0, self.input)
raise nvae
if alt11 == 1:
pass
self.match(self.input, MONTH,
self.FOLLOW_MONTH_in_monthspec459)
self.month_set = self.month_set.union(
set([
self.ValueOf(JANUARY),
self.ValueOf(FEBRUARY),
self.ValueOf(MARCH),
self.ValueOf(APRIL),
self.ValueOf(MAY),
self.ValueOf(JUNE),
self.ValueOf(JULY),
self.ValueOf(AUGUST),
self.ValueOf(SEPTEMBER),
self.ValueOf(OCTOBER),
self.ValueOf(NOVEMBER),
self.ValueOf(DECEMBER)
]))
elif alt11 == 2:
pass
self._state.following.append(
self.FOLLOW_months_in_monthspec469)
self.months()
self._state.following.pop()
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def months(self, ):
try:
try:
pass
pass
self._state.following.append(self.FOLLOW_month_in_months486)
self.month()
self._state.following.pop()
while True:
alt12 = 2
LA12_0 = self.input.LA(1)
if (LA12_0 == COMMA):
alt12 = 1
if alt12 == 1:
pass
self.match(self.input, COMMA,
self.FOLLOW_COMMA_in_months489)
self._state.following.append(
self.FOLLOW_month_in_months491)
self.month()
self._state.following.pop()
else:
break
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def month(self, ):
monthname = None
try:
try:
pass
monthname = self.input.LT(1)
if (JANUARY <= self.input.LA(1) <= DECEMBER):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self.month_set.add(self.ValueOf(monthname.type))
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def quarterspec(self, ):
try:
try:
pass
alt13 = 2
LA13_0 = self.input.LA(1)
if (LA13_0 == QUARTER):
alt13 = 1
elif ((FIRST <= LA13_0 <= THIRD)):
alt13 = 2
else:
nvae = NoViableAltException("", 13, 0, self.input)
raise nvae
if alt13 == 1:
pass
self.match(self.input, QUARTER,
self.FOLLOW_QUARTER_in_quarterspec583)
self.month_set = self.month_set.union(
set([
self.ValueOf(JANUARY),
self.ValueOf(APRIL),
self.ValueOf(JULY),
self.ValueOf(OCTOBER)
]))
elif alt13 == 2:
pass
pass
self._state.following.append(
self.FOLLOW_quarter_ordinals_in_quarterspec595)
self.quarter_ordinals()
self._state.following.pop()
self.match(self.input, MONTH,
self.FOLLOW_MONTH_in_quarterspec597)
self.match(self.input, OF,
self.FOLLOW_OF_in_quarterspec599)
self.match(self.input, QUARTER,
self.FOLLOW_QUARTER_in_quarterspec601)
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def quarter_ordinals(self, ):
try:
try:
pass
pass
self._state.following.append(
self.FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals620
)
self.month_of_quarter_ordinal()
self._state.following.pop()
while True:
alt14 = 2
LA14_0 = self.input.LA(1)
if (LA14_0 == COMMA):
alt14 = 1
if alt14 == 1:
pass
self.match(self.input, COMMA,
self.FOLLOW_COMMA_in_quarter_ordinals623)
self._state.following.append(
self.
FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals625
)
self.month_of_quarter_ordinal()
self._state.following.pop()
else:
break
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def month_of_quarter_ordinal(self, ):
offset = None
try:
try:
pass
offset = self.input.LT(1)
if (FIRST <= self.input.LA(1) <= THIRD):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
jOffset = self.ValueOf(offset.type) - 1
self.month_set = self.month_set.union(
set([
jOffset + self.ValueOf(JANUARY),
jOffset + self.ValueOf(APRIL),
jOffset + self.ValueOf(JULY),
jOffset + self.ValueOf(OCTOBER)
]))
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
def time_range(self, ):
start_time = None
end_time = None
try:
try:
pass
pass
self.match(self.input, FROM, self.FOLLOW_FROM_in_time_range673)
pass
start_time = self.match(self.input, TIME,
self.FOLLOW_TIME_in_time_range680)
self.start_time_string = start_time.text
self.match(self.input, TO, self.FOLLOW_TO_in_time_range691)
pass
end_time = self.match(self.input, TIME,
self.FOLLOW_TIME_in_time_range698)
self.end_time_string = end_time.text
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
DFA4_eot = DFA.unpack(u"\13\uffff")
DFA4_eof = DFA.unpack(u"\13\uffff")
DFA4_min = DFA.unpack(
u"\1\6\1\23\1\12\1\uffff\2\4\1\13\1\uffff\1\24\1\12\1\4")
DFA4_max = DFA.unpack(
u"\1\20\2\32\1\uffff\1\5\1\12\1\20\1\uffff\2\32\1\12")
DFA4_accept = DFA.unpack(u"\3\uffff\1\1\3\uffff\1\2\3\uffff")
DFA4_special = DFA.unpack(u"\13\uffff")
DFA4_transition = [
DFA.unpack(u"\1\1\2\3\2\uffff\6\2"),
DFA.unpack(u"\1\4\7\5"),
DFA.unpack(u"\1\6\10\uffff\1\4\7\5"),
DFA.unpack(u""),
DFA.unpack(u"\1\3\1\7"),
DFA.unpack(u"\1\3\1\7\4\uffff\1\10"),
DFA.unpack(u"\6\11"),
DFA.unpack(u""),
DFA.unpack(u"\7\12"),
DFA.unpack(u"\1\6\10\uffff\1\4\7\5"),
DFA.unpack(u"\1\3\1\7\4\uffff\1\10")
]
DFA4 = DFA
FOLLOW_specifictime_in_timespec44 = frozenset([])
FOLLOW_interval_in_timespec48 = frozenset([])
FOLLOW_EOF_in_timespec52 = frozenset([1])
FOLLOW_ordinals_in_specifictime72 = frozenset(
[19, 20, 21, 22, 23, 24, 25, 26])
FOLLOW_weekdays_in_specifictime74 = frozenset([4])
FOLLOW_monthdays_in_specifictime77 = frozenset([4])
FOLLOW_OF_in_specifictime80 = frozenset(
[11, 12, 13, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40])
FOLLOW_monthspec_in_specifictime83 = frozenset([5])
FOLLOW_quarterspec_in_specifictime85 = frozenset([5])
FOLLOW_ordinals_in_specifictime101 = frozenset(
[19, 20, 21, 22, 23, 24, 25, 26])
FOLLOW_weekdays_in_specifictime103 = frozenset([5])
FOLLOW_TIME_in_specifictime117 = frozenset([1])
FOLLOW_EVERY_in_interval136 = frozenset([7, 8])
FOLLOW_set_in_interval146 = frozenset([17, 18])
FOLLOW_period_in_interval164 = frozenset([1, 9, 41])
FOLLOW_time_range_in_interval176 = frozenset([1])
FOLLOW_SYNCHRONIZED_in_interval189 = frozenset([1])
FOLLOW_EVERY_in_ordinals218 = frozenset([1])
FOLLOW_ordinal_in_ordinals226 = frozenset([1, 10])
FOLLOW_COMMA_in_ordinals229 = frozenset([11, 12, 13, 14, 15, 16])
FOLLOW_ordinal_in_ordinals231 = frozenset([1, 10])
FOLLOW_set_in_ordinal252 = frozenset([1])
FOLLOW_set_in_period291 = frozenset([1])
FOLLOW_monthday_in_monthdays314 = frozenset([1, 10])
FOLLOW_COMMA_in_monthdays318 = frozenset([7, 8])
FOLLOW_monthday_in_monthdays320 = frozenset([1, 10])
FOLLOW_set_in_monthday340 = frozenset([1])
FOLLOW_DAY_in_weekdays365 = frozenset([1])
FOLLOW_weekday_in_weekdays373 = frozenset([1, 10])
FOLLOW_COMMA_in_weekdays376 = frozenset([19, 20, 21, 22, 23, 24, 25, 26])
FOLLOW_weekday_in_weekdays378 = frozenset([1, 10])
FOLLOW_set_in_weekday400 = frozenset([1])
FOLLOW_MONTH_in_monthspec459 = frozenset([1])
FOLLOW_months_in_monthspec469 = frozenset([1])
FOLLOW_month_in_months486 = frozenset([1, 10])
FOLLOW_COMMA_in_months489 = frozenset(
[27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39])
FOLLOW_month_in_months491 = frozenset([1, 10])
FOLLOW_set_in_month510 = frozenset([1])
FOLLOW_QUARTER_in_quarterspec583 = frozenset([1])
FOLLOW_quarter_ordinals_in_quarterspec595 = frozenset([27])
FOLLOW_MONTH_in_quarterspec597 = frozenset([4])
FOLLOW_OF_in_quarterspec599 = frozenset([40])
FOLLOW_QUARTER_in_quarterspec601 = frozenset([1])
FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals620 = frozenset([1, 10])
FOLLOW_COMMA_in_quarter_ordinals623 = frozenset(
[11, 12, 13, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40])
FOLLOW_month_of_quarter_ordinal_in_quarter_ordinals625 = frozenset([1, 10])
FOLLOW_set_in_month_of_quarter_ordinal644 = frozenset([1])
FOLLOW_FROM_in_time_range673 = frozenset([5])
FOLLOW_TIME_in_time_range680 = frozenset([42])
FOLLOW_TO_in_time_range691 = frozenset([5])
FOLLOW_TIME_in_time_range698 = frozenset([1])
class bound(TreeParser):
grammarFileName = "bound.g"
api_version = 1
tokenNames = tokenNames
def __init__(self, input, state=None, *args, **kwargs):
if state is None:
state = RecognizerSharedState()
super(bound, self).__init__(input, state, *args, **kwargs)
self.delegates = []
bound = 0
def getBound(self):
return self.bound
# $ANTLR start "eval"
# bound.g:58:1: eval : formula ;
def eval(self, ):
formula1 = None
try:
try:
# bound.g:58:5: ( formula )
# bound.g:58:9: formula
pass
self._state.following.append(self.FOLLOW_formula_in_eval62)
formula1 = self.formula()
self._state.following.pop()
#action start
self.bound = formula1
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return
# $ANTLR end "eval"
# $ANTLR start "formula"
# bound.g:61:1: formula returns [value] : ( ^( OR a= formula b= formula ) | ^( AND a= formula b= formula ) | ^( NOT a= formula ) | ^( CONCAT a= formula b= formula ) | ^( HOLD INT PROP ) | ^( HOLD INT ^( NOT PROP ) ) | ^( WITHIN phi= formula low= INT high= INT ) | PROP | TRUE | FALSE );
def formula(self, ):
value = None
low = None
high = None
INT2 = None
INT3 = None
a = None
b = None
phi = None
try:
try:
# bound.g:62:5: ( ^( OR a= formula b= formula ) | ^( AND a= formula b= formula ) | ^( NOT a= formula ) | ^( CONCAT a= formula b= formula ) | ^( HOLD INT PROP ) | ^( HOLD INT ^( NOT PROP ) ) | ^( WITHIN phi= formula low= INT high= INT ) | PROP | TRUE | FALSE )
alt1 = 10
LA1 = self.input.LA(1)
if LA1 == OR:
alt1 = 1
elif LA1 == AND:
alt1 = 2
elif LA1 == NOT:
alt1 = 3
elif LA1 == CONCAT:
alt1 = 4
elif LA1 == HOLD:
LA1_5 = self.input.LA(2)
if (LA1_5 == 2):
LA1_10 = self.input.LA(3)
if (LA1_10 == INT):
LA1_11 = self.input.LA(4)
if (LA1_11 == PROP):
alt1 = 5
elif (LA1_11 == NOT):
alt1 = 6
else:
nvae = NoViableAltException(
"", 1, 11, self.input)
raise nvae
else:
nvae = NoViableAltException("", 1, 10, self.input)
raise nvae
else:
nvae = NoViableAltException("", 1, 5, self.input)
raise nvae
elif LA1 == WITHIN:
alt1 = 7
elif LA1 == PROP:
alt1 = 8
elif LA1 == TRUE:
alt1 = 9
elif LA1 == FALSE:
alt1 = 10
else:
nvae = NoViableAltException("", 1, 0, self.input)
raise nvae
if alt1 == 1:
# bound.g:62:9: ^( OR a= formula b= formula )
pass
self.match(self.input, OR, self.FOLLOW_OR_in_formula88)
self.match(self.input, DOWN, None)
self._state.following.append(
self.FOLLOW_formula_in_formula93)
a = self.formula()
self._state.following.pop()
self._state.following.append(
self.FOLLOW_formula_in_formula97)
b = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
value = (min(a[0], b[0]), max(a[1], b[1]))
#action end
elif alt1 == 2:
# bound.g:63:9: ^( AND a= formula b= formula )
pass
self.match(self.input, AND, self.FOLLOW_AND_in_formula111)
self.match(self.input, DOWN, None)
self._state.following.append(
self.FOLLOW_formula_in_formula115)
a = self.formula()
self._state.following.pop()
self._state.following.append(
self.FOLLOW_formula_in_formula119)
b = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
value = (max(a[0], b[0]), max(a[1], b[1]))
#action end
elif alt1 == 3:
# bound.g:64:9: ^( NOT a= formula )
pass
self.match(self.input, NOT, self.FOLLOW_NOT_in_formula133)
self.match(self.input, DOWN, None)
self._state.following.append(
self.FOLLOW_formula_in_formula137)
a = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
value = a
#action end
elif alt1 == 4:
# bound.g:65:9: ^( CONCAT a= formula b= formula )
pass
self.match(self.input, CONCAT,
self.FOLLOW_CONCAT_in_formula161)
self.match(self.input, DOWN, None)
self._state.following.append(
self.FOLLOW_formula_in_formula165)
a = self.formula()
self._state.following.pop()
self._state.following.append(
self.FOLLOW_formula_in_formula169)
b = self.formula()
self._state.following.pop()
self.match(self.input, UP, None)
#action start
value = [x + y + 1 for x, y in zip(a, b)]
#action end
elif alt1 == 5:
# bound.g:66:9: ^( HOLD INT PROP )
pass
self.match(self.input, HOLD,
self.FOLLOW_HOLD_in_formula183)
self.match(self.input, DOWN, None)
INT2 = self.match(self.input, INT,
self.FOLLOW_INT_in_formula185)
self.match(self.input, PROP,
self.FOLLOW_PROP_in_formula187)
self.match(self.input, UP, None)
#action start
value = (int(INT2.text), int(INT2.text))
#action end
elif alt1 == 6:
# bound.g:67:9: ^( HOLD INT ^( NOT PROP ) )
pass
self.match(self.input, HOLD,
self.FOLLOW_HOLD_in_formula208)
self.match(self.input, DOWN, None)
INT3 = self.match(self.input, INT,
self.FOLLOW_INT_in_formula210)
self.match(self.input, NOT, self.FOLLOW_NOT_in_formula213)
self.match(self.input, DOWN, None)
self.match(self.input, PROP,
self.FOLLOW_PROP_in_formula215)
self.match(self.input, UP, None)
self.match(self.input, UP, None)
#action start
value = (int(INT3.text), int(INT3.text))
#action end
elif alt1 == 7:
# bound.g:68:9: ^( WITHIN phi= formula low= INT high= INT )
pass
self.match(self.input, WITHIN,
self.FOLLOW_WITHIN_in_formula230)
self.match(self.input, DOWN, None)
self._state.following.append(
self.FOLLOW_formula_in_formula234)
phi = self.formula()
self._state.following.pop()
low = self.match(self.input, INT,
self.FOLLOW_INT_in_formula238)
high = self.match(self.input, INT,
self.FOLLOW_INT_in_formula242)
self.match(self.input, UP, None)
#action start
value = (int(low.text) + phi[0], int(high.text)
) # - int(low.text)
if phi[1] > int(high.text) - int(low.text):
raise ValueError(
"Within operator deadline is invalid!")
#action end
elif alt1 == 8:
# bound.g:73:9: PROP
pass
self.match(self.input, PROP,
self.FOLLOW_PROP_in_formula255)
#action start
value = (0, 0)
#action end
elif alt1 == 9:
# bound.g:74:9: TRUE
pass
self.match(self.input, TRUE,
self.FOLLOW_TRUE_in_formula290)
#action start
value = (0, 0)
#action end
elif alt1 == 10:
# bound.g:75:9: FALSE
pass
self.match(self.input, FALSE,
self.FOLLOW_FALSE_in_formula325)
#action start
value = (0, 0)
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return value
# $ANTLR end "formula"
FOLLOW_formula_in_eval62 = frozenset([1])
FOLLOW_OR_in_formula88 = frozenset([2])
FOLLOW_formula_in_formula93 = frozenset([4, 5, 6, 7, 9, 10, 11, 12, 13])
FOLLOW_formula_in_formula97 = frozenset([3])
FOLLOW_AND_in_formula111 = frozenset([2])
FOLLOW_formula_in_formula115 = frozenset([4, 5, 6, 7, 9, 10, 11, 12, 13])
FOLLOW_formula_in_formula119 = frozenset([3])
FOLLOW_NOT_in_formula133 = frozenset([2])
FOLLOW_formula_in_formula137 = frozenset([3])
FOLLOW_CONCAT_in_formula161 = frozenset([2])
FOLLOW_formula_in_formula165 = frozenset([4, 5, 6, 7, 9, 10, 11, 12, 13])
FOLLOW_formula_in_formula169 = frozenset([3])
FOLLOW_HOLD_in_formula183 = frozenset([2])
FOLLOW_INT_in_formula185 = frozenset([11])
FOLLOW_PROP_in_formula187 = frozenset([3])
FOLLOW_HOLD_in_formula208 = frozenset([2])
FOLLOW_INT_in_formula210 = frozenset([9])
FOLLOW_NOT_in_formula213 = frozenset([2])
FOLLOW_PROP_in_formula215 = frozenset([3])
FOLLOW_WITHIN_in_formula230 = frozenset([2])
FOLLOW_formula_in_formula234 = frozenset([8])
FOLLOW_INT_in_formula238 = frozenset([8])
FOLLOW_INT_in_formula242 = frozenset([3])
FOLLOW_PROP_in_formula255 = frozenset([1])
FOLLOW_TRUE_in_formula290 = frozenset([1])
FOLLOW_FALSE_in_formula325 = frozenset([1])
class DeclarationsParser(Parser):
grammarFileName = "grammars/Declarations.g"
antlr_version = version_str_to_tuple("3.1.1")
antlr_version_str = "3.1.1"
tokenNames = tokenNames
def __init__(self, input, state=None):
if state is None:
state = RecognizerSharedState()
Parser.__init__(self, input, state)
self.declarations_stack = []
# $ANTLR start "declarations"
# grammars/Declarations.g:73:1: declarations returns [r] : ( declaration )+ ;
def declarations(self, ):
self.declarations_stack.append(declarations_scope())
r = None
try:
try:
# grammars/Declarations.g:78:2: ( ( declaration )+ )
# grammars/Declarations.g:79:2: ( declaration )+
pass
#action start
self.declarations_stack[-1].decls = []
#action end
# grammars/Declarations.g:82:2: ( declaration )+
cnt1 = 0
while True: #loop1
alt1 = 2
LA1_0 = self.input.LA(1)
if (LA1_0 == 8 or (14 <= LA1_0 <= 16)):
alt1 = 1
if alt1 == 1:
# grammars/Declarations.g:82:3: declaration
pass
self._state.following.append(
self.FOLLOW_declaration_in_declarations68)
self.declaration()
self._state.following.pop()
else:
if cnt1 >= 1:
break #loop1
eee = EarlyExitException(1, self.input)
raise eee
cnt1 += 1
#action start
r = self.declarations_stack[-1].decls
#action end
except RecognitionException, e:
raise
finally:
self.declarations_stack.pop()
pass
return r
# $ANTLR end "declarations"
# $ANTLR start "declaration"
# grammars/Declarations.g:87:1: declaration : ( 'int' ( '[' low= INT '..' high= INT ']' ) i= ID '=' inn= INT ';' | 'clock' i= ID ';' | 'signal' i= ID ';' | 'bool' i= ID '=' inn= BOOL ';' );
def declaration(self, ):
low = None
high = None
i = None
inn = None
try:
try:
# grammars/Declarations.g:87:13: ( 'int' ( '[' low= INT '..' high= INT ']' ) i= ID '=' inn= INT ';' | 'clock' i= ID ';' | 'signal' i= ID ';' | 'bool' i= ID '=' inn= BOOL ';' )
alt2 = 4
LA2 = self.input.LA(1)
if LA2 == 8:
alt2 = 1
elif LA2 == 14:
alt2 = 2
elif LA2 == 15:
alt2 = 3
elif LA2 == 16:
alt2 = 4
else:
nvae = NoViableAltException("", 2, 0, self.input)
raise nvae
if alt2 == 1:
# grammars/Declarations.g:88:3: 'int' ( '[' low= INT '..' high= INT ']' ) i= ID '=' inn= INT ';'
pass
self.match(self.input, 8, self.FOLLOW_8_in_declaration83)
# grammars/Declarations.g:88:10: ( '[' low= INT '..' high= INT ']' )
# grammars/Declarations.g:88:11: '[' low= INT '..' high= INT ']'
pass
self.match(self.input, 9, self.FOLLOW_9_in_declaration87)
low = self.match(self.input, INT,
self.FOLLOW_INT_in_declaration92)
self.match(self.input, 10, self.FOLLOW_10_in_declaration95)
high = self.match(self.input, INT,
self.FOLLOW_INT_in_declaration100)
self.match(self.input, 11,
self.FOLLOW_11_in_declaration103)
i = self.match(self.input, ID,
self.FOLLOW_ID_in_declaration108)
self.match(self.input, 12,
self.FOLLOW_12_in_declaration111)
inn = self.match(self.input, INT,
self.FOLLOW_INT_in_declaration116)
self.match(self.input, 13,
self.FOLLOW_13_in_declaration119)
#action start
self.declarations_stack[-1].decls.append(
IntVar(i.text, (int(low.text), int(high.text)),
int(inn.text)))
#action end
elif alt2 == 2:
# grammars/Declarations.g:90:3: 'clock' i= ID ';'
pass
self.match(self.input, 14,
self.FOLLOW_14_in_declaration129)
i = self.match(self.input, ID,
self.FOLLOW_ID_in_declaration134)
self.match(self.input, 13,
self.FOLLOW_13_in_declaration137)
#action start
self.declarations_stack[-1].decls.append(ClockVar(i.text))
#action end
elif alt2 == 3:
# grammars/Declarations.g:92:3: 'signal' i= ID ';'
pass
self.match(self.input, 15,
self.FOLLOW_15_in_declaration147)
i = self.match(self.input, ID,
self.FOLLOW_ID_in_declaration152)
self.match(self.input, 13,
self.FOLLOW_13_in_declaration155)
#action start
self.declarations_stack[-1].decls.append(SignalVar(i.text))
#action end
elif alt2 == 4:
# grammars/Declarations.g:94:3: 'bool' i= ID '=' inn= BOOL ';'
pass
self.match(self.input, 16,
self.FOLLOW_16_in_declaration165)
i = self.match(self.input, ID,
self.FOLLOW_ID_in_declaration170)
self.match(self.input, 12,
self.FOLLOW_12_in_declaration172)
inn = self.match(self.input, BOOL,
self.FOLLOW_BOOL_in_declaration177)
self.match(self.input, 13,
self.FOLLOW_13_in_declaration180)
#action start
self.declarations_stack[-1].decls.append(
BoolVar(i.text, {
'true': True,
'false': False
}[inn.text]))
#action end
except RecognitionException, e:
raise
finally:
pass
return
# $ANTLR end "declaration"
# $ANTLR start "empty"
# grammars/Declarations.g:97:1: empty : ( WS | );
def empty(self, ):
try:
try:
# grammars/Declarations.g:97:7: ( WS | )
alt3 = 2
LA3_0 = self.input.LA(1)
if (LA3_0 == WS):
alt3 = 1
elif (LA3_0 == EOF):
alt3 = 2
else:
nvae = NoViableAltException("", 3, 0, self.input)
raise nvae
if alt3 == 1:
# grammars/Declarations.g:98:2: WS
pass
self.match(self.input, WS, self.FOLLOW_WS_in_empty193)
elif alt3 == 2:
# grammars/Declarations.g:98:6:
pass
except RecognitionException, e:
raise
finally:
pass
return
# $ANTLR end "empty"
# Delegated rules
FOLLOW_declaration_in_declarations68 = frozenset([1, 8, 14, 15, 16])
FOLLOW_8_in_declaration83 = frozenset([9])
FOLLOW_9_in_declaration87 = frozenset([4])
FOLLOW_INT_in_declaration92 = frozenset([10])
FOLLOW_10_in_declaration95 = frozenset([4])
FOLLOW_INT_in_declaration100 = frozenset([11])
FOLLOW_11_in_declaration103 = frozenset([5])
FOLLOW_ID_in_declaration108 = frozenset([12])
FOLLOW_12_in_declaration111 = frozenset([4])
FOLLOW_INT_in_declaration116 = frozenset([13])
FOLLOW_13_in_declaration119 = frozenset([1])
FOLLOW_14_in_declaration129 = frozenset([5])
FOLLOW_ID_in_declaration134 = frozenset([13])
FOLLOW_13_in_declaration137 = frozenset([1])
FOLLOW_15_in_declaration147 = frozenset([5])
FOLLOW_ID_in_declaration152 = frozenset([13])
FOLLOW_13_in_declaration155 = frozenset([1])
FOLLOW_16_in_declaration165 = frozenset([5])
FOLLOW_ID_in_declaration170 = frozenset([12])
FOLLOW_12_in_declaration172 = frozenset([6])
FOLLOW_BOOL_in_declaration177 = frozenset([13])
FOLLOW_13_in_declaration180 = frozenset([1])
FOLLOW_WS_in_empty193 = frozenset([1])
class ActionParser(Parser):
grammarFileName = "grammars/Action.g"
antlr_version = version_str_to_tuple("3.1.1")
antlr_version_str = "3.1.1"
tokenNames = tokenNames
def __init__(self, input, state=None):
if state is None:
state = RecognizerSharedState()
Parser.__init__(self, input, state)
self.action_stack = []
self.add_expr_stack = []
self.mult_expr_stack = []
self.comp_expr_stack = []
self.or_expr_stack = []
self.and_expr_stack = []
# $ANTLR start "action"
# grammars/Action.g:148:1: action returns [r] : assign_statement ( ';' assign_statement )* ( ';' )? EOF ;
def action(self, ):
self.action_stack.append(action_scope())
r = None
try:
try:
# grammars/Action.g:153:2: ( assign_statement ( ';' assign_statement )* ( ';' )? EOF )
# grammars/Action.g:154:2: assign_statement ( ';' assign_statement )* ( ';' )? EOF
pass
#action start
self.action_stack[-1].statements = []
#action end
self._state.following.append(
self.FOLLOW_assign_statement_in_action68)
self.assign_statement()
self._state.following.pop()
# grammars/Action.g:157:19: ( ';' assign_statement )*
while True: #loop1
alt1 = 2
LA1_0 = self.input.LA(1)
if (LA1_0 == 8):
LA1_1 = self.input.LA(2)
if (LA1_1 == ID or LA1_1 == 10):
alt1 = 1
if alt1 == 1:
# grammars/Action.g:157:20: ';' assign_statement
pass
self.match(self.input, 8, self.FOLLOW_8_in_action71)
self._state.following.append(
self.FOLLOW_assign_statement_in_action73)
self.assign_statement()
self._state.following.pop()
else:
break #loop1
# grammars/Action.g:157:43: ( ';' )?
alt2 = 2
LA2_0 = self.input.LA(1)
if (LA2_0 == 8):
alt2 = 1
if alt2 == 1:
# grammars/Action.g:157:43: ';'
pass
self.match(self.input, 8, self.FOLLOW_8_in_action77)
#action start
r = self.action_stack[-1].statements
#action end
self.match(self.input, EOF, self.FOLLOW_EOF_in_action82)
except RecognitionException, e:
raise
finally:
self.action_stack.pop()
pass
return r
# $ANTLR end "action"
# $ANTLR start "assign_statement"
# grammars/Action.g:162:1: assign_statement : (var= ID '=' op= expr | ( ( '!!' i= ID ) | ( '!!' '(' i= ID ')' ) ) | var= ID '=' 'random()' );
def assign_statement(self, ):
var = None
i = None
op = None
try:
try:
# grammars/Action.g:162:18: (var= ID '=' op= expr | ( ( '!!' i= ID ) | ( '!!' '(' i= ID ')' ) ) | var= ID '=' 'random()' )
alt4 = 3
LA4_0 = self.input.LA(1)
if (LA4_0 == ID):
LA4_1 = self.input.LA(2)
if (LA4_1 == 9):
LA4_3 = self.input.LA(3)
if (LA4_3 == 13):
alt4 = 3
elif ((ID <= LA4_3 <= BOOLCONST) or LA4_3 == 11
or (16 <= LA4_3 <= 17)):
alt4 = 1
else:
nvae = NoViableAltException("", 4, 3, self.input)
raise nvae
else:
nvae = NoViableAltException("", 4, 1, self.input)
raise nvae
elif (LA4_0 == 10):
alt4 = 2
else:
nvae = NoViableAltException("", 4, 0, self.input)
raise nvae
if alt4 == 1:
# grammars/Action.g:163:2: var= ID '=' op= expr
pass
var = self.match(self.input, ID,
self.FOLLOW_ID_in_assign_statement95)
self.match(self.input, 9,
self.FOLLOW_9_in_assign_statement97)
self._state.following.append(
self.FOLLOW_expr_in_assign_statement101)
op = self.expr()
self._state.following.pop()
#action start
self.action_stack[-1].statements.append(
AssignStatement(var.text, op))
#action end
elif alt4 == 2:
# grammars/Action.g:164:2: ( ( '!!' i= ID ) | ( '!!' '(' i= ID ')' ) )
pass
# grammars/Action.g:164:2: ( ( '!!' i= ID ) | ( '!!' '(' i= ID ')' ) )
alt3 = 2
LA3_0 = self.input.LA(1)
if (LA3_0 == 10):
LA3_1 = self.input.LA(2)
if (LA3_1 == ID):
alt3 = 1
elif (LA3_1 == 11):
alt3 = 2
else:
nvae = NoViableAltException("", 3, 1, self.input)
raise nvae
else:
nvae = NoViableAltException("", 3, 0, self.input)
raise nvae
if alt3 == 1:
# grammars/Action.g:164:3: ( '!!' i= ID )
pass
# grammars/Action.g:164:3: ( '!!' i= ID )
# grammars/Action.g:164:4: '!!' i= ID
pass
self.match(self.input, 10,
self.FOLLOW_10_in_assign_statement110)
i = self.match(self.input, ID,
self.FOLLOW_ID_in_assign_statement114)
elif alt3 == 2:
# grammars/Action.g:164:15: ( '!!' '(' i= ID ')' )
pass
# grammars/Action.g:164:15: ( '!!' '(' i= ID ')' )
# grammars/Action.g:164:16: '!!' '(' i= ID ')'
pass
self.match(self.input, 10,
self.FOLLOW_10_in_assign_statement118)
self.match(self.input, 11,
self.FOLLOW_11_in_assign_statement120)
i = self.match(self.input, ID,
self.FOLLOW_ID_in_assign_statement124)
self.match(self.input, 12,
self.FOLLOW_12_in_assign_statement126)
#action start
self.action_stack[-1].statements.append(
SendSignalStatement(i.text))
#action end
elif alt4 == 3:
# grammars/Action.g:165:2: var= ID '=' 'random()'
pass
var = self.match(self.input, ID,
self.FOLLOW_ID_in_assign_statement137)
self.match(self.input, 9,
self.FOLLOW_9_in_assign_statement139)
self.match(self.input, 13,
self.FOLLOW_13_in_assign_statement141)
#action start
self.action_stack[-1].statements.append(
RandomAssignStatement(var.text))
#action end
except RecognitionException, e:
raise
finally:
pass
return
# $ANTLR end "assign_statement"
# $ANTLR start "expr"
# grammars/Action.g:167:1: expr returns [a] : op1= add_expr ( '?' op2= add_expr ':' op3= add_expr )? ;
def expr(self, ):
a = None
op1 = None
op2 = None
op3 = None
try:
try:
# grammars/Action.g:167:18: (op1= add_expr ( '?' op2= add_expr ':' op3= add_expr )? )
# grammars/Action.g:168:2: op1= add_expr ( '?' op2= add_expr ':' op3= add_expr )?
pass
self._state.following.append(self.FOLLOW_add_expr_in_expr159)
op1 = self.add_expr()
self._state.following.pop()
# grammars/Action.g:168:16: ( '?' op2= add_expr ':' op3= add_expr )?
alt5 = 2
LA5_0 = self.input.LA(1)
if (LA5_0 == 14):
alt5 = 1
if alt5 == 1:
# grammars/Action.g:168:17: '?' op2= add_expr ':' op3= add_expr
pass
self.match(self.input, 14, self.FOLLOW_14_in_expr163)
self._state.following.append(
self.FOLLOW_add_expr_in_expr167)
op2 = self.add_expr()
self._state.following.pop()
self.match(self.input, 15, self.FOLLOW_15_in_expr169)
self._state.following.append(
self.FOLLOW_add_expr_in_expr173)
op3 = self.add_expr()
self._state.following.pop()
#action start
a = ConditionalOp(op1, op2, op3)
#action end
#action start
a = {
False: ConditionalOp(op1, op2, op3),
True: op1
}[op2 == None]
#action end
except RecognitionException, e:
raise
finally:
pass
return a
# $ANTLR end "expr"
# $ANTLR start "add_expr"
# grammars/Action.g:170:1: add_expr returns [a] : (o= ( '+' | '-' ) )? e= mult_expr (o= ( '+' | '-' ) e= mult_expr )* ;
def add_expr(self, ):
self.add_expr_stack.append(add_expr_scope())
a = None
o = None
e = None
try:
try:
# grammars/Action.g:170:31: ( (o= ( '+' | '-' ) )? e= mult_expr (o= ( '+' | '-' ) e= mult_expr )* )
# grammars/Action.g:171:2: (o= ( '+' | '-' ) )? e= mult_expr (o= ( '+' | '-' ) e= mult_expr )*
pass
# grammars/Action.g:171:3: (o= ( '+' | '-' ) )?
alt6 = 2
LA6_0 = self.input.LA(1)
if ((16 <= LA6_0 <= 17)):
alt6 = 1
if alt6 == 1:
# grammars/Action.g:171:3: o= ( '+' | '-' )
pass
o = self.input.LT(1)
if (16 <= self.input.LA(1) <= 17):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self._state.following.append(
self.FOLLOW_mult_expr_in_add_expr207)
e = self.mult_expr()
self._state.following.pop()
#action start
self.add_expr_stack[-1].l = [({
True: (lambda x: '+'),
False: (lambda i: i.text)
}[o == None](o), e)]
#action end
# grammars/Action.g:171:112: (o= ( '+' | '-' ) e= mult_expr )*
while True: #loop7
alt7 = 2
LA7_0 = self.input.LA(1)
if ((16 <= LA7_0 <= 17)):
alt7 = 1
if alt7 == 1:
# grammars/Action.g:171:113: o= ( '+' | '-' ) e= mult_expr
pass
o = self.input.LT(1)
if (16 <= self.input.LA(1) <= 17):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self._state.following.append(
self.FOLLOW_mult_expr_in_add_expr222)
e = self.mult_expr()
self._state.following.pop()
#action start
self.add_expr_stack[-1].l.append((o.text, e))
#action end
else:
break #loop7
#action start
a = {
True: PlusOp(self.add_expr_stack[-1].l),
False: self.add_expr_stack[-1].l[0][1]
}[len(self.add_expr_stack[-1].l) > 1]
#action end
except RecognitionException, e:
raise
finally:
self.add_expr_stack.pop()
pass
return a
# $ANTLR end "add_expr"
# $ANTLR start "mult_expr"
# grammars/Action.g:173:1: mult_expr returns [a] : o= comp_expr ( '*' o= comp_expr )* ;
def mult_expr(self, ):
self.mult_expr_stack.append(mult_expr_scope())
a = None
o = None
try:
try:
# grammars/Action.g:173:32: (o= comp_expr ( '*' o= comp_expr )* )
# grammars/Action.g:174:2: o= comp_expr ( '*' o= comp_expr )*
pass
self._state.following.append(
self.FOLLOW_comp_expr_in_mult_expr246)
o = self.comp_expr()
self._state.following.pop()
#action start
self.mult_expr_stack[-1].l = [o]
#action end
# grammars/Action.g:174:34: ( '*' o= comp_expr )*
while True: #loop8
alt8 = 2
LA8_0 = self.input.LA(1)
if (LA8_0 == 18):
alt8 = 1
if alt8 == 1:
# grammars/Action.g:174:35: '*' o= comp_expr
pass
self.match(self.input, 18,
self.FOLLOW_18_in_mult_expr251)
self._state.following.append(
self.FOLLOW_comp_expr_in_mult_expr255)
o = self.comp_expr()
self._state.following.pop()
#action start
self.mult_expr_stack[-1].l.append(o)
#action end
else:
break #loop8
#action start
a = {
True: MultOp(self.mult_expr_stack[-1].l),
False: self.mult_expr_stack[-1].l[0]
}[len(self.mult_expr_stack[-1].l) > 1]
#action end
except RecognitionException, e:
raise
finally:
self.mult_expr_stack.pop()
pass
return a
# $ANTLR end "mult_expr"
# $ANTLR start "comp_expr"
# grammars/Action.g:176:1: comp_expr returns [a] : o= or_expr (sign= ( '>' | '<' | '==' | '!=' | '>=' | '<=' ) o= or_expr )? ;
def comp_expr(self, ):
self.comp_expr_stack.append(comp_expr_scope())
a = None
sign = None
o = None
try:
try:
# grammars/Action.g:176:32: (o= or_expr (sign= ( '>' | '<' | '==' | '!=' | '>=' | '<=' ) o= or_expr )? )
# grammars/Action.g:177:2: o= or_expr (sign= ( '>' | '<' | '==' | '!=' | '>=' | '<=' ) o= or_expr )?
pass
self._state.following.append(
self.FOLLOW_or_expr_in_comp_expr279)
o = self.or_expr()
self._state.following.pop()
#action start
self.comp_expr_stack[-1].l = [o]
#action end
# grammars/Action.g:177:32: (sign= ( '>' | '<' | '==' | '!=' | '>=' | '<=' ) o= or_expr )?
alt9 = 2
LA9_0 = self.input.LA(1)
if ((19 <= LA9_0 <= 24)):
alt9 = 1
if alt9 == 1:
# grammars/Action.g:177:33: sign= ( '>' | '<' | '==' | '!=' | '>=' | '<=' ) o= or_expr
pass
sign = self.input.LT(1)
if (19 <= self.input.LA(1) <= 24):
self.input.consume()
self._state.errorRecovery = False
else:
mse = MismatchedSetException(None, self.input)
raise mse
self._state.following.append(
self.FOLLOW_or_expr_in_comp_expr302)
o = self.or_expr()
self._state.following.pop()
#action start
self.comp_expr_stack[-1].l.append(o)
#action end
#action start
a = {
True:
CompOp(self.comp_expr_stack[-1].l,
sign.text if sign else None),
False:
self.comp_expr_stack[-1].l[0]
}[len(self.comp_expr_stack[-1].l) > 1]
#action end
except RecognitionException, e:
raise
finally:
self.comp_expr_stack.pop()
pass
return a
# $ANTLR end "comp_expr"
# $ANTLR start "or_expr"
# grammars/Action.g:180:1: or_expr returns [a] : o= and_expr ( '||' o= and_expr )* ;
def or_expr(self, ):
self.or_expr_stack.append(or_expr_scope())
a = None
o = None
try:
try:
# grammars/Action.g:180:30: (o= and_expr ( '||' o= and_expr )* )
# grammars/Action.g:181:2: o= and_expr ( '||' o= and_expr )*
pass
self._state.following.append(
self.FOLLOW_and_expr_in_or_expr328)
o = self.and_expr()
self._state.following.pop()
#action start
self.or_expr_stack[-1].l = [o]
#action end
# grammars/Action.g:181:31: ( '||' o= and_expr )*
while True: #loop10
alt10 = 2
LA10_0 = self.input.LA(1)
if (LA10_0 == 25):
alt10 = 1
if alt10 == 1:
# grammars/Action.g:181:32: '||' o= and_expr
pass
self.match(self.input, 25,
self.FOLLOW_25_in_or_expr333)
self._state.following.append(
self.FOLLOW_and_expr_in_or_expr337)
o = self.and_expr()
self._state.following.pop()
#action start
self.or_expr_stack[-1].l.append(o)
#action end
else:
break #loop10
#action start
a = {
True: OrOp(self.or_expr_stack[-1].l),
False: self.or_expr_stack[-1].l[0]
}[len(self.or_expr_stack[-1].l) > 1]
#action end
except RecognitionException, e:
raise
finally:
self.or_expr_stack.pop()
pass
return a
# $ANTLR end "or_expr"
# $ANTLR start "and_expr"
# grammars/Action.g:183:1: and_expr returns [a] : o= atom ( '&&' o= atom )* ;
def and_expr(self, ):
self.and_expr_stack.append(and_expr_scope())
a = None
o = None
try:
try:
# grammars/Action.g:183:31: (o= atom ( '&&' o= atom )* )
# grammars/Action.g:184:2: o= atom ( '&&' o= atom )*
pass
self._state.following.append(self.FOLLOW_atom_in_and_expr362)
o = self.atom()
self._state.following.pop()
#action start
self.and_expr_stack[-1].l = [o]
#action end
# grammars/Action.g:184:28: ( '&&' o= atom )*
while True: #loop11
alt11 = 2
LA11_0 = self.input.LA(1)
if (LA11_0 == 26):
alt11 = 1
if alt11 == 1:
# grammars/Action.g:184:29: '&&' o= atom
pass
self.match(self.input, 26,
self.FOLLOW_26_in_and_expr367)
self._state.following.append(
self.FOLLOW_atom_in_and_expr371)
o = self.atom()
self._state.following.pop()
#action start
self.and_expr_stack[-1].l.append(o)
#action end
else:
break #loop11
#action start
a = {
True: AndOp(self.and_expr_stack[-1].l),
False: self.and_expr_stack[-1].l[0]
}[len(self.and_expr_stack[-1].l) > 1]
#action end
except RecognitionException, e:
raise
finally:
self.and_expr_stack.pop()
pass
return a
# $ANTLR end "and_expr"
# $ANTLR start "atom"
# grammars/Action.g:186:1: atom returns [a] : ( (o1= ID ) | (o2= INT ) | (o3= BOOLCONST ) | ( '(' o4= expr ')' ) );
def atom(self, ):
a = None
o1 = None
o2 = None
o3 = None
o4 = None
try:
try:
# grammars/Action.g:186:17: ( (o1= ID ) | (o2= INT ) | (o3= BOOLCONST ) | ( '(' o4= expr ')' ) )
alt12 = 4
LA12 = self.input.LA(1)
if LA12 == ID:
alt12 = 1
elif LA12 == INT:
alt12 = 2
elif LA12 == BOOLCONST:
alt12 = 3
elif LA12 == 11:
alt12 = 4
else:
nvae = NoViableAltException("", 12, 0, self.input)
raise nvae
if alt12 == 1:
# grammars/Action.g:187:2: (o1= ID )
pass
# grammars/Action.g:187:2: (o1= ID )
# grammars/Action.g:187:3: o1= ID
pass
o1 = self.match(self.input, ID, self.FOLLOW_ID_in_atom392)
#action start
a = VarName(o1.text)
#action end
elif alt12 == 2:
# grammars/Action.g:187:33: (o2= INT )
pass
# grammars/Action.g:187:33: (o2= INT )
# grammars/Action.g:187:34: o2= INT
pass
o2 = self.match(self.input, INT,
self.FOLLOW_INT_in_atom402)
#action start
a = IntConst(o2.text)
#action end
elif alt12 == 3:
# grammars/Action.g:187:66: (o3= BOOLCONST )
pass
# grammars/Action.g:187:66: (o3= BOOLCONST )
# grammars/Action.g:187:67: o3= BOOLCONST
pass
o3 = self.match(self.input, BOOLCONST,
self.FOLLOW_BOOLCONST_in_atom412)
#action start
a = BoolConst(o3.text == "true")
#action end
elif alt12 == 4:
# grammars/Action.g:187:116: ( '(' o4= expr ')' )
pass
# grammars/Action.g:187:116: ( '(' o4= expr ')' )
# grammars/Action.g:187:117: '(' o4= expr ')'
pass
self.match(self.input, 11, self.FOLLOW_11_in_atom420)
self._state.following.append(self.FOLLOW_expr_in_atom424)
o4 = self.expr()
self._state.following.pop()
self.match(self.input, 12, self.FOLLOW_12_in_atom426)
#action start
a = o4
#action end
except RecognitionException, e:
raise
finally:
pass
return a
# $ANTLR end "atom"
# $ANTLR start "send_signal_statement"
# grammars/Action.g:189:1: send_signal_statement : ( ( '!!' i= ID ) | ( '!!' '(' i= ID ')' ) );
def send_signal_statement(self, ):
i = None
try:
try:
# grammars/Action.g:189:23: ( ( '!!' i= ID ) | ( '!!' '(' i= ID ')' ) )
alt13 = 2
LA13_0 = self.input.LA(1)
if (LA13_0 == 10):
LA13_1 = self.input.LA(2)
if (LA13_1 == ID):
alt13 = 1
elif (LA13_1 == 11):
alt13 = 2
else:
nvae = NoViableAltException("", 13, 1, self.input)
raise nvae
else:
nvae = NoViableAltException("", 13, 0, self.input)
raise nvae
if alt13 == 1:
# grammars/Action.g:190:2: ( '!!' i= ID )
pass
# grammars/Action.g:190:2: ( '!!' i= ID )
# grammars/Action.g:190:3: '!!' i= ID
pass
self.match(self.input, 10,
self.FOLLOW_10_in_send_signal_statement439)
i = self.match(self.input, ID,
self.FOLLOW_ID_in_send_signal_statement443)
elif alt13 == 2:
# grammars/Action.g:190:14: ( '!!' '(' i= ID ')' )
pass
# grammars/Action.g:190:14: ( '!!' '(' i= ID ')' )
# grammars/Action.g:190:15: '!!' '(' i= ID ')'
pass
self.match(self.input, 10,
self.FOLLOW_10_in_send_signal_statement447)
self.match(self.input, 11,
self.FOLLOW_11_in_send_signal_statement449)
i = self.match(self.input, ID,
self.FOLLOW_ID_in_send_signal_statement453)
self.match(self.input, 12,
self.FOLLOW_12_in_send_signal_statement455)
#action start
self.action_stack[-1].statements.append(
SendSignalStatement(i.text))
#action end
except RecognitionException, e:
raise
finally:
pass
return
# $ANTLR end "send_signal_statement"
# Delegated rules
FOLLOW_assign_statement_in_action68 = frozenset([8])
FOLLOW_8_in_action71 = frozenset([4, 10])
FOLLOW_assign_statement_in_action73 = frozenset([8])
FOLLOW_8_in_action77 = frozenset([])
FOLLOW_EOF_in_action82 = frozenset([1])
FOLLOW_ID_in_assign_statement95 = frozenset([9])
FOLLOW_9_in_assign_statement97 = frozenset([4, 5, 6, 11, 16, 17])
FOLLOW_expr_in_assign_statement101 = frozenset([1])
FOLLOW_10_in_assign_statement110 = frozenset([4])
FOLLOW_ID_in_assign_statement114 = frozenset([1])
FOLLOW_10_in_assign_statement118 = frozenset([11])
FOLLOW_11_in_assign_statement120 = frozenset([4])
FOLLOW_ID_in_assign_statement124 = frozenset([12])
FOLLOW_12_in_assign_statement126 = frozenset([1])
FOLLOW_ID_in_assign_statement137 = frozenset([9])
FOLLOW_9_in_assign_statement139 = frozenset([13])
FOLLOW_13_in_assign_statement141 = frozenset([1])
FOLLOW_add_expr_in_expr159 = frozenset([1, 14])
FOLLOW_14_in_expr163 = frozenset([4, 5, 6, 11, 16, 17])
FOLLOW_add_expr_in_expr167 = frozenset([15])
FOLLOW_15_in_expr169 = frozenset([4, 5, 6, 11, 16, 17])
FOLLOW_add_expr_in_expr173 = frozenset([1])
FOLLOW_set_in_add_expr198 = frozenset([4, 5, 6, 11, 16, 17])
FOLLOW_mult_expr_in_add_expr207 = frozenset([1, 16, 17])
FOLLOW_set_in_add_expr214 = frozenset([4, 5, 6, 11, 16, 17])
FOLLOW_mult_expr_in_add_expr222 = frozenset([1, 16, 17])
FOLLOW_comp_expr_in_mult_expr246 = frozenset([1, 18])
FOLLOW_18_in_mult_expr251 = frozenset([4, 5, 6, 11, 16, 17])
FOLLOW_comp_expr_in_mult_expr255 = frozenset([1, 18])
FOLLOW_or_expr_in_comp_expr279 = frozenset([1, 19, 20, 21, 22, 23, 24])
FOLLOW_set_in_comp_expr286 = frozenset([4, 5, 6, 11, 16, 17])
FOLLOW_or_expr_in_comp_expr302 = frozenset([1])
FOLLOW_and_expr_in_or_expr328 = frozenset([1, 25])
FOLLOW_25_in_or_expr333 = frozenset([4, 5, 6, 11, 16, 17])
FOLLOW_and_expr_in_or_expr337 = frozenset([1, 25])
FOLLOW_atom_in_and_expr362 = frozenset([1, 26])
FOLLOW_26_in_and_expr367 = frozenset([4, 5, 6, 11, 16, 17])
FOLLOW_atom_in_and_expr371 = frozenset([1, 26])
FOLLOW_ID_in_atom392 = frozenset([1])
FOLLOW_INT_in_atom402 = frozenset([1])
FOLLOW_BOOLCONST_in_atom412 = frozenset([1])
FOLLOW_11_in_atom420 = frozenset([4, 5, 6, 11, 16, 17])
FOLLOW_expr_in_atom424 = frozenset([12])
FOLLOW_12_in_atom426 = frozenset([1])
FOLLOW_10_in_send_signal_statement439 = frozenset([4])
FOLLOW_ID_in_send_signal_statement443 = frozenset([1])
FOLLOW_10_in_send_signal_statement447 = frozenset([11])
FOLLOW_11_in_send_signal_statement449 = frozenset([4])
FOLLOW_ID_in_send_signal_statement453 = frozenset([12])
FOLLOW_12_in_send_signal_statement455 = frozenset([1])
class AS3_exParser(Parser):
grammarFileName = "AS3_ex.g"
antlr_version = version_str_to_tuple("3.1.3 Mar 18, 2009 10:09:25")
antlr_version_str = "3.1.3 Mar 18, 2009 10:09:25"
tokenNames = tokenNames
def __init__(self, input, state=None, *args, **kwargs):
if state is None:
state = RecognizerSharedState()
super(AS3_exParser, self).__init__(input, state, *args, **kwargs)
self._state.ruleMemo = {}
self._adaptor = None
self.adaptor = CommonTreeAdaptor()
def getTreeAdaptor(self):
return self._adaptor
def setTreeAdaptor(self, adaptor):
self._adaptor = adaptor
adaptor = property(getTreeAdaptor, setTreeAdaptor)
def converT(self, t):
global madict
r = madict.get(t)
if r != None:
return r
else:
return t
class numericLiteral_return(ParserRuleReturnScope):
def __init__(self):
super(AS3_exParser.numericLiteral_return, self).__init__()
self.tree = None
# $ANTLR start "numericLiteral"
# AS3_ex.g:236:1: numericLiteral : (D= DEC_NUMBER_LITERAL | H= HEX_NUMBER_LITERAL );
def numericLiteral(self, ):
retval = self.numericLiteral_return()
retval.start = self.input.LT(1)
numericLiteral_StartIndex = self.input.index()
root_0 = None
D = None
H = None
D_tree = None
H_tree = None
success = False
try:
try:
if self._state.backtracking > 0 and self.alreadyParsedRule(
self.input, 1):
# for cached failed rules, alreadyParsedRule will raise an exception
success = True
return retval
# AS3_ex.g:237:5: (D= DEC_NUMBER_LITERAL | H= HEX_NUMBER_LITERAL )
alt1 = 2
LA1_0 = self.input.LA(1)
if (LA1_0 == DEC_NUMBER_LITERAL):
alt1 = 1
elif (LA1_0 == HEX_NUMBER_LITERAL):
alt1 = 2
else:
if self._state.backtracking > 0:
raise BacktrackingFailed
nvae = NoViableAltException("", 1, 0, self.input)
raise nvae
if alt1 == 1:
# AS3_ex.g:238:5: D= DEC_NUMBER_LITERAL
pass
root_0 = self._adaptor.nil()
D = self.match(
self.input, DEC_NUMBER_LITERAL,
self.FOLLOW_DEC_NUMBER_LITERAL_in_numericLiteral2187)
if self._state.backtracking == 0:
D_tree = self._adaptor.createWithPayload(D)
self._adaptor.addChild(root_0, D_tree)
if self._state.backtracking == 0:
pass #self.pass#Emit(D);
elif alt1 == 2:
# AS3_ex.g:242:7: H= HEX_NUMBER_LITERAL
pass
root_0 = self._adaptor.nil()
H = self.match(
self.input, HEX_NUMBER_LITERAL,
self.FOLLOW_HEX_NUMBER_LITERAL_in_numericLiteral2209)
if self._state.backtracking == 0:
H_tree = self._adaptor.createWithPayload(H)
self._adaptor.addChild(root_0, H_tree)
if self._state.backtracking == 0:
pass #self.pass#Emit(H);
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
success = True
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
if self._state.backtracking > 0:
self.memoize(self.input, 1, numericLiteral_StartIndex, success)
pass
return retval
# $ANTLR end "numericLiteral"
class stringLiteral_return(ParserRuleReturnScope):
def __init__(self):
super(AS3_exParser.stringLiteral_return, self).__init__()
self.tree = None
# $ANTLR start "stringLiteral"
# AS3_ex.g:248:1: stringLiteral : (S= SINGLE_QUOTE_LITERAL | D= DOUBLE_QUOTE_LITERAL );
def stringLiteral(self, ):
retval = self.stringLiteral_return()
retval.start = self.input.LT(1)
stringLiteral_StartIndex = self.input.index()
root_0 = None
S = None
D = None
S_tree = None
D_tree = None
success = False
try:
try:
if self._state.backtracking > 0 and self.alreadyParsedRule(
self.input, 2):
# for cached failed rules, alreadyParsedRule will raise an exception
success = True
return retval
# AS3_ex.g:249:5: (S= SINGLE_QUOTE_LITERAL | D= DOUBLE_QUOTE_LITERAL )
alt2 = 2
LA2_0 = self.input.LA(1)
if (LA2_0 == SINGLE_QUOTE_LITERAL):
alt2 = 1
elif (LA2_0 == DOUBLE_QUOTE_LITERAL):
alt2 = 2
else:
if self._state.backtracking > 0:
raise BacktrackingFailed
nvae = NoViableAltException("", 2, 0, self.input)
raise nvae
if alt2 == 1:
# AS3_ex.g:250:5: S= SINGLE_QUOTE_LITERAL
pass
root_0 = self._adaptor.nil()
S = self.match(
self.input, SINGLE_QUOTE_LITERAL,
self.FOLLOW_SINGLE_QUOTE_LITERAL_in_stringLiteral2256)
if self._state.backtracking == 0:
S_tree = self._adaptor.createWithPayload(S)
self._adaptor.addChild(root_0, S_tree)
if self._state.backtracking == 0:
pass #self.pass#Emit(S);
elif alt2 == 2:
# AS3_ex.g:254:7: D= DOUBLE_QUOTE_LITERAL
pass
root_0 = self._adaptor.nil()
D = self.match(
self.input, DOUBLE_QUOTE_LITERAL,
self.FOLLOW_DOUBLE_QUOTE_LITERAL_in_stringLiteral2273)
if self._state.backtracking == 0:
D_tree = self._adaptor.createWithPayload(D)
self._adaptor.addChild(root_0, D_tree)
if self._state.backtracking == 0:
pass #self.pass#Emit(D);
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
success = True
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
if self._state.backtracking > 0:
self.memoize(self.input, 2, stringLiteral_StartIndex, success)
pass
return retval
# $ANTLR end "stringLiteral"
class identifierLiteral_return(ParserRuleReturnScope):
def __init__(self):
super(AS3_exParser.identifierLiteral_return, self).__init__()
self.value = None
self.tree = None
# $ANTLR start "identifierLiteral"
# AS3_ex.g:261:1: identifierLiteral returns [value] : I= IDENTIFIER ;
def identifierLiteral(self, ):
retval = self.identifierLiteral_return()
retval.start = self.input.LT(1)
identifierLiteral_StartIndex = self.input.index()
root_0 = None
I = None
I_tree = None
success = False
try:
try:
if self._state.backtracking > 0 and self.alreadyParsedRule(
self.input, 3):
# for cached failed rules, alreadyParsedRule will raise an exception
success = True
return retval
# AS3_ex.g:262:5: (I= IDENTIFIER )
# AS3_ex.g:263:5: I= IDENTIFIER
pass
root_0 = self._adaptor.nil()
I = self.match(self.input, IDENTIFIER,
self.FOLLOW_IDENTIFIER_in_identifierLiteral2321)
if self._state.backtracking == 0:
I_tree = self._adaptor.createWithPayload(I)
self._adaptor.addChild(root_0, I_tree)
if self._state.backtracking == 0:
retval.value = self.converT(I.text)
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
success = True
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
if self._state.backtracking > 0:
self.memoize(self.input, 3, identifierLiteral_StartIndex,
success)
pass
return retval
# $ANTLR end "identifierLiteral"
class literal_return(ParserRuleReturnScope):
def __init__(self):
super(AS3_exParser.literal_return, self).__init__()
self.value = None
self.tree = None
# $ANTLR start "literal"
# AS3_ex.g:270:1: literal returns [value] : ( numericLiteral | stringLiteral );
def literal(self, ):
retval = self.literal_return()
retval.start = self.input.LT(1)
literal_StartIndex = self.input.index()
root_0 = None
numericLiteral1 = None
stringLiteral2 = None
success = False
try:
try:
if self._state.backtracking > 0 and self.alreadyParsedRule(
self.input, 4):
# for cached failed rules, alreadyParsedRule will raise an exception
success = True
return retval
# AS3_ex.g:271:5: ( numericLiteral | stringLiteral )
alt3 = 2
LA3_0 = self.input.LA(1)
if (LA3_0 == HEX_NUMBER_LITERAL
or LA3_0 == DEC_NUMBER_LITERAL):
alt3 = 1
elif ((SINGLE_QUOTE_LITERAL <= LA3_0 <= DOUBLE_QUOTE_LITERAL)):
alt3 = 2
else:
if self._state.backtracking > 0:
raise BacktrackingFailed
nvae = NoViableAltException("", 3, 0, self.input)
raise nvae
if alt3 == 1:
# AS3_ex.g:272:6: numericLiteral
pass
root_0 = self._adaptor.nil()
self._state.following.append(
self.FOLLOW_numericLiteral_in_literal2375)
numericLiteral1 = self.numericLiteral()
self._state.following.pop()
if self._state.backtracking == 0:
self._adaptor.addChild(root_0, numericLiteral1.tree)
if self._state.backtracking == 0:
retval.value = ((numericLiteral1 is not None) and [
self.input.toString(numericLiteral1.start,
numericLiteral1.stop)
] or [None])[0]
elif alt3 == 2:
# AS3_ex.g:276:7: stringLiteral
pass
root_0 = self._adaptor.nil()
self._state.following.append(
self.FOLLOW_stringLiteral_in_literal2394)
stringLiteral2 = self.stringLiteral()
self._state.following.pop()
if self._state.backtracking == 0:
self._adaptor.addChild(root_0, stringLiteral2.tree)
if self._state.backtracking == 0:
retval.value = ((stringLiteral2 is not None) and [
self.input.toString(stringLiteral2.start,
stringLiteral2.stop)
] or [None])[0]
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
success = True
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
if self._state.backtracking > 0:
self.memoize(self.input, 4, literal_StartIndex, success)
pass
return retval
# $ANTLR end "literal"
class fileContents_return(ParserRuleReturnScope):
def __init__(self):
super(AS3_exParser.fileContents_return, self).__init__()
self.value = None
self.tree = None
# $ANTLR start "fileContents"
# AS3_ex.g:282:1: fileContents returns [value] : ( stringLiteral | numericLiteral | identifierLiteral | EOL | xx= ( LCURLY | RCURLY | WHITESPACE | DOT | STAR | SEMI | COLON | ASSIGN | JING | COMMA | LPAREN | RPAREN | ZHI | DIV ) )* EOF ;
def fileContents(self, ):
retval = self.fileContents_return()
retval.start = self.input.LT(1)
fileContents_StartIndex = self.input.index()
root_0 = None
xx = None
EOL6 = None
EOF7 = None
stringLiteral3 = None
numericLiteral4 = None
identifierLiteral5 = None
xx_tree = None
EOL6_tree = None
EOF7_tree = None
retval.value = unicode("")
success = False
try:
try:
if self._state.backtracking > 0 and self.alreadyParsedRule(
self.input, 5):
# for cached failed rules, alreadyParsedRule will raise an exception
success = True
return retval
# AS3_ex.g:286:5: ( ( stringLiteral | numericLiteral | identifierLiteral | EOL | xx= ( LCURLY | RCURLY | WHITESPACE | DOT | STAR | SEMI | COLON | ASSIGN | JING | COMMA | LPAREN | RPAREN | ZHI | DIV ) )* EOF )
# AS3_ex.g:287:5: ( stringLiteral | numericLiteral | identifierLiteral | EOL | xx= ( LCURLY | RCURLY | WHITESPACE | DOT | STAR | SEMI | COLON | ASSIGN | JING | COMMA | LPAREN | RPAREN | ZHI | DIV ) )* EOF
pass
root_0 = self._adaptor.nil()
# AS3_ex.g:287:5: ( stringLiteral | numericLiteral | identifierLiteral | EOL | xx= ( LCURLY | RCURLY | WHITESPACE | DOT | STAR | SEMI | COLON | ASSIGN | JING | COMMA | LPAREN | RPAREN | ZHI | DIV ) )*
while True: #loop4
alt4 = 6
LA4 = self.input.LA(1)
if LA4 == SINGLE_QUOTE_LITERAL or LA4 == DOUBLE_QUOTE_LITERAL:
alt4 = 1
elif LA4 == HEX_NUMBER_LITERAL or LA4 == DEC_NUMBER_LITERAL:
alt4 = 2
elif LA4 == IDENTIFIER:
alt4 = 3
elif LA4 == EOL:
alt4 = 4
elif LA4 == SEMI or LA4 == LCURLY or LA4 == RCURLY or LA4 == LPAREN or LA4 == RPAREN or LA4 == DOT or LA4 == COMMA or LA4 == STAR or LA4 == DIV or LA4 == COLON or LA4 == ASSIGN or LA4 == JING or LA4 == ZHI or LA4 == WHITESPACE:
alt4 = 5
if alt4 == 1:
# AS3_ex.g:288:9: stringLiteral
pass
self._state.following.append(
self.FOLLOW_stringLiteral_in_fileContents2445)
stringLiteral3 = self.stringLiteral()
self._state.following.pop()
if self._state.backtracking == 0:
self._adaptor.addChild(root_0, stringLiteral3.tree)
if self._state.backtracking == 0:
retval.value += ((stringLiteral3 is not None) and [
self.input.toString(stringLiteral3.start,
stringLiteral3.stop)
] or [None])[0]
elif alt4 == 2:
# AS3_ex.g:293:10: numericLiteral
pass
self._state.following.append(
self.FOLLOW_numericLiteral_in_fileContents2468)
numericLiteral4 = self.numericLiteral()
self._state.following.pop()
if self._state.backtracking == 0:
self._adaptor.addChild(root_0,
numericLiteral4.tree)
if self._state.backtracking == 0:
retval.value += ((numericLiteral4 is not None)
and [
self.input.toString(
numericLiteral4.start,
numericLiteral4.stop)
] or [None])[0]
elif alt4 == 3:
# AS3_ex.g:297:10: identifierLiteral
pass
self._state.following.append(
self.FOLLOW_identifierLiteral_in_fileContents2489)
identifierLiteral5 = self.identifierLiteral()
self._state.following.pop()
if self._state.backtracking == 0:
self._adaptor.addChild(root_0,
identifierLiteral5.tree)
if self._state.backtracking == 0:
retval.value += ((identifierLiteral5 is not None)
and [
self.input.toString(
identifierLiteral5.start,
identifierLiteral5.stop)
] or [None])[0]
elif alt4 == 4:
# AS3_ex.g:301:10: EOL
pass
EOL6 = self.match(self.input, EOL,
self.FOLLOW_EOL_in_fileContents2510)
if self._state.backtracking == 0:
EOL6_tree = self._adaptor.createWithPayload(EOL6)
self._adaptor.addChild(root_0, EOL6_tree)
if self._state.backtracking == 0:
retval.value += EOL6.text
elif alt4 == 5:
# AS3_ex.g:306:9: xx= ( LCURLY | RCURLY | WHITESPACE | DOT | STAR | SEMI | COLON | ASSIGN | JING | COMMA | LPAREN | RPAREN | ZHI | DIV )
pass
xx = self.input.LT(1)
if (SEMI <= self.input.LA(1) <= RPAREN
) or (DOT <= self.input.LA(1) <= COMMA) or (
STAR <= self.input.LA(1) <= DIV) or (
COLON <= self.input.LA(1) <= ASSIGN) or (
JING <= self.input.LA(1) <=
ZHI) or self.input.LA(1) == WHITESPACE:
self.input.consume()
if self._state.backtracking == 0:
self._adaptor.addChild(
root_0,
self._adaptor.createWithPayload(xx))
self._state.errorRecovery = False
else:
if self._state.backtracking > 0:
raise BacktrackingFailed
mse = MismatchedSetException(None, self.input)
raise mse
if self._state.backtracking == 0:
retval.value += xx.text
else:
break #loop4
EOF7 = self.match(self.input, EOF,
self.FOLLOW_EOF_in_fileContents2771)
if self._state.backtracking == 0:
EOF7_tree = self._adaptor.createWithPayload(EOF7)
self._adaptor.addChild(root_0, EOF7_tree)
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
success = True
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
if self._state.backtracking > 0:
self.memoize(self.input, 5, fileContents_StartIndex, success)
pass
return retval
# $ANTLR end "fileContents"
# Delegated rules
FOLLOW_DEC_NUMBER_LITERAL_in_numericLiteral2187 = frozenset([1])
FOLLOW_HEX_NUMBER_LITERAL_in_numericLiteral2209 = frozenset([1])
FOLLOW_SINGLE_QUOTE_LITERAL_in_stringLiteral2256 = frozenset([1])
FOLLOW_DOUBLE_QUOTE_LITERAL_in_stringLiteral2273 = frozenset([1])
FOLLOW_IDENTIFIER_in_identifierLiteral2321 = frozenset([1])
FOLLOW_numericLiteral_in_literal2375 = frozenset([1])
FOLLOW_stringLiteral_in_literal2394 = frozenset([1])
FOLLOW_stringLiteral_in_fileContents2445 = frozenset([
4, 5, 6, 7, 8, 11, 12, 23, 24, 39, 40, 48, 49, 57, 58, 61, 62, 69, 72,
74
])
FOLLOW_numericLiteral_in_fileContents2468 = frozenset([
4, 5, 6, 7, 8, 11, 12, 23, 24, 39, 40, 48, 49, 57, 58, 61, 62, 69, 72,
74
])
FOLLOW_identifierLiteral_in_fileContents2489 = frozenset([
4, 5, 6, 7, 8, 11, 12, 23, 24, 39, 40, 48, 49, 57, 58, 61, 62, 69, 72,
74
])
FOLLOW_EOL_in_fileContents2510 = frozenset([
4, 5, 6, 7, 8, 11, 12, 23, 24, 39, 40, 48, 49, 57, 58, 61, 62, 69, 72,
74
])
FOLLOW_set_in_fileContents2542 = frozenset([
4, 5, 6, 7, 8, 11, 12, 23, 24, 39, 40, 48, 49, 57, 58, 61, 62, 69, 72,
74
])
FOLLOW_EOF_in_fileContents2771 = frozenset([1])
class cp_parser(Parser):
grammarFileName = "cp_parser.g"
antlr_version = version_str_to_tuple("3.1.2")
antlr_version_str = "3.1.2"
tokenNames = tokenNames
def __init__(self, input, state=None):
if state is None:
state = RecognizerSharedState()
Parser.__init__(self, input, state)
self.dfa5 = self.DFA5(self,
5,
eot=self.DFA5_eot,
eof=self.DFA5_eof,
min=self.DFA5_min,
max=self.DFA5_max,
accept=self.DFA5_accept,
special=self.DFA5_special,
transition=self.DFA5_transition)
self._adaptor = CommonTreeAdaptor()
def getTreeAdaptor(self):
return self._adaptor
def setTreeAdaptor(self, adaptor):
self._adaptor = adaptor
adaptor = property(getTreeAdaptor, setTreeAdaptor)
class doc_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
self.tree = None
# $ANTLR start "doc"
# cp_parser.g:35:1: doc : ( citation )+ ;
def doc(self, ):
retval = self.doc_return()
retval.start = self.input.LT(1)
root_0 = None
citation1 = None
try:
try:
# cp_parser.g:35:5: ( ( citation )+ )
# cp_parser.g:35:7: ( citation )+
pass
root_0 = self._adaptor.nil()
# cp_parser.g:35:7: ( citation )+
cnt1 = 0
while True: #loop1
alt1 = 2
LA1_0 = self.input.LA(1)
if (LA1_0 == INT or LA1_0 == LITERAL):
alt1 = 1
if alt1 == 1:
# cp_parser.g:35:8: citation
pass
self._state.following.append(
self.FOLLOW_citation_in_doc104)
citation1 = self.citation()
self._state.following.pop()
if self._state.backtracking == 0:
self._adaptor.addChild(root_0, citation1.tree)
else:
if cnt1 >= 1:
break #loop1
if self._state.backtracking > 0:
raise BacktrackingFailed
eee = EarlyExitException(1, self.input)
raise eee
cnt1 += 1
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "doc"
class citation_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
self.tree = None
# $ANTLR start "citation"
# cp_parser.g:37:1: citation : ( ref ( ref_separator ref )* ) -> ^( CITATION ref ( ref )* ) ;
def citation(self, ):
retval = self.citation_return()
retval.start = self.input.LT(1)
root_0 = None
ref2 = None
ref_separator3 = None
ref4 = None
stream_ref = RewriteRuleSubtreeStream(self._adaptor, "rule ref")
stream_ref_separator = RewriteRuleSubtreeStream(
self._adaptor, "rule ref_separator")
try:
try:
# cp_parser.g:37:10: ( ( ref ( ref_separator ref )* ) -> ^( CITATION ref ( ref )* ) )
# cp_parser.g:37:12: ( ref ( ref_separator ref )* )
pass
# cp_parser.g:37:12: ( ref ( ref_separator ref )* )
# cp_parser.g:37:13: ref ( ref_separator ref )*
pass
self._state.following.append(self.FOLLOW_ref_in_citation115)
ref2 = self.ref()
self._state.following.pop()
if self._state.backtracking == 0:
stream_ref.add(ref2.tree)
# cp_parser.g:37:17: ( ref_separator ref )*
while True: #loop2
alt2 = 2
LA2_0 = self.input.LA(1)
if (LA2_0 == SEMICOL):
alt2 = 1
if alt2 == 1:
# cp_parser.g:37:18: ref_separator ref
pass
self._state.following.append(
self.FOLLOW_ref_separator_in_citation118)
ref_separator3 = self.ref_separator()
self._state.following.pop()
if self._state.backtracking == 0:
stream_ref_separator.add(ref_separator3.tree)
self._state.following.append(
self.FOLLOW_ref_in_citation120)
ref4 = self.ref()
self._state.following.pop()
if self._state.backtracking == 0:
stream_ref.add(ref4.tree)
else:
break #loop2
# AST Rewrite
# elements: ref, ref
# token labels:
# rule labels: retval
# token list labels:
# rule list labels:
# wildcard labels:
if self._state.backtracking == 0:
retval.tree = root_0
if retval is not None:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "rule retval", retval.tree)
else:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "token retval", None)
root_0 = self._adaptor.nil()
# 38:1: -> ^( CITATION ref ( ref )* )
# cp_parser.g:39:1: ^( CITATION ref ( ref )* )
root_1 = self._adaptor.nil()
root_1 = self._adaptor.becomeRoot(
self._adaptor.createFromType(CITATION, "CITATION"),
root_1)
self._adaptor.addChild(root_1, stream_ref.nextTree())
# cp_parser.g:39:16: ( ref )*
while stream_ref.hasNext():
self._adaptor.addChild(root_1, stream_ref.nextTree())
stream_ref.reset()
self._adaptor.addChild(root_0, root_1)
retval.tree = root_0
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "citation"
class ref_separator_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
self.tree = None
# $ANTLR start "ref_separator"
# cp_parser.g:45:1: ref_separator : SEMICOL ->;
def ref_separator(self, ):
retval = self.ref_separator_return()
retval.start = self.input.LT(1)
root_0 = None
SEMICOL5 = None
SEMICOL5_tree = None
stream_SEMICOL = RewriteRuleTokenStream(self._adaptor, "token SEMICOL")
try:
try:
# cp_parser.g:45:14: ( SEMICOL ->)
# cp_parser.g:45:16: SEMICOL
pass
SEMICOL5 = self.match(self.input, SEMICOL,
self.FOLLOW_SEMICOL_in_ref_separator145)
if self._state.backtracking == 0:
stream_SEMICOL.add(SEMICOL5)
# AST Rewrite
# elements:
# token labels:
# rule labels: retval
# token list labels:
# rule list labels:
# wildcard labels:
if self._state.backtracking == 0:
retval.tree = root_0
if retval is not None:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "rule retval", retval.tree)
else:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "token retval", None)
root_0 = self._adaptor.nil()
# 45:24: ->
root_0 = None
retval.tree = root_0
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "ref_separator"
class ref_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
self.tree = None
# $ANTLR start "ref"
# cp_parser.g:47:1: ref : ( work )* scp ( editor )* -> ^( REF ( work )* scp ( editor )* ) ;
def ref(self, ):
retval = self.ref_return()
retval.start = self.input.LT(1)
root_0 = None
work6 = None
scp7 = None
editor8 = None
stream_work = RewriteRuleSubtreeStream(self._adaptor, "rule work")
stream_scp = RewriteRuleSubtreeStream(self._adaptor, "rule scp")
stream_editor = RewriteRuleSubtreeStream(self._adaptor, "rule editor")
try:
try:
# cp_parser.g:47:4: ( ( work )* scp ( editor )* -> ^( REF ( work )* scp ( editor )* ) )
# cp_parser.g:47:6: ( work )* scp ( editor )*
pass
# cp_parser.g:47:6: ( work )*
while True: #loop3
alt3 = 2
LA3_0 = self.input.LA(1)
if (LA3_0 == LITERAL):
alt3 = 1
if alt3 == 1:
# cp_parser.g:0:0: work
pass
self._state.following.append(
self.FOLLOW_work_in_ref154)
work6 = self.work()
self._state.following.pop()
if self._state.backtracking == 0:
stream_work.add(work6.tree)
else:
break #loop3
self._state.following.append(self.FOLLOW_scp_in_ref157)
scp7 = self.scp()
self._state.following.pop()
if self._state.backtracking == 0:
stream_scp.add(scp7.tree)
# cp_parser.g:47:16: ( editor )*
while True: #loop4
alt4 = 2
LA4_0 = self.input.LA(1)
if (LA4_0 == LITERAL):
LA4_2 = self.input.LA(2)
if (self.synpred4_cp_parser()):
alt4 = 1
if alt4 == 1:
# cp_parser.g:0:0: editor
pass
self._state.following.append(
self.FOLLOW_editor_in_ref159)
editor8 = self.editor()
self._state.following.pop()
if self._state.backtracking == 0:
stream_editor.add(editor8.tree)
else:
break #loop4
# AST Rewrite
# elements: scp, work, editor
# token labels:
# rule labels: retval
# token list labels:
# rule list labels:
# wildcard labels:
if self._state.backtracking == 0:
retval.tree = root_0
if retval is not None:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "rule retval", retval.tree)
else:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "token retval", None)
root_0 = self._adaptor.nil()
# 48:1: -> ^( REF ( work )* scp ( editor )* )
# cp_parser.g:49:1: ^( REF ( work )* scp ( editor )* )
root_1 = self._adaptor.nil()
root_1 = self._adaptor.becomeRoot(
self._adaptor.createFromType(REF, "REF"), root_1)
# cp_parser.g:49:7: ( work )*
while stream_work.hasNext():
self._adaptor.addChild(root_1, stream_work.nextTree())
stream_work.reset()
self._adaptor.addChild(root_1, stream_scp.nextTree())
# cp_parser.g:49:17: ( editor )*
while stream_editor.hasNext():
self._adaptor.addChild(root_1,
stream_editor.nextTree())
stream_editor.reset()
self._adaptor.addChild(root_0, root_1)
retval.tree = root_0
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "ref"
class scp_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
self.tree = None
# $ANTLR start "scp"
# cp_parser.g:52:1: scp : ( scp_single | scp_range ) ;
def scp(self, ):
retval = self.scp_return()
retval.start = self.input.LT(1)
root_0 = None
scp_single9 = None
scp_range10 = None
try:
try:
# cp_parser.g:52:4: ( ( scp_single | scp_range ) )
# cp_parser.g:52:6: ( scp_single | scp_range )
pass
root_0 = self._adaptor.nil()
# cp_parser.g:52:6: ( scp_single | scp_range )
alt5 = 2
alt5 = self.dfa5.predict(self.input)
if alt5 == 1:
# cp_parser.g:52:7: scp_single
pass
self._state.following.append(
self.FOLLOW_scp_single_in_scp183)
scp_single9 = self.scp_single()
self._state.following.pop()
if self._state.backtracking == 0:
self._adaptor.addChild(root_0, scp_single9.tree)
elif alt5 == 2:
# cp_parser.g:52:18: scp_range
pass
self._state.following.append(
self.FOLLOW_scp_range_in_scp185)
scp_range10 = self.scp_range()
self._state.following.pop()
if self._state.backtracking == 0:
self._adaptor.addChild(root_0, scp_range10.tree)
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "scp"
class work_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
self.tree = None
# $ANTLR start "work"
# cp_parser.g:54:1: work : ( ( LITERAL )+ ) -> ^( WORK ( LITERAL )+ ) ;
def work(self, ):
retval = self.work_return()
retval.start = self.input.LT(1)
root_0 = None
LITERAL11 = None
LITERAL11_tree = None
stream_LITERAL = RewriteRuleTokenStream(self._adaptor, "token LITERAL")
try:
try:
# cp_parser.g:54:5: ( ( ( LITERAL )+ ) -> ^( WORK ( LITERAL )+ ) )
# cp_parser.g:55:1: ( ( LITERAL )+ )
pass
# cp_parser.g:55:1: ( ( LITERAL )+ )
# cp_parser.g:55:2: ( LITERAL )+
pass
# cp_parser.g:55:2: ( LITERAL )+
cnt6 = 0
while True: #loop6
alt6 = 2
LA6_0 = self.input.LA(1)
if (LA6_0 == LITERAL):
LA6_2 = self.input.LA(2)
if (self.synpred6_cp_parser()):
alt6 = 1
if alt6 == 1:
# cp_parser.g:0:0: LITERAL
pass
LITERAL11 = self.match(self.input, LITERAL,
self.FOLLOW_LITERAL_in_work194)
if self._state.backtracking == 0:
stream_LITERAL.add(LITERAL11)
else:
if cnt6 >= 1:
break #loop6
if self._state.backtracking > 0:
raise BacktrackingFailed
eee = EarlyExitException(6, self.input)
raise eee
cnt6 += 1
# AST Rewrite
# elements: LITERAL
# token labels:
# rule labels: retval
# token list labels:
# rule list labels:
# wildcard labels:
if self._state.backtracking == 0:
retval.tree = root_0
if retval is not None:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "rule retval", retval.tree)
else:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "token retval", None)
root_0 = self._adaptor.nil()
# 56:1: -> ^( WORK ( LITERAL )+ )
# cp_parser.g:57:1: ^( WORK ( LITERAL )+ )
root_1 = self._adaptor.nil()
root_1 = self._adaptor.becomeRoot(
self._adaptor.createFromType(WORK, "WORK"), root_1)
# cp_parser.g:57:8: ( LITERAL )+
if not (stream_LITERAL.hasNext()):
raise RewriteEarlyExitException()
while stream_LITERAL.hasNext():
self._adaptor.addChild(root_1,
stream_LITERAL.nextNode())
stream_LITERAL.reset()
self._adaptor.addChild(root_0, root_1)
retval.tree = root_0
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "work"
class editor_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
self.tree = None
# $ANTLR start "editor"
# cp_parser.g:60:1: editor : ( LITERAL ) -> ^( EDITOR LITERAL ) ;
def editor(self, ):
retval = self.editor_return()
retval.start = self.input.LT(1)
root_0 = None
LITERAL12 = None
LITERAL12_tree = None
stream_LITERAL = RewriteRuleTokenStream(self._adaptor, "token LITERAL")
try:
try:
# cp_parser.g:60:7: ( ( LITERAL ) -> ^( EDITOR LITERAL ) )
# cp_parser.g:61:1: ( LITERAL )
pass
# cp_parser.g:61:1: ( LITERAL )
# cp_parser.g:61:2: LITERAL
pass
LITERAL12 = self.match(self.input, LITERAL,
self.FOLLOW_LITERAL_in_editor214)
if self._state.backtracking == 0:
stream_LITERAL.add(LITERAL12)
# AST Rewrite
# elements: LITERAL
# token labels:
# rule labels: retval
# token list labels:
# rule list labels:
# wildcard labels:
if self._state.backtracking == 0:
retval.tree = root_0
if retval is not None:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "rule retval", retval.tree)
else:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "token retval", None)
root_0 = self._adaptor.nil()
# 62:1: -> ^( EDITOR LITERAL )
# cp_parser.g:63:1: ^( EDITOR LITERAL )
root_1 = self._adaptor.nil()
root_1 = self._adaptor.becomeRoot(
self._adaptor.createFromType(EDITOR, "EDITOR"), root_1)
self._adaptor.addChild(root_1, stream_LITERAL.nextNode())
self._adaptor.addChild(root_0, root_1)
retval.tree = root_0
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "editor"
class lev_sep_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
self.tree = None
# $ANTLR start "lev_sep"
# cp_parser.g:67:1: lev_sep : ( VIRGOLA | PUNTO ) ;
def lev_sep(self, ):
retval = self.lev_sep_return()
retval.start = self.input.LT(1)
root_0 = None
set13 = None
set13_tree = None
try:
try:
# cp_parser.g:67:8: ( ( VIRGOLA | PUNTO ) )
# cp_parser.g:67:9: ( VIRGOLA | PUNTO )
pass
root_0 = self._adaptor.nil()
set13 = self.input.LT(1)
if self.input.LA(1) == PUNTO or self.input.LA(1) == VIRGOLA:
self.input.consume()
if self._state.backtracking == 0:
self._adaptor.addChild(
root_0, self._adaptor.createWithPayload(set13))
self._state.errorRecovery = False
else:
if self._state.backtracking > 0:
raise BacktrackingFailed
mse = MismatchedSetException(None, self.input)
raise mse
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "lev_sep"
class level_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
self.tree = None
# $ANTLR start "level"
# cp_parser.g:69:1: level : INT ( lev_sep INT )* -> ^( LEVEL INT ) ( ^( LEVEL INT ) )* ;
def level(self, ):
retval = self.level_return()
retval.start = self.input.LT(1)
root_0 = None
INT14 = None
INT16 = None
lev_sep15 = None
INT14_tree = None
INT16_tree = None
stream_INT = RewriteRuleTokenStream(self._adaptor, "token INT")
stream_lev_sep = RewriteRuleSubtreeStream(self._adaptor,
"rule lev_sep")
try:
try:
# cp_parser.g:69:6: ( INT ( lev_sep INT )* -> ^( LEVEL INT ) ( ^( LEVEL INT ) )* )
# cp_parser.g:70:1: INT ( lev_sep INT )*
pass
INT14 = self.match(self.input, INT,
self.FOLLOW_INT_in_level242)
if self._state.backtracking == 0:
stream_INT.add(INT14)
# cp_parser.g:70:5: ( lev_sep INT )*
while True: #loop7
alt7 = 2
LA7_0 = self.input.LA(1)
if (LA7_0 == PUNTO or LA7_0 == VIRGOLA):
alt7 = 1
if alt7 == 1:
# cp_parser.g:70:6: lev_sep INT
pass
self._state.following.append(
self.FOLLOW_lev_sep_in_level245)
lev_sep15 = self.lev_sep()
self._state.following.pop()
if self._state.backtracking == 0:
stream_lev_sep.add(lev_sep15.tree)
INT16 = self.match(self.input, INT,
self.FOLLOW_INT_in_level247)
if self._state.backtracking == 0:
stream_INT.add(INT16)
else:
break #loop7
# AST Rewrite
# elements: INT, INT
# token labels:
# rule labels: retval
# token list labels:
# rule list labels:
# wildcard labels:
if self._state.backtracking == 0:
retval.tree = root_0
if retval is not None:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "rule retval", retval.tree)
else:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "token retval", None)
root_0 = self._adaptor.nil()
# 71:1: -> ^( LEVEL INT ) ( ^( LEVEL INT ) )*
# cp_parser.g:72:1: ^( LEVEL INT )
root_1 = self._adaptor.nil()
root_1 = self._adaptor.becomeRoot(
self._adaptor.createFromType(LEVEL, "LEVEL"), root_1)
self._adaptor.addChild(root_1, stream_INT.nextNode())
self._adaptor.addChild(root_0, root_1)
# cp_parser.g:72:14: ( ^( LEVEL INT ) )*
while stream_INT.hasNext():
# cp_parser.g:72:14: ^( LEVEL INT )
root_1 = self._adaptor.nil()
root_1 = self._adaptor.becomeRoot(
self._adaptor.createFromType(LEVEL, "LEVEL"),
root_1)
self._adaptor.addChild(root_1, stream_INT.nextNode())
self._adaptor.addChild(root_0, root_1)
stream_INT.reset()
retval.tree = root_0
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "level"
class scp_single_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
self.tree = None
# $ANTLR start "scp_single"
# cp_parser.g:75:1: scp_single : ( level ) -> ^( SCOPE_S level ) ;
def scp_single(self, ):
retval = self.scp_single_return()
retval.start = self.input.LT(1)
root_0 = None
level17 = None
stream_level = RewriteRuleSubtreeStream(self._adaptor, "rule level")
try:
try:
# cp_parser.g:75:11: ( ( level ) -> ^( SCOPE_S level ) )
# cp_parser.g:76:1: ( level )
pass
# cp_parser.g:76:1: ( level )
# cp_parser.g:76:2: level
pass
self._state.following.append(
self.FOLLOW_level_in_scp_single273)
level17 = self.level()
self._state.following.pop()
if self._state.backtracking == 0:
stream_level.add(level17.tree)
# AST Rewrite
# elements: level
# token labels:
# rule labels: retval
# token list labels:
# rule list labels:
# wildcard labels:
if self._state.backtracking == 0:
retval.tree = root_0
if retval is not None:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "rule retval", retval.tree)
else:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "token retval", None)
root_0 = self._adaptor.nil()
# 77:1: -> ^( SCOPE_S level )
# cp_parser.g:78:1: ^( SCOPE_S level )
root_1 = self._adaptor.nil()
root_1 = self._adaptor.becomeRoot(
self._adaptor.createFromType(SCOPE_S, "SCOPE_S"),
root_1)
self._adaptor.addChild(root_1, stream_level.nextTree())
self._adaptor.addChild(root_0, root_1)
retval.tree = root_0
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "scp_single"
class scp_range_return(ParserRuleReturnScope):
def __init__(self):
ParserRuleReturnScope.__init__(self)
self.tree = None
# $ANTLR start "scp_range"
# cp_parser.g:81:1: scp_range : ( level HYPHEN level ) -> ^( SCOPE_R ^( START level ) ^( END level ) ) ;
def scp_range(self, ):
retval = self.scp_range_return()
retval.start = self.input.LT(1)
root_0 = None
HYPHEN19 = None
level18 = None
level20 = None
HYPHEN19_tree = None
stream_HYPHEN = RewriteRuleTokenStream(self._adaptor, "token HYPHEN")
stream_level = RewriteRuleSubtreeStream(self._adaptor, "rule level")
try:
try:
# cp_parser.g:81:10: ( ( level HYPHEN level ) -> ^( SCOPE_R ^( START level ) ^( END level ) ) )
# cp_parser.g:82:1: ( level HYPHEN level )
pass
# cp_parser.g:82:1: ( level HYPHEN level )
# cp_parser.g:82:2: level HYPHEN level
pass
self._state.following.append(self.FOLLOW_level_in_scp_range291)
level18 = self.level()
self._state.following.pop()
if self._state.backtracking == 0:
stream_level.add(level18.tree)
HYPHEN19 = self.match(self.input, HYPHEN,
self.FOLLOW_HYPHEN_in_scp_range293)
if self._state.backtracking == 0:
stream_HYPHEN.add(HYPHEN19)
self._state.following.append(self.FOLLOW_level_in_scp_range295)
level20 = self.level()
self._state.following.pop()
if self._state.backtracking == 0:
stream_level.add(level20.tree)
# AST Rewrite
# elements: level, level
# token labels:
# rule labels: retval
# token list labels:
# rule list labels:
# wildcard labels:
if self._state.backtracking == 0:
retval.tree = root_0
if retval is not None:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "rule retval", retval.tree)
else:
stream_retval = RewriteRuleSubtreeStream(
self._adaptor, "token retval", None)
root_0 = self._adaptor.nil()
# 83:1: -> ^( SCOPE_R ^( START level ) ^( END level ) )
# cp_parser.g:84:1: ^( SCOPE_R ^( START level ) ^( END level ) )
root_1 = self._adaptor.nil()
root_1 = self._adaptor.becomeRoot(
self._adaptor.createFromType(SCOPE_R, "SCOPE_R"),
root_1)
# cp_parser.g:84:11: ^( START level )
root_2 = self._adaptor.nil()
root_2 = self._adaptor.becomeRoot(
self._adaptor.createFromType(START, "START"), root_2)
self._adaptor.addChild(root_2, stream_level.nextTree())
self._adaptor.addChild(root_1, root_2)
# cp_parser.g:84:26: ^( END level )
root_2 = self._adaptor.nil()
root_2 = self._adaptor.becomeRoot(
self._adaptor.createFromType(END, "END"), root_2)
self._adaptor.addChild(root_2, stream_level.nextTree())
self._adaptor.addChild(root_1, root_2)
self._adaptor.addChild(root_0, root_1)
retval.tree = root_0
retval.stop = self.input.LT(-1)
if self._state.backtracking == 0:
retval.tree = self._adaptor.rulePostProcessing(root_0)
self._adaptor.setTokenBoundaries(retval.tree, retval.start,
retval.stop)
except RecognitionException as re:
self.reportError(re)
self.recover(self.input, re)
retval.tree = self._adaptor.errorNode(self.input, retval.start,
self.input.LT(-1), re)
finally:
pass
return retval
# $ANTLR end "scp_range"
# $ANTLR start "synpred4_cp_parser"
def synpred4_cp_parser_fragment(self, ):
# cp_parser.g:47:16: ( editor )
# cp_parser.g:47:16: editor
pass
self._state.following.append(
self.FOLLOW_editor_in_synpred4_cp_parser159)
self.editor()
self._state.following.pop()
# $ANTLR end "synpred4_cp_parser"
# $ANTLR start "synpred6_cp_parser"
def synpred6_cp_parser_fragment(self, ):
# cp_parser.g:55:2: ( LITERAL )
# cp_parser.g:55:2: LITERAL
pass
self.match(self.input, LITERAL,
self.FOLLOW_LITERAL_in_synpred6_cp_parser194)
# $ANTLR end "synpred6_cp_parser"
# Delegated rules
def synpred6_cp_parser(self):
self._state.backtracking += 1
start = self.input.mark()
try:
self.synpred6_cp_parser_fragment()
except BacktrackingFailed:
success = False
else:
success = True
self.input.rewind(start)
self._state.backtracking -= 1
return success
def synpred4_cp_parser(self):
self._state.backtracking += 1
start = self.input.mark()
try:
self.synpred4_cp_parser_fragment()
except BacktrackingFailed:
success = False
else:
success = True
self.input.rewind(start)
self._state.backtracking -= 1
return success
# lookup tables for DFA #5
DFA5_eot = DFA.unpack("\6\uffff")
DFA5_eof = DFA.unpack("\1\uffff\1\4\3\uffff\1\4")
DFA5_min = DFA.unpack("\3\4\2\uffff\1\4")
DFA5_max = DFA.unpack("\1\4\1\21\1\4\2\uffff\1\21")
DFA5_accept = DFA.unpack("\3\uffff\1\2\1\1\1\uffff")
DFA5_special = DFA.unpack("\6\uffff")
DFA5_transition = [
DFA.unpack("\1\1"),
DFA.unpack("\1\4\1\uffff\1\2\1\uffff\1\2\1\uffff\1\3\1\4\5\uffff"
"\1\4"),
DFA.unpack("\1\5"),
DFA.unpack(""),
DFA.unpack(""),
DFA.unpack("\1\4\1\uffff\1\2\1\uffff\1\2\1\uffff\1\3\1\4\5\uffff"
"\1\4")
]
# class definition for DFA #5
DFA5 = DFA
FOLLOW_citation_in_doc104 = frozenset([1, 4, 17])
FOLLOW_ref_in_citation115 = frozenset([1, 11])
FOLLOW_ref_separator_in_citation118 = frozenset([4, 11, 17])
FOLLOW_ref_in_citation120 = frozenset([1, 11])
FOLLOW_SEMICOL_in_ref_separator145 = frozenset([1])
FOLLOW_work_in_ref154 = frozenset([4, 17])
FOLLOW_scp_in_ref157 = frozenset([1, 17])
FOLLOW_editor_in_ref159 = frozenset([1, 17])
FOLLOW_scp_single_in_scp183 = frozenset([1])
FOLLOW_scp_range_in_scp185 = frozenset([1])
FOLLOW_LITERAL_in_work194 = frozenset([1, 17])
FOLLOW_LITERAL_in_editor214 = frozenset([1])
FOLLOW_set_in_lev_sep231 = frozenset([1])
FOLLOW_INT_in_level242 = frozenset([1, 6, 8])
FOLLOW_lev_sep_in_level245 = frozenset([4])
FOLLOW_INT_in_level247 = frozenset([1, 6, 8])
FOLLOW_level_in_scp_single273 = frozenset([1])
FOLLOW_level_in_scp_range291 = frozenset([10])
FOLLOW_HYPHEN_in_scp_range293 = frozenset([4])
FOLLOW_level_in_scp_range295 = frozenset([1])
FOLLOW_editor_in_synpred4_cp_parser159 = frozenset([1])
FOLLOW_LITERAL_in_synpred6_cp_parser194 = frozenset([1])
