# $ANTLR 3.1.3 Mar 17, 2009 19:23:44 sdl92.g 2016-01-31 20:41:34 import sys from antlr3 import * from antlr3.compat import set, frozenset from antlr3.tree import * # for convenience in actions HIDDEN = BaseRecognizer.HIDDEN # token types NUMBER_OF_INSTANCES=61 COMMENT2=220 MANTISSA=177 ROUTE=83 MOD=169 GROUND=45 PARAM=66 NOT=171 SEQOF=86 TEXTAREA_CONTENT=110 EOF=-1 ACTION=4 IMPORT=181 CREATE=159 FPAR=44 NEXTSTATE=60 RETURN=81 THIS=160 CHANNEL=13 VIAPATH=121 ENDCONNECTION=136 EXPORT=33 EQ=153 GEODE=185 INFORMAL_TEXT=50 D=194 E=197 F=204 GE=158 G=205 A=191 IMPLIES=162 B=213 C=195 L=196 M=201 N=192 O=206 STOPIF=98 TERMINATOR=107 H=207 I=203 J=214 ELSE=27 K=198 U=210 T=208 W=212 V=211 STOP=97 TYPE_INSTANCE=115 Q=221 INT=134 P=199 S=202 R=200 VALUE=117 Y=193 X=209 FI=36 Z=222 MINUS_INFINITY=176 WS=219 OUT=133 NONE=144 INPUT_NONE=53 CONSTANT=22 GT=155 CALL=149 END=187 FLOATING_LABEL=42 IFTHENELSE=48 POINT=71 INPUT=52 ENDSUBSTRUCTURE=141 FLOAT=41 SUBSTRUCTURE=140 T__223=223 PAREN=69 ASTERISK=139 INOUT=51 STR=216 STIMULUS=96 SELECTOR=85 THEN=111 ENDDECISION=151 OPEN_RANGE=63 SIGNAL=89 ENDSYSTEM=122 PLUS=165 CHOICE=14 RETURNS=82 TASK_BODY=106 PARAMS=68 CLOSED_RANGE=16 STATE=92 STATELIST=95 TO=113 ASSIG_OP=188 SIGNALROUTE=128 ENDSYNTYPE=30 SORT=91 SET=88 TEXT=108 SEMI=137 TEXTAREA=109 T__228=228 T__229=229 T__224=224 T__225=225 T__226=226 T__227=227 BLOCK=12 CIF=15 START=135 DECISION=25 DIV=168 PROCESS=76 T__230=230 STRING=99 INPUTLIST=54 EXTERNAL=35 EXPONENT=179 LT=156 TRANSITION=114 ENDBLOCK=127 RESET=80 ENDNEWTYPE=29 SIGNAL_LIST=90 ENDTEXT=31 CONNECTION=21 SYSTEM=104 CONNECT=20 STATE_PARTITION_CONNECTION=94 L_PAREN=146 PROCEDURE_CALL=74 BASE=178 COMMENT=17 SYNONYM=101 ENDALTERNATIVE=150 ARRAY=8 ACTIVE=180 ENDFOR=161 FIELD_NAME=38 VIEW=182 OCTSTR=62 EMPTYSTR=28 PFPAR=70 ENDCHANNEL=124 NULL=174 ANSWER=7 CONDITIONAL=19 PRIMARY=72 TASK=105 REFERENCED=130 ALPHA=217 SEQUENCE=87 VARIABLE=118 PRIORITY=145 SPECIFIC=184 AGGREGATION=142 OR=163 COMPOSITE_STATE=18 FIELD=37 USE=116 FROM=125 ENDPROCEDURE=132 FALSE=173 OUTPUT=64 SYNONYM_LIST=102 APPEND=167 L_BRACKET=189 DIGITS=26 HYPERLINK=46 NEWTYPE=59 Exponent=218 FOR=43 ENDSTATE=138 PROCEDURE_NAME=75 CONSTANTS=23 ID=123 AND=129 FLOAT2=40 IF=47 IN=49 PROVIDED=77 COMMA=148 ALL=5 ASNFILENAME=186 DOT=215 EXPRESSION=34 WITH=126 BITSTR=11 XOR=164 DASH=166 DCL=24 ENDPROCESS=131 DEFAULT=143 RANGE=79 VIA=120 LITERAL=57 SAVE=84 STRUCT=100 FIELDS=39 REM=170 STATE_AGGREGATION=93 TRUE=172 R_BRACKET=190 PROCEDURE=73 JOIN=55 R_PAREN=147 OUTPUT_BODY=65 ANY=152 NEQ=154 QUESTION=78 LABEL=56 PARAMNAMES=67 PLUS_INFINITY=175 ASN1=9 ENTRY_POINT=32 KEEP=183 NEG=58 ASSIGN=10 VARIABLES=119 ALTERNATIVE=6 SYNTYPE=103 TIMER=112 LE=157 # token names tokenNames = [ "", "", "", "", "ACTION", "ALL", "ALTERNATIVE", "ANSWER", "ARRAY", "ASN1", "ASSIGN", "BITSTR", "BLOCK", "CHANNEL", "CHOICE", "CIF", "CLOSED_RANGE", "COMMENT", "COMPOSITE_STATE", "CONDITIONAL", "CONNECT", "CONNECTION", "CONSTANT", "CONSTANTS", "DCL", "DECISION", "DIGITS", "ELSE", "EMPTYSTR", "ENDNEWTYPE", "ENDSYNTYPE", "ENDTEXT", "ENTRY_POINT", "EXPORT", "EXPRESSION", "EXTERNAL", "FI", "FIELD", "FIELD_NAME", "FIELDS", "FLOAT2", "FLOAT", "FLOATING_LABEL", "FOR", "FPAR", "GROUND", "HYPERLINK", "IF", "IFTHENELSE", "IN", "INFORMAL_TEXT", "INOUT", "INPUT", "INPUT_NONE", "INPUTLIST", "JOIN", "LABEL", "LITERAL", "NEG", "NEWTYPE", "NEXTSTATE", "NUMBER_OF_INSTANCES", "OCTSTR", "OPEN_RANGE", "OUTPUT", "OUTPUT_BODY", "PARAM", "PARAMNAMES", "PARAMS", "PAREN", "PFPAR", "POINT", "PRIMARY", "PROCEDURE", "PROCEDURE_CALL", "PROCEDURE_NAME", "PROCESS", "PROVIDED", "QUESTION", "RANGE", "RESET", "RETURN", "RETURNS", "ROUTE", "SAVE", "SELECTOR", "SEQOF", "SEQUENCE", "SET", "SIGNAL", "SIGNAL_LIST", "SORT", "STATE", "STATE_AGGREGATION", "STATE_PARTITION_CONNECTION", "STATELIST", "STIMULUS", "STOP", "STOPIF", "STRING", "STRUCT", "SYNONYM", "SYNONYM_LIST", "SYNTYPE", "SYSTEM", "TASK", "TASK_BODY", "TERMINATOR", "TEXT", "TEXTAREA", "TEXTAREA_CONTENT", "THEN", "TIMER", "TO", "TRANSITION", "TYPE_INSTANCE", "USE", "VALUE", "VARIABLE", "VARIABLES", "VIA", "VIAPATH", "ENDSYSTEM", "ID", "ENDCHANNEL", "FROM", "WITH", "ENDBLOCK", "SIGNALROUTE", "AND", "REFERENCED", "ENDPROCESS", "ENDPROCEDURE", "OUT", "INT", "START", "ENDCONNECTION", "SEMI", "ENDSTATE", "ASTERISK", "SUBSTRUCTURE", "ENDSUBSTRUCTURE", "AGGREGATION", "DEFAULT", "NONE", "PRIORITY", "L_PAREN", "R_PAREN", "COMMA", "CALL", "ENDALTERNATIVE", "ENDDECISION", "ANY", "EQ", "NEQ", "GT", "LT", "LE", "GE", "CREATE", "THIS", "ENDFOR", "IMPLIES", "OR", "XOR", "PLUS", "DASH", "APPEND", "DIV", "MOD", "REM", "NOT", "TRUE", "FALSE", "NULL", "PLUS_INFINITY", "MINUS_INFINITY", "MANTISSA", "BASE", "EXPONENT", "ACTIVE", "IMPORT", "VIEW", "KEEP", "SPECIFIC", "GEODE", "ASNFILENAME", "END", "ASSIG_OP", "L_BRACKET", "R_BRACKET", "A", "N", "Y", "D", "C", "L", "E", "K", "P", "R", "M", "S", "I", "F", "G", "O", "H", "T", "X", "U", "V", "W", "B", "J", "DOT", "STR", "ALPHA", "Exponent", "WS", "COMMENT2", "Q", "Z", "':'", "'->'", "'!'", "'(.'", "'.)'", "'ERROR'", "'/* CIF'", "'*/'" ] class sdl92Parser(Parser): grammarFileName = "sdl92.g" antlr_version = version_str_to_tuple("3.1.3 Mar 17, 2009 19:23:44") antlr_version_str = "3.1.3 Mar 17, 2009 19:23:44" tokenNames = tokenNames def __init__(self, input, state=None, *args, **kwargs): if state is None: state = RecognizerSharedState() super(sdl92Parser, self).__init__(input, state, *args, **kwargs) self.dfa20 = self.DFA20( self, 20, eot = self.DFA20_eot, eof = self.DFA20_eof, min = self.DFA20_min, max = self.DFA20_max, accept = self.DFA20_accept, special = self.DFA20_special, transition = self.DFA20_transition ) self.dfa21 = self.DFA21( self, 21, eot = self.DFA21_eot, eof = self.DFA21_eof, min = self.DFA21_min, max = self.DFA21_max, accept = self.DFA21_accept, special = self.DFA21_special, transition = self.DFA21_transition ) self.dfa24 = self.DFA24( self, 24, eot = self.DFA24_eot, eof = self.DFA24_eof, min = self.DFA24_min, max = self.DFA24_max, accept = self.DFA24_accept, special = self.DFA24_special, transition = self.DFA24_transition ) self.dfa26 = self.DFA26( self, 26, eot = self.DFA26_eot, eof = self.DFA26_eof, min = self.DFA26_min, max = self.DFA26_max, accept = self.DFA26_accept, special = self.DFA26_special, transition = self.DFA26_transition ) self.dfa38 = self.DFA38( self, 38, eot = self.DFA38_eot, eof = self.DFA38_eof, min = self.DFA38_min, max = self.DFA38_max, accept = self.DFA38_accept, special = self.DFA38_special, transition = self.DFA38_transition ) self.dfa42 = self.DFA42( self, 42, eot = self.DFA42_eot, eof = self.DFA42_eof, min = self.DFA42_min, max = self.DFA42_max, accept = self.DFA42_accept, special = self.DFA42_special, transition = self.DFA42_transition ) self.dfa49 = self.DFA49( self, 49, eot = self.DFA49_eot, eof = self.DFA49_eof, min = self.DFA49_min, max = self.DFA49_max, accept = self.DFA49_accept, special = self.DFA49_special, transition = self.DFA49_transition ) self.dfa55 = self.DFA55( self, 55, eot = self.DFA55_eot, eof = self.DFA55_eof, min = self.DFA55_min, max = self.DFA55_max, accept = self.DFA55_accept, special = self.DFA55_special, transition = self.DFA55_transition ) self.dfa56 = self.DFA56( self, 56, eot = self.DFA56_eot, eof = self.DFA56_eof, min = self.DFA56_min, max = self.DFA56_max, accept = self.DFA56_accept, special = self.DFA56_special, transition = self.DFA56_transition ) self.dfa60 = self.DFA60( self, 60, eot = self.DFA60_eot, eof = self.DFA60_eof, min = self.DFA60_min, max = self.DFA60_max, accept = self.DFA60_accept, special = self.DFA60_special, transition = self.DFA60_transition ) self.dfa77 = self.DFA77( self, 77, eot = self.DFA77_eot, eof = self.DFA77_eof, min = self.DFA77_min, max = self.DFA77_max, accept = self.DFA77_accept, special = self.DFA77_special, transition = self.DFA77_transition ) self.dfa80 = self.DFA80( self, 80, eot = self.DFA80_eot, eof = self.DFA80_eof, min = self.DFA80_min, max = self.DFA80_max, accept = self.DFA80_accept, special = self.DFA80_special, transition = self.DFA80_transition ) self.dfa86 = self.DFA86( self, 86, eot = self.DFA86_eot, eof = self.DFA86_eof, min = self.DFA86_min, max = self.DFA86_max, accept = self.DFA86_accept, special = self.DFA86_special, transition = self.DFA86_transition ) self.dfa87 = self.DFA87( self, 87, eot = self.DFA87_eot, eof = self.DFA87_eof, min = self.DFA87_min, max = self.DFA87_max, accept = self.DFA87_accept, special = self.DFA87_special, transition = self.DFA87_transition ) self.dfa88 = self.DFA88( self, 88, eot = self.DFA88_eot, eof = self.DFA88_eof, min = self.DFA88_min, max = self.DFA88_max, accept = self.DFA88_accept, special = self.DFA88_special, transition = self.DFA88_transition ) self.dfa92 = self.DFA92( self, 92, eot = self.DFA92_eot, eof = self.DFA92_eof, min = self.DFA92_min, max = self.DFA92_max, accept = self.DFA92_accept, special = self.DFA92_special, transition = self.DFA92_transition ) self.dfa101 = self.DFA101( self, 101, eot = self.DFA101_eot, eof = self.DFA101_eof, min = self.DFA101_min, max = self.DFA101_max, accept = self.DFA101_accept, special = self.DFA101_special, transition = self.DFA101_transition ) self.dfa106 = self.DFA106( self, 106, eot = self.DFA106_eot, eof = self.DFA106_eof, min = self.DFA106_min, max = self.DFA106_max, accept = self.DFA106_accept, special = self.DFA106_special, transition = self.DFA106_transition ) self.dfa107 = self.DFA107( self, 107, eot = self.DFA107_eot, eof = self.DFA107_eof, min = self.DFA107_min, max = self.DFA107_max, accept = self.DFA107_accept, special = self.DFA107_special, transition = self.DFA107_transition ) self.dfa115 = self.DFA115( self, 115, eot = self.DFA115_eot, eof = self.DFA115_eof, min = self.DFA115_min, max = self.DFA115_max, accept = self.DFA115_accept, special = self.DFA115_special, transition = self.DFA115_transition ) self.dfa112 = self.DFA112( self, 112, eot = self.DFA112_eot, eof = self.DFA112_eof, min = self.DFA112_min, max = self.DFA112_max, accept = self.DFA112_accept, special = self.DFA112_special, transition = self.DFA112_transition ) self.dfa113 = self.DFA113( self, 113, eot = self.DFA113_eot, eof = self.DFA113_eof, min = self.DFA113_min, max = self.DFA113_max, accept = self.DFA113_accept, special = self.DFA113_special, transition = self.DFA113_transition ) self.dfa114 = self.DFA114( self, 114, eot = self.DFA114_eot, eof = self.DFA114_eof, min = self.DFA114_min, max = self.DFA114_max, accept = self.DFA114_accept, special = self.DFA114_special, transition = self.DFA114_transition ) self.dfa116 = self.DFA116( self, 116, eot = self.DFA116_eot, eof = self.DFA116_eof, min = self.DFA116_min, max = self.DFA116_max, accept = self.DFA116_accept, special = self.DFA116_special, transition = self.DFA116_transition ) self.dfa117 = self.DFA117( self, 117, eot = self.DFA117_eot, eof = self.DFA117_eof, min = self.DFA117_min, max = self.DFA117_max, accept = self.DFA117_accept, special = self.DFA117_special, transition = self.DFA117_transition ) self.dfa128 = self.DFA128( self, 128, eot = self.DFA128_eot, eof = self.DFA128_eof, min = self.DFA128_min, max = self.DFA128_max, accept = self.DFA128_accept, special = self.DFA128_special, transition = self.DFA128_transition ) self.dfa126 = self.DFA126( self, 126, eot = self.DFA126_eot, eof = self.DFA126_eof, min = self.DFA126_min, max = self.DFA126_max, accept = self.DFA126_accept, special = self.DFA126_special, transition = self.DFA126_transition ) self.dfa136 = self.DFA136( self, 136, eot = self.DFA136_eot, eof = self.DFA136_eof, min = self.DFA136_min, max = self.DFA136_max, accept = self.DFA136_accept, special = self.DFA136_special, transition = self.DFA136_transition ) self.dfa142 = self.DFA142( self, 142, eot = self.DFA142_eot, eof = self.DFA142_eof, min = self.DFA142_min, max = self.DFA142_max, accept = self.DFA142_accept, special = self.DFA142_special, transition = self.DFA142_transition ) self.dfa175 = self.DFA175( self, 175, eot = self.DFA175_eot, eof = self.DFA175_eof, min = self.DFA175_min, max = self.DFA175_max, accept = self.DFA175_accept, special = self.DFA175_special, transition = self.DFA175_transition ) self.dfa180 = self.DFA180( self, 180, eot = self.DFA180_eot, eof = self.DFA180_eof, min = self.DFA180_min, max = self.DFA180_max, accept = self.DFA180_accept, special = self.DFA180_special, transition = self.DFA180_transition ) self.dfa181 = self.DFA181( self, 181, eot = self.DFA181_eot, eof = self.DFA181_eof, min = self.DFA181_min, max = self.DFA181_max, accept = self.DFA181_accept, special = self.DFA181_special, transition = self.DFA181_transition ) self.dfa185 = self.DFA185( self, 185, eot = self.DFA185_eot, eof = self.DFA185_eof, min = self.DFA185_min, max = self.DFA185_max, accept = self.DFA185_accept, special = self.DFA185_special, transition = self.DFA185_transition ) self.dfa194 = self.DFA194( self, 194, eot = self.DFA194_eot, eof = self.DFA194_eof, min = self.DFA194_min, max = self.DFA194_max, accept = self.DFA194_accept, special = self.DFA194_special, transition = self.DFA194_transition ) self._adaptor = None self.adaptor = CommonTreeAdaptor() def getTreeAdaptor(self): return self._adaptor def setTreeAdaptor(self, adaptor): self._adaptor = adaptor adaptor = property(getTreeAdaptor, setTreeAdaptor) class pr_file_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.pr_file_return, self).__init__() self.tree = None # $ANTLR start "pr_file" # sdl92.g:146:1: pr_file : ( use_clause | system_definition | process_definition )+ ; def pr_file(self, ): retval = self.pr_file_return() retval.start = self.input.LT(1) root_0 = None use_clause1 = None system_definition2 = None process_definition3 = None try: try: # sdl92.g:147:9: ( ( use_clause | system_definition | process_definition )+ ) # sdl92.g:147:17: ( use_clause | system_definition | process_definition )+ pass root_0 = self._adaptor.nil() # sdl92.g:147:17: ( use_clause | system_definition | process_definition )+ cnt1 = 0 while True: #loop1 alt1 = 4 LA1 = self.input.LA(1) if LA1 == 229: LA1_2 = self.input.LA(2) if (LA1_2 == KEEP) : alt1 = 1 elif (LA1_2 == ANSWER or LA1_2 == COMMENT or LA1_2 == CONNECT or LA1_2 == DECISION or LA1_2 == INPUT or (JOIN <= LA1_2 <= LABEL) or LA1_2 == NEXTSTATE or LA1_2 == OUTPUT or (PROCEDURE <= LA1_2 <= PROCEDURE_CALL) or (PROCESS <= LA1_2 <= PROVIDED) or LA1_2 == RETURN or LA1_2 == STATE or LA1_2 == STOP or LA1_2 == TASK or LA1_2 == TEXT or LA1_2 == START) : alt1 = 3 elif LA1 == USE: alt1 = 1 elif LA1 == SYSTEM: alt1 = 2 elif LA1 == PROCESS: alt1 = 3 if alt1 == 1: # sdl92.g:147:18: use_clause pass self._state.following.append(self.FOLLOW_use_clause_in_pr_file1375) use_clause1 = self.use_clause() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, use_clause1.tree) elif alt1 == 2: # sdl92.g:148:19: system_definition pass self._state.following.append(self.FOLLOW_system_definition_in_pr_file1395) system_definition2 = self.system_definition() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, system_definition2.tree) elif alt1 == 3: # sdl92.g:149:19: process_definition pass self._state.following.append(self.FOLLOW_process_definition_in_pr_file1415) process_definition3 = self.process_definition() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, process_definition3.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, 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 "pr_file" class system_definition_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.system_definition_return, self).__init__() self.tree = None # $ANTLR start "system_definition" # sdl92.g:153:1: system_definition : SYSTEM system_name end ( entity_in_system )* ENDSYSTEM ( system_name )? end -> ^( SYSTEM system_name ( entity_in_system )* ) ; def system_definition(self, ): retval = self.system_definition_return() retval.start = self.input.LT(1) root_0 = None SYSTEM4 = None ENDSYSTEM8 = None system_name5 = None end6 = None entity_in_system7 = None system_name9 = None end10 = None SYSTEM4_tree = None ENDSYSTEM8_tree = None stream_ENDSYSTEM = RewriteRuleTokenStream(self._adaptor, "token ENDSYSTEM") stream_SYSTEM = RewriteRuleTokenStream(self._adaptor, "token SYSTEM") stream_entity_in_system = RewriteRuleSubtreeStream(self._adaptor, "rule entity_in_system") stream_system_name = RewriteRuleSubtreeStream(self._adaptor, "rule system_name") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:154:9: ( SYSTEM system_name end ( entity_in_system )* ENDSYSTEM ( system_name )? end -> ^( SYSTEM system_name ( entity_in_system )* ) ) # sdl92.g:154:17: SYSTEM system_name end ( entity_in_system )* ENDSYSTEM ( system_name )? end pass SYSTEM4=self.match(self.input, SYSTEM, self.FOLLOW_SYSTEM_in_system_definition1449) if self._state.backtracking == 0: stream_SYSTEM.add(SYSTEM4) self._state.following.append(self.FOLLOW_system_name_in_system_definition1451) system_name5 = self.system_name() self._state.following.pop() if self._state.backtracking == 0: stream_system_name.add(system_name5.tree) self._state.following.append(self.FOLLOW_end_in_system_definition1453) end6 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end6.tree) # sdl92.g:155:17: ( entity_in_system )* while True: #loop2 alt2 = 2 LA2_0 = self.input.LA(1) if ((BLOCK <= LA2_0 <= CHANNEL) or LA2_0 == PROCEDURE or LA2_0 == SIGNAL or LA2_0 == 229) : alt2 = 1 if alt2 == 1: # sdl92.g:0:0: entity_in_system pass self._state.following.append(self.FOLLOW_entity_in_system_in_system_definition1471) entity_in_system7 = self.entity_in_system() self._state.following.pop() if self._state.backtracking == 0: stream_entity_in_system.add(entity_in_system7.tree) else: break #loop2 ENDSYSTEM8=self.match(self.input, ENDSYSTEM, self.FOLLOW_ENDSYSTEM_in_system_definition1490) if self._state.backtracking == 0: stream_ENDSYSTEM.add(ENDSYSTEM8) # sdl92.g:156:27: ( system_name )? alt3 = 2 LA3_0 = self.input.LA(1) if (LA3_0 == ID) : alt3 = 1 if alt3 == 1: # sdl92.g:0:0: system_name pass self._state.following.append(self.FOLLOW_system_name_in_system_definition1492) system_name9 = self.system_name() self._state.following.pop() if self._state.backtracking == 0: stream_system_name.add(system_name9.tree) self._state.following.append(self.FOLLOW_end_in_system_definition1495) end10 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end10.tree) # AST Rewrite # elements: system_name, SYSTEM, entity_in_system # 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() # 157:9: -> ^( SYSTEM system_name ( entity_in_system )* ) # sdl92.g:157:17: ^( SYSTEM system_name ( entity_in_system )* ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_SYSTEM.nextNode(), root_1) self._adaptor.addChild(root_1, stream_system_name.nextTree()) # sdl92.g:157:38: ( entity_in_system )* while stream_entity_in_system.hasNext(): self._adaptor.addChild(root_1, stream_entity_in_system.nextTree()) stream_entity_in_system.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, 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 "system_definition" class use_clause_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.use_clause_return, self).__init__() self.tree = None # $ANTLR start "use_clause" # sdl92.g:161:1: use_clause : ( use_asn1 )? USE package_name ( '/' def_selection_list )? end -> ^( USE ( use_asn1 )? ( end )? package_name ( def_selection_list )? ) ; def use_clause(self, ): retval = self.use_clause_return() retval.start = self.input.LT(1) root_0 = None USE12 = None char_literal14 = None use_asn111 = None package_name13 = None def_selection_list15 = None end16 = None USE12_tree = None char_literal14_tree = None stream_USE = RewriteRuleTokenStream(self._adaptor, "token USE") stream_DIV = RewriteRuleTokenStream(self._adaptor, "token DIV") stream_use_asn1 = RewriteRuleSubtreeStream(self._adaptor, "rule use_asn1") stream_package_name = RewriteRuleSubtreeStream(self._adaptor, "rule package_name") stream_def_selection_list = RewriteRuleSubtreeStream(self._adaptor, "rule def_selection_list") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:162:9: ( ( use_asn1 )? USE package_name ( '/' def_selection_list )? end -> ^( USE ( use_asn1 )? ( end )? package_name ( def_selection_list )? ) ) # sdl92.g:162:17: ( use_asn1 )? USE package_name ( '/' def_selection_list )? end pass # sdl92.g:162:17: ( use_asn1 )? alt4 = 2 LA4_0 = self.input.LA(1) if (LA4_0 == 229) : alt4 = 1 if alt4 == 1: # sdl92.g:0:0: use_asn1 pass self._state.following.append(self.FOLLOW_use_asn1_in_use_clause1551) use_asn111 = self.use_asn1() self._state.following.pop() if self._state.backtracking == 0: stream_use_asn1.add(use_asn111.tree) USE12=self.match(self.input, USE, self.FOLLOW_USE_in_use_clause1570) if self._state.backtracking == 0: stream_USE.add(USE12) self._state.following.append(self.FOLLOW_package_name_in_use_clause1572) package_name13 = self.package_name() self._state.following.pop() if self._state.backtracking == 0: stream_package_name.add(package_name13.tree) # sdl92.g:164:17: ( '/' def_selection_list )? alt5 = 2 LA5_0 = self.input.LA(1) if (LA5_0 == DIV) : alt5 = 1 if alt5 == 1: # sdl92.g:164:18: '/' def_selection_list pass char_literal14=self.match(self.input, DIV, self.FOLLOW_DIV_in_use_clause1591) if self._state.backtracking == 0: stream_DIV.add(char_literal14) self._state.following.append(self.FOLLOW_def_selection_list_in_use_clause1593) def_selection_list15 = self.def_selection_list() self._state.following.pop() if self._state.backtracking == 0: stream_def_selection_list.add(def_selection_list15.tree) self._state.following.append(self.FOLLOW_end_in_use_clause1614) end16 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end16.tree) # AST Rewrite # elements: USE, end, def_selection_list, use_asn1, package_name # 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() # 166:9: -> ^( USE ( use_asn1 )? ( end )? package_name ( def_selection_list )? ) # sdl92.g:166:17: ^( USE ( use_asn1 )? ( end )? package_name ( def_selection_list )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_USE.nextNode(), root_1) # sdl92.g:166:23: ( use_asn1 )? if stream_use_asn1.hasNext(): self._adaptor.addChild(root_1, stream_use_asn1.nextTree()) stream_use_asn1.reset(); # sdl92.g:166:33: ( end )? if stream_end.hasNext(): self._adaptor.addChild(root_1, stream_end.nextTree()) stream_end.reset(); self._adaptor.addChild(root_1, stream_package_name.nextTree()) # sdl92.g:166:51: ( def_selection_list )? if stream_def_selection_list.hasNext(): self._adaptor.addChild(root_1, stream_def_selection_list.nextTree()) stream_def_selection_list.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, 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 "use_clause" class def_selection_list_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.def_selection_list_return, self).__init__() self.tree = None # $ANTLR start "def_selection_list" # sdl92.g:173:1: def_selection_list : ID ( ',' ID )* ; def def_selection_list(self, ): retval = self.def_selection_list_return() retval.start = self.input.LT(1) root_0 = None ID17 = None char_literal18 = None ID19 = None ID17_tree = None char_literal18_tree = None ID19_tree = None try: try: # sdl92.g:174:9: ( ID ( ',' ID )* ) # sdl92.g:174:17: ID ( ',' ID )* pass root_0 = self._adaptor.nil() ID17=self.match(self.input, ID, self.FOLLOW_ID_in_def_selection_list1678) if self._state.backtracking == 0: ID17_tree = self._adaptor.createWithPayload(ID17) self._adaptor.addChild(root_0, ID17_tree) # sdl92.g:174:20: ( ',' ID )* while True: #loop6 alt6 = 2 LA6_0 = self.input.LA(1) if (LA6_0 == COMMA) : alt6 = 1 if alt6 == 1: # sdl92.g:174:21: ',' ID pass char_literal18=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_def_selection_list1681) ID19=self.match(self.input, ID, self.FOLLOW_ID_in_def_selection_list1684) if self._state.backtracking == 0: ID19_tree = self._adaptor.createWithPayload(ID19) self._adaptor.addChild(root_0, ID19_tree) else: break #loop6 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, 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 "def_selection_list" class entity_in_system_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.entity_in_system_return, self).__init__() self.tree = None # $ANTLR start "entity_in_system" # sdl92.g:181:1: entity_in_system : ( signal_declaration | text_area | procedure | channel | block_definition ); def entity_in_system(self, ): retval = self.entity_in_system_return() retval.start = self.input.LT(1) root_0 = None signal_declaration20 = None text_area21 = None procedure22 = None channel23 = None block_definition24 = None try: try: # sdl92.g:182:9: ( signal_declaration | text_area | procedure | channel | block_definition ) alt7 = 5 LA7 = self.input.LA(1) if LA7 == 229: LA7_1 = self.input.LA(2) if (self.synpred9_sdl92()) : alt7 = 1 elif (self.synpred10_sdl92()) : alt7 = 2 elif (self.synpred11_sdl92()) : alt7 = 3 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 7, 1, self.input) raise nvae elif LA7 == SIGNAL: alt7 = 1 elif LA7 == PROCEDURE: alt7 = 3 elif LA7 == CHANNEL: alt7 = 4 elif LA7 == BLOCK: alt7 = 5 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 7, 0, self.input) raise nvae if alt7 == 1: # sdl92.g:182:17: signal_declaration pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_signal_declaration_in_entity_in_system1720) signal_declaration20 = self.signal_declaration() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, signal_declaration20.tree) elif alt7 == 2: # sdl92.g:183:19: text_area pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_text_area_in_entity_in_system1740) text_area21 = self.text_area() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, text_area21.tree) elif alt7 == 3: # sdl92.g:184:19: procedure pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_procedure_in_entity_in_system1760) procedure22 = self.procedure() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, procedure22.tree) elif alt7 == 4: # sdl92.g:185:19: channel pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_channel_in_entity_in_system1780) channel23 = self.channel() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, channel23.tree) elif alt7 == 5: # sdl92.g:186:19: block_definition pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_block_definition_in_entity_in_system1800) block_definition24 = self.block_definition() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, block_definition24.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, 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 "entity_in_system" class signal_declaration_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.signal_declaration_return, self).__init__() self.tree = None # $ANTLR start "signal_declaration" # sdl92.g:192:1: signal_declaration : ( paramnames )? SIGNAL signal_id ( input_params )? end -> ^( SIGNAL ( paramnames )? signal_id ( input_params )? ) ; def signal_declaration(self, ): retval = self.signal_declaration_return() retval.start = self.input.LT(1) root_0 = None SIGNAL26 = None paramnames25 = None signal_id27 = None input_params28 = None end29 = None SIGNAL26_tree = None stream_SIGNAL = RewriteRuleTokenStream(self._adaptor, "token SIGNAL") stream_input_params = RewriteRuleSubtreeStream(self._adaptor, "rule input_params") stream_paramnames = RewriteRuleSubtreeStream(self._adaptor, "rule paramnames") stream_signal_id = RewriteRuleSubtreeStream(self._adaptor, "rule signal_id") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:193:9: ( ( paramnames )? SIGNAL signal_id ( input_params )? end -> ^( SIGNAL ( paramnames )? signal_id ( input_params )? ) ) # sdl92.g:193:17: ( paramnames )? SIGNAL signal_id ( input_params )? end pass # sdl92.g:193:17: ( paramnames )? alt8 = 2 LA8_0 = self.input.LA(1) if (LA8_0 == 229) : alt8 = 1 if alt8 == 1: # sdl92.g:0:0: paramnames pass self._state.following.append(self.FOLLOW_paramnames_in_signal_declaration1833) paramnames25 = self.paramnames() self._state.following.pop() if self._state.backtracking == 0: stream_paramnames.add(paramnames25.tree) SIGNAL26=self.match(self.input, SIGNAL, self.FOLLOW_SIGNAL_in_signal_declaration1852) if self._state.backtracking == 0: stream_SIGNAL.add(SIGNAL26) self._state.following.append(self.FOLLOW_signal_id_in_signal_declaration1854) signal_id27 = self.signal_id() self._state.following.pop() if self._state.backtracking == 0: stream_signal_id.add(signal_id27.tree) # sdl92.g:194:34: ( input_params )? alt9 = 2 LA9_0 = self.input.LA(1) if (LA9_0 == L_PAREN) : alt9 = 1 if alt9 == 1: # sdl92.g:0:0: input_params pass self._state.following.append(self.FOLLOW_input_params_in_signal_declaration1856) input_params28 = self.input_params() self._state.following.pop() if self._state.backtracking == 0: stream_input_params.add(input_params28.tree) self._state.following.append(self.FOLLOW_end_in_signal_declaration1859) end29 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end29.tree) # AST Rewrite # elements: signal_id, SIGNAL, input_params, paramnames # 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() # 195:9: -> ^( SIGNAL ( paramnames )? signal_id ( input_params )? ) # sdl92.g:195:17: ^( SIGNAL ( paramnames )? signal_id ( input_params )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_SIGNAL.nextNode(), root_1) # sdl92.g:195:26: ( paramnames )? if stream_paramnames.hasNext(): self._adaptor.addChild(root_1, stream_paramnames.nextTree()) stream_paramnames.reset(); self._adaptor.addChild(root_1, stream_signal_id.nextTree()) # sdl92.g:195:48: ( input_params )? if stream_input_params.hasNext(): self._adaptor.addChild(root_1, stream_input_params.nextTree()) stream_input_params.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, 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 "signal_declaration" class channel_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.channel_return, self).__init__() self.tree = None # $ANTLR start "channel" # sdl92.g:199:1: channel : CHANNEL channel_id ( route )+ ENDCHANNEL end -> ^( CHANNEL channel_id ( route )+ ) ; def channel(self, ): retval = self.channel_return() retval.start = self.input.LT(1) root_0 = None CHANNEL30 = None ENDCHANNEL33 = None channel_id31 = None route32 = None end34 = None CHANNEL30_tree = None ENDCHANNEL33_tree = None stream_CHANNEL = RewriteRuleTokenStream(self._adaptor, "token CHANNEL") stream_ENDCHANNEL = RewriteRuleTokenStream(self._adaptor, "token ENDCHANNEL") stream_route = RewriteRuleSubtreeStream(self._adaptor, "rule route") stream_channel_id = RewriteRuleSubtreeStream(self._adaptor, "rule channel_id") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:200:9: ( CHANNEL channel_id ( route )+ ENDCHANNEL end -> ^( CHANNEL channel_id ( route )+ ) ) # sdl92.g:200:17: CHANNEL channel_id ( route )+ ENDCHANNEL end pass CHANNEL30=self.match(self.input, CHANNEL, self.FOLLOW_CHANNEL_in_channel1918) if self._state.backtracking == 0: stream_CHANNEL.add(CHANNEL30) self._state.following.append(self.FOLLOW_channel_id_in_channel1920) channel_id31 = self.channel_id() self._state.following.pop() if self._state.backtracking == 0: stream_channel_id.add(channel_id31.tree) # sdl92.g:201:17: ( route )+ cnt10 = 0 while True: #loop10 alt10 = 2 LA10_0 = self.input.LA(1) if (LA10_0 == FROM) : alt10 = 1 if alt10 == 1: # sdl92.g:0:0: route pass self._state.following.append(self.FOLLOW_route_in_channel1938) route32 = self.route() self._state.following.pop() if self._state.backtracking == 0: stream_route.add(route32.tree) else: if cnt10 >= 1: break #loop10 if self._state.backtracking > 0: raise BacktrackingFailed eee = EarlyExitException(10, self.input) raise eee cnt10 += 1 ENDCHANNEL33=self.match(self.input, ENDCHANNEL, self.FOLLOW_ENDCHANNEL_in_channel1957) if self._state.backtracking == 0: stream_ENDCHANNEL.add(ENDCHANNEL33) self._state.following.append(self.FOLLOW_end_in_channel1959) end34 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end34.tree) # AST Rewrite # elements: route, channel_id, CHANNEL # 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() # 203:9: -> ^( CHANNEL channel_id ( route )+ ) # sdl92.g:203:17: ^( CHANNEL channel_id ( route )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_CHANNEL.nextNode(), root_1) self._adaptor.addChild(root_1, stream_channel_id.nextTree()) # sdl92.g:203:38: ( route )+ if not (stream_route.hasNext()): raise RewriteEarlyExitException() while stream_route.hasNext(): self._adaptor.addChild(root_1, stream_route.nextTree()) stream_route.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, 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 "channel" class route_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.route_return, self).__init__() self.tree = None # $ANTLR start "route" # sdl92.g:207:1: route : FROM source_id TO dest_id WITH signal_id ( ',' signal_id )* end -> ^( ROUTE source_id dest_id ( signal_id )+ ) ; def route(self, ): retval = self.route_return() retval.start = self.input.LT(1) root_0 = None FROM35 = None TO37 = None WITH39 = None char_literal41 = None source_id36 = None dest_id38 = None signal_id40 = None signal_id42 = None end43 = None FROM35_tree = None TO37_tree = None WITH39_tree = None char_literal41_tree = None stream_FROM = RewriteRuleTokenStream(self._adaptor, "token FROM") stream_TO = RewriteRuleTokenStream(self._adaptor, "token TO") stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_WITH = RewriteRuleTokenStream(self._adaptor, "token WITH") stream_source_id = RewriteRuleSubtreeStream(self._adaptor, "rule source_id") stream_dest_id = RewriteRuleSubtreeStream(self._adaptor, "rule dest_id") stream_signal_id = RewriteRuleSubtreeStream(self._adaptor, "rule signal_id") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:208:9: ( FROM source_id TO dest_id WITH signal_id ( ',' signal_id )* end -> ^( ROUTE source_id dest_id ( signal_id )+ ) ) # sdl92.g:208:17: FROM source_id TO dest_id WITH signal_id ( ',' signal_id )* end pass FROM35=self.match(self.input, FROM, self.FOLLOW_FROM_in_route2015) if self._state.backtracking == 0: stream_FROM.add(FROM35) self._state.following.append(self.FOLLOW_source_id_in_route2017) source_id36 = self.source_id() self._state.following.pop() if self._state.backtracking == 0: stream_source_id.add(source_id36.tree) TO37=self.match(self.input, TO, self.FOLLOW_TO_in_route2019) if self._state.backtracking == 0: stream_TO.add(TO37) self._state.following.append(self.FOLLOW_dest_id_in_route2021) dest_id38 = self.dest_id() self._state.following.pop() if self._state.backtracking == 0: stream_dest_id.add(dest_id38.tree) WITH39=self.match(self.input, WITH, self.FOLLOW_WITH_in_route2023) if self._state.backtracking == 0: stream_WITH.add(WITH39) self._state.following.append(self.FOLLOW_signal_id_in_route2025) signal_id40 = self.signal_id() self._state.following.pop() if self._state.backtracking == 0: stream_signal_id.add(signal_id40.tree) # sdl92.g:208:58: ( ',' signal_id )* while True: #loop11 alt11 = 2 LA11_0 = self.input.LA(1) if (LA11_0 == COMMA) : alt11 = 1 if alt11 == 1: # sdl92.g:208:59: ',' signal_id pass char_literal41=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_route2028) if self._state.backtracking == 0: stream_COMMA.add(char_literal41) self._state.following.append(self.FOLLOW_signal_id_in_route2030) signal_id42 = self.signal_id() self._state.following.pop() if self._state.backtracking == 0: stream_signal_id.add(signal_id42.tree) else: break #loop11 self._state.following.append(self.FOLLOW_end_in_route2034) end43 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end43.tree) # AST Rewrite # elements: source_id, signal_id, dest_id # 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() # 209:9: -> ^( ROUTE source_id dest_id ( signal_id )+ ) # sdl92.g:209:17: ^( ROUTE source_id dest_id ( signal_id )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(ROUTE, "ROUTE"), root_1) self._adaptor.addChild(root_1, stream_source_id.nextTree()) self._adaptor.addChild(root_1, stream_dest_id.nextTree()) # sdl92.g:209:43: ( signal_id )+ if not (stream_signal_id.hasNext()): raise RewriteEarlyExitException() while stream_signal_id.hasNext(): self._adaptor.addChild(root_1, stream_signal_id.nextTree()) stream_signal_id.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, 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 "route" class block_definition_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.block_definition_return, self).__init__() self.tree = None # $ANTLR start "block_definition" # sdl92.g:213:1: block_definition : BLOCK block_id end ( entity_in_block )* ENDBLOCK end -> ^( BLOCK block_id ( entity_in_block )* ) ; def block_definition(self, ): retval = self.block_definition_return() retval.start = self.input.LT(1) root_0 = None BLOCK44 = None ENDBLOCK48 = None block_id45 = None end46 = None entity_in_block47 = None end49 = None BLOCK44_tree = None ENDBLOCK48_tree = None stream_ENDBLOCK = RewriteRuleTokenStream(self._adaptor, "token ENDBLOCK") stream_BLOCK = RewriteRuleTokenStream(self._adaptor, "token BLOCK") stream_entity_in_block = RewriteRuleSubtreeStream(self._adaptor, "rule entity_in_block") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_block_id = RewriteRuleSubtreeStream(self._adaptor, "rule block_id") try: try: # sdl92.g:214:9: ( BLOCK block_id end ( entity_in_block )* ENDBLOCK end -> ^( BLOCK block_id ( entity_in_block )* ) ) # sdl92.g:214:17: BLOCK block_id end ( entity_in_block )* ENDBLOCK end pass BLOCK44=self.match(self.input, BLOCK, self.FOLLOW_BLOCK_in_block_definition2092) if self._state.backtracking == 0: stream_BLOCK.add(BLOCK44) self._state.following.append(self.FOLLOW_block_id_in_block_definition2094) block_id45 = self.block_id() self._state.following.pop() if self._state.backtracking == 0: stream_block_id.add(block_id45.tree) self._state.following.append(self.FOLLOW_end_in_block_definition2096) end46 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end46.tree) # sdl92.g:215:17: ( entity_in_block )* while True: #loop12 alt12 = 2 LA12_0 = self.input.LA(1) if (LA12_0 == BLOCK or LA12_0 == CONNECT or LA12_0 == PROCESS or LA12_0 == SIGNAL or LA12_0 == SIGNALROUTE or LA12_0 == 229) : alt12 = 1 if alt12 == 1: # sdl92.g:0:0: entity_in_block pass self._state.following.append(self.FOLLOW_entity_in_block_in_block_definition2114) entity_in_block47 = self.entity_in_block() self._state.following.pop() if self._state.backtracking == 0: stream_entity_in_block.add(entity_in_block47.tree) else: break #loop12 ENDBLOCK48=self.match(self.input, ENDBLOCK, self.FOLLOW_ENDBLOCK_in_block_definition2133) if self._state.backtracking == 0: stream_ENDBLOCK.add(ENDBLOCK48) self._state.following.append(self.FOLLOW_end_in_block_definition2135) end49 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end49.tree) # AST Rewrite # elements: block_id, entity_in_block, BLOCK # 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() # 217:9: -> ^( BLOCK block_id ( entity_in_block )* ) # sdl92.g:217:17: ^( BLOCK block_id ( entity_in_block )* ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_BLOCK.nextNode(), root_1) self._adaptor.addChild(root_1, stream_block_id.nextTree()) # sdl92.g:217:34: ( entity_in_block )* while stream_entity_in_block.hasNext(): self._adaptor.addChild(root_1, stream_entity_in_block.nextTree()) stream_entity_in_block.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, 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 "block_definition" class entity_in_block_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.entity_in_block_return, self).__init__() self.tree = None # $ANTLR start "entity_in_block" # sdl92.g:225:1: entity_in_block : ( signal_declaration | signalroute | connection | block_definition | process_definition ); def entity_in_block(self, ): retval = self.entity_in_block_return() retval.start = self.input.LT(1) root_0 = None signal_declaration50 = None signalroute51 = None connection52 = None block_definition53 = None process_definition54 = None try: try: # sdl92.g:226:9: ( signal_declaration | signalroute | connection | block_definition | process_definition ) alt13 = 5 LA13 = self.input.LA(1) if LA13 == 229: LA13_1 = self.input.LA(2) if (LA13_1 == ANSWER or LA13_1 == COMMENT or LA13_1 == CONNECT or LA13_1 == DECISION or LA13_1 == INPUT or (JOIN <= LA13_1 <= LABEL) or LA13_1 == NEXTSTATE or LA13_1 == OUTPUT or (PROCEDURE <= LA13_1 <= PROCEDURE_CALL) or (PROCESS <= LA13_1 <= PROVIDED) or LA13_1 == RETURN or LA13_1 == STATE or LA13_1 == STOP or LA13_1 == TASK or LA13_1 == TEXT or LA13_1 == START) : alt13 = 5 elif (LA13_1 == KEEP) : alt13 = 1 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 13, 1, self.input) raise nvae elif LA13 == SIGNAL: alt13 = 1 elif LA13 == SIGNALROUTE: alt13 = 2 elif LA13 == CONNECT: alt13 = 3 elif LA13 == BLOCK: alt13 = 4 elif LA13 == PROCESS: alt13 = 5 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 13, 0, self.input) raise nvae if alt13 == 1: # sdl92.g:226:17: signal_declaration pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_signal_declaration_in_entity_in_block2193) signal_declaration50 = self.signal_declaration() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, signal_declaration50.tree) elif alt13 == 2: # sdl92.g:227:19: signalroute pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_signalroute_in_entity_in_block2213) signalroute51 = self.signalroute() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, signalroute51.tree) elif alt13 == 3: # sdl92.g:228:19: connection pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_connection_in_entity_in_block2233) connection52 = self.connection() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, connection52.tree) elif alt13 == 4: # sdl92.g:229:19: block_definition pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_block_definition_in_entity_in_block2253) block_definition53 = self.block_definition() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, block_definition53.tree) elif alt13 == 5: # sdl92.g:230:19: process_definition pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_process_definition_in_entity_in_block2273) process_definition54 = self.process_definition() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, process_definition54.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, 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 "entity_in_block" class signalroute_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.signalroute_return, self).__init__() self.tree = None # $ANTLR start "signalroute" # sdl92.g:234:1: signalroute : SIGNALROUTE route_id ( route )+ -> ^( SIGNALROUTE route_id ( route )+ ) ; def signalroute(self, ): retval = self.signalroute_return() retval.start = self.input.LT(1) root_0 = None SIGNALROUTE55 = None route_id56 = None route57 = None SIGNALROUTE55_tree = None stream_SIGNALROUTE = RewriteRuleTokenStream(self._adaptor, "token SIGNALROUTE") stream_route_id = RewriteRuleSubtreeStream(self._adaptor, "rule route_id") stream_route = RewriteRuleSubtreeStream(self._adaptor, "rule route") try: try: # sdl92.g:235:9: ( SIGNALROUTE route_id ( route )+ -> ^( SIGNALROUTE route_id ( route )+ ) ) # sdl92.g:235:17: SIGNALROUTE route_id ( route )+ pass SIGNALROUTE55=self.match(self.input, SIGNALROUTE, self.FOLLOW_SIGNALROUTE_in_signalroute2305) if self._state.backtracking == 0: stream_SIGNALROUTE.add(SIGNALROUTE55) self._state.following.append(self.FOLLOW_route_id_in_signalroute2307) route_id56 = self.route_id() self._state.following.pop() if self._state.backtracking == 0: stream_route_id.add(route_id56.tree) # sdl92.g:236:17: ( route )+ cnt14 = 0 while True: #loop14 alt14 = 2 LA14_0 = self.input.LA(1) if (LA14_0 == FROM) : alt14 = 1 if alt14 == 1: # sdl92.g:0:0: route pass self._state.following.append(self.FOLLOW_route_in_signalroute2325) route57 = self.route() self._state.following.pop() if self._state.backtracking == 0: stream_route.add(route57.tree) else: if cnt14 >= 1: break #loop14 if self._state.backtracking > 0: raise BacktrackingFailed eee = EarlyExitException(14, self.input) raise eee cnt14 += 1 # AST Rewrite # elements: SIGNALROUTE, route, route_id # 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() # 237:9: -> ^( SIGNALROUTE route_id ( route )+ ) # sdl92.g:237:17: ^( SIGNALROUTE route_id ( route )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_SIGNALROUTE.nextNode(), root_1) self._adaptor.addChild(root_1, stream_route_id.nextTree()) # sdl92.g:237:40: ( route )+ if not (stream_route.hasNext()): raise RewriteEarlyExitException() while stream_route.hasNext(): self._adaptor.addChild(root_1, stream_route.nextTree()) stream_route.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, 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 "signalroute" class connection_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.connection_return, self).__init__() self.tree = None # $ANTLR start "connection" # sdl92.g:241:1: connection : CONNECT channel_id AND route_id end -> ^( CONNECTION channel_id route_id ) ; def connection(self, ): retval = self.connection_return() retval.start = self.input.LT(1) root_0 = None CONNECT58 = None AND60 = None channel_id59 = None route_id61 = None end62 = None CONNECT58_tree = None AND60_tree = None stream_CONNECT = RewriteRuleTokenStream(self._adaptor, "token CONNECT") stream_AND = RewriteRuleTokenStream(self._adaptor, "token AND") stream_route_id = RewriteRuleSubtreeStream(self._adaptor, "rule route_id") stream_channel_id = RewriteRuleSubtreeStream(self._adaptor, "rule channel_id") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:242:9: ( CONNECT channel_id AND route_id end -> ^( CONNECTION channel_id route_id ) ) # sdl92.g:242:17: CONNECT channel_id AND route_id end pass CONNECT58=self.match(self.input, CONNECT, self.FOLLOW_CONNECT_in_connection2382) if self._state.backtracking == 0: stream_CONNECT.add(CONNECT58) self._state.following.append(self.FOLLOW_channel_id_in_connection2384) channel_id59 = self.channel_id() self._state.following.pop() if self._state.backtracking == 0: stream_channel_id.add(channel_id59.tree) AND60=self.match(self.input, AND, self.FOLLOW_AND_in_connection2386) if self._state.backtracking == 0: stream_AND.add(AND60) self._state.following.append(self.FOLLOW_route_id_in_connection2388) route_id61 = self.route_id() self._state.following.pop() if self._state.backtracking == 0: stream_route_id.add(route_id61.tree) self._state.following.append(self.FOLLOW_end_in_connection2390) end62 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end62.tree) # AST Rewrite # elements: channel_id, route_id # 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() # 243:9: -> ^( CONNECTION channel_id route_id ) # sdl92.g:243:17: ^( CONNECTION channel_id route_id ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(CONNECTION, "CONNECTION"), root_1) self._adaptor.addChild(root_1, stream_channel_id.nextTree()) self._adaptor.addChild(root_1, stream_route_id.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, 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 "connection" class process_definition_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.process_definition_return, self).__init__() self.tree = None # $ANTLR start "process_definition" # sdl92.g:255:1: process_definition : ( cif )? PROCESS process_id ( number_of_instances )? ( ':' type_inst )? ( REFERENCED )? a= end ( pfpar )? ( text_area | procedure | composite_state )* ( processBody )? ( ENDPROCESS )? ( process_id )? ( end )? -> ^( PROCESS ( cif )? process_id ( number_of_instances )? ( type_inst )? ( REFERENCED )? ( $a)? ( pfpar )? ( text_area )* ( procedure )* ( composite_state )* ( processBody )? ) ; def process_definition(self, ): retval = self.process_definition_return() retval.start = self.input.LT(1) root_0 = None PROCESS64 = None char_literal67 = None REFERENCED69 = None ENDPROCESS75 = None a = None cif63 = None process_id65 = None number_of_instances66 = None type_inst68 = None pfpar70 = None text_area71 = None procedure72 = None composite_state73 = None processBody74 = None process_id76 = None end77 = None PROCESS64_tree = None char_literal67_tree = None REFERENCED69_tree = None ENDPROCESS75_tree = None stream_223 = RewriteRuleTokenStream(self._adaptor, "token 223") stream_REFERENCED = RewriteRuleTokenStream(self._adaptor, "token REFERENCED") stream_PROCESS = RewriteRuleTokenStream(self._adaptor, "token PROCESS") stream_ENDPROCESS = RewriteRuleTokenStream(self._adaptor, "token ENDPROCESS") stream_composite_state = RewriteRuleSubtreeStream(self._adaptor, "rule composite_state") stream_process_id = RewriteRuleSubtreeStream(self._adaptor, "rule process_id") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_processBody = RewriteRuleSubtreeStream(self._adaptor, "rule processBody") stream_text_area = RewriteRuleSubtreeStream(self._adaptor, "rule text_area") stream_number_of_instances = RewriteRuleSubtreeStream(self._adaptor, "rule number_of_instances") stream_type_inst = RewriteRuleSubtreeStream(self._adaptor, "rule type_inst") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_procedure = RewriteRuleSubtreeStream(self._adaptor, "rule procedure") stream_pfpar = RewriteRuleSubtreeStream(self._adaptor, "rule pfpar") try: try: # sdl92.g:256:9: ( ( cif )? PROCESS process_id ( number_of_instances )? ( ':' type_inst )? ( REFERENCED )? a= end ( pfpar )? ( text_area | procedure | composite_state )* ( processBody )? ( ENDPROCESS )? ( process_id )? ( end )? -> ^( PROCESS ( cif )? process_id ( number_of_instances )? ( type_inst )? ( REFERENCED )? ( $a)? ( pfpar )? ( text_area )* ( procedure )* ( composite_state )* ( processBody )? ) ) # sdl92.g:256:17: ( cif )? PROCESS process_id ( number_of_instances )? ( ':' type_inst )? ( REFERENCED )? a= end ( pfpar )? ( text_area | procedure | composite_state )* ( processBody )? ( ENDPROCESS )? ( process_id )? ( end )? pass # sdl92.g:256:17: ( cif )? alt15 = 2 LA15_0 = self.input.LA(1) if (LA15_0 == 229) : alt15 = 1 if alt15 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_process_definition2447) cif63 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif63.tree) PROCESS64=self.match(self.input, PROCESS, self.FOLLOW_PROCESS_in_process_definition2466) if self._state.backtracking == 0: stream_PROCESS.add(PROCESS64) self._state.following.append(self.FOLLOW_process_id_in_process_definition2468) process_id65 = self.process_id() self._state.following.pop() if self._state.backtracking == 0: stream_process_id.add(process_id65.tree) # sdl92.g:258:17: ( number_of_instances )? alt16 = 2 LA16_0 = self.input.LA(1) if (LA16_0 == L_PAREN) : alt16 = 1 if alt16 == 1: # sdl92.g:0:0: number_of_instances pass self._state.following.append(self.FOLLOW_number_of_instances_in_process_definition2486) number_of_instances66 = self.number_of_instances() self._state.following.pop() if self._state.backtracking == 0: stream_number_of_instances.add(number_of_instances66.tree) # sdl92.g:258:38: ( ':' type_inst )? alt17 = 2 LA17_0 = self.input.LA(1) if (LA17_0 == 223) : alt17 = 1 if alt17 == 1: # sdl92.g:258:39: ':' type_inst pass char_literal67=self.match(self.input, 223, self.FOLLOW_223_in_process_definition2490) if self._state.backtracking == 0: stream_223.add(char_literal67) self._state.following.append(self.FOLLOW_type_inst_in_process_definition2492) type_inst68 = self.type_inst() self._state.following.pop() if self._state.backtracking == 0: stream_type_inst.add(type_inst68.tree) # sdl92.g:258:55: ( REFERENCED )? alt18 = 2 LA18_0 = self.input.LA(1) if (LA18_0 == REFERENCED) : alt18 = 1 if alt18 == 1: # sdl92.g:0:0: REFERENCED pass REFERENCED69=self.match(self.input, REFERENCED, self.FOLLOW_REFERENCED_in_process_definition2496) if self._state.backtracking == 0: stream_REFERENCED.add(REFERENCED69) self._state.following.append(self.FOLLOW_end_in_process_definition2501) a = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(a.tree) # sdl92.g:259:17: ( pfpar )? alt19 = 2 LA19_0 = self.input.LA(1) if (LA19_0 == FPAR) : alt19 = 1 if alt19 == 1: # sdl92.g:0:0: pfpar pass self._state.following.append(self.FOLLOW_pfpar_in_process_definition2519) pfpar70 = self.pfpar() self._state.following.pop() if self._state.backtracking == 0: stream_pfpar.add(pfpar70.tree) # sdl92.g:260:17: ( text_area | procedure | composite_state )* while True: #loop20 alt20 = 4 alt20 = self.dfa20.predict(self.input) if alt20 == 1: # sdl92.g:260:18: text_area pass self._state.following.append(self.FOLLOW_text_area_in_process_definition2539) text_area71 = self.text_area() self._state.following.pop() if self._state.backtracking == 0: stream_text_area.add(text_area71.tree) elif alt20 == 2: # sdl92.g:260:30: procedure pass self._state.following.append(self.FOLLOW_procedure_in_process_definition2543) procedure72 = self.procedure() self._state.following.pop() if self._state.backtracking == 0: stream_procedure.add(procedure72.tree) elif alt20 == 3: # sdl92.g:260:42: composite_state pass self._state.following.append(self.FOLLOW_composite_state_in_process_definition2547) composite_state73 = self.composite_state() self._state.following.pop() if self._state.backtracking == 0: stream_composite_state.add(composite_state73.tree) else: break #loop20 # sdl92.g:261:17: ( processBody )? alt21 = 2 alt21 = self.dfa21.predict(self.input) if alt21 == 1: # sdl92.g:0:0: processBody pass self._state.following.append(self.FOLLOW_processBody_in_process_definition2567) processBody74 = self.processBody() self._state.following.pop() if self._state.backtracking == 0: stream_processBody.add(processBody74.tree) # sdl92.g:261:30: ( ENDPROCESS )? alt22 = 2 LA22_0 = self.input.LA(1) if (LA22_0 == ENDPROCESS) : alt22 = 1 if alt22 == 1: # sdl92.g:0:0: ENDPROCESS pass ENDPROCESS75=self.match(self.input, ENDPROCESS, self.FOLLOW_ENDPROCESS_in_process_definition2570) if self._state.backtracking == 0: stream_ENDPROCESS.add(ENDPROCESS75) # sdl92.g:261:42: ( process_id )? alt23 = 2 LA23_0 = self.input.LA(1) if (LA23_0 == ID) : alt23 = 1 if alt23 == 1: # sdl92.g:0:0: process_id pass self._state.following.append(self.FOLLOW_process_id_in_process_definition2573) process_id76 = self.process_id() self._state.following.pop() if self._state.backtracking == 0: stream_process_id.add(process_id76.tree) # sdl92.g:262:17: ( end )? alt24 = 2 alt24 = self.dfa24.predict(self.input) if alt24 == 1: # sdl92.g:0:0: end pass self._state.following.append(self.FOLLOW_end_in_process_definition2592) end77 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end77.tree) # AST Rewrite # elements: processBody, a, REFERENCED, pfpar, type_inst, PROCESS, composite_state, process_id, text_area, procedure, number_of_instances, cif # token labels: # rule labels: retval, a # 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) if a is not None: stream_a = RewriteRuleSubtreeStream(self._adaptor, "rule a", a.tree) else: stream_a = RewriteRuleSubtreeStream(self._adaptor, "token a", None) root_0 = self._adaptor.nil() # 263:9: -> ^( PROCESS ( cif )? process_id ( number_of_instances )? ( type_inst )? ( REFERENCED )? ( $a)? ( pfpar )? ( text_area )* ( procedure )* ( composite_state )* ( processBody )? ) # sdl92.g:263:17: ^( PROCESS ( cif )? process_id ( number_of_instances )? ( type_inst )? ( REFERENCED )? ( $a)? ( pfpar )? ( text_area )* ( procedure )* ( composite_state )* ( processBody )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_PROCESS.nextNode(), root_1) # sdl92.g:263:27: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); self._adaptor.addChild(root_1, stream_process_id.nextTree()) # sdl92.g:263:43: ( number_of_instances )? if stream_number_of_instances.hasNext(): self._adaptor.addChild(root_1, stream_number_of_instances.nextTree()) stream_number_of_instances.reset(); # sdl92.g:263:64: ( type_inst )? if stream_type_inst.hasNext(): self._adaptor.addChild(root_1, stream_type_inst.nextTree()) stream_type_inst.reset(); # sdl92.g:264:17: ( REFERENCED )? if stream_REFERENCED.hasNext(): self._adaptor.addChild(root_1, stream_REFERENCED.nextNode()) stream_REFERENCED.reset(); # sdl92.g:264:29: ( $a)? if stream_a.hasNext(): self._adaptor.addChild(root_1, stream_a.nextTree()) stream_a.reset(); # sdl92.g:264:33: ( pfpar )? if stream_pfpar.hasNext(): self._adaptor.addChild(root_1, stream_pfpar.nextTree()) stream_pfpar.reset(); # sdl92.g:264:40: ( text_area )* while stream_text_area.hasNext(): self._adaptor.addChild(root_1, stream_text_area.nextTree()) stream_text_area.reset(); # sdl92.g:264:51: ( procedure )* while stream_procedure.hasNext(): self._adaptor.addChild(root_1, stream_procedure.nextTree()) stream_procedure.reset(); # sdl92.g:265:17: ( composite_state )* while stream_composite_state.hasNext(): self._adaptor.addChild(root_1, stream_composite_state.nextTree()) stream_composite_state.reset(); # sdl92.g:265:34: ( processBody )? if stream_processBody.hasNext(): self._adaptor.addChild(root_1, stream_processBody.nextTree()) stream_processBody.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, 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 "process_definition" class pfpar_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.pfpar_return, self).__init__() self.tree = None # $ANTLR start "pfpar" # sdl92.g:270:1: pfpar : FPAR parameters_of_sort ( ',' parameters_of_sort )* ( end )? -> ^( PFPAR ( parameters_of_sort )+ ) ; def pfpar(self, ): retval = self.pfpar_return() retval.start = self.input.LT(1) root_0 = None FPAR78 = None char_literal80 = None parameters_of_sort79 = None parameters_of_sort81 = None end82 = None FPAR78_tree = None char_literal80_tree = None stream_FPAR = RewriteRuleTokenStream(self._adaptor, "token FPAR") stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_parameters_of_sort = RewriteRuleSubtreeStream(self._adaptor, "rule parameters_of_sort") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:271:9: ( FPAR parameters_of_sort ( ',' parameters_of_sort )* ( end )? -> ^( PFPAR ( parameters_of_sort )+ ) ) # sdl92.g:271:17: FPAR parameters_of_sort ( ',' parameters_of_sort )* ( end )? pass FPAR78=self.match(self.input, FPAR, self.FOLLOW_FPAR_in_pfpar2710) if self._state.backtracking == 0: stream_FPAR.add(FPAR78) self._state.following.append(self.FOLLOW_parameters_of_sort_in_pfpar2712) parameters_of_sort79 = self.parameters_of_sort() self._state.following.pop() if self._state.backtracking == 0: stream_parameters_of_sort.add(parameters_of_sort79.tree) # sdl92.g:272:17: ( ',' parameters_of_sort )* while True: #loop25 alt25 = 2 LA25_0 = self.input.LA(1) if (LA25_0 == COMMA) : alt25 = 1 if alt25 == 1: # sdl92.g:272:18: ',' parameters_of_sort pass char_literal80=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_pfpar2731) if self._state.backtracking == 0: stream_COMMA.add(char_literal80) self._state.following.append(self.FOLLOW_parameters_of_sort_in_pfpar2733) parameters_of_sort81 = self.parameters_of_sort() self._state.following.pop() if self._state.backtracking == 0: stream_parameters_of_sort.add(parameters_of_sort81.tree) else: break #loop25 # sdl92.g:273:17: ( end )? alt26 = 2 alt26 = self.dfa26.predict(self.input) if alt26 == 1: # sdl92.g:0:0: end pass self._state.following.append(self.FOLLOW_end_in_pfpar2753) end82 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end82.tree) # AST Rewrite # elements: parameters_of_sort # 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() # 274:9: -> ^( PFPAR ( parameters_of_sort )+ ) # sdl92.g:274:17: ^( PFPAR ( parameters_of_sort )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(PFPAR, "PFPAR"), root_1) # sdl92.g:274:25: ( parameters_of_sort )+ if not (stream_parameters_of_sort.hasNext()): raise RewriteEarlyExitException() while stream_parameters_of_sort.hasNext(): self._adaptor.addChild(root_1, stream_parameters_of_sort.nextTree()) stream_parameters_of_sort.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, 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 "pfpar" class parameters_of_sort_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.parameters_of_sort_return, self).__init__() self.tree = None # $ANTLR start "parameters_of_sort" # sdl92.g:278:1: parameters_of_sort : variable_id ( ',' variable_id )* sort -> ^( PARAM ( variable_id )+ sort ) ; def parameters_of_sort(self, ): retval = self.parameters_of_sort_return() retval.start = self.input.LT(1) root_0 = None char_literal84 = None variable_id83 = None variable_id85 = None sort86 = None char_literal84_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_sort = RewriteRuleSubtreeStream(self._adaptor, "rule sort") stream_variable_id = RewriteRuleSubtreeStream(self._adaptor, "rule variable_id") try: try: # sdl92.g:279:9: ( variable_id ( ',' variable_id )* sort -> ^( PARAM ( variable_id )+ sort ) ) # sdl92.g:279:17: variable_id ( ',' variable_id )* sort pass self._state.following.append(self.FOLLOW_variable_id_in_parameters_of_sort2808) variable_id83 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id83.tree) # sdl92.g:279:29: ( ',' variable_id )* while True: #loop27 alt27 = 2 LA27_0 = self.input.LA(1) if (LA27_0 == COMMA) : alt27 = 1 if alt27 == 1: # sdl92.g:279:30: ',' variable_id pass char_literal84=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_parameters_of_sort2811) if self._state.backtracking == 0: stream_COMMA.add(char_literal84) self._state.following.append(self.FOLLOW_variable_id_in_parameters_of_sort2813) variable_id85 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id85.tree) else: break #loop27 self._state.following.append(self.FOLLOW_sort_in_parameters_of_sort2817) sort86 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort86.tree) # AST Rewrite # elements: sort, variable_id # 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() # 280:9: -> ^( PARAM ( variable_id )+ sort ) # sdl92.g:280:17: ^( PARAM ( variable_id )+ sort ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(PARAM, "PARAM"), root_1) # sdl92.g:280:25: ( variable_id )+ if not (stream_variable_id.hasNext()): raise RewriteEarlyExitException() while stream_variable_id.hasNext(): self._adaptor.addChild(root_1, stream_variable_id.nextTree()) stream_variable_id.reset() self._adaptor.addChild(root_1, stream_sort.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, 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 "parameters_of_sort" class procedure_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.procedure_return, self).__init__() self.tree = None # $ANTLR start "procedure" # sdl92.g:286:1: procedure : ( cif )? PROCEDURE procedure_id e1= end ( fpar )? (res= procedure_result )? ( text_area | procedure )* ( ( ( processBody )? ENDPROCEDURE ( procedure_id )? ) | EXTERNAL ) e2= end -> ^( PROCEDURE ( cif )? procedure_id ( $e1)? ( $e2)? ( fpar )? ( $res)? ( text_area )* ( procedure )* ( processBody )? ( EXTERNAL )? ) ; def procedure(self, ): retval = self.procedure_return() retval.start = self.input.LT(1) root_0 = None PROCEDURE88 = None ENDPROCEDURE94 = None EXTERNAL96 = None e1 = None res = None e2 = None cif87 = None procedure_id89 = None fpar90 = None text_area91 = None procedure92 = None processBody93 = None procedure_id95 = None PROCEDURE88_tree = None ENDPROCEDURE94_tree = None EXTERNAL96_tree = None stream_EXTERNAL = RewriteRuleTokenStream(self._adaptor, "token EXTERNAL") stream_ENDPROCEDURE = RewriteRuleTokenStream(self._adaptor, "token ENDPROCEDURE") stream_PROCEDURE = RewriteRuleTokenStream(self._adaptor, "token PROCEDURE") stream_procedure_id = RewriteRuleSubtreeStream(self._adaptor, "rule procedure_id") stream_procedure_result = RewriteRuleSubtreeStream(self._adaptor, "rule procedure_result") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_fpar = RewriteRuleSubtreeStream(self._adaptor, "rule fpar") stream_processBody = RewriteRuleSubtreeStream(self._adaptor, "rule processBody") stream_text_area = RewriteRuleSubtreeStream(self._adaptor, "rule text_area") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_procedure = RewriteRuleSubtreeStream(self._adaptor, "rule procedure") try: try: # sdl92.g:287:9: ( ( cif )? PROCEDURE procedure_id e1= end ( fpar )? (res= procedure_result )? ( text_area | procedure )* ( ( ( processBody )? ENDPROCEDURE ( procedure_id )? ) | EXTERNAL ) e2= end -> ^( PROCEDURE ( cif )? procedure_id ( $e1)? ( $e2)? ( fpar )? ( $res)? ( text_area )* ( procedure )* ( processBody )? ( EXTERNAL )? ) ) # sdl92.g:287:17: ( cif )? PROCEDURE procedure_id e1= end ( fpar )? (res= procedure_result )? ( text_area | procedure )* ( ( ( processBody )? ENDPROCEDURE ( procedure_id )? ) | EXTERNAL ) e2= end pass # sdl92.g:287:17: ( cif )? alt28 = 2 LA28_0 = self.input.LA(1) if (LA28_0 == 229) : alt28 = 1 if alt28 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_procedure2875) cif87 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif87.tree) PROCEDURE88=self.match(self.input, PROCEDURE, self.FOLLOW_PROCEDURE_in_procedure2894) if self._state.backtracking == 0: stream_PROCEDURE.add(PROCEDURE88) self._state.following.append(self.FOLLOW_procedure_id_in_procedure2896) procedure_id89 = self.procedure_id() self._state.following.pop() if self._state.backtracking == 0: stream_procedure_id.add(procedure_id89.tree) self._state.following.append(self.FOLLOW_end_in_procedure2900) e1 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(e1.tree) # sdl92.g:289:17: ( fpar )? alt29 = 2 LA29_0 = self.input.LA(1) if (LA29_0 == FPAR) : alt29 = 1 if alt29 == 1: # sdl92.g:0:0: fpar pass self._state.following.append(self.FOLLOW_fpar_in_procedure2918) fpar90 = self.fpar() self._state.following.pop() if self._state.backtracking == 0: stream_fpar.add(fpar90.tree) # sdl92.g:290:20: (res= procedure_result )? alt30 = 2 LA30_0 = self.input.LA(1) if (LA30_0 == RETURNS or LA30_0 == 224) : alt30 = 1 if alt30 == 1: # sdl92.g:0:0: res= procedure_result pass self._state.following.append(self.FOLLOW_procedure_result_in_procedure2939) res = self.procedure_result() self._state.following.pop() if self._state.backtracking == 0: stream_procedure_result.add(res.tree) # sdl92.g:291:17: ( text_area | procedure )* while True: #loop31 alt31 = 3 LA31_0 = self.input.LA(1) if (LA31_0 == 229) : LA31_1 = self.input.LA(2) if (self.synpred41_sdl92()) : alt31 = 1 elif (self.synpred42_sdl92()) : alt31 = 2 elif (LA31_0 == PROCEDURE) : alt31 = 2 if alt31 == 1: # sdl92.g:291:18: text_area pass self._state.following.append(self.FOLLOW_text_area_in_procedure2959) text_area91 = self.text_area() self._state.following.pop() if self._state.backtracking == 0: stream_text_area.add(text_area91.tree) elif alt31 == 2: # sdl92.g:291:30: procedure pass self._state.following.append(self.FOLLOW_procedure_in_procedure2963) procedure92 = self.procedure() self._state.following.pop() if self._state.backtracking == 0: stream_procedure.add(procedure92.tree) else: break #loop31 # sdl92.g:292:17: ( ( ( processBody )? ENDPROCEDURE ( procedure_id )? ) | EXTERNAL ) alt34 = 2 LA34_0 = self.input.LA(1) if (LA34_0 == EOF or LA34_0 == BLOCK or LA34_0 == COMMENT or (CONNECT <= LA34_0 <= CONNECTION) or LA34_0 == PROCESS or LA34_0 == SIGNAL or LA34_0 == STATE or LA34_0 == SYSTEM or LA34_0 == USE or LA34_0 == ID or (ENDBLOCK <= LA34_0 <= SIGNALROUTE) or (ENDPROCESS <= LA34_0 <= ENDPROCEDURE) or LA34_0 == START or LA34_0 == SEMI or LA34_0 == 229) : alt34 = 1 elif (LA34_0 == EXTERNAL) : alt34 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 34, 0, self.input) raise nvae if alt34 == 1: # sdl92.g:292:18: ( ( processBody )? ENDPROCEDURE ( procedure_id )? ) pass # sdl92.g:292:18: ( ( processBody )? ENDPROCEDURE ( procedure_id )? ) # sdl92.g:292:19: ( processBody )? ENDPROCEDURE ( procedure_id )? pass # sdl92.g:292:19: ( processBody )? alt32 = 2 LA32_0 = self.input.LA(1) if (LA32_0 == CONNECTION or LA32_0 == STATE or LA32_0 == START or LA32_0 == 229) : alt32 = 1 elif (LA32_0 == ENDPROCEDURE) : LA32_2 = self.input.LA(2) if (self.synpred43_sdl92()) : alt32 = 1 if alt32 == 1: # sdl92.g:0:0: processBody pass self._state.following.append(self.FOLLOW_processBody_in_procedure2985) processBody93 = self.processBody() self._state.following.pop() if self._state.backtracking == 0: stream_processBody.add(processBody93.tree) ENDPROCEDURE94=self.match(self.input, ENDPROCEDURE, self.FOLLOW_ENDPROCEDURE_in_procedure2988) if self._state.backtracking == 0: stream_ENDPROCEDURE.add(ENDPROCEDURE94) # sdl92.g:292:45: ( procedure_id )? alt33 = 2 LA33_0 = self.input.LA(1) if (LA33_0 == ID) : alt33 = 1 if alt33 == 1: # sdl92.g:0:0: procedure_id pass self._state.following.append(self.FOLLOW_procedure_id_in_procedure2990) procedure_id95 = self.procedure_id() self._state.following.pop() if self._state.backtracking == 0: stream_procedure_id.add(procedure_id95.tree) elif alt34 == 2: # sdl92.g:292:62: EXTERNAL pass EXTERNAL96=self.match(self.input, EXTERNAL, self.FOLLOW_EXTERNAL_in_procedure2996) if self._state.backtracking == 0: stream_EXTERNAL.add(EXTERNAL96) self._state.following.append(self.FOLLOW_end_in_procedure3017) e2 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(e2.tree) # AST Rewrite # elements: processBody, fpar, e2, res, PROCEDURE, e1, EXTERNAL, cif, text_area, procedure, procedure_id # token labels: # rule labels: res, retval, e1, e2 # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 if res is not None: stream_res = RewriteRuleSubtreeStream(self._adaptor, "rule res", res.tree) else: stream_res = RewriteRuleSubtreeStream(self._adaptor, "token res", None) if retval is not None: stream_retval = RewriteRuleSubtreeStream(self._adaptor, "rule retval", retval.tree) else: stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None) if e1 is not None: stream_e1 = RewriteRuleSubtreeStream(self._adaptor, "rule e1", e1.tree) else: stream_e1 = RewriteRuleSubtreeStream(self._adaptor, "token e1", None) if e2 is not None: stream_e2 = RewriteRuleSubtreeStream(self._adaptor, "rule e2", e2.tree) else: stream_e2 = RewriteRuleSubtreeStream(self._adaptor, "token e2", None) root_0 = self._adaptor.nil() # 294:9: -> ^( PROCEDURE ( cif )? procedure_id ( $e1)? ( $e2)? ( fpar )? ( $res)? ( text_area )* ( procedure )* ( processBody )? ( EXTERNAL )? ) # sdl92.g:294:17: ^( PROCEDURE ( cif )? procedure_id ( $e1)? ( $e2)? ( fpar )? ( $res)? ( text_area )* ( procedure )* ( processBody )? ( EXTERNAL )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_PROCEDURE.nextNode(), root_1) # sdl92.g:294:29: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); self._adaptor.addChild(root_1, stream_procedure_id.nextTree()) # sdl92.g:294:47: ( $e1)? if stream_e1.hasNext(): self._adaptor.addChild(root_1, stream_e1.nextTree()) stream_e1.reset(); # sdl92.g:294:52: ( $e2)? if stream_e2.hasNext(): self._adaptor.addChild(root_1, stream_e2.nextTree()) stream_e2.reset(); # sdl92.g:294:57: ( fpar )? if stream_fpar.hasNext(): self._adaptor.addChild(root_1, stream_fpar.nextTree()) stream_fpar.reset(); # sdl92.g:294:63: ( $res)? if stream_res.hasNext(): self._adaptor.addChild(root_1, stream_res.nextTree()) stream_res.reset(); # sdl92.g:295:17: ( text_area )* while stream_text_area.hasNext(): self._adaptor.addChild(root_1, stream_text_area.nextTree()) stream_text_area.reset(); # sdl92.g:295:28: ( procedure )* while stream_procedure.hasNext(): self._adaptor.addChild(root_1, stream_procedure.nextTree()) stream_procedure.reset(); # sdl92.g:295:39: ( processBody )? if stream_processBody.hasNext(): self._adaptor.addChild(root_1, stream_processBody.nextTree()) stream_processBody.reset(); # sdl92.g:295:52: ( EXTERNAL )? if stream_EXTERNAL.hasNext(): self._adaptor.addChild(root_1, stream_EXTERNAL.nextNode()) stream_EXTERNAL.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, 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 "procedure" class procedure_result_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.procedure_result_return, self).__init__() self.tree = None # $ANTLR start "procedure_result" # sdl92.g:299:1: procedure_result : ( '->' | RETURNS ) ( variable_id )? sort -> ^( RETURNS ( variable_id )? sort ) ; def procedure_result(self, ): retval = self.procedure_result_return() retval.start = self.input.LT(1) root_0 = None string_literal97 = None RETURNS98 = None variable_id99 = None sort100 = None string_literal97_tree = None RETURNS98_tree = None stream_224 = RewriteRuleTokenStream(self._adaptor, "token 224") stream_RETURNS = RewriteRuleTokenStream(self._adaptor, "token RETURNS") stream_sort = RewriteRuleSubtreeStream(self._adaptor, "rule sort") stream_variable_id = RewriteRuleSubtreeStream(self._adaptor, "rule variable_id") try: try: # sdl92.g:300:9: ( ( '->' | RETURNS ) ( variable_id )? sort -> ^( RETURNS ( variable_id )? sort ) ) # sdl92.g:300:17: ( '->' | RETURNS ) ( variable_id )? sort pass # sdl92.g:300:17: ( '->' | RETURNS ) alt35 = 2 LA35_0 = self.input.LA(1) if (LA35_0 == 224) : alt35 = 1 elif (LA35_0 == RETURNS) : alt35 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 35, 0, self.input) raise nvae if alt35 == 1: # sdl92.g:300:18: '->' pass string_literal97=self.match(self.input, 224, self.FOLLOW_224_in_procedure_result3117) if self._state.backtracking == 0: stream_224.add(string_literal97) elif alt35 == 2: # sdl92.g:300:25: RETURNS pass RETURNS98=self.match(self.input, RETURNS, self.FOLLOW_RETURNS_in_procedure_result3121) if self._state.backtracking == 0: stream_RETURNS.add(RETURNS98) # sdl92.g:301:17: ( variable_id )? alt36 = 2 LA36_0 = self.input.LA(1) if (LA36_0 == ID) : LA36_1 = self.input.LA(2) if (LA36_1 == ID) : alt36 = 1 if alt36 == 1: # sdl92.g:0:0: variable_id pass self._state.following.append(self.FOLLOW_variable_id_in_procedure_result3140) variable_id99 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id99.tree) self._state.following.append(self.FOLLOW_sort_in_procedure_result3159) sort100 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort100.tree) # AST Rewrite # elements: variable_id, sort, RETURNS # 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() # 303:9: -> ^( RETURNS ( variable_id )? sort ) # sdl92.g:303:17: ^( RETURNS ( variable_id )? sort ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_RETURNS.nextNode(), root_1) # sdl92.g:303:27: ( variable_id )? if stream_variable_id.hasNext(): self._adaptor.addChild(root_1, stream_variable_id.nextTree()) stream_variable_id.reset(); self._adaptor.addChild(root_1, stream_sort.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, 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 "procedure_result" class fpar_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.fpar_return, self).__init__() self.tree = None # $ANTLR start "fpar" # sdl92.g:307:1: fpar : FPAR formal_variable_param ( ',' formal_variable_param )* ( end )? -> ^( FPAR ( formal_variable_param )+ ) ; def fpar(self, ): retval = self.fpar_return() retval.start = self.input.LT(1) root_0 = None FPAR101 = None char_literal103 = None formal_variable_param102 = None formal_variable_param104 = None end105 = None FPAR101_tree = None char_literal103_tree = None stream_FPAR = RewriteRuleTokenStream(self._adaptor, "token FPAR") stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_formal_variable_param = RewriteRuleSubtreeStream(self._adaptor, "rule formal_variable_param") try: try: # sdl92.g:308:9: ( FPAR formal_variable_param ( ',' formal_variable_param )* ( end )? -> ^( FPAR ( formal_variable_param )+ ) ) # sdl92.g:308:17: FPAR formal_variable_param ( ',' formal_variable_param )* ( end )? pass FPAR101=self.match(self.input, FPAR, self.FOLLOW_FPAR_in_fpar3215) if self._state.backtracking == 0: stream_FPAR.add(FPAR101) self._state.following.append(self.FOLLOW_formal_variable_param_in_fpar3217) formal_variable_param102 = self.formal_variable_param() self._state.following.pop() if self._state.backtracking == 0: stream_formal_variable_param.add(formal_variable_param102.tree) # sdl92.g:309:17: ( ',' formal_variable_param )* while True: #loop37 alt37 = 2 LA37_0 = self.input.LA(1) if (LA37_0 == COMMA) : alt37 = 1 if alt37 == 1: # sdl92.g:309:18: ',' formal_variable_param pass char_literal103=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_fpar3236) if self._state.backtracking == 0: stream_COMMA.add(char_literal103) self._state.following.append(self.FOLLOW_formal_variable_param_in_fpar3238) formal_variable_param104 = self.formal_variable_param() self._state.following.pop() if self._state.backtracking == 0: stream_formal_variable_param.add(formal_variable_param104.tree) else: break #loop37 # sdl92.g:310:17: ( end )? alt38 = 2 alt38 = self.dfa38.predict(self.input) if alt38 == 1: # sdl92.g:0:0: end pass self._state.following.append(self.FOLLOW_end_in_fpar3258) end105 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end105.tree) # AST Rewrite # elements: formal_variable_param, FPAR # 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() # 311:9: -> ^( FPAR ( formal_variable_param )+ ) # sdl92.g:311:17: ^( FPAR ( formal_variable_param )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_FPAR.nextNode(), root_1) # sdl92.g:311:24: ( formal_variable_param )+ if not (stream_formal_variable_param.hasNext()): raise RewriteEarlyExitException() while stream_formal_variable_param.hasNext(): self._adaptor.addChild(root_1, stream_formal_variable_param.nextTree()) stream_formal_variable_param.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, 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 "fpar" class formal_variable_param_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.formal_variable_param_return, self).__init__() self.tree = None # $ANTLR start "formal_variable_param" # sdl92.g:315:1: formal_variable_param : ( INOUT | IN | OUT )? variable_id ( ',' variable_id )* sort -> ^( PARAM ( INOUT )? ( IN )? ( OUT )? ( variable_id )+ sort ) ; def formal_variable_param(self, ): retval = self.formal_variable_param_return() retval.start = self.input.LT(1) root_0 = None INOUT106 = None IN107 = None OUT108 = None char_literal110 = None variable_id109 = None variable_id111 = None sort112 = None INOUT106_tree = None IN107_tree = None OUT108_tree = None char_literal110_tree = None stream_IN = RewriteRuleTokenStream(self._adaptor, "token IN") stream_OUT = RewriteRuleTokenStream(self._adaptor, "token OUT") stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_INOUT = RewriteRuleTokenStream(self._adaptor, "token INOUT") stream_sort = RewriteRuleSubtreeStream(self._adaptor, "rule sort") stream_variable_id = RewriteRuleSubtreeStream(self._adaptor, "rule variable_id") try: try: # sdl92.g:316:9: ( ( INOUT | IN | OUT )? variable_id ( ',' variable_id )* sort -> ^( PARAM ( INOUT )? ( IN )? ( OUT )? ( variable_id )+ sort ) ) # sdl92.g:316:17: ( INOUT | IN | OUT )? variable_id ( ',' variable_id )* sort pass # sdl92.g:316:17: ( INOUT | IN | OUT )? alt39 = 4 LA39 = self.input.LA(1) if LA39 == INOUT: alt39 = 1 elif LA39 == IN: alt39 = 2 elif LA39 == OUT: alt39 = 3 if alt39 == 1: # sdl92.g:316:18: INOUT pass INOUT106=self.match(self.input, INOUT, self.FOLLOW_INOUT_in_formal_variable_param3314) if self._state.backtracking == 0: stream_INOUT.add(INOUT106) elif alt39 == 2: # sdl92.g:316:26: IN pass IN107=self.match(self.input, IN, self.FOLLOW_IN_in_formal_variable_param3318) if self._state.backtracking == 0: stream_IN.add(IN107) elif alt39 == 3: # sdl92.g:316:31: OUT pass OUT108=self.match(self.input, OUT, self.FOLLOW_OUT_in_formal_variable_param3322) if self._state.backtracking == 0: stream_OUT.add(OUT108) self._state.following.append(self.FOLLOW_variable_id_in_formal_variable_param3342) variable_id109 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id109.tree) # sdl92.g:317:29: ( ',' variable_id )* while True: #loop40 alt40 = 2 LA40_0 = self.input.LA(1) if (LA40_0 == COMMA) : alt40 = 1 if alt40 == 1: # sdl92.g:317:30: ',' variable_id pass char_literal110=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_formal_variable_param3345) if self._state.backtracking == 0: stream_COMMA.add(char_literal110) self._state.following.append(self.FOLLOW_variable_id_in_formal_variable_param3347) variable_id111 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id111.tree) else: break #loop40 self._state.following.append(self.FOLLOW_sort_in_formal_variable_param3351) sort112 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort112.tree) # AST Rewrite # elements: sort, OUT, INOUT, IN, variable_id # 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() # 318:9: -> ^( PARAM ( INOUT )? ( IN )? ( OUT )? ( variable_id )+ sort ) # sdl92.g:318:17: ^( PARAM ( INOUT )? ( IN )? ( OUT )? ( variable_id )+ sort ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(PARAM, "PARAM"), root_1) # sdl92.g:318:25: ( INOUT )? if stream_INOUT.hasNext(): self._adaptor.addChild(root_1, stream_INOUT.nextNode()) stream_INOUT.reset(); # sdl92.g:318:32: ( IN )? if stream_IN.hasNext(): self._adaptor.addChild(root_1, stream_IN.nextNode()) stream_IN.reset(); # sdl92.g:318:36: ( OUT )? if stream_OUT.hasNext(): self._adaptor.addChild(root_1, stream_OUT.nextNode()) stream_OUT.reset(); # sdl92.g:318:41: ( variable_id )+ if not (stream_variable_id.hasNext()): raise RewriteEarlyExitException() while stream_variable_id.hasNext(): self._adaptor.addChild(root_1, stream_variable_id.nextTree()) stream_variable_id.reset() self._adaptor.addChild(root_1, stream_sort.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, 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 "formal_variable_param" class text_area_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.text_area_return, self).__init__() self.tree = None # $ANTLR start "text_area" # sdl92.g:323:1: text_area : cif ( content )? cif_end_text -> ^( TEXTAREA cif ( content )? cif_end_text ) ; def text_area(self, ): retval = self.text_area_return() retval.start = self.input.LT(1) root_0 = None cif113 = None content114 = None cif_end_text115 = None stream_content = RewriteRuleSubtreeStream(self._adaptor, "rule content") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_cif_end_text = RewriteRuleSubtreeStream(self._adaptor, "rule cif_end_text") try: try: # sdl92.g:324:9: ( cif ( content )? cif_end_text -> ^( TEXTAREA cif ( content )? cif_end_text ) ) # sdl92.g:324:17: cif ( content )? cif_end_text pass self._state.following.append(self.FOLLOW_cif_in_text_area3417) cif113 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif113.tree) # sdl92.g:325:17: ( content )? alt41 = 2 LA41_0 = self.input.LA(1) if (LA41_0 == 229) : LA41_1 = self.input.LA(2) if (self.synpred54_sdl92()) : alt41 = 1 elif (LA41_0 == DCL or LA41_0 == FPAR or LA41_0 == NEWTYPE or LA41_0 == PROCEDURE or LA41_0 == RETURNS or LA41_0 == SIGNAL or LA41_0 == SYNONYM or LA41_0 == SYNTYPE or LA41_0 == TIMER or LA41_0 == USE or LA41_0 == 224) : alt41 = 1 if alt41 == 1: # sdl92.g:0:0: content pass self._state.following.append(self.FOLLOW_content_in_text_area3435) content114 = self.content() self._state.following.pop() if self._state.backtracking == 0: stream_content.add(content114.tree) self._state.following.append(self.FOLLOW_cif_end_text_in_text_area3454) cif_end_text115 = self.cif_end_text() self._state.following.pop() if self._state.backtracking == 0: stream_cif_end_text.add(cif_end_text115.tree) # AST Rewrite # elements: content, cif_end_text, cif # 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() # 327:9: -> ^( TEXTAREA cif ( content )? cif_end_text ) # sdl92.g:327:17: ^( TEXTAREA cif ( content )? cif_end_text ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(TEXTAREA, "TEXTAREA"), root_1) self._adaptor.addChild(root_1, stream_cif.nextTree()) # sdl92.g:327:32: ( content )? if stream_content.hasNext(): self._adaptor.addChild(root_1, stream_content.nextTree()) stream_content.reset(); self._adaptor.addChild(root_1, stream_cif_end_text.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, 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 "text_area" class content_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.content_return, self).__init__() self.tree = None # $ANTLR start "content" # sdl92.g:333:1: content : ( procedure | use_clause | signal_declaration | fpar | res= procedure_result | timer_declaration | syntype_definition | newtype_definition | variable_definition | synonym_definition )* -> ^( TEXTAREA_CONTENT ( fpar )* ( $res)? ( procedure )* ( variable_definition )* ( syntype_definition )* ( newtype_definition )* ( timer_declaration )* ( signal_declaration )* ( use_clause )* ( synonym_definition )* ) ; def content(self, ): retval = self.content_return() retval.start = self.input.LT(1) root_0 = None res = None procedure116 = None use_clause117 = None signal_declaration118 = None fpar119 = None timer_declaration120 = None syntype_definition121 = None newtype_definition122 = None variable_definition123 = None synonym_definition124 = None stream_use_clause = RewriteRuleSubtreeStream(self._adaptor, "rule use_clause") stream_procedure_result = RewriteRuleSubtreeStream(self._adaptor, "rule procedure_result") stream_timer_declaration = RewriteRuleSubtreeStream(self._adaptor, "rule timer_declaration") stream_signal_declaration = RewriteRuleSubtreeStream(self._adaptor, "rule signal_declaration") stream_syntype_definition = RewriteRuleSubtreeStream(self._adaptor, "rule syntype_definition") stream_variable_definition = RewriteRuleSubtreeStream(self._adaptor, "rule variable_definition") stream_synonym_definition = RewriteRuleSubtreeStream(self._adaptor, "rule synonym_definition") stream_fpar = RewriteRuleSubtreeStream(self._adaptor, "rule fpar") stream_newtype_definition = RewriteRuleSubtreeStream(self._adaptor, "rule newtype_definition") stream_procedure = RewriteRuleSubtreeStream(self._adaptor, "rule procedure") try: try: # sdl92.g:334:9: ( ( procedure | use_clause | signal_declaration | fpar | res= procedure_result | timer_declaration | syntype_definition | newtype_definition | variable_definition | synonym_definition )* -> ^( TEXTAREA_CONTENT ( fpar )* ( $res)? ( procedure )* ( variable_definition )* ( syntype_definition )* ( newtype_definition )* ( timer_declaration )* ( signal_declaration )* ( use_clause )* ( synonym_definition )* ) ) # sdl92.g:334:18: ( procedure | use_clause | signal_declaration | fpar | res= procedure_result | timer_declaration | syntype_definition | newtype_definition | variable_definition | synonym_definition )* pass # sdl92.g:334:18: ( procedure | use_clause | signal_declaration | fpar | res= procedure_result | timer_declaration | syntype_definition | newtype_definition | variable_definition | synonym_definition )* while True: #loop42 alt42 = 11 alt42 = self.dfa42.predict(self.input) if alt42 == 1: # sdl92.g:334:19: procedure pass self._state.following.append(self.FOLLOW_procedure_in_content3516) procedure116 = self.procedure() self._state.following.pop() if self._state.backtracking == 0: stream_procedure.add(procedure116.tree) elif alt42 == 2: # sdl92.g:335:20: use_clause pass self._state.following.append(self.FOLLOW_use_clause_in_content3537) use_clause117 = self.use_clause() self._state.following.pop() if self._state.backtracking == 0: stream_use_clause.add(use_clause117.tree) elif alt42 == 3: # sdl92.g:336:20: signal_declaration pass self._state.following.append(self.FOLLOW_signal_declaration_in_content3558) signal_declaration118 = self.signal_declaration() self._state.following.pop() if self._state.backtracking == 0: stream_signal_declaration.add(signal_declaration118.tree) elif alt42 == 4: # sdl92.g:337:20: fpar pass self._state.following.append(self.FOLLOW_fpar_in_content3579) fpar119 = self.fpar() self._state.following.pop() if self._state.backtracking == 0: stream_fpar.add(fpar119.tree) elif alt42 == 5: # sdl92.g:338:20: res= procedure_result pass self._state.following.append(self.FOLLOW_procedure_result_in_content3602) res = self.procedure_result() self._state.following.pop() if self._state.backtracking == 0: stream_procedure_result.add(res.tree) elif alt42 == 6: # sdl92.g:339:20: timer_declaration pass self._state.following.append(self.FOLLOW_timer_declaration_in_content3623) timer_declaration120 = self.timer_declaration() self._state.following.pop() if self._state.backtracking == 0: stream_timer_declaration.add(timer_declaration120.tree) elif alt42 == 7: # sdl92.g:340:20: syntype_definition pass self._state.following.append(self.FOLLOW_syntype_definition_in_content3644) syntype_definition121 = self.syntype_definition() self._state.following.pop() if self._state.backtracking == 0: stream_syntype_definition.add(syntype_definition121.tree) elif alt42 == 8: # sdl92.g:341:20: newtype_definition pass self._state.following.append(self.FOLLOW_newtype_definition_in_content3665) newtype_definition122 = self.newtype_definition() self._state.following.pop() if self._state.backtracking == 0: stream_newtype_definition.add(newtype_definition122.tree) elif alt42 == 9: # sdl92.g:342:20: variable_definition pass self._state.following.append(self.FOLLOW_variable_definition_in_content3686) variable_definition123 = self.variable_definition() self._state.following.pop() if self._state.backtracking == 0: stream_variable_definition.add(variable_definition123.tree) elif alt42 == 10: # sdl92.g:343:20: synonym_definition pass self._state.following.append(self.FOLLOW_synonym_definition_in_content3707) synonym_definition124 = self.synonym_definition() self._state.following.pop() if self._state.backtracking == 0: stream_synonym_definition.add(synonym_definition124.tree) else: break #loop42 # AST Rewrite # elements: use_clause, synonym_definition, procedure, fpar, res, syntype_definition, variable_definition, newtype_definition, signal_declaration, timer_declaration # token labels: # rule labels: res, retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 if res is not None: stream_res = RewriteRuleSubtreeStream(self._adaptor, "rule res", res.tree) else: stream_res = RewriteRuleSubtreeStream(self._adaptor, "token res", 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() # 344:9: -> ^( TEXTAREA_CONTENT ( fpar )* ( $res)? ( procedure )* ( variable_definition )* ( syntype_definition )* ( newtype_definition )* ( timer_declaration )* ( signal_declaration )* ( use_clause )* ( synonym_definition )* ) # sdl92.g:344:18: ^( TEXTAREA_CONTENT ( fpar )* ( $res)? ( procedure )* ( variable_definition )* ( syntype_definition )* ( newtype_definition )* ( timer_declaration )* ( signal_declaration )* ( use_clause )* ( synonym_definition )* ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(TEXTAREA_CONTENT, "TEXTAREA_CONTENT"), root_1) # sdl92.g:344:37: ( fpar )* while stream_fpar.hasNext(): self._adaptor.addChild(root_1, stream_fpar.nextTree()) stream_fpar.reset(); # sdl92.g:344:43: ( $res)? if stream_res.hasNext(): self._adaptor.addChild(root_1, stream_res.nextTree()) stream_res.reset(); # sdl92.g:344:49: ( procedure )* while stream_procedure.hasNext(): self._adaptor.addChild(root_1, stream_procedure.nextTree()) stream_procedure.reset(); # sdl92.g:344:60: ( variable_definition )* while stream_variable_definition.hasNext(): self._adaptor.addChild(root_1, stream_variable_definition.nextTree()) stream_variable_definition.reset(); # sdl92.g:345:20: ( syntype_definition )* while stream_syntype_definition.hasNext(): self._adaptor.addChild(root_1, stream_syntype_definition.nextTree()) stream_syntype_definition.reset(); # sdl92.g:345:40: ( newtype_definition )* while stream_newtype_definition.hasNext(): self._adaptor.addChild(root_1, stream_newtype_definition.nextTree()) stream_newtype_definition.reset(); # sdl92.g:345:60: ( timer_declaration )* while stream_timer_declaration.hasNext(): self._adaptor.addChild(root_1, stream_timer_declaration.nextTree()) stream_timer_declaration.reset(); # sdl92.g:346:20: ( signal_declaration )* while stream_signal_declaration.hasNext(): self._adaptor.addChild(root_1, stream_signal_declaration.nextTree()) stream_signal_declaration.reset(); # sdl92.g:346:40: ( use_clause )* while stream_use_clause.hasNext(): self._adaptor.addChild(root_1, stream_use_clause.nextTree()) stream_use_clause.reset(); # sdl92.g:346:52: ( synonym_definition )* while stream_synonym_definition.hasNext(): self._adaptor.addChild(root_1, stream_synonym_definition.nextTree()) stream_synonym_definition.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, 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 "content" class timer_declaration_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.timer_declaration_return, self).__init__() self.tree = None # $ANTLR start "timer_declaration" # sdl92.g:350:1: timer_declaration : TIMER timer_id ( ',' timer_id )* end -> ^( TIMER ( timer_id )+ ) ; def timer_declaration(self, ): retval = self.timer_declaration_return() retval.start = self.input.LT(1) root_0 = None TIMER125 = None char_literal127 = None timer_id126 = None timer_id128 = None end129 = None TIMER125_tree = None char_literal127_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_TIMER = RewriteRuleTokenStream(self._adaptor, "token TIMER") stream_timer_id = RewriteRuleSubtreeStream(self._adaptor, "rule timer_id") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:351:9: ( TIMER timer_id ( ',' timer_id )* end -> ^( TIMER ( timer_id )+ ) ) # sdl92.g:351:17: TIMER timer_id ( ',' timer_id )* end pass TIMER125=self.match(self.input, TIMER, self.FOLLOW_TIMER_in_timer_declaration3830) if self._state.backtracking == 0: stream_TIMER.add(TIMER125) self._state.following.append(self.FOLLOW_timer_id_in_timer_declaration3832) timer_id126 = self.timer_id() self._state.following.pop() if self._state.backtracking == 0: stream_timer_id.add(timer_id126.tree) # sdl92.g:352:17: ( ',' timer_id )* while True: #loop43 alt43 = 2 LA43_0 = self.input.LA(1) if (LA43_0 == COMMA) : alt43 = 1 if alt43 == 1: # sdl92.g:352:18: ',' timer_id pass char_literal127=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_timer_declaration3851) if self._state.backtracking == 0: stream_COMMA.add(char_literal127) self._state.following.append(self.FOLLOW_timer_id_in_timer_declaration3853) timer_id128 = self.timer_id() self._state.following.pop() if self._state.backtracking == 0: stream_timer_id.add(timer_id128.tree) else: break #loop43 self._state.following.append(self.FOLLOW_end_in_timer_declaration3873) end129 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end129.tree) # AST Rewrite # elements: TIMER, timer_id # 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() # 354:9: -> ^( TIMER ( timer_id )+ ) # sdl92.g:354:17: ^( TIMER ( timer_id )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_TIMER.nextNode(), root_1) # sdl92.g:354:25: ( timer_id )+ if not (stream_timer_id.hasNext()): raise RewriteEarlyExitException() while stream_timer_id.hasNext(): self._adaptor.addChild(root_1, stream_timer_id.nextTree()) stream_timer_id.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, 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 "timer_declaration" class syntype_definition_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.syntype_definition_return, self).__init__() self.tree = None # $ANTLR start "syntype_definition" # sdl92.g:358:1: syntype_definition : SYNTYPE syntype_name '=' parent_sort ( CONSTANTS ( range_condition ( ',' range_condition )* ) )? ENDSYNTYPE ( syntype_name )? end -> ^( SYNTYPE syntype_name parent_sort ( range_condition )* ) ; def syntype_definition(self, ): retval = self.syntype_definition_return() retval.start = self.input.LT(1) root_0 = None SYNTYPE130 = None char_literal132 = None CONSTANTS134 = None char_literal136 = None ENDSYNTYPE138 = None syntype_name131 = None parent_sort133 = None range_condition135 = None range_condition137 = None syntype_name139 = None end140 = None SYNTYPE130_tree = None char_literal132_tree = None CONSTANTS134_tree = None char_literal136_tree = None ENDSYNTYPE138_tree = None stream_CONSTANTS = RewriteRuleTokenStream(self._adaptor, "token CONSTANTS") stream_EQ = RewriteRuleTokenStream(self._adaptor, "token EQ") stream_SYNTYPE = RewriteRuleTokenStream(self._adaptor, "token SYNTYPE") stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_ENDSYNTYPE = RewriteRuleTokenStream(self._adaptor, "token ENDSYNTYPE") stream_syntype_name = RewriteRuleSubtreeStream(self._adaptor, "rule syntype_name") stream_parent_sort = RewriteRuleSubtreeStream(self._adaptor, "rule parent_sort") stream_range_condition = RewriteRuleSubtreeStream(self._adaptor, "rule range_condition") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:359:9: ( SYNTYPE syntype_name '=' parent_sort ( CONSTANTS ( range_condition ( ',' range_condition )* ) )? ENDSYNTYPE ( syntype_name )? end -> ^( SYNTYPE syntype_name parent_sort ( range_condition )* ) ) # sdl92.g:359:17: SYNTYPE syntype_name '=' parent_sort ( CONSTANTS ( range_condition ( ',' range_condition )* ) )? ENDSYNTYPE ( syntype_name )? end pass SYNTYPE130=self.match(self.input, SYNTYPE, self.FOLLOW_SYNTYPE_in_syntype_definition3927) if self._state.backtracking == 0: stream_SYNTYPE.add(SYNTYPE130) self._state.following.append(self.FOLLOW_syntype_name_in_syntype_definition3929) syntype_name131 = self.syntype_name() self._state.following.pop() if self._state.backtracking == 0: stream_syntype_name.add(syntype_name131.tree) char_literal132=self.match(self.input, EQ, self.FOLLOW_EQ_in_syntype_definition3931) if self._state.backtracking == 0: stream_EQ.add(char_literal132) self._state.following.append(self.FOLLOW_parent_sort_in_syntype_definition3933) parent_sort133 = self.parent_sort() self._state.following.pop() if self._state.backtracking == 0: stream_parent_sort.add(parent_sort133.tree) # sdl92.g:360:17: ( CONSTANTS ( range_condition ( ',' range_condition )* ) )? alt45 = 2 LA45_0 = self.input.LA(1) if (LA45_0 == CONSTANTS) : alt45 = 1 if alt45 == 1: # sdl92.g:360:18: CONSTANTS ( range_condition ( ',' range_condition )* ) pass CONSTANTS134=self.match(self.input, CONSTANTS, self.FOLLOW_CONSTANTS_in_syntype_definition3952) if self._state.backtracking == 0: stream_CONSTANTS.add(CONSTANTS134) # sdl92.g:360:28: ( range_condition ( ',' range_condition )* ) # sdl92.g:360:29: range_condition ( ',' range_condition )* pass self._state.following.append(self.FOLLOW_range_condition_in_syntype_definition3955) range_condition135 = self.range_condition() self._state.following.pop() if self._state.backtracking == 0: stream_range_condition.add(range_condition135.tree) # sdl92.g:360:45: ( ',' range_condition )* while True: #loop44 alt44 = 2 LA44_0 = self.input.LA(1) if (LA44_0 == COMMA) : alt44 = 1 if alt44 == 1: # sdl92.g:360:46: ',' range_condition pass char_literal136=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_syntype_definition3958) if self._state.backtracking == 0: stream_COMMA.add(char_literal136) self._state.following.append(self.FOLLOW_range_condition_in_syntype_definition3960) range_condition137 = self.range_condition() self._state.following.pop() if self._state.backtracking == 0: stream_range_condition.add(range_condition137.tree) else: break #loop44 ENDSYNTYPE138=self.match(self.input, ENDSYNTYPE, self.FOLLOW_ENDSYNTYPE_in_syntype_definition3984) if self._state.backtracking == 0: stream_ENDSYNTYPE.add(ENDSYNTYPE138) # sdl92.g:361:28: ( syntype_name )? alt46 = 2 LA46_0 = self.input.LA(1) if (LA46_0 == ID) : alt46 = 1 if alt46 == 1: # sdl92.g:0:0: syntype_name pass self._state.following.append(self.FOLLOW_syntype_name_in_syntype_definition3986) syntype_name139 = self.syntype_name() self._state.following.pop() if self._state.backtracking == 0: stream_syntype_name.add(syntype_name139.tree) self._state.following.append(self.FOLLOW_end_in_syntype_definition3989) end140 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end140.tree) # AST Rewrite # elements: parent_sort, syntype_name, SYNTYPE, range_condition # 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() # 362:9: -> ^( SYNTYPE syntype_name parent_sort ( range_condition )* ) # sdl92.g:362:17: ^( SYNTYPE syntype_name parent_sort ( range_condition )* ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_SYNTYPE.nextNode(), root_1) self._adaptor.addChild(root_1, stream_syntype_name.nextTree()) self._adaptor.addChild(root_1, stream_parent_sort.nextTree()) # sdl92.g:362:52: ( range_condition )* while stream_range_condition.hasNext(): self._adaptor.addChild(root_1, stream_range_condition.nextTree()) stream_range_condition.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, 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 "syntype_definition" class syntype_name_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.syntype_name_return, self).__init__() self.tree = None # $ANTLR start "syntype_name" # sdl92.g:366:1: syntype_name : sort ; def syntype_name(self, ): retval = self.syntype_name_return() retval.start = self.input.LT(1) root_0 = None sort141 = None try: try: # sdl92.g:367:9: ( sort ) # sdl92.g:367:17: sort pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_sort_in_syntype_name4047) sort141 = self.sort() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, sort141.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, 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 "syntype_name" class parent_sort_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.parent_sort_return, self).__init__() self.tree = None # $ANTLR start "parent_sort" # sdl92.g:371:1: parent_sort : sort ; def parent_sort(self, ): retval = self.parent_sort_return() retval.start = self.input.LT(1) root_0 = None sort142 = None try: try: # sdl92.g:372:9: ( sort ) # sdl92.g:372:17: sort pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_sort_in_parent_sort4079) sort142 = self.sort() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, sort142.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, 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 "parent_sort" class newtype_definition_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.newtype_definition_return, self).__init__() self.tree = None # $ANTLR start "newtype_definition" # sdl92.g:376:1: newtype_definition : NEWTYPE type_name ( array_definition | structure_definition )? ENDNEWTYPE ( type_name )? end -> ^( NEWTYPE type_name ( array_definition )* ( structure_definition )* ) ; def newtype_definition(self, ): retval = self.newtype_definition_return() retval.start = self.input.LT(1) root_0 = None NEWTYPE143 = None ENDNEWTYPE147 = None type_name144 = None array_definition145 = None structure_definition146 = None type_name148 = None end149 = None NEWTYPE143_tree = None ENDNEWTYPE147_tree = None stream_NEWTYPE = RewriteRuleTokenStream(self._adaptor, "token NEWTYPE") stream_ENDNEWTYPE = RewriteRuleTokenStream(self._adaptor, "token ENDNEWTYPE") stream_structure_definition = RewriteRuleSubtreeStream(self._adaptor, "rule structure_definition") stream_type_name = RewriteRuleSubtreeStream(self._adaptor, "rule type_name") stream_array_definition = RewriteRuleSubtreeStream(self._adaptor, "rule array_definition") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:377:9: ( NEWTYPE type_name ( array_definition | structure_definition )? ENDNEWTYPE ( type_name )? end -> ^( NEWTYPE type_name ( array_definition )* ( structure_definition )* ) ) # sdl92.g:377:17: NEWTYPE type_name ( array_definition | structure_definition )? ENDNEWTYPE ( type_name )? end pass NEWTYPE143=self.match(self.input, NEWTYPE, self.FOLLOW_NEWTYPE_in_newtype_definition4111) if self._state.backtracking == 0: stream_NEWTYPE.add(NEWTYPE143) self._state.following.append(self.FOLLOW_type_name_in_newtype_definition4113) type_name144 = self.type_name() self._state.following.pop() if self._state.backtracking == 0: stream_type_name.add(type_name144.tree) # sdl92.g:377:35: ( array_definition | structure_definition )? alt47 = 3 LA47_0 = self.input.LA(1) if (LA47_0 == ARRAY) : alt47 = 1 elif (LA47_0 == STRUCT) : alt47 = 2 if alt47 == 1: # sdl92.g:377:36: array_definition pass self._state.following.append(self.FOLLOW_array_definition_in_newtype_definition4116) array_definition145 = self.array_definition() self._state.following.pop() if self._state.backtracking == 0: stream_array_definition.add(array_definition145.tree) elif alt47 == 2: # sdl92.g:377:53: structure_definition pass self._state.following.append(self.FOLLOW_structure_definition_in_newtype_definition4118) structure_definition146 = self.structure_definition() self._state.following.pop() if self._state.backtracking == 0: stream_structure_definition.add(structure_definition146.tree) ENDNEWTYPE147=self.match(self.input, ENDNEWTYPE, self.FOLLOW_ENDNEWTYPE_in_newtype_definition4138) if self._state.backtracking == 0: stream_ENDNEWTYPE.add(ENDNEWTYPE147) # sdl92.g:378:28: ( type_name )? alt48 = 2 LA48_0 = self.input.LA(1) if (LA48_0 == ID) : alt48 = 1 if alt48 == 1: # sdl92.g:0:0: type_name pass self._state.following.append(self.FOLLOW_type_name_in_newtype_definition4140) type_name148 = self.type_name() self._state.following.pop() if self._state.backtracking == 0: stream_type_name.add(type_name148.tree) self._state.following.append(self.FOLLOW_end_in_newtype_definition4143) end149 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end149.tree) # AST Rewrite # elements: NEWTYPE, structure_definition, array_definition, type_name # 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() # 379:9: -> ^( NEWTYPE type_name ( array_definition )* ( structure_definition )* ) # sdl92.g:379:17: ^( NEWTYPE type_name ( array_definition )* ( structure_definition )* ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_NEWTYPE.nextNode(), root_1) self._adaptor.addChild(root_1, stream_type_name.nextTree()) # sdl92.g:379:37: ( array_definition )* while stream_array_definition.hasNext(): self._adaptor.addChild(root_1, stream_array_definition.nextTree()) stream_array_definition.reset(); # sdl92.g:379:55: ( structure_definition )* while stream_structure_definition.hasNext(): self._adaptor.addChild(root_1, stream_structure_definition.nextTree()) stream_structure_definition.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, 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 "newtype_definition" class type_name_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.type_name_return, self).__init__() self.tree = None # $ANTLR start "type_name" # sdl92.g:383:1: type_name : sort ; def type_name(self, ): retval = self.type_name_return() retval.start = self.input.LT(1) root_0 = None sort150 = None try: try: # sdl92.g:384:9: ( sort ) # sdl92.g:384:17: sort pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_sort_in_type_name4202) sort150 = self.sort() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, sort150.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, 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 "type_name" class array_definition_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.array_definition_return, self).__init__() self.tree = None # $ANTLR start "array_definition" # sdl92.g:388:1: array_definition : ARRAY '(' sort ',' sort ')' -> ^( ARRAY sort sort ) ; def array_definition(self, ): retval = self.array_definition_return() retval.start = self.input.LT(1) root_0 = None ARRAY151 = None char_literal152 = None char_literal154 = None char_literal156 = None sort153 = None sort155 = None ARRAY151_tree = None char_literal152_tree = None char_literal154_tree = None char_literal156_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_ARRAY = RewriteRuleTokenStream(self._adaptor, "token ARRAY") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_sort = RewriteRuleSubtreeStream(self._adaptor, "rule sort") try: try: # sdl92.g:389:9: ( ARRAY '(' sort ',' sort ')' -> ^( ARRAY sort sort ) ) # sdl92.g:389:17: ARRAY '(' sort ',' sort ')' pass ARRAY151=self.match(self.input, ARRAY, self.FOLLOW_ARRAY_in_array_definition4234) if self._state.backtracking == 0: stream_ARRAY.add(ARRAY151) char_literal152=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_array_definition4236) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal152) self._state.following.append(self.FOLLOW_sort_in_array_definition4238) sort153 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort153.tree) char_literal154=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_array_definition4240) if self._state.backtracking == 0: stream_COMMA.add(char_literal154) self._state.following.append(self.FOLLOW_sort_in_array_definition4242) sort155 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort155.tree) char_literal156=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_array_definition4244) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal156) # AST Rewrite # elements: ARRAY, sort, sort # 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() # 390:9: -> ^( ARRAY sort sort ) # sdl92.g:390:17: ^( ARRAY sort sort ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_ARRAY.nextNode(), root_1) self._adaptor.addChild(root_1, stream_sort.nextTree()) self._adaptor.addChild(root_1, stream_sort.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, 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 "array_definition" class structure_definition_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.structure_definition_return, self).__init__() self.tree = None # $ANTLR start "structure_definition" # sdl92.g:394:1: structure_definition : STRUCT field_list end -> ^( STRUCT field_list ) ; def structure_definition(self, ): retval = self.structure_definition_return() retval.start = self.input.LT(1) root_0 = None STRUCT157 = None field_list158 = None end159 = None STRUCT157_tree = None stream_STRUCT = RewriteRuleTokenStream(self._adaptor, "token STRUCT") stream_field_list = RewriteRuleSubtreeStream(self._adaptor, "rule field_list") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:395:9: ( STRUCT field_list end -> ^( STRUCT field_list ) ) # sdl92.g:395:17: STRUCT field_list end pass STRUCT157=self.match(self.input, STRUCT, self.FOLLOW_STRUCT_in_structure_definition4299) if self._state.backtracking == 0: stream_STRUCT.add(STRUCT157) self._state.following.append(self.FOLLOW_field_list_in_structure_definition4301) field_list158 = self.field_list() self._state.following.pop() if self._state.backtracking == 0: stream_field_list.add(field_list158.tree) self._state.following.append(self.FOLLOW_end_in_structure_definition4303) end159 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end159.tree) # AST Rewrite # elements: STRUCT, field_list # 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() # 396:9: -> ^( STRUCT field_list ) # sdl92.g:396:17: ^( STRUCT field_list ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_STRUCT.nextNode(), root_1) self._adaptor.addChild(root_1, stream_field_list.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, 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 "structure_definition" class field_list_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.field_list_return, self).__init__() self.tree = None # $ANTLR start "field_list" # sdl92.g:400:1: field_list : field_definition ( end field_definition )* -> ^( FIELDS ( field_definition )+ ) ; def field_list(self, ): retval = self.field_list_return() retval.start = self.input.LT(1) root_0 = None field_definition160 = None end161 = None field_definition162 = None stream_field_definition = RewriteRuleSubtreeStream(self._adaptor, "rule field_definition") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:401:9: ( field_definition ( end field_definition )* -> ^( FIELDS ( field_definition )+ ) ) # sdl92.g:401:17: field_definition ( end field_definition )* pass self._state.following.append(self.FOLLOW_field_definition_in_field_list4356) field_definition160 = self.field_definition() self._state.following.pop() if self._state.backtracking == 0: stream_field_definition.add(field_definition160.tree) # sdl92.g:401:34: ( end field_definition )* while True: #loop49 alt49 = 2 alt49 = self.dfa49.predict(self.input) if alt49 == 1: # sdl92.g:401:35: end field_definition pass self._state.following.append(self.FOLLOW_end_in_field_list4359) end161 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end161.tree) self._state.following.append(self.FOLLOW_field_definition_in_field_list4361) field_definition162 = self.field_definition() self._state.following.pop() if self._state.backtracking == 0: stream_field_definition.add(field_definition162.tree) else: break #loop49 # AST Rewrite # elements: field_definition # 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() # 402:9: -> ^( FIELDS ( field_definition )+ ) # sdl92.g:402:17: ^( FIELDS ( field_definition )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(FIELDS, "FIELDS"), root_1) # sdl92.g:402:26: ( field_definition )+ if not (stream_field_definition.hasNext()): raise RewriteEarlyExitException() while stream_field_definition.hasNext(): self._adaptor.addChild(root_1, stream_field_definition.nextTree()) stream_field_definition.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, 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 "field_list" class field_definition_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.field_definition_return, self).__init__() self.tree = None # $ANTLR start "field_definition" # sdl92.g:406:1: field_definition : field_name ( ',' field_name )* sort -> ^( FIELD ( field_name )+ sort ) ; def field_definition(self, ): retval = self.field_definition_return() retval.start = self.input.LT(1) root_0 = None char_literal164 = None field_name163 = None field_name165 = None sort166 = None char_literal164_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_field_name = RewriteRuleSubtreeStream(self._adaptor, "rule field_name") stream_sort = RewriteRuleSubtreeStream(self._adaptor, "rule sort") try: try: # sdl92.g:407:9: ( field_name ( ',' field_name )* sort -> ^( FIELD ( field_name )+ sort ) ) # sdl92.g:407:17: field_name ( ',' field_name )* sort pass self._state.following.append(self.FOLLOW_field_name_in_field_definition4417) field_name163 = self.field_name() self._state.following.pop() if self._state.backtracking == 0: stream_field_name.add(field_name163.tree) # sdl92.g:407:28: ( ',' field_name )* while True: #loop50 alt50 = 2 LA50_0 = self.input.LA(1) if (LA50_0 == COMMA) : alt50 = 1 if alt50 == 1: # sdl92.g:407:29: ',' field_name pass char_literal164=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_field_definition4420) if self._state.backtracking == 0: stream_COMMA.add(char_literal164) self._state.following.append(self.FOLLOW_field_name_in_field_definition4422) field_name165 = self.field_name() self._state.following.pop() if self._state.backtracking == 0: stream_field_name.add(field_name165.tree) else: break #loop50 self._state.following.append(self.FOLLOW_sort_in_field_definition4426) sort166 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort166.tree) # AST Rewrite # elements: sort, field_name # 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() # 408:9: -> ^( FIELD ( field_name )+ sort ) # sdl92.g:408:17: ^( FIELD ( field_name )+ sort ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(FIELD, "FIELD"), root_1) # sdl92.g:408:25: ( field_name )+ if not (stream_field_name.hasNext()): raise RewriteEarlyExitException() while stream_field_name.hasNext(): self._adaptor.addChild(root_1, stream_field_name.nextTree()) stream_field_name.reset() self._adaptor.addChild(root_1, stream_sort.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, 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 "field_definition" class variable_definition_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.variable_definition_return, self).__init__() self.tree = None # $ANTLR start "variable_definition" # sdl92.g:412:1: variable_definition : DCL variables_of_sort ( ',' variables_of_sort )* end -> ^( DCL ( variables_of_sort )+ ) ; def variable_definition(self, ): retval = self.variable_definition_return() retval.start = self.input.LT(1) root_0 = None DCL167 = None char_literal169 = None variables_of_sort168 = None variables_of_sort170 = None end171 = None DCL167_tree = None char_literal169_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_DCL = RewriteRuleTokenStream(self._adaptor, "token DCL") stream_variables_of_sort = RewriteRuleSubtreeStream(self._adaptor, "rule variables_of_sort") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:413:9: ( DCL variables_of_sort ( ',' variables_of_sort )* end -> ^( DCL ( variables_of_sort )+ ) ) # sdl92.g:413:17: DCL variables_of_sort ( ',' variables_of_sort )* end pass DCL167=self.match(self.input, DCL, self.FOLLOW_DCL_in_variable_definition4482) if self._state.backtracking == 0: stream_DCL.add(DCL167) self._state.following.append(self.FOLLOW_variables_of_sort_in_variable_definition4484) variables_of_sort168 = self.variables_of_sort() self._state.following.pop() if self._state.backtracking == 0: stream_variables_of_sort.add(variables_of_sort168.tree) # sdl92.g:414:17: ( ',' variables_of_sort )* while True: #loop51 alt51 = 2 LA51_0 = self.input.LA(1) if (LA51_0 == COMMA) : alt51 = 1 if alt51 == 1: # sdl92.g:414:18: ',' variables_of_sort pass char_literal169=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_variable_definition4503) if self._state.backtracking == 0: stream_COMMA.add(char_literal169) self._state.following.append(self.FOLLOW_variables_of_sort_in_variable_definition4505) variables_of_sort170 = self.variables_of_sort() self._state.following.pop() if self._state.backtracking == 0: stream_variables_of_sort.add(variables_of_sort170.tree) else: break #loop51 self._state.following.append(self.FOLLOW_end_in_variable_definition4525) end171 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end171.tree) # AST Rewrite # elements: variables_of_sort, DCL # 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() # 416:9: -> ^( DCL ( variables_of_sort )+ ) # sdl92.g:416:17: ^( DCL ( variables_of_sort )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_DCL.nextNode(), root_1) # sdl92.g:416:23: ( variables_of_sort )+ if not (stream_variables_of_sort.hasNext()): raise RewriteEarlyExitException() while stream_variables_of_sort.hasNext(): self._adaptor.addChild(root_1, stream_variables_of_sort.nextTree()) stream_variables_of_sort.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, 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 "variable_definition" class synonym_definition_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.synonym_definition_return, self).__init__() self.tree = None # $ANTLR start "synonym_definition" # sdl92.g:420:1: synonym_definition : internal_synonym_definition ; def synonym_definition(self, ): retval = self.synonym_definition_return() retval.start = self.input.LT(1) root_0 = None internal_synonym_definition172 = None try: try: # sdl92.g:421:9: ( internal_synonym_definition ) # sdl92.g:421:17: internal_synonym_definition pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_internal_synonym_definition_in_synonym_definition4579) internal_synonym_definition172 = self.internal_synonym_definition() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, internal_synonym_definition172.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, 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 "synonym_definition" class internal_synonym_definition_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.internal_synonym_definition_return, self).__init__() self.tree = None # $ANTLR start "internal_synonym_definition" # sdl92.g:425:1: internal_synonym_definition : SYNONYM synonym_definition_item ( ',' synonym_definition_item )* end -> ^( SYNONYM_LIST ( synonym_definition_item )+ ) ; def internal_synonym_definition(self, ): retval = self.internal_synonym_definition_return() retval.start = self.input.LT(1) root_0 = None SYNONYM173 = None char_literal175 = None synonym_definition_item174 = None synonym_definition_item176 = None end177 = None SYNONYM173_tree = None char_literal175_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_SYNONYM = RewriteRuleTokenStream(self._adaptor, "token SYNONYM") stream_synonym_definition_item = RewriteRuleSubtreeStream(self._adaptor, "rule synonym_definition_item") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:426:9: ( SYNONYM synonym_definition_item ( ',' synonym_definition_item )* end -> ^( SYNONYM_LIST ( synonym_definition_item )+ ) ) # sdl92.g:426:17: SYNONYM synonym_definition_item ( ',' synonym_definition_item )* end pass SYNONYM173=self.match(self.input, SYNONYM, self.FOLLOW_SYNONYM_in_internal_synonym_definition4611) if self._state.backtracking == 0: stream_SYNONYM.add(SYNONYM173) self._state.following.append(self.FOLLOW_synonym_definition_item_in_internal_synonym_definition4613) synonym_definition_item174 = self.synonym_definition_item() self._state.following.pop() if self._state.backtracking == 0: stream_synonym_definition_item.add(synonym_definition_item174.tree) # sdl92.g:426:49: ( ',' synonym_definition_item )* while True: #loop52 alt52 = 2 LA52_0 = self.input.LA(1) if (LA52_0 == COMMA) : alt52 = 1 if alt52 == 1: # sdl92.g:426:50: ',' synonym_definition_item pass char_literal175=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_internal_synonym_definition4616) if self._state.backtracking == 0: stream_COMMA.add(char_literal175) self._state.following.append(self.FOLLOW_synonym_definition_item_in_internal_synonym_definition4618) synonym_definition_item176 = self.synonym_definition_item() self._state.following.pop() if self._state.backtracking == 0: stream_synonym_definition_item.add(synonym_definition_item176.tree) else: break #loop52 self._state.following.append(self.FOLLOW_end_in_internal_synonym_definition4638) end177 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end177.tree) # AST Rewrite # elements: synonym_definition_item # 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() # 428:9: -> ^( SYNONYM_LIST ( synonym_definition_item )+ ) # sdl92.g:428:17: ^( SYNONYM_LIST ( synonym_definition_item )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(SYNONYM_LIST, "SYNONYM_LIST"), root_1) # sdl92.g:428:32: ( synonym_definition_item )+ if not (stream_synonym_definition_item.hasNext()): raise RewriteEarlyExitException() while stream_synonym_definition_item.hasNext(): self._adaptor.addChild(root_1, stream_synonym_definition_item.nextTree()) stream_synonym_definition_item.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, 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 "internal_synonym_definition" class synonym_definition_item_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.synonym_definition_item_return, self).__init__() self.tree = None # $ANTLR start "synonym_definition_item" # sdl92.g:432:1: synonym_definition_item : sort sort '=' ground_expression -> ^( SYNONYM sort sort ground_expression ) ; def synonym_definition_item(self, ): retval = self.synonym_definition_item_return() retval.start = self.input.LT(1) root_0 = None char_literal180 = None sort178 = None sort179 = None ground_expression181 = None char_literal180_tree = None stream_EQ = RewriteRuleTokenStream(self._adaptor, "token EQ") stream_sort = RewriteRuleSubtreeStream(self._adaptor, "rule sort") stream_ground_expression = RewriteRuleSubtreeStream(self._adaptor, "rule ground_expression") try: try: # sdl92.g:433:9: ( sort sort '=' ground_expression -> ^( SYNONYM sort sort ground_expression ) ) # sdl92.g:433:17: sort sort '=' ground_expression pass self._state.following.append(self.FOLLOW_sort_in_synonym_definition_item4692) sort178 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort178.tree) self._state.following.append(self.FOLLOW_sort_in_synonym_definition_item4694) sort179 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort179.tree) char_literal180=self.match(self.input, EQ, self.FOLLOW_EQ_in_synonym_definition_item4696) if self._state.backtracking == 0: stream_EQ.add(char_literal180) self._state.following.append(self.FOLLOW_ground_expression_in_synonym_definition_item4698) ground_expression181 = self.ground_expression() self._state.following.pop() if self._state.backtracking == 0: stream_ground_expression.add(ground_expression181.tree) # AST Rewrite # elements: sort, ground_expression, sort # 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() # 434:9: -> ^( SYNONYM sort sort ground_expression ) # sdl92.g:434:17: ^( SYNONYM sort sort ground_expression ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(SYNONYM, "SYNONYM"), root_1) self._adaptor.addChild(root_1, stream_sort.nextTree()) self._adaptor.addChild(root_1, stream_sort.nextTree()) self._adaptor.addChild(root_1, stream_ground_expression.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, 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 "synonym_definition_item" class variables_of_sort_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.variables_of_sort_return, self).__init__() self.tree = None # $ANTLR start "variables_of_sort" # sdl92.g:438:1: variables_of_sort : variable_id ( ',' variable_id )* sort ( ':=' ground_expression )? -> ^( VARIABLES ( variable_id )+ sort ( ground_expression )? ) ; def variables_of_sort(self, ): retval = self.variables_of_sort_return() retval.start = self.input.LT(1) root_0 = None char_literal183 = None string_literal186 = None variable_id182 = None variable_id184 = None sort185 = None ground_expression187 = None char_literal183_tree = None string_literal186_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_ASSIG_OP = RewriteRuleTokenStream(self._adaptor, "token ASSIG_OP") stream_sort = RewriteRuleSubtreeStream(self._adaptor, "rule sort") stream_ground_expression = RewriteRuleSubtreeStream(self._adaptor, "rule ground_expression") stream_variable_id = RewriteRuleSubtreeStream(self._adaptor, "rule variable_id") try: try: # sdl92.g:439:9: ( variable_id ( ',' variable_id )* sort ( ':=' ground_expression )? -> ^( VARIABLES ( variable_id )+ sort ( ground_expression )? ) ) # sdl92.g:439:17: variable_id ( ',' variable_id )* sort ( ':=' ground_expression )? pass self._state.following.append(self.FOLLOW_variable_id_in_variables_of_sort4755) variable_id182 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id182.tree) # sdl92.g:439:29: ( ',' variable_id )* while True: #loop53 alt53 = 2 LA53_0 = self.input.LA(1) if (LA53_0 == COMMA) : alt53 = 1 if alt53 == 1: # sdl92.g:439:30: ',' variable_id pass char_literal183=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_variables_of_sort4758) if self._state.backtracking == 0: stream_COMMA.add(char_literal183) self._state.following.append(self.FOLLOW_variable_id_in_variables_of_sort4760) variable_id184 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id184.tree) else: break #loop53 self._state.following.append(self.FOLLOW_sort_in_variables_of_sort4764) sort185 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort185.tree) # sdl92.g:439:53: ( ':=' ground_expression )? alt54 = 2 LA54_0 = self.input.LA(1) if (LA54_0 == ASSIG_OP) : alt54 = 1 if alt54 == 1: # sdl92.g:439:54: ':=' ground_expression pass string_literal186=self.match(self.input, ASSIG_OP, self.FOLLOW_ASSIG_OP_in_variables_of_sort4767) if self._state.backtracking == 0: stream_ASSIG_OP.add(string_literal186) self._state.following.append(self.FOLLOW_ground_expression_in_variables_of_sort4769) ground_expression187 = self.ground_expression() self._state.following.pop() if self._state.backtracking == 0: stream_ground_expression.add(ground_expression187.tree) # AST Rewrite # elements: sort, ground_expression, variable_id # 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() # 440:9: -> ^( VARIABLES ( variable_id )+ sort ( ground_expression )? ) # sdl92.g:440:17: ^( VARIABLES ( variable_id )+ sort ( ground_expression )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(VARIABLES, "VARIABLES"), root_1) # sdl92.g:440:29: ( variable_id )+ if not (stream_variable_id.hasNext()): raise RewriteEarlyExitException() while stream_variable_id.hasNext(): self._adaptor.addChild(root_1, stream_variable_id.nextTree()) stream_variable_id.reset() self._adaptor.addChild(root_1, stream_sort.nextTree()) # sdl92.g:440:47: ( ground_expression )? if stream_ground_expression.hasNext(): self._adaptor.addChild(root_1, stream_ground_expression.nextTree()) stream_ground_expression.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, 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 "variables_of_sort" class ground_expression_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.ground_expression_return, self).__init__() self.tree = None # $ANTLR start "ground_expression" # sdl92.g:444:1: ground_expression : expression -> ^( GROUND expression ) ; def ground_expression(self, ): retval = self.ground_expression_return() retval.start = self.input.LT(1) root_0 = None expression188 = None stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:445:9: ( expression -> ^( GROUND expression ) ) # sdl92.g:445:17: expression pass self._state.following.append(self.FOLLOW_expression_in_ground_expression4830) expression188 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression188.tree) # AST Rewrite # elements: expression # 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() # 446:9: -> ^( GROUND expression ) # sdl92.g:446:17: ^( GROUND expression ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(GROUND, "GROUND"), root_1) self._adaptor.addChild(root_1, stream_expression.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, 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 "ground_expression" class number_of_instances_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.number_of_instances_return, self).__init__() self.tree = None # $ANTLR start "number_of_instances" # sdl92.g:450:1: number_of_instances : '(' initial_number= INT ',' maximum_number= INT ')' -> ^( NUMBER_OF_INSTANCES $initial_number $maximum_number) ; def number_of_instances(self, ): retval = self.number_of_instances_return() retval.start = self.input.LT(1) root_0 = None initial_number = None maximum_number = None char_literal189 = None char_literal190 = None char_literal191 = None initial_number_tree = None maximum_number_tree = None char_literal189_tree = None char_literal190_tree = None char_literal191_tree = None stream_INT = RewriteRuleTokenStream(self._adaptor, "token INT") stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") try: try: # sdl92.g:451:9: ( '(' initial_number= INT ',' maximum_number= INT ')' -> ^( NUMBER_OF_INSTANCES $initial_number $maximum_number) ) # sdl92.g:451:17: '(' initial_number= INT ',' maximum_number= INT ')' pass char_literal189=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_number_of_instances4883) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal189) initial_number=self.match(self.input, INT, self.FOLLOW_INT_in_number_of_instances4887) if self._state.backtracking == 0: stream_INT.add(initial_number) char_literal190=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_number_of_instances4889) if self._state.backtracking == 0: stream_COMMA.add(char_literal190) maximum_number=self.match(self.input, INT, self.FOLLOW_INT_in_number_of_instances4893) if self._state.backtracking == 0: stream_INT.add(maximum_number) char_literal191=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_number_of_instances4895) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal191) # AST Rewrite # elements: initial_number, maximum_number # token labels: maximum_number, initial_number # rule labels: retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 stream_maximum_number = RewriteRuleTokenStream(self._adaptor, "token maximum_number", maximum_number) stream_initial_number = RewriteRuleTokenStream(self._adaptor, "token initial_number", initial_number) 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() # 452:9: -> ^( NUMBER_OF_INSTANCES $initial_number $maximum_number) # sdl92.g:452:17: ^( NUMBER_OF_INSTANCES $initial_number $maximum_number) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(NUMBER_OF_INSTANCES, "NUMBER_OF_INSTANCES"), root_1) self._adaptor.addChild(root_1, stream_initial_number.nextNode()) self._adaptor.addChild(root_1, stream_maximum_number.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, 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 "number_of_instances" class processBody_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.processBody_return, self).__init__() self.tree = None # $ANTLR start "processBody" # sdl92.g:456:1: processBody : ( start )? ( state | floating_label )* ; def processBody(self, ): retval = self.processBody_return() retval.start = self.input.LT(1) root_0 = None start192 = None state193 = None floating_label194 = None try: try: # sdl92.g:457:9: ( ( start )? ( state | floating_label )* ) # sdl92.g:457:17: ( start )? ( state | floating_label )* pass root_0 = self._adaptor.nil() # sdl92.g:457:17: ( start )? alt55 = 2 alt55 = self.dfa55.predict(self.input) if alt55 == 1: # sdl92.g:0:0: start pass self._state.following.append(self.FOLLOW_start_in_processBody4952) start192 = self.start() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, start192.tree) # sdl92.g:457:24: ( state | floating_label )* while True: #loop56 alt56 = 3 alt56 = self.dfa56.predict(self.input) if alt56 == 1: # sdl92.g:457:25: state pass self._state.following.append(self.FOLLOW_state_in_processBody4956) state193 = self.state() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, state193.tree) elif alt56 == 2: # sdl92.g:457:33: floating_label pass self._state.following.append(self.FOLLOW_floating_label_in_processBody4960) floating_label194 = self.floating_label() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, floating_label194.tree) else: break #loop56 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, 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 "processBody" class start_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.start_return, self).__init__() self.tree = None # $ANTLR start "start" # sdl92.g:461:1: start : ( cif )? ( hyperlink )? START (name= state_entry_point_name )? end ( transition )? -> ^( START ( cif )? ( hyperlink )? ( $name)? ( end )? ( transition )? ) ; def start(self, ): retval = self.start_return() retval.start = self.input.LT(1) root_0 = None START197 = None name = None cif195 = None hyperlink196 = None end198 = None transition199 = None START197_tree = None stream_START = RewriteRuleTokenStream(self._adaptor, "token START") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_state_entry_point_name = RewriteRuleSubtreeStream(self._adaptor, "rule state_entry_point_name") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:462:9: ( ( cif )? ( hyperlink )? START (name= state_entry_point_name )? end ( transition )? -> ^( START ( cif )? ( hyperlink )? ( $name)? ( end )? ( transition )? ) ) # sdl92.g:462:17: ( cif )? ( hyperlink )? START (name= state_entry_point_name )? end ( transition )? pass # sdl92.g:462:17: ( cif )? alt57 = 2 LA57_0 = self.input.LA(1) if (LA57_0 == 229) : LA57_1 = self.input.LA(2) if (LA57_1 == ANSWER or LA57_1 == COMMENT or LA57_1 == CONNECT or LA57_1 == DECISION or LA57_1 == INPUT or (JOIN <= LA57_1 <= LABEL) or LA57_1 == NEXTSTATE or LA57_1 == OUTPUT or (PROCEDURE <= LA57_1 <= PROCEDURE_CALL) or (PROCESS <= LA57_1 <= PROVIDED) or LA57_1 == RETURN or LA57_1 == STATE or LA57_1 == STOP or LA57_1 == TASK or LA57_1 == TEXT or LA57_1 == START) : alt57 = 1 if alt57 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_start4994) cif195 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif195.tree) # sdl92.g:463:17: ( hyperlink )? alt58 = 2 LA58_0 = self.input.LA(1) if (LA58_0 == 229) : alt58 = 1 if alt58 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_start5013) hyperlink196 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink196.tree) START197=self.match(self.input, START, self.FOLLOW_START_in_start5032) if self._state.backtracking == 0: stream_START.add(START197) # sdl92.g:464:27: (name= state_entry_point_name )? alt59 = 2 LA59_0 = self.input.LA(1) if (LA59_0 == ID) : alt59 = 1 if alt59 == 1: # sdl92.g:0:0: name= state_entry_point_name pass self._state.following.append(self.FOLLOW_state_entry_point_name_in_start5036) name = self.state_entry_point_name() self._state.following.pop() if self._state.backtracking == 0: stream_state_entry_point_name.add(name.tree) self._state.following.append(self.FOLLOW_end_in_start5039) end198 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end198.tree) # sdl92.g:465:17: ( transition )? alt60 = 2 alt60 = self.dfa60.predict(self.input) if alt60 == 1: # sdl92.g:0:0: transition pass self._state.following.append(self.FOLLOW_transition_in_start5057) transition199 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition199.tree) # AST Rewrite # elements: hyperlink, cif, START, end, name, transition # token labels: # rule labels: retval, name # 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) if name is not None: stream_name = RewriteRuleSubtreeStream(self._adaptor, "rule name", name.tree) else: stream_name = RewriteRuleSubtreeStream(self._adaptor, "token name", None) root_0 = self._adaptor.nil() # 466:9: -> ^( START ( cif )? ( hyperlink )? ( $name)? ( end )? ( transition )? ) # sdl92.g:466:17: ^( START ( cif )? ( hyperlink )? ( $name)? ( end )? ( transition )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_START.nextNode(), root_1) # sdl92.g:466:25: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:466:30: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:466:41: ( $name)? if stream_name.hasNext(): self._adaptor.addChild(root_1, stream_name.nextTree()) stream_name.reset(); # sdl92.g:466:48: ( end )? if stream_end.hasNext(): self._adaptor.addChild(root_1, stream_end.nextTree()) stream_end.reset(); # sdl92.g:466:53: ( transition )? if stream_transition.hasNext(): self._adaptor.addChild(root_1, stream_transition.nextTree()) stream_transition.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, 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 "start" class floating_label_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.floating_label_return, self).__init__() self.tree = None # $ANTLR start "floating_label" # sdl92.g:470:1: floating_label : ( cif )? ( hyperlink )? CONNECTION connector_name ':' ( transition )? ( cif_end_label )? ENDCONNECTION SEMI -> ^( FLOATING_LABEL ( cif )? ( hyperlink )? connector_name ( transition )? ) ; def floating_label(self, ): retval = self.floating_label_return() retval.start = self.input.LT(1) root_0 = None CONNECTION202 = None char_literal204 = None ENDCONNECTION207 = None SEMI208 = None cif200 = None hyperlink201 = None connector_name203 = None transition205 = None cif_end_label206 = None CONNECTION202_tree = None char_literal204_tree = None ENDCONNECTION207_tree = None SEMI208_tree = None stream_ENDCONNECTION = RewriteRuleTokenStream(self._adaptor, "token ENDCONNECTION") stream_CONNECTION = RewriteRuleTokenStream(self._adaptor, "token CONNECTION") stream_223 = RewriteRuleTokenStream(self._adaptor, "token 223") stream_SEMI = RewriteRuleTokenStream(self._adaptor, "token SEMI") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_cif_end_label = RewriteRuleSubtreeStream(self._adaptor, "rule cif_end_label") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") stream_connector_name = RewriteRuleSubtreeStream(self._adaptor, "rule connector_name") try: try: # sdl92.g:471:9: ( ( cif )? ( hyperlink )? CONNECTION connector_name ':' ( transition )? ( cif_end_label )? ENDCONNECTION SEMI -> ^( FLOATING_LABEL ( cif )? ( hyperlink )? connector_name ( transition )? ) ) # sdl92.g:471:17: ( cif )? ( hyperlink )? CONNECTION connector_name ':' ( transition )? ( cif_end_label )? ENDCONNECTION SEMI pass # sdl92.g:471:17: ( cif )? alt61 = 2 LA61_0 = self.input.LA(1) if (LA61_0 == 229) : LA61_1 = self.input.LA(2) if (LA61_1 == ANSWER or LA61_1 == COMMENT or LA61_1 == CONNECT or LA61_1 == DECISION or LA61_1 == INPUT or (JOIN <= LA61_1 <= LABEL) or LA61_1 == NEXTSTATE or LA61_1 == OUTPUT or (PROCEDURE <= LA61_1 <= PROCEDURE_CALL) or (PROCESS <= LA61_1 <= PROVIDED) or LA61_1 == RETURN or LA61_1 == STATE or LA61_1 == STOP or LA61_1 == TASK or LA61_1 == TEXT or LA61_1 == START) : alt61 = 1 if alt61 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_floating_label5125) cif200 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif200.tree) # sdl92.g:472:17: ( hyperlink )? alt62 = 2 LA62_0 = self.input.LA(1) if (LA62_0 == 229) : alt62 = 1 if alt62 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_floating_label5144) hyperlink201 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink201.tree) CONNECTION202=self.match(self.input, CONNECTION, self.FOLLOW_CONNECTION_in_floating_label5163) if self._state.backtracking == 0: stream_CONNECTION.add(CONNECTION202) self._state.following.append(self.FOLLOW_connector_name_in_floating_label5165) connector_name203 = self.connector_name() self._state.following.pop() if self._state.backtracking == 0: stream_connector_name.add(connector_name203.tree) char_literal204=self.match(self.input, 223, self.FOLLOW_223_in_floating_label5167) if self._state.backtracking == 0: stream_223.add(char_literal204) # sdl92.g:474:17: ( transition )? alt63 = 2 LA63_0 = self.input.LA(1) if (LA63_0 == 229) : LA63_1 = self.input.LA(2) if (LA63_1 == ANSWER or LA63_1 == COMMENT or LA63_1 == CONNECT or LA63_1 == DECISION or LA63_1 == INPUT or (JOIN <= LA63_1 <= LABEL) or LA63_1 == NEXTSTATE or LA63_1 == OUTPUT or (PROCEDURE <= LA63_1 <= PROCEDURE_CALL) or (PROCESS <= LA63_1 <= PROVIDED) or LA63_1 == RETURN or LA63_1 == STATE or LA63_1 == STOP or LA63_1 == TASK or LA63_1 == TEXT or LA63_1 == START or LA63_1 == KEEP) : alt63 = 1 elif (LA63_0 == ALTERNATIVE or LA63_0 == DECISION or LA63_0 == EXPORT or LA63_0 == FOR or LA63_0 == JOIN or LA63_0 == NEXTSTATE or LA63_0 == OUTPUT or (RESET <= LA63_0 <= RETURN) or LA63_0 == SET or LA63_0 == STOP or LA63_0 == STRING or LA63_0 == TASK or LA63_0 == ID or LA63_0 == CALL or LA63_0 == CREATE) : alt63 = 1 if alt63 == 1: # sdl92.g:0:0: transition pass self._state.following.append(self.FOLLOW_transition_in_floating_label5185) transition205 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition205.tree) # sdl92.g:475:17: ( cif_end_label )? alt64 = 2 LA64_0 = self.input.LA(1) if (LA64_0 == 229) : alt64 = 1 if alt64 == 1: # sdl92.g:0:0: cif_end_label pass self._state.following.append(self.FOLLOW_cif_end_label_in_floating_label5204) cif_end_label206 = self.cif_end_label() self._state.following.pop() if self._state.backtracking == 0: stream_cif_end_label.add(cif_end_label206.tree) ENDCONNECTION207=self.match(self.input, ENDCONNECTION, self.FOLLOW_ENDCONNECTION_in_floating_label5223) if self._state.backtracking == 0: stream_ENDCONNECTION.add(ENDCONNECTION207) SEMI208=self.match(self.input, SEMI, self.FOLLOW_SEMI_in_floating_label5225) if self._state.backtracking == 0: stream_SEMI.add(SEMI208) # AST Rewrite # elements: transition, connector_name, cif, hyperlink # 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() # 477:9: -> ^( FLOATING_LABEL ( cif )? ( hyperlink )? connector_name ( transition )? ) # sdl92.g:477:17: ^( FLOATING_LABEL ( cif )? ( hyperlink )? connector_name ( transition )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(FLOATING_LABEL, "FLOATING_LABEL"), root_1) # sdl92.g:477:34: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:477:39: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); self._adaptor.addChild(root_1, stream_connector_name.nextTree()) # sdl92.g:477:65: ( transition )? if stream_transition.hasNext(): self._adaptor.addChild(root_1, stream_transition.nextTree()) stream_transition.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, 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 "floating_label" class state_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.state_return, self).__init__() self.tree = None # $ANTLR start "state" # sdl92.g:481:1: state : ( cif )? ( hyperlink )? STATE statelist e= end ( state_part )* ENDSTATE ( statename )? f= end -> ^( STATE ( cif )? ( hyperlink )? ( $e)? statelist ( state_part )* ) ; def state(self, ): retval = self.state_return() retval.start = self.input.LT(1) root_0 = None STATE211 = None ENDSTATE214 = None e = None f = None cif209 = None hyperlink210 = None statelist212 = None state_part213 = None statename215 = None STATE211_tree = None ENDSTATE214_tree = None stream_STATE = RewriteRuleTokenStream(self._adaptor, "token STATE") stream_ENDSTATE = RewriteRuleTokenStream(self._adaptor, "token ENDSTATE") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_statelist = RewriteRuleSubtreeStream(self._adaptor, "rule statelist") stream_state_part = RewriteRuleSubtreeStream(self._adaptor, "rule state_part") stream_statename = RewriteRuleSubtreeStream(self._adaptor, "rule statename") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:482:9: ( ( cif )? ( hyperlink )? STATE statelist e= end ( state_part )* ENDSTATE ( statename )? f= end -> ^( STATE ( cif )? ( hyperlink )? ( $e)? statelist ( state_part )* ) ) # sdl92.g:482:17: ( cif )? ( hyperlink )? STATE statelist e= end ( state_part )* ENDSTATE ( statename )? f= end pass # sdl92.g:482:17: ( cif )? alt65 = 2 LA65_0 = self.input.LA(1) if (LA65_0 == 229) : LA65_1 = self.input.LA(2) if (LA65_1 == ANSWER or LA65_1 == COMMENT or LA65_1 == CONNECT or LA65_1 == DECISION or LA65_1 == INPUT or (JOIN <= LA65_1 <= LABEL) or LA65_1 == NEXTSTATE or LA65_1 == OUTPUT or (PROCEDURE <= LA65_1 <= PROCEDURE_CALL) or (PROCESS <= LA65_1 <= PROVIDED) or LA65_1 == RETURN or LA65_1 == STATE or LA65_1 == STOP or LA65_1 == TASK or LA65_1 == TEXT or LA65_1 == START) : alt65 = 1 if alt65 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_state5287) cif209 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif209.tree) # sdl92.g:483:17: ( hyperlink )? alt66 = 2 LA66_0 = self.input.LA(1) if (LA66_0 == 229) : alt66 = 1 if alt66 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_state5306) hyperlink210 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink210.tree) STATE211=self.match(self.input, STATE, self.FOLLOW_STATE_in_state5325) if self._state.backtracking == 0: stream_STATE.add(STATE211) self._state.following.append(self.FOLLOW_statelist_in_state5327) statelist212 = self.statelist() self._state.following.pop() if self._state.backtracking == 0: stream_statelist.add(statelist212.tree) self._state.following.append(self.FOLLOW_end_in_state5331) e = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(e.tree) # sdl92.g:485:17: ( state_part )* while True: #loop67 alt67 = 2 LA67_0 = self.input.LA(1) if (LA67_0 == CONNECT or LA67_0 == INPUT or LA67_0 == PROVIDED or LA67_0 == SAVE or LA67_0 == 229) : alt67 = 1 if alt67 == 1: # sdl92.g:485:18: state_part pass self._state.following.append(self.FOLLOW_state_part_in_state5350) state_part213 = self.state_part() self._state.following.pop() if self._state.backtracking == 0: stream_state_part.add(state_part213.tree) else: break #loop67 ENDSTATE214=self.match(self.input, ENDSTATE, self.FOLLOW_ENDSTATE_in_state5370) if self._state.backtracking == 0: stream_ENDSTATE.add(ENDSTATE214) # sdl92.g:486:26: ( statename )? alt68 = 2 LA68_0 = self.input.LA(1) if (LA68_0 == ID) : alt68 = 1 if alt68 == 1: # sdl92.g:0:0: statename pass self._state.following.append(self.FOLLOW_statename_in_state5372) statename215 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename215.tree) self._state.following.append(self.FOLLOW_end_in_state5377) f = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(f.tree) # AST Rewrite # elements: e, STATE, cif, statelist, hyperlink, state_part # token labels: # rule labels: retval, e # 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) if e is not None: stream_e = RewriteRuleSubtreeStream(self._adaptor, "rule e", e.tree) else: stream_e = RewriteRuleSubtreeStream(self._adaptor, "token e", None) root_0 = self._adaptor.nil() # 487:9: -> ^( STATE ( cif )? ( hyperlink )? ( $e)? statelist ( state_part )* ) # sdl92.g:487:17: ^( STATE ( cif )? ( hyperlink )? ( $e)? statelist ( state_part )* ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_STATE.nextNode(), root_1) # sdl92.g:487:25: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:487:30: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:487:41: ( $e)? if stream_e.hasNext(): self._adaptor.addChild(root_1, stream_e.nextTree()) stream_e.reset(); self._adaptor.addChild(root_1, stream_statelist.nextTree()) # sdl92.g:487:55: ( state_part )* while stream_state_part.hasNext(): self._adaptor.addChild(root_1, stream_state_part.nextTree()) stream_state_part.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, 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 "state" class statelist_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.statelist_return, self).__init__() self.tree = None # $ANTLR start "statelist" # sdl92.g:491:1: statelist : ( ( ( statename ) ( ',' statename )* ) -> ^( STATELIST ( statename )+ ) | ASTERISK ( exception_state )? -> ^( ASTERISK ( exception_state )? ) ); def statelist(self, ): retval = self.statelist_return() retval.start = self.input.LT(1) root_0 = None char_literal217 = None ASTERISK219 = None statename216 = None statename218 = None exception_state220 = None char_literal217_tree = None ASTERISK219_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_ASTERISK = RewriteRuleTokenStream(self._adaptor, "token ASTERISK") stream_exception_state = RewriteRuleSubtreeStream(self._adaptor, "rule exception_state") stream_statename = RewriteRuleSubtreeStream(self._adaptor, "rule statename") try: try: # sdl92.g:492:9: ( ( ( statename ) ( ',' statename )* ) -> ^( STATELIST ( statename )+ ) | ASTERISK ( exception_state )? -> ^( ASTERISK ( exception_state )? ) ) alt71 = 2 LA71_0 = self.input.LA(1) if (LA71_0 == ID) : alt71 = 1 elif (LA71_0 == ASTERISK) : alt71 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 71, 0, self.input) raise nvae if alt71 == 1: # sdl92.g:492:17: ( ( statename ) ( ',' statename )* ) pass # sdl92.g:492:17: ( ( statename ) ( ',' statename )* ) # sdl92.g:492:18: ( statename ) ( ',' statename )* pass # sdl92.g:492:18: ( statename ) # sdl92.g:492:19: statename pass self._state.following.append(self.FOLLOW_statename_in_statelist5445) statename216 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename216.tree) # sdl92.g:492:29: ( ',' statename )* while True: #loop69 alt69 = 2 LA69_0 = self.input.LA(1) if (LA69_0 == COMMA) : alt69 = 1 if alt69 == 1: # sdl92.g:492:30: ',' statename pass char_literal217=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_statelist5448) if self._state.backtracking == 0: stream_COMMA.add(char_literal217) self._state.following.append(self.FOLLOW_statename_in_statelist5450) statename218 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename218.tree) else: break #loop69 # AST Rewrite # elements: statename # 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() # 493:9: -> ^( STATELIST ( statename )+ ) # sdl92.g:493:17: ^( STATELIST ( statename )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(STATELIST, "STATELIST"), root_1) # sdl92.g:493:29: ( statename )+ if not (stream_statename.hasNext()): raise RewriteEarlyExitException() while stream_statename.hasNext(): self._adaptor.addChild(root_1, stream_statename.nextTree()) stream_statename.reset() self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt71 == 2: # sdl92.g:494:19: ASTERISK ( exception_state )? pass ASTERISK219=self.match(self.input, ASTERISK, self.FOLLOW_ASTERISK_in_statelist5495) if self._state.backtracking == 0: stream_ASTERISK.add(ASTERISK219) # sdl92.g:494:28: ( exception_state )? alt70 = 2 LA70_0 = self.input.LA(1) if (LA70_0 == L_PAREN) : alt70 = 1 if alt70 == 1: # sdl92.g:0:0: exception_state pass self._state.following.append(self.FOLLOW_exception_state_in_statelist5497) exception_state220 = self.exception_state() self._state.following.pop() if self._state.backtracking == 0: stream_exception_state.add(exception_state220.tree) # AST Rewrite # elements: ASTERISK, exception_state # 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() # 495:9: -> ^( ASTERISK ( exception_state )? ) # sdl92.g:495:17: ^( ASTERISK ( exception_state )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_ASTERISK.nextNode(), root_1) # sdl92.g:495:28: ( exception_state )? if stream_exception_state.hasNext(): self._adaptor.addChild(root_1, stream_exception_state.nextTree()) stream_exception_state.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, 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 "statelist" class exception_state_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.exception_state_return, self).__init__() self.tree = None # $ANTLR start "exception_state" # sdl92.g:499:1: exception_state : '(' statename ( ',' statename )* ')' -> ( statename )+ ; def exception_state(self, ): retval = self.exception_state_return() retval.start = self.input.LT(1) root_0 = None char_literal221 = None char_literal223 = None char_literal225 = None statename222 = None statename224 = None char_literal221_tree = None char_literal223_tree = None char_literal225_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_statename = RewriteRuleSubtreeStream(self._adaptor, "rule statename") try: try: # sdl92.g:500:9: ( '(' statename ( ',' statename )* ')' -> ( statename )+ ) # sdl92.g:500:17: '(' statename ( ',' statename )* ')' pass char_literal221=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_exception_state5552) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal221) self._state.following.append(self.FOLLOW_statename_in_exception_state5554) statename222 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename222.tree) # sdl92.g:500:31: ( ',' statename )* while True: #loop72 alt72 = 2 LA72_0 = self.input.LA(1) if (LA72_0 == COMMA) : alt72 = 1 if alt72 == 1: # sdl92.g:500:32: ',' statename pass char_literal223=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_exception_state5557) if self._state.backtracking == 0: stream_COMMA.add(char_literal223) self._state.following.append(self.FOLLOW_statename_in_exception_state5559) statename224 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename224.tree) else: break #loop72 char_literal225=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_exception_state5563) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal225) # AST Rewrite # elements: statename # 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() # 501:9: -> ( statename )+ # sdl92.g:501:17: ( statename )+ if not (stream_statename.hasNext()): raise RewriteEarlyExitException() while stream_statename.hasNext(): self._adaptor.addChild(root_0, stream_statename.nextTree()) stream_statename.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, 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 "exception_state" class composite_state_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.composite_state_return, self).__init__() self.tree = None # $ANTLR start "composite_state" # sdl92.g:506:1: composite_state : ( composite_state_graph | state_aggregation ); def composite_state(self, ): retval = self.composite_state_return() retval.start = self.input.LT(1) root_0 = None composite_state_graph226 = None state_aggregation227 = None try: try: # sdl92.g:507:9: ( composite_state_graph | state_aggregation ) alt73 = 2 LA73_0 = self.input.LA(1) if (LA73_0 == STATE) : LA73_1 = self.input.LA(2) if (LA73_1 == AGGREGATION) : alt73 = 2 elif (LA73_1 == ID) : alt73 = 1 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 73, 1, self.input) raise nvae else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 73, 0, self.input) raise nvae if alt73 == 1: # sdl92.g:507:17: composite_state_graph pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_composite_state_graph_in_composite_state5614) composite_state_graph226 = self.composite_state_graph() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, composite_state_graph226.tree) elif alt73 == 2: # sdl92.g:508:19: state_aggregation pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_state_aggregation_in_composite_state5634) state_aggregation227 = self.state_aggregation() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, state_aggregation227.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, 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 "composite_state" class composite_state_graph_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.composite_state_graph_return, self).__init__() self.tree = None # $ANTLR start "composite_state_graph" # sdl92.g:512:1: composite_state_graph : STATE statename e= end SUBSTRUCTURE ( connection_points )* body= composite_state_body ENDSUBSTRUCTURE ( statename )? f= end -> ^( COMPOSITE_STATE statename ( connection_points )* $body ( $e)? ) ; def composite_state_graph(self, ): retval = self.composite_state_graph_return() retval.start = self.input.LT(1) root_0 = None STATE228 = None SUBSTRUCTURE230 = None ENDSUBSTRUCTURE232 = None e = None body = None f = None statename229 = None connection_points231 = None statename233 = None STATE228_tree = None SUBSTRUCTURE230_tree = None ENDSUBSTRUCTURE232_tree = None stream_STATE = RewriteRuleTokenStream(self._adaptor, "token STATE") stream_ENDSUBSTRUCTURE = RewriteRuleTokenStream(self._adaptor, "token ENDSUBSTRUCTURE") stream_SUBSTRUCTURE = RewriteRuleTokenStream(self._adaptor, "token SUBSTRUCTURE") stream_connection_points = RewriteRuleSubtreeStream(self._adaptor, "rule connection_points") stream_composite_state_body = RewriteRuleSubtreeStream(self._adaptor, "rule composite_state_body") stream_statename = RewriteRuleSubtreeStream(self._adaptor, "rule statename") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:513:9: ( STATE statename e= end SUBSTRUCTURE ( connection_points )* body= composite_state_body ENDSUBSTRUCTURE ( statename )? f= end -> ^( COMPOSITE_STATE statename ( connection_points )* $body ( $e)? ) ) # sdl92.g:513:17: STATE statename e= end SUBSTRUCTURE ( connection_points )* body= composite_state_body ENDSUBSTRUCTURE ( statename )? f= end pass STATE228=self.match(self.input, STATE, self.FOLLOW_STATE_in_composite_state_graph5666) if self._state.backtracking == 0: stream_STATE.add(STATE228) self._state.following.append(self.FOLLOW_statename_in_composite_state_graph5668) statename229 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename229.tree) self._state.following.append(self.FOLLOW_end_in_composite_state_graph5672) e = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(e.tree) SUBSTRUCTURE230=self.match(self.input, SUBSTRUCTURE, self.FOLLOW_SUBSTRUCTURE_in_composite_state_graph5690) if self._state.backtracking == 0: stream_SUBSTRUCTURE.add(SUBSTRUCTURE230) # sdl92.g:515:17: ( connection_points )* while True: #loop74 alt74 = 2 LA74_0 = self.input.LA(1) if (LA74_0 == IN or LA74_0 == OUT) : alt74 = 1 if alt74 == 1: # sdl92.g:0:0: connection_points pass self._state.following.append(self.FOLLOW_connection_points_in_composite_state_graph5708) connection_points231 = self.connection_points() self._state.following.pop() if self._state.backtracking == 0: stream_connection_points.add(connection_points231.tree) else: break #loop74 self._state.following.append(self.FOLLOW_composite_state_body_in_composite_state_graph5729) body = self.composite_state_body() self._state.following.pop() if self._state.backtracking == 0: stream_composite_state_body.add(body.tree) ENDSUBSTRUCTURE232=self.match(self.input, ENDSUBSTRUCTURE, self.FOLLOW_ENDSUBSTRUCTURE_in_composite_state_graph5747) if self._state.backtracking == 0: stream_ENDSUBSTRUCTURE.add(ENDSUBSTRUCTURE232) # sdl92.g:517:33: ( statename )? alt75 = 2 LA75_0 = self.input.LA(1) if (LA75_0 == ID) : alt75 = 1 if alt75 == 1: # sdl92.g:0:0: statename pass self._state.following.append(self.FOLLOW_statename_in_composite_state_graph5749) statename233 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename233.tree) self._state.following.append(self.FOLLOW_end_in_composite_state_graph5754) f = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(f.tree) # AST Rewrite # elements: statename, e, connection_points, body # token labels: # rule labels: body, retval, e # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 if body is not None: stream_body = RewriteRuleSubtreeStream(self._adaptor, "rule body", body.tree) else: stream_body = RewriteRuleSubtreeStream(self._adaptor, "token body", None) if retval is not None: stream_retval = RewriteRuleSubtreeStream(self._adaptor, "rule retval", retval.tree) else: stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None) if e is not None: stream_e = RewriteRuleSubtreeStream(self._adaptor, "rule e", e.tree) else: stream_e = RewriteRuleSubtreeStream(self._adaptor, "token e", None) root_0 = self._adaptor.nil() # 518:9: -> ^( COMPOSITE_STATE statename ( connection_points )* $body ( $e)? ) # sdl92.g:518:17: ^( COMPOSITE_STATE statename ( connection_points )* $body ( $e)? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(COMPOSITE_STATE, "COMPOSITE_STATE"), root_1) self._adaptor.addChild(root_1, stream_statename.nextTree()) # sdl92.g:518:45: ( connection_points )* while stream_connection_points.hasNext(): self._adaptor.addChild(root_1, stream_connection_points.nextTree()) stream_connection_points.reset(); self._adaptor.addChild(root_1, stream_body.nextTree()) # sdl92.g:518:70: ( $e)? if stream_e.hasNext(): self._adaptor.addChild(root_1, stream_e.nextTree()) stream_e.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, 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 "composite_state_graph" class state_aggregation_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.state_aggregation_return, self).__init__() self.tree = None # $ANTLR start "state_aggregation" # sdl92.g:523:1: state_aggregation : STATE AGGREGATION statename e= end SUBSTRUCTURE ( connection_points )* (entities= entity_in_composite_state )* body= state_aggregation_body ENDSUBSTRUCTURE ( statename )? f= end -> ^( STATE_AGGREGATION statename ( connection_points )* ( $entities)* $body ( $e)? ) ; def state_aggregation(self, ): retval = self.state_aggregation_return() retval.start = self.input.LT(1) root_0 = None STATE234 = None AGGREGATION235 = None SUBSTRUCTURE237 = None ENDSUBSTRUCTURE239 = None e = None entities = None body = None f = None statename236 = None connection_points238 = None statename240 = None STATE234_tree = None AGGREGATION235_tree = None SUBSTRUCTURE237_tree = None ENDSUBSTRUCTURE239_tree = None stream_STATE = RewriteRuleTokenStream(self._adaptor, "token STATE") stream_ENDSUBSTRUCTURE = RewriteRuleTokenStream(self._adaptor, "token ENDSUBSTRUCTURE") stream_AGGREGATION = RewriteRuleTokenStream(self._adaptor, "token AGGREGATION") stream_SUBSTRUCTURE = RewriteRuleTokenStream(self._adaptor, "token SUBSTRUCTURE") stream_connection_points = RewriteRuleSubtreeStream(self._adaptor, "rule connection_points") stream_state_aggregation_body = RewriteRuleSubtreeStream(self._adaptor, "rule state_aggregation_body") stream_statename = RewriteRuleSubtreeStream(self._adaptor, "rule statename") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_entity_in_composite_state = RewriteRuleSubtreeStream(self._adaptor, "rule entity_in_composite_state") try: try: # sdl92.g:524:9: ( STATE AGGREGATION statename e= end SUBSTRUCTURE ( connection_points )* (entities= entity_in_composite_state )* body= state_aggregation_body ENDSUBSTRUCTURE ( statename )? f= end -> ^( STATE_AGGREGATION statename ( connection_points )* ( $entities)* $body ( $e)? ) ) # sdl92.g:524:17: STATE AGGREGATION statename e= end SUBSTRUCTURE ( connection_points )* (entities= entity_in_composite_state )* body= state_aggregation_body ENDSUBSTRUCTURE ( statename )? f= end pass STATE234=self.match(self.input, STATE, self.FOLLOW_STATE_in_state_aggregation5818) if self._state.backtracking == 0: stream_STATE.add(STATE234) AGGREGATION235=self.match(self.input, AGGREGATION, self.FOLLOW_AGGREGATION_in_state_aggregation5820) if self._state.backtracking == 0: stream_AGGREGATION.add(AGGREGATION235) self._state.following.append(self.FOLLOW_statename_in_state_aggregation5822) statename236 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename236.tree) self._state.following.append(self.FOLLOW_end_in_state_aggregation5826) e = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(e.tree) SUBSTRUCTURE237=self.match(self.input, SUBSTRUCTURE, self.FOLLOW_SUBSTRUCTURE_in_state_aggregation5844) if self._state.backtracking == 0: stream_SUBSTRUCTURE.add(SUBSTRUCTURE237) # sdl92.g:526:17: ( connection_points )* while True: #loop76 alt76 = 2 LA76_0 = self.input.LA(1) if (LA76_0 == IN or LA76_0 == OUT) : alt76 = 1 if alt76 == 1: # sdl92.g:0:0: connection_points pass self._state.following.append(self.FOLLOW_connection_points_in_state_aggregation5862) connection_points238 = self.connection_points() self._state.following.pop() if self._state.backtracking == 0: stream_connection_points.add(connection_points238.tree) else: break #loop76 # sdl92.g:527:25: (entities= entity_in_composite_state )* while True: #loop77 alt77 = 2 alt77 = self.dfa77.predict(self.input) if alt77 == 1: # sdl92.g:0:0: entities= entity_in_composite_state pass self._state.following.append(self.FOLLOW_entity_in_composite_state_in_state_aggregation5883) entities = self.entity_in_composite_state() self._state.following.pop() if self._state.backtracking == 0: stream_entity_in_composite_state.add(entities.tree) else: break #loop77 self._state.following.append(self.FOLLOW_state_aggregation_body_in_state_aggregation5904) body = self.state_aggregation_body() self._state.following.pop() if self._state.backtracking == 0: stream_state_aggregation_body.add(body.tree) ENDSUBSTRUCTURE239=self.match(self.input, ENDSUBSTRUCTURE, self.FOLLOW_ENDSUBSTRUCTURE_in_state_aggregation5922) if self._state.backtracking == 0: stream_ENDSUBSTRUCTURE.add(ENDSUBSTRUCTURE239) # sdl92.g:529:33: ( statename )? alt78 = 2 LA78_0 = self.input.LA(1) if (LA78_0 == ID) : alt78 = 1 if alt78 == 1: # sdl92.g:0:0: statename pass self._state.following.append(self.FOLLOW_statename_in_state_aggregation5924) statename240 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename240.tree) self._state.following.append(self.FOLLOW_end_in_state_aggregation5929) f = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(f.tree) # AST Rewrite # elements: body, e, connection_points, entities, statename # token labels: # rule labels: body, retval, e, entities # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 if body is not None: stream_body = RewriteRuleSubtreeStream(self._adaptor, "rule body", body.tree) else: stream_body = RewriteRuleSubtreeStream(self._adaptor, "token body", None) if retval is not None: stream_retval = RewriteRuleSubtreeStream(self._adaptor, "rule retval", retval.tree) else: stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None) if e is not None: stream_e = RewriteRuleSubtreeStream(self._adaptor, "rule e", e.tree) else: stream_e = RewriteRuleSubtreeStream(self._adaptor, "token e", None) if entities is not None: stream_entities = RewriteRuleSubtreeStream(self._adaptor, "rule entities", entities.tree) else: stream_entities = RewriteRuleSubtreeStream(self._adaptor, "token entities", None) root_0 = self._adaptor.nil() # 530:9: -> ^( STATE_AGGREGATION statename ( connection_points )* ( $entities)* $body ( $e)? ) # sdl92.g:530:17: ^( STATE_AGGREGATION statename ( connection_points )* ( $entities)* $body ( $e)? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(STATE_AGGREGATION, "STATE_AGGREGATION"), root_1) self._adaptor.addChild(root_1, stream_statename.nextTree()) # sdl92.g:530:47: ( connection_points )* while stream_connection_points.hasNext(): self._adaptor.addChild(root_1, stream_connection_points.nextTree()) stream_connection_points.reset(); # sdl92.g:531:37: ( $entities)* while stream_entities.hasNext(): self._adaptor.addChild(root_1, stream_entities.nextTree()) stream_entities.reset(); self._adaptor.addChild(root_1, stream_body.nextTree()) # sdl92.g:531:54: ( $e)? if stream_e.hasNext(): self._adaptor.addChild(root_1, stream_e.nextTree()) stream_e.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, 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 "state_aggregation" class entity_in_composite_state_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.entity_in_composite_state_return, self).__init__() self.tree = None # $ANTLR start "entity_in_composite_state" # sdl92.g:536:1: entity_in_composite_state : ( text_area | procedure ) ; def entity_in_composite_state(self, ): retval = self.entity_in_composite_state_return() retval.start = self.input.LT(1) root_0 = None text_area241 = None procedure242 = None try: try: # sdl92.g:537:9: ( ( text_area | procedure ) ) # sdl92.g:537:17: ( text_area | procedure ) pass root_0 = self._adaptor.nil() # sdl92.g:537:17: ( text_area | procedure ) alt79 = 2 LA79_0 = self.input.LA(1) if (LA79_0 == 229) : LA79_1 = self.input.LA(2) if (self.synpred103_sdl92()) : alt79 = 1 elif (True) : alt79 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 79, 1, self.input) raise nvae elif (LA79_0 == PROCEDURE) : alt79 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 79, 0, self.input) raise nvae if alt79 == 1: # sdl92.g:537:18: text_area pass self._state.following.append(self.FOLLOW_text_area_in_entity_in_composite_state6034) text_area241 = self.text_area() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, text_area241.tree) elif alt79 == 2: # sdl92.g:537:30: procedure pass self._state.following.append(self.FOLLOW_procedure_in_entity_in_composite_state6038) procedure242 = self.procedure() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, procedure242.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, 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 "entity_in_composite_state" class state_aggregation_body_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.state_aggregation_body_return, self).__init__() self.tree = None # $ANTLR start "state_aggregation_body" # sdl92.g:542:1: state_aggregation_body : ( state_partitioning | state_partition_connection )* ( state )* ; def state_aggregation_body(self, ): retval = self.state_aggregation_body_return() retval.start = self.input.LT(1) root_0 = None state_partitioning243 = None state_partition_connection244 = None state245 = None try: try: # sdl92.g:543:9: ( ( state_partitioning | state_partition_connection )* ( state )* ) # sdl92.g:543:17: ( state_partitioning | state_partition_connection )* ( state )* pass root_0 = self._adaptor.nil() # sdl92.g:543:17: ( state_partitioning | state_partition_connection )* while True: #loop80 alt80 = 3 alt80 = self.dfa80.predict(self.input) if alt80 == 1: # sdl92.g:543:18: state_partitioning pass self._state.following.append(self.FOLLOW_state_partitioning_in_state_aggregation_body6073) state_partitioning243 = self.state_partitioning() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, state_partitioning243.tree) elif alt80 == 2: # sdl92.g:543:39: state_partition_connection pass self._state.following.append(self.FOLLOW_state_partition_connection_in_state_aggregation_body6077) state_partition_connection244 = self.state_partition_connection() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, state_partition_connection244.tree) else: break #loop80 # sdl92.g:544:17: ( state )* while True: #loop81 alt81 = 2 LA81_0 = self.input.LA(1) if (LA81_0 == STATE or LA81_0 == 229) : alt81 = 1 if alt81 == 1: # sdl92.g:0:0: state pass self._state.following.append(self.FOLLOW_state_in_state_aggregation_body6097) state245 = self.state() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, state245.tree) else: break #loop81 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, 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 "state_aggregation_body" class state_partitioning_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.state_partitioning_return, self).__init__() self.tree = None # $ANTLR start "state_partitioning" # sdl92.g:549:1: state_partitioning : composite_state ; def state_partitioning(self, ): retval = self.state_partitioning_return() retval.start = self.input.LT(1) root_0 = None composite_state246 = None try: try: # sdl92.g:550:9: ( composite_state ) # sdl92.g:550:17: composite_state pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_composite_state_in_state_partitioning6131) composite_state246 = self.composite_state() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, composite_state246.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, 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 "state_partitioning" class state_partition_connection_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.state_partition_connection_return, self).__init__() self.tree = None # $ANTLR start "state_partition_connection" # sdl92.g:555:1: state_partition_connection : CONNECT outer= entry_point AND inner= entry_point end -> ^( STATE_PARTITION_CONNECTION $outer $inner ( end )? ) ; def state_partition_connection(self, ): retval = self.state_partition_connection_return() retval.start = self.input.LT(1) root_0 = None CONNECT247 = None AND248 = None outer = None inner = None end249 = None CONNECT247_tree = None AND248_tree = None stream_CONNECT = RewriteRuleTokenStream(self._adaptor, "token CONNECT") stream_AND = RewriteRuleTokenStream(self._adaptor, "token AND") stream_entry_point = RewriteRuleSubtreeStream(self._adaptor, "rule entry_point") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:556:9: ( CONNECT outer= entry_point AND inner= entry_point end -> ^( STATE_PARTITION_CONNECTION $outer $inner ( end )? ) ) # sdl92.g:556:17: CONNECT outer= entry_point AND inner= entry_point end pass CONNECT247=self.match(self.input, CONNECT, self.FOLLOW_CONNECT_in_state_partition_connection6164) if self._state.backtracking == 0: stream_CONNECT.add(CONNECT247) self._state.following.append(self.FOLLOW_entry_point_in_state_partition_connection6168) outer = self.entry_point() self._state.following.pop() if self._state.backtracking == 0: stream_entry_point.add(outer.tree) AND248=self.match(self.input, AND, self.FOLLOW_AND_in_state_partition_connection6170) if self._state.backtracking == 0: stream_AND.add(AND248) self._state.following.append(self.FOLLOW_entry_point_in_state_partition_connection6174) inner = self.entry_point() self._state.following.pop() if self._state.backtracking == 0: stream_entry_point.add(inner.tree) self._state.following.append(self.FOLLOW_end_in_state_partition_connection6176) end249 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end249.tree) # AST Rewrite # elements: end, outer, inner # token labels: # rule labels: retval, outer, inner # 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) if outer is not None: stream_outer = RewriteRuleSubtreeStream(self._adaptor, "rule outer", outer.tree) else: stream_outer = RewriteRuleSubtreeStream(self._adaptor, "token outer", None) if inner is not None: stream_inner = RewriteRuleSubtreeStream(self._adaptor, "rule inner", inner.tree) else: stream_inner = RewriteRuleSubtreeStream(self._adaptor, "token inner", None) root_0 = self._adaptor.nil() # 557:9: -> ^( STATE_PARTITION_CONNECTION $outer $inner ( end )? ) # sdl92.g:557:17: ^( STATE_PARTITION_CONNECTION $outer $inner ( end )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(STATE_PARTITION_CONNECTION, "STATE_PARTITION_CONNECTION"), root_1) self._adaptor.addChild(root_1, stream_outer.nextTree()) self._adaptor.addChild(root_1, stream_inner.nextTree()) # sdl92.g:557:60: ( end )? if stream_end.hasNext(): self._adaptor.addChild(root_1, stream_end.nextTree()) stream_end.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, 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 "state_partition_connection" class entry_point_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.entry_point_return, self).__init__() self.tree = None # $ANTLR start "entry_point" # sdl92.g:562:1: entry_point : state_part_id= ID VIA point -> ^( ENTRY_POINT $state_part_id point ) ; def entry_point(self, ): retval = self.entry_point_return() retval.start = self.input.LT(1) root_0 = None state_part_id = None VIA250 = None point251 = None state_part_id_tree = None VIA250_tree = None stream_VIA = RewriteRuleTokenStream(self._adaptor, "token VIA") stream_ID = RewriteRuleTokenStream(self._adaptor, "token ID") stream_point = RewriteRuleSubtreeStream(self._adaptor, "rule point") try: try: # sdl92.g:563:9: (state_part_id= ID VIA point -> ^( ENTRY_POINT $state_part_id point ) ) # sdl92.g:563:17: state_part_id= ID VIA point pass state_part_id=self.match(self.input, ID, self.FOLLOW_ID_in_entry_point6239) if self._state.backtracking == 0: stream_ID.add(state_part_id) VIA250=self.match(self.input, VIA, self.FOLLOW_VIA_in_entry_point6241) if self._state.backtracking == 0: stream_VIA.add(VIA250) self._state.following.append(self.FOLLOW_point_in_entry_point6243) point251 = self.point() self._state.following.pop() if self._state.backtracking == 0: stream_point.add(point251.tree) # AST Rewrite # elements: point, state_part_id # token labels: state_part_id # rule labels: retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 stream_state_part_id = RewriteRuleTokenStream(self._adaptor, "token state_part_id", state_part_id) 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() # 564:9: -> ^( ENTRY_POINT $state_part_id point ) # sdl92.g:564:17: ^( ENTRY_POINT $state_part_id point ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(ENTRY_POINT, "ENTRY_POINT"), root_1) self._adaptor.addChild(root_1, stream_state_part_id.nextNode()) self._adaptor.addChild(root_1, stream_point.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, 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 "entry_point" class point_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.point_return, self).__init__() self.tree = None # $ANTLR start "point" # sdl92.g:569:1: point : (state_point= ID | DEFAULT ) -> ^( POINT ( $state_point)? ( DEFAULT )? ) ; def point(self, ): retval = self.point_return() retval.start = self.input.LT(1) root_0 = None state_point = None DEFAULT252 = None state_point_tree = None DEFAULT252_tree = None stream_ID = RewriteRuleTokenStream(self._adaptor, "token ID") stream_DEFAULT = RewriteRuleTokenStream(self._adaptor, "token DEFAULT") try: try: # sdl92.g:570:9: ( (state_point= ID | DEFAULT ) -> ^( POINT ( $state_point)? ( DEFAULT )? ) ) # sdl92.g:570:17: (state_point= ID | DEFAULT ) pass # sdl92.g:570:17: (state_point= ID | DEFAULT ) alt82 = 2 LA82_0 = self.input.LA(1) if (LA82_0 == ID) : alt82 = 1 elif (LA82_0 == DEFAULT) : alt82 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 82, 0, self.input) raise nvae if alt82 == 1: # sdl92.g:570:18: state_point= ID pass state_point=self.match(self.input, ID, self.FOLLOW_ID_in_point6303) if self._state.backtracking == 0: stream_ID.add(state_point) elif alt82 == 2: # sdl92.g:570:35: DEFAULT pass DEFAULT252=self.match(self.input, DEFAULT, self.FOLLOW_DEFAULT_in_point6307) if self._state.backtracking == 0: stream_DEFAULT.add(DEFAULT252) # AST Rewrite # elements: DEFAULT, state_point # token labels: state_point # rule labels: retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 stream_state_point = RewriteRuleTokenStream(self._adaptor, "token state_point", state_point) 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() # 571:9: -> ^( POINT ( $state_point)? ( DEFAULT )? ) # sdl92.g:571:17: ^( POINT ( $state_point)? ( DEFAULT )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(POINT, "POINT"), root_1) # sdl92.g:571:25: ( $state_point)? if stream_state_point.hasNext(): self._adaptor.addChild(root_1, stream_state_point.nextNode()) stream_state_point.reset(); # sdl92.g:571:39: ( DEFAULT )? if stream_DEFAULT.hasNext(): self._adaptor.addChild(root_1, stream_DEFAULT.nextNode()) stream_DEFAULT.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, 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 "point" class connection_points_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.connection_points_return, self).__init__() self.tree = None # $ANTLR start "connection_points" # sdl92.g:576:1: connection_points : ( IN state_entry_exit_points end -> ^( IN state_entry_exit_points ( end )? ) | OUT state_entry_exit_points end -> ^( OUT state_entry_exit_points ( end )? ) ); def connection_points(self, ): retval = self.connection_points_return() retval.start = self.input.LT(1) root_0 = None IN253 = None OUT256 = None state_entry_exit_points254 = None end255 = None state_entry_exit_points257 = None end258 = None IN253_tree = None OUT256_tree = None stream_IN = RewriteRuleTokenStream(self._adaptor, "token IN") stream_OUT = RewriteRuleTokenStream(self._adaptor, "token OUT") stream_state_entry_exit_points = RewriteRuleSubtreeStream(self._adaptor, "rule state_entry_exit_points") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:577:9: ( IN state_entry_exit_points end -> ^( IN state_entry_exit_points ( end )? ) | OUT state_entry_exit_points end -> ^( OUT state_entry_exit_points ( end )? ) ) alt83 = 2 LA83_0 = self.input.LA(1) if (LA83_0 == IN) : alt83 = 1 elif (LA83_0 == OUT) : alt83 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 83, 0, self.input) raise nvae if alt83 == 1: # sdl92.g:577:17: IN state_entry_exit_points end pass IN253=self.match(self.input, IN, self.FOLLOW_IN_in_connection_points6367) if self._state.backtracking == 0: stream_IN.add(IN253) self._state.following.append(self.FOLLOW_state_entry_exit_points_in_connection_points6369) state_entry_exit_points254 = self.state_entry_exit_points() self._state.following.pop() if self._state.backtracking == 0: stream_state_entry_exit_points.add(state_entry_exit_points254.tree) self._state.following.append(self.FOLLOW_end_in_connection_points6371) end255 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end255.tree) # AST Rewrite # elements: end, IN, state_entry_exit_points # 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() # 578:9: -> ^( IN state_entry_exit_points ( end )? ) # sdl92.g:578:17: ^( IN state_entry_exit_points ( end )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_IN.nextNode(), root_1) self._adaptor.addChild(root_1, stream_state_entry_exit_points.nextTree()) # sdl92.g:578:46: ( end )? if stream_end.hasNext(): self._adaptor.addChild(root_1, stream_end.nextTree()) stream_end.reset(); self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt83 == 2: # sdl92.g:579:19: OUT state_entry_exit_points end pass OUT256=self.match(self.input, OUT, self.FOLLOW_OUT_in_connection_points6415) if self._state.backtracking == 0: stream_OUT.add(OUT256) self._state.following.append(self.FOLLOW_state_entry_exit_points_in_connection_points6417) state_entry_exit_points257 = self.state_entry_exit_points() self._state.following.pop() if self._state.backtracking == 0: stream_state_entry_exit_points.add(state_entry_exit_points257.tree) self._state.following.append(self.FOLLOW_end_in_connection_points6419) end258 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end258.tree) # AST Rewrite # elements: state_entry_exit_points, end, OUT # 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() # 580:9: -> ^( OUT state_entry_exit_points ( end )? ) # sdl92.g:580:17: ^( OUT state_entry_exit_points ( end )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_OUT.nextNode(), root_1) self._adaptor.addChild(root_1, stream_state_entry_exit_points.nextTree()) # sdl92.g:580:47: ( end )? if stream_end.hasNext(): self._adaptor.addChild(root_1, stream_end.nextTree()) stream_end.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, 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 "connection_points" class state_entry_exit_points_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.state_entry_exit_points_return, self).__init__() self.tree = None # $ANTLR start "state_entry_exit_points" # sdl92.g:585:1: state_entry_exit_points : '(' statename ( ',' statename )* ')' -> ( statename )+ ; def state_entry_exit_points(self, ): retval = self.state_entry_exit_points_return() retval.start = self.input.LT(1) root_0 = None char_literal259 = None char_literal261 = None char_literal263 = None statename260 = None statename262 = None char_literal259_tree = None char_literal261_tree = None char_literal263_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_statename = RewriteRuleSubtreeStream(self._adaptor, "rule statename") try: try: # sdl92.g:586:9: ( '(' statename ( ',' statename )* ')' -> ( statename )+ ) # sdl92.g:586:17: '(' statename ( ',' statename )* ')' pass char_literal259=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_state_entry_exit_points6476) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal259) self._state.following.append(self.FOLLOW_statename_in_state_entry_exit_points6478) statename260 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename260.tree) # sdl92.g:586:31: ( ',' statename )* while True: #loop84 alt84 = 2 LA84_0 = self.input.LA(1) if (LA84_0 == COMMA) : alt84 = 1 if alt84 == 1: # sdl92.g:586:32: ',' statename pass char_literal261=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_state_entry_exit_points6481) if self._state.backtracking == 0: stream_COMMA.add(char_literal261) self._state.following.append(self.FOLLOW_statename_in_state_entry_exit_points6483) statename262 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename262.tree) else: break #loop84 char_literal263=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_state_entry_exit_points6487) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal263) # AST Rewrite # elements: statename # 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() # 587:9: -> ( statename )+ # sdl92.g:587:17: ( statename )+ if not (stream_statename.hasNext()): raise RewriteEarlyExitException() while stream_statename.hasNext(): self._adaptor.addChild(root_0, stream_statename.nextTree()) stream_statename.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, 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 "state_entry_exit_points" class composite_state_body_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.composite_state_body_return, self).__init__() self.tree = None # $ANTLR start "composite_state_body" # sdl92.g:592:1: composite_state_body : ( text_area | procedure | composite_state )* ( start )* ( state | floating_label )* ; def composite_state_body(self, ): retval = self.composite_state_body_return() retval.start = self.input.LT(1) root_0 = None text_area264 = None procedure265 = None composite_state266 = None start267 = None state268 = None floating_label269 = None try: try: # sdl92.g:593:9: ( ( text_area | procedure | composite_state )* ( start )* ( state | floating_label )* ) # sdl92.g:593:17: ( text_area | procedure | composite_state )* ( start )* ( state | floating_label )* pass root_0 = self._adaptor.nil() # sdl92.g:593:17: ( text_area | procedure | composite_state )* while True: #loop85 alt85 = 4 LA85 = self.input.LA(1) if LA85 == 229: LA85_1 = self.input.LA(2) if (self.synpred110_sdl92()) : alt85 = 1 elif (self.synpred111_sdl92()) : alt85 = 2 elif LA85 == STATE: LA85_3 = self.input.LA(2) if (self.synpred112_sdl92()) : alt85 = 3 elif LA85 == PROCEDURE: alt85 = 2 if alt85 == 1: # sdl92.g:593:18: text_area pass self._state.following.append(self.FOLLOW_text_area_in_composite_state_body6539) text_area264 = self.text_area() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, text_area264.tree) elif alt85 == 2: # sdl92.g:593:30: procedure pass self._state.following.append(self.FOLLOW_procedure_in_composite_state_body6543) procedure265 = self.procedure() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, procedure265.tree) elif alt85 == 3: # sdl92.g:593:42: composite_state pass self._state.following.append(self.FOLLOW_composite_state_in_composite_state_body6547) composite_state266 = self.composite_state() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, composite_state266.tree) else: break #loop85 # sdl92.g:594:17: ( start )* while True: #loop86 alt86 = 2 alt86 = self.dfa86.predict(self.input) if alt86 == 1: # sdl92.g:0:0: start pass self._state.following.append(self.FOLLOW_start_in_composite_state_body6567) start267 = self.start() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, start267.tree) else: break #loop86 # sdl92.g:594:24: ( state | floating_label )* while True: #loop87 alt87 = 3 alt87 = self.dfa87.predict(self.input) if alt87 == 1: # sdl92.g:594:25: state pass self._state.following.append(self.FOLLOW_state_in_composite_state_body6571) state268 = self.state() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, state268.tree) elif alt87 == 2: # sdl92.g:594:33: floating_label pass self._state.following.append(self.FOLLOW_floating_label_in_composite_state_body6575) floating_label269 = self.floating_label() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, floating_label269.tree) else: break #loop87 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, 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 "composite_state_body" class state_part_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.state_part_return, self).__init__() self.tree = None # $ANTLR start "state_part" # sdl92.g:598:1: state_part : ( input_part | save_part | spontaneous_transition | continuous_signal | connect_part ); def state_part(self, ): retval = self.state_part_return() retval.start = self.input.LT(1) root_0 = None input_part270 = None save_part271 = None spontaneous_transition272 = None continuous_signal273 = None connect_part274 = None try: try: # sdl92.g:599:9: ( input_part | save_part | spontaneous_transition | continuous_signal | connect_part ) alt88 = 5 alt88 = self.dfa88.predict(self.input) if alt88 == 1: # sdl92.g:599:17: input_part pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_input_part_in_state_part6609) input_part270 = self.input_part() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, input_part270.tree) elif alt88 == 2: # sdl92.g:601:19: save_part pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_save_part_in_state_part6646) save_part271 = self.save_part() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, save_part271.tree) elif alt88 == 3: # sdl92.g:602:19: spontaneous_transition pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_spontaneous_transition_in_state_part6681) spontaneous_transition272 = self.spontaneous_transition() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, spontaneous_transition272.tree) elif alt88 == 4: # sdl92.g:603:19: continuous_signal pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_continuous_signal_in_state_part6701) continuous_signal273 = self.continuous_signal() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, continuous_signal273.tree) elif alt88 == 5: # sdl92.g:604:19: connect_part pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_connect_part_in_state_part6721) connect_part274 = self.connect_part() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, connect_part274.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, 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 "state_part" class connect_part_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.connect_part_return, self).__init__() self.tree = None # $ANTLR start "connect_part" # sdl92.g:609:1: connect_part : ( cif )? ( hyperlink )? CONNECT ( connect_list )? end ( transition )? -> ^( CONNECT ( cif )? ( hyperlink )? ( connect_list )? ( end )? ( transition )? ) ; def connect_part(self, ): retval = self.connect_part_return() retval.start = self.input.LT(1) root_0 = None CONNECT277 = None cif275 = None hyperlink276 = None connect_list278 = None end279 = None transition280 = None CONNECT277_tree = None stream_CONNECT = RewriteRuleTokenStream(self._adaptor, "token CONNECT") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") stream_connect_list = RewriteRuleSubtreeStream(self._adaptor, "rule connect_list") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:610:9: ( ( cif )? ( hyperlink )? CONNECT ( connect_list )? end ( transition )? -> ^( CONNECT ( cif )? ( hyperlink )? ( connect_list )? ( end )? ( transition )? ) ) # sdl92.g:610:17: ( cif )? ( hyperlink )? CONNECT ( connect_list )? end ( transition )? pass # sdl92.g:610:17: ( cif )? alt89 = 2 LA89_0 = self.input.LA(1) if (LA89_0 == 229) : LA89_1 = self.input.LA(2) if (LA89_1 == ANSWER or LA89_1 == COMMENT or LA89_1 == CONNECT or LA89_1 == DECISION or LA89_1 == INPUT or (JOIN <= LA89_1 <= LABEL) or LA89_1 == NEXTSTATE or LA89_1 == OUTPUT or (PROCEDURE <= LA89_1 <= PROCEDURE_CALL) or (PROCESS <= LA89_1 <= PROVIDED) or LA89_1 == RETURN or LA89_1 == STATE or LA89_1 == STOP or LA89_1 == TASK or LA89_1 == TEXT or LA89_1 == START) : alt89 = 1 if alt89 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_connect_part6754) cif275 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif275.tree) # sdl92.g:611:17: ( hyperlink )? alt90 = 2 LA90_0 = self.input.LA(1) if (LA90_0 == 229) : alt90 = 1 if alt90 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_connect_part6773) hyperlink276 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink276.tree) CONNECT277=self.match(self.input, CONNECT, self.FOLLOW_CONNECT_in_connect_part6792) if self._state.backtracking == 0: stream_CONNECT.add(CONNECT277) # sdl92.g:612:25: ( connect_list )? alt91 = 2 LA91_0 = self.input.LA(1) if (LA91_0 == ID or LA91_0 == ASTERISK) : alt91 = 1 if alt91 == 1: # sdl92.g:0:0: connect_list pass self._state.following.append(self.FOLLOW_connect_list_in_connect_part6794) connect_list278 = self.connect_list() self._state.following.pop() if self._state.backtracking == 0: stream_connect_list.add(connect_list278.tree) self._state.following.append(self.FOLLOW_end_in_connect_part6797) end279 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end279.tree) # sdl92.g:613:17: ( transition )? alt92 = 2 alt92 = self.dfa92.predict(self.input) if alt92 == 1: # sdl92.g:0:0: transition pass self._state.following.append(self.FOLLOW_transition_in_connect_part6815) transition280 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition280.tree) # AST Rewrite # elements: transition, cif, hyperlink, connect_list, CONNECT, end # 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() # 614:9: -> ^( CONNECT ( cif )? ( hyperlink )? ( connect_list )? ( end )? ( transition )? ) # sdl92.g:614:17: ^( CONNECT ( cif )? ( hyperlink )? ( connect_list )? ( end )? ( transition )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_CONNECT.nextNode(), root_1) # sdl92.g:614:27: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:614:32: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:614:43: ( connect_list )? if stream_connect_list.hasNext(): self._adaptor.addChild(root_1, stream_connect_list.nextTree()) stream_connect_list.reset(); # sdl92.g:614:57: ( end )? if stream_end.hasNext(): self._adaptor.addChild(root_1, stream_end.nextTree()) stream_end.reset(); # sdl92.g:614:62: ( transition )? if stream_transition.hasNext(): self._adaptor.addChild(root_1, stream_transition.nextTree()) stream_transition.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, 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 "connect_part" class connect_list_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.connect_list_return, self).__init__() self.tree = None # $ANTLR start "connect_list" # sdl92.g:618:1: connect_list : ( state_exit_point_name ( ',' state_exit_point_name )* -> ( state_exit_point_name )+ | ASTERISK ); def connect_list(self, ): retval = self.connect_list_return() retval.start = self.input.LT(1) root_0 = None char_literal282 = None ASTERISK284 = None state_exit_point_name281 = None state_exit_point_name283 = None char_literal282_tree = None ASTERISK284_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_state_exit_point_name = RewriteRuleSubtreeStream(self._adaptor, "rule state_exit_point_name") try: try: # sdl92.g:619:9: ( state_exit_point_name ( ',' state_exit_point_name )* -> ( state_exit_point_name )+ | ASTERISK ) alt94 = 2 LA94_0 = self.input.LA(1) if (LA94_0 == ID) : alt94 = 1 elif (LA94_0 == ASTERISK) : alt94 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 94, 0, self.input) raise nvae if alt94 == 1: # sdl92.g:619:17: state_exit_point_name ( ',' state_exit_point_name )* pass self._state.following.append(self.FOLLOW_state_exit_point_name_in_connect_list6882) state_exit_point_name281 = self.state_exit_point_name() self._state.following.pop() if self._state.backtracking == 0: stream_state_exit_point_name.add(state_exit_point_name281.tree) # sdl92.g:619:39: ( ',' state_exit_point_name )* while True: #loop93 alt93 = 2 LA93_0 = self.input.LA(1) if (LA93_0 == COMMA) : alt93 = 1 if alt93 == 1: # sdl92.g:619:40: ',' state_exit_point_name pass char_literal282=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_connect_list6885) if self._state.backtracking == 0: stream_COMMA.add(char_literal282) self._state.following.append(self.FOLLOW_state_exit_point_name_in_connect_list6887) state_exit_point_name283 = self.state_exit_point_name() self._state.following.pop() if self._state.backtracking == 0: stream_state_exit_point_name.add(state_exit_point_name283.tree) else: break #loop93 # AST Rewrite # elements: state_exit_point_name # 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() # 620:17: -> ( state_exit_point_name )+ # sdl92.g:620:20: ( state_exit_point_name )+ if not (stream_state_exit_point_name.hasNext()): raise RewriteEarlyExitException() while stream_state_exit_point_name.hasNext(): self._adaptor.addChild(root_0, stream_state_exit_point_name.nextTree()) stream_state_exit_point_name.reset() retval.tree = root_0 elif alt94 == 2: # sdl92.g:621:19: ASTERISK pass root_0 = self._adaptor.nil() ASTERISK284=self.match(self.input, ASTERISK, self.FOLLOW_ASTERISK_in_connect_list6930) if self._state.backtracking == 0: ASTERISK284_tree = self._adaptor.createWithPayload(ASTERISK284) self._adaptor.addChild(root_0, ASTERISK284_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, 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 "connect_list" class spontaneous_transition_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.spontaneous_transition_return, self).__init__() self.tree = None # $ANTLR start "spontaneous_transition" # sdl92.g:625:1: spontaneous_transition : ( cif )? ( hyperlink )? INPUT NONE end ( enabling_condition )? transition -> ^( INPUT_NONE ( cif )? ( hyperlink )? transition ) ; def spontaneous_transition(self, ): retval = self.spontaneous_transition_return() retval.start = self.input.LT(1) root_0 = None INPUT287 = None NONE288 = None cif285 = None hyperlink286 = None end289 = None enabling_condition290 = None transition291 = None INPUT287_tree = None NONE288_tree = None stream_INPUT = RewriteRuleTokenStream(self._adaptor, "token INPUT") stream_NONE = RewriteRuleTokenStream(self._adaptor, "token NONE") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") stream_enabling_condition = RewriteRuleSubtreeStream(self._adaptor, "rule enabling_condition") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:626:9: ( ( cif )? ( hyperlink )? INPUT NONE end ( enabling_condition )? transition -> ^( INPUT_NONE ( cif )? ( hyperlink )? transition ) ) # sdl92.g:626:17: ( cif )? ( hyperlink )? INPUT NONE end ( enabling_condition )? transition pass # sdl92.g:626:17: ( cif )? alt95 = 2 LA95_0 = self.input.LA(1) if (LA95_0 == 229) : LA95_1 = self.input.LA(2) if (LA95_1 == ANSWER or LA95_1 == COMMENT or LA95_1 == CONNECT or LA95_1 == DECISION or LA95_1 == INPUT or (JOIN <= LA95_1 <= LABEL) or LA95_1 == NEXTSTATE or LA95_1 == OUTPUT or (PROCEDURE <= LA95_1 <= PROCEDURE_CALL) or (PROCESS <= LA95_1 <= PROVIDED) or LA95_1 == RETURN or LA95_1 == STATE or LA95_1 == STOP or LA95_1 == TASK or LA95_1 == TEXT or LA95_1 == START) : alt95 = 1 if alt95 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_spontaneous_transition6962) cif285 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif285.tree) # sdl92.g:627:17: ( hyperlink )? alt96 = 2 LA96_0 = self.input.LA(1) if (LA96_0 == 229) : alt96 = 1 if alt96 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_spontaneous_transition6981) hyperlink286 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink286.tree) INPUT287=self.match(self.input, INPUT, self.FOLLOW_INPUT_in_spontaneous_transition7000) if self._state.backtracking == 0: stream_INPUT.add(INPUT287) NONE288=self.match(self.input, NONE, self.FOLLOW_NONE_in_spontaneous_transition7002) if self._state.backtracking == 0: stream_NONE.add(NONE288) self._state.following.append(self.FOLLOW_end_in_spontaneous_transition7004) end289 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end289.tree) # sdl92.g:629:17: ( enabling_condition )? alt97 = 2 LA97_0 = self.input.LA(1) if (LA97_0 == PROVIDED) : alt97 = 1 if alt97 == 1: # sdl92.g:0:0: enabling_condition pass self._state.following.append(self.FOLLOW_enabling_condition_in_spontaneous_transition7022) enabling_condition290 = self.enabling_condition() self._state.following.pop() if self._state.backtracking == 0: stream_enabling_condition.add(enabling_condition290.tree) self._state.following.append(self.FOLLOW_transition_in_spontaneous_transition7041) transition291 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition291.tree) # AST Rewrite # elements: transition, cif, hyperlink # 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() # 631:9: -> ^( INPUT_NONE ( cif )? ( hyperlink )? transition ) # sdl92.g:631:17: ^( INPUT_NONE ( cif )? ( hyperlink )? transition ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(INPUT_NONE, "INPUT_NONE"), root_1) # sdl92.g:631:30: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:631:35: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); self._adaptor.addChild(root_1, stream_transition.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, 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 "spontaneous_transition" class enabling_condition_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.enabling_condition_return, self).__init__() self.tree = None # $ANTLR start "enabling_condition" # sdl92.g:635:1: enabling_condition : PROVIDED expression end -> ^( PROVIDED expression ) ; def enabling_condition(self, ): retval = self.enabling_condition_return() retval.start = self.input.LT(1) root_0 = None PROVIDED292 = None expression293 = None end294 = None PROVIDED292_tree = None stream_PROVIDED = RewriteRuleTokenStream(self._adaptor, "token PROVIDED") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:636:9: ( PROVIDED expression end -> ^( PROVIDED expression ) ) # sdl92.g:636:17: PROVIDED expression end pass PROVIDED292=self.match(self.input, PROVIDED, self.FOLLOW_PROVIDED_in_enabling_condition7100) if self._state.backtracking == 0: stream_PROVIDED.add(PROVIDED292) self._state.following.append(self.FOLLOW_expression_in_enabling_condition7102) expression293 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression293.tree) self._state.following.append(self.FOLLOW_end_in_enabling_condition7104) end294 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end294.tree) # AST Rewrite # elements: PROVIDED, expression # 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() # 637:9: -> ^( PROVIDED expression ) # sdl92.g:637:17: ^( PROVIDED expression ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_PROVIDED.nextNode(), root_1) self._adaptor.addChild(root_1, stream_expression.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, 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 "enabling_condition" class continuous_signal_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.continuous_signal_return, self).__init__() self.tree = None # $ANTLR start "continuous_signal" # sdl92.g:641:1: continuous_signal : ( cif )? ( hyperlink )? PROVIDED expression e= end ( PRIORITY p= INT end )? ( transition )? -> ^( PROVIDED expression ( cif )? ( hyperlink )? ( $p)? ( $e)? ( transition )? ) ; def continuous_signal(self, ): retval = self.continuous_signal_return() retval.start = self.input.LT(1) root_0 = None p = None PROVIDED297 = None PRIORITY299 = None e = None cif295 = None hyperlink296 = None expression298 = None end300 = None transition301 = None p_tree = None PROVIDED297_tree = None PRIORITY299_tree = None stream_INT = RewriteRuleTokenStream(self._adaptor, "token INT") stream_PRIORITY = RewriteRuleTokenStream(self._adaptor, "token PRIORITY") stream_PROVIDED = RewriteRuleTokenStream(self._adaptor, "token PROVIDED") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:642:9: ( ( cif )? ( hyperlink )? PROVIDED expression e= end ( PRIORITY p= INT end )? ( transition )? -> ^( PROVIDED expression ( cif )? ( hyperlink )? ( $p)? ( $e)? ( transition )? ) ) # sdl92.g:642:17: ( cif )? ( hyperlink )? PROVIDED expression e= end ( PRIORITY p= INT end )? ( transition )? pass # sdl92.g:642:17: ( cif )? alt98 = 2 LA98_0 = self.input.LA(1) if (LA98_0 == 229) : LA98_1 = self.input.LA(2) if (LA98_1 == ANSWER or LA98_1 == COMMENT or LA98_1 == CONNECT or LA98_1 == DECISION or LA98_1 == INPUT or (JOIN <= LA98_1 <= LABEL) or LA98_1 == NEXTSTATE or LA98_1 == OUTPUT or (PROCEDURE <= LA98_1 <= PROCEDURE_CALL) or (PROCESS <= LA98_1 <= PROVIDED) or LA98_1 == RETURN or LA98_1 == STATE or LA98_1 == STOP or LA98_1 == TASK or LA98_1 == TEXT or LA98_1 == START) : alt98 = 1 if alt98 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_continuous_signal7157) cif295 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif295.tree) # sdl92.g:643:17: ( hyperlink )? alt99 = 2 LA99_0 = self.input.LA(1) if (LA99_0 == 229) : alt99 = 1 if alt99 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_continuous_signal7176) hyperlink296 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink296.tree) PROVIDED297=self.match(self.input, PROVIDED, self.FOLLOW_PROVIDED_in_continuous_signal7195) if self._state.backtracking == 0: stream_PROVIDED.add(PROVIDED297) self._state.following.append(self.FOLLOW_expression_in_continuous_signal7197) expression298 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression298.tree) self._state.following.append(self.FOLLOW_end_in_continuous_signal7201) e = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(e.tree) # sdl92.g:645:17: ( PRIORITY p= INT end )? alt100 = 2 LA100_0 = self.input.LA(1) if (LA100_0 == PRIORITY) : alt100 = 1 if alt100 == 1: # sdl92.g:645:18: PRIORITY p= INT end pass PRIORITY299=self.match(self.input, PRIORITY, self.FOLLOW_PRIORITY_in_continuous_signal7220) if self._state.backtracking == 0: stream_PRIORITY.add(PRIORITY299) p=self.match(self.input, INT, self.FOLLOW_INT_in_continuous_signal7224) if self._state.backtracking == 0: stream_INT.add(p) self._state.following.append(self.FOLLOW_end_in_continuous_signal7226) end300 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end300.tree) # sdl92.g:646:17: ( transition )? alt101 = 2 alt101 = self.dfa101.predict(self.input) if alt101 == 1: # sdl92.g:0:0: transition pass self._state.following.append(self.FOLLOW_transition_in_continuous_signal7246) transition301 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition301.tree) # AST Rewrite # elements: expression, transition, cif, PROVIDED, e, p, hyperlink # token labels: p # rule labels: retval, e # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 stream_p = RewriteRuleTokenStream(self._adaptor, "token p", p) if retval is not None: stream_retval = RewriteRuleSubtreeStream(self._adaptor, "rule retval", retval.tree) else: stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None) if e is not None: stream_e = RewriteRuleSubtreeStream(self._adaptor, "rule e", e.tree) else: stream_e = RewriteRuleSubtreeStream(self._adaptor, "token e", None) root_0 = self._adaptor.nil() # 647:9: -> ^( PROVIDED expression ( cif )? ( hyperlink )? ( $p)? ( $e)? ( transition )? ) # sdl92.g:647:17: ^( PROVIDED expression ( cif )? ( hyperlink )? ( $p)? ( $e)? ( transition )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_PROVIDED.nextNode(), root_1) self._adaptor.addChild(root_1, stream_expression.nextTree()) # sdl92.g:647:39: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:647:44: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:647:55: ( $p)? if stream_p.hasNext(): self._adaptor.addChild(root_1, stream_p.nextNode()) stream_p.reset(); # sdl92.g:647:59: ( $e)? if stream_e.hasNext(): self._adaptor.addChild(root_1, stream_e.nextTree()) stream_e.reset(); # sdl92.g:647:63: ( transition )? if stream_transition.hasNext(): self._adaptor.addChild(root_1, stream_transition.nextTree()) stream_transition.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, 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 "continuous_signal" class save_part_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.save_part_return, self).__init__() self.tree = None # $ANTLR start "save_part" # sdl92.g:651:1: save_part : SAVE save_list end -> ^( SAVE save_list ) ; def save_part(self, ): retval = self.save_part_return() retval.start = self.input.LT(1) root_0 = None SAVE302 = None save_list303 = None end304 = None SAVE302_tree = None stream_SAVE = RewriteRuleTokenStream(self._adaptor, "token SAVE") stream_save_list = RewriteRuleSubtreeStream(self._adaptor, "rule save_list") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:652:9: ( SAVE save_list end -> ^( SAVE save_list ) ) # sdl92.g:652:17: SAVE save_list end pass SAVE302=self.match(self.input, SAVE, self.FOLLOW_SAVE_in_save_part7317) if self._state.backtracking == 0: stream_SAVE.add(SAVE302) self._state.following.append(self.FOLLOW_save_list_in_save_part7319) save_list303 = self.save_list() self._state.following.pop() if self._state.backtracking == 0: stream_save_list.add(save_list303.tree) self._state.following.append(self.FOLLOW_end_in_save_part7337) end304 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end304.tree) # AST Rewrite # elements: save_list, SAVE # 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() # 654:9: -> ^( SAVE save_list ) # sdl92.g:654:17: ^( SAVE save_list ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_SAVE.nextNode(), root_1) self._adaptor.addChild(root_1, stream_save_list.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, 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 "save_part" class save_list_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.save_list_return, self).__init__() self.tree = None # $ANTLR start "save_list" # sdl92.g:658:1: save_list : ( signal_list | asterisk_save_list ); def save_list(self, ): retval = self.save_list_return() retval.start = self.input.LT(1) root_0 = None signal_list305 = None asterisk_save_list306 = None try: try: # sdl92.g:659:9: ( signal_list | asterisk_save_list ) alt102 = 2 LA102_0 = self.input.LA(1) if (LA102_0 == ID) : alt102 = 1 elif (LA102_0 == ASTERISK) : alt102 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 102, 0, self.input) raise nvae if alt102 == 1: # sdl92.g:659:17: signal_list pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_signal_list_in_save_list7390) signal_list305 = self.signal_list() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, signal_list305.tree) elif alt102 == 2: # sdl92.g:660:19: asterisk_save_list pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_asterisk_save_list_in_save_list7410) asterisk_save_list306 = self.asterisk_save_list() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, asterisk_save_list306.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, 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 "save_list" class asterisk_save_list_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.asterisk_save_list_return, self).__init__() self.tree = None # $ANTLR start "asterisk_save_list" # sdl92.g:664:1: asterisk_save_list : ASTERISK ; def asterisk_save_list(self, ): retval = self.asterisk_save_list_return() retval.start = self.input.LT(1) root_0 = None ASTERISK307 = None ASTERISK307_tree = None try: try: # sdl92.g:665:9: ( ASTERISK ) # sdl92.g:665:17: ASTERISK pass root_0 = self._adaptor.nil() ASTERISK307=self.match(self.input, ASTERISK, self.FOLLOW_ASTERISK_in_asterisk_save_list7442) if self._state.backtracking == 0: ASTERISK307_tree = self._adaptor.createWithPayload(ASTERISK307) self._adaptor.addChild(root_0, ASTERISK307_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, 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 "asterisk_save_list" class signal_list_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.signal_list_return, self).__init__() self.tree = None # $ANTLR start "signal_list" # sdl92.g:668:1: signal_list : signal_item ( ',' signal_item )* -> ^( SIGNAL_LIST ( signal_item )+ ) ; def signal_list(self, ): retval = self.signal_list_return() retval.start = self.input.LT(1) root_0 = None char_literal309 = None signal_item308 = None signal_item310 = None char_literal309_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_signal_item = RewriteRuleSubtreeStream(self._adaptor, "rule signal_item") try: try: # sdl92.g:669:9: ( signal_item ( ',' signal_item )* -> ^( SIGNAL_LIST ( signal_item )+ ) ) # sdl92.g:669:17: signal_item ( ',' signal_item )* pass self._state.following.append(self.FOLLOW_signal_item_in_signal_list7465) signal_item308 = self.signal_item() self._state.following.pop() if self._state.backtracking == 0: stream_signal_item.add(signal_item308.tree) # sdl92.g:669:29: ( ',' signal_item )* while True: #loop103 alt103 = 2 LA103_0 = self.input.LA(1) if (LA103_0 == COMMA) : alt103 = 1 if alt103 == 1: # sdl92.g:669:30: ',' signal_item pass char_literal309=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_signal_list7468) if self._state.backtracking == 0: stream_COMMA.add(char_literal309) self._state.following.append(self.FOLLOW_signal_item_in_signal_list7470) signal_item310 = self.signal_item() self._state.following.pop() if self._state.backtracking == 0: stream_signal_item.add(signal_item310.tree) else: break #loop103 # AST Rewrite # elements: signal_item # 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() # 670:9: -> ^( SIGNAL_LIST ( signal_item )+ ) # sdl92.g:670:17: ^( SIGNAL_LIST ( signal_item )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(SIGNAL_LIST, "SIGNAL_LIST"), root_1) # sdl92.g:670:31: ( signal_item )+ if not (stream_signal_item.hasNext()): raise RewriteEarlyExitException() while stream_signal_item.hasNext(): self._adaptor.addChild(root_1, stream_signal_item.nextTree()) stream_signal_item.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, 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 "signal_list" class signal_item_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.signal_item_return, self).__init__() self.tree = None # $ANTLR start "signal_item" # sdl92.g:677:1: signal_item : signal_id ; def signal_item(self, ): retval = self.signal_item_return() retval.start = self.input.LT(1) root_0 = None signal_id311 = None try: try: # sdl92.g:678:9: ( signal_id ) # sdl92.g:678:17: signal_id pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_signal_id_in_signal_item7529) signal_id311 = self.signal_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, signal_id311.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, 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 "signal_item" class input_part_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.input_part_return, self).__init__() self.tree = None # $ANTLR start "input_part" # sdl92.g:698:1: input_part : ( cif )? ( hyperlink )? INPUT inputlist end ( enabling_condition )? ( transition )? -> ^( INPUT ( cif )? ( hyperlink )? ( end )? inputlist ( enabling_condition )? ( transition )? ) ; def input_part(self, ): retval = self.input_part_return() retval.start = self.input.LT(1) root_0 = None INPUT314 = None cif312 = None hyperlink313 = None inputlist315 = None end316 = None enabling_condition317 = None transition318 = None INPUT314_tree = None stream_INPUT = RewriteRuleTokenStream(self._adaptor, "token INPUT") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") stream_inputlist = RewriteRuleSubtreeStream(self._adaptor, "rule inputlist") stream_enabling_condition = RewriteRuleSubtreeStream(self._adaptor, "rule enabling_condition") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:699:9: ( ( cif )? ( hyperlink )? INPUT inputlist end ( enabling_condition )? ( transition )? -> ^( INPUT ( cif )? ( hyperlink )? ( end )? inputlist ( enabling_condition )? ( transition )? ) ) # sdl92.g:699:17: ( cif )? ( hyperlink )? INPUT inputlist end ( enabling_condition )? ( transition )? pass # sdl92.g:699:17: ( cif )? alt104 = 2 LA104_0 = self.input.LA(1) if (LA104_0 == 229) : LA104_1 = self.input.LA(2) if (LA104_1 == ANSWER or LA104_1 == COMMENT or LA104_1 == CONNECT or LA104_1 == DECISION or LA104_1 == INPUT or (JOIN <= LA104_1 <= LABEL) or LA104_1 == NEXTSTATE or LA104_1 == OUTPUT or (PROCEDURE <= LA104_1 <= PROCEDURE_CALL) or (PROCESS <= LA104_1 <= PROVIDED) or LA104_1 == RETURN or LA104_1 == STATE or LA104_1 == STOP or LA104_1 == TASK or LA104_1 == TEXT or LA104_1 == START) : alt104 = 1 if alt104 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_input_part7558) cif312 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif312.tree) # sdl92.g:700:17: ( hyperlink )? alt105 = 2 LA105_0 = self.input.LA(1) if (LA105_0 == 229) : alt105 = 1 if alt105 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_input_part7577) hyperlink313 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink313.tree) INPUT314=self.match(self.input, INPUT, self.FOLLOW_INPUT_in_input_part7596) if self._state.backtracking == 0: stream_INPUT.add(INPUT314) self._state.following.append(self.FOLLOW_inputlist_in_input_part7598) inputlist315 = self.inputlist() self._state.following.pop() if self._state.backtracking == 0: stream_inputlist.add(inputlist315.tree) self._state.following.append(self.FOLLOW_end_in_input_part7600) end316 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end316.tree) # sdl92.g:702:17: ( enabling_condition )? alt106 = 2 alt106 = self.dfa106.predict(self.input) if alt106 == 1: # sdl92.g:0:0: enabling_condition pass self._state.following.append(self.FOLLOW_enabling_condition_in_input_part7618) enabling_condition317 = self.enabling_condition() self._state.following.pop() if self._state.backtracking == 0: stream_enabling_condition.add(enabling_condition317.tree) # sdl92.g:703:17: ( transition )? alt107 = 2 alt107 = self.dfa107.predict(self.input) if alt107 == 1: # sdl92.g:0:0: transition pass self._state.following.append(self.FOLLOW_transition_in_input_part7637) transition318 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition318.tree) # AST Rewrite # elements: INPUT, end, inputlist, hyperlink, enabling_condition, transition, cif # 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() # 704:9: -> ^( INPUT ( cif )? ( hyperlink )? ( end )? inputlist ( enabling_condition )? ( transition )? ) # sdl92.g:704:17: ^( INPUT ( cif )? ( hyperlink )? ( end )? inputlist ( enabling_condition )? ( transition )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_INPUT.nextNode(), root_1) # sdl92.g:704:25: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:704:30: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:704:41: ( end )? if stream_end.hasNext(): self._adaptor.addChild(root_1, stream_end.nextTree()) stream_end.reset(); self._adaptor.addChild(root_1, stream_inputlist.nextTree()) # sdl92.g:705:27: ( enabling_condition )? if stream_enabling_condition.hasNext(): self._adaptor.addChild(root_1, stream_enabling_condition.nextTree()) stream_enabling_condition.reset(); # sdl92.g:705:47: ( transition )? if stream_transition.hasNext(): self._adaptor.addChild(root_1, stream_transition.nextTree()) stream_transition.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, 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 "input_part" class inputlist_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.inputlist_return, self).__init__() self.tree = None # $ANTLR start "inputlist" # sdl92.g:711:1: inputlist : ( ASTERISK | ( stimulus ( ',' stimulus )* ) -> ^( INPUTLIST ( stimulus )+ ) ); def inputlist(self, ): retval = self.inputlist_return() retval.start = self.input.LT(1) root_0 = None ASTERISK319 = None char_literal321 = None stimulus320 = None stimulus322 = None ASTERISK319_tree = None char_literal321_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_stimulus = RewriteRuleSubtreeStream(self._adaptor, "rule stimulus") try: try: # sdl92.g:712:9: ( ASTERISK | ( stimulus ( ',' stimulus )* ) -> ^( INPUTLIST ( stimulus )+ ) ) alt109 = 2 LA109_0 = self.input.LA(1) if (LA109_0 == ASTERISK) : alt109 = 1 elif (LA109_0 == ID) : alt109 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 109, 0, self.input) raise nvae if alt109 == 1: # sdl92.g:712:17: ASTERISK pass root_0 = self._adaptor.nil() ASTERISK319=self.match(self.input, ASTERISK, self.FOLLOW_ASTERISK_in_inputlist7724) if self._state.backtracking == 0: ASTERISK319_tree = self._adaptor.createWithPayload(ASTERISK319) self._adaptor.addChild(root_0, ASTERISK319_tree) elif alt109 == 2: # sdl92.g:713:19: ( stimulus ( ',' stimulus )* ) pass # sdl92.g:713:19: ( stimulus ( ',' stimulus )* ) # sdl92.g:713:20: stimulus ( ',' stimulus )* pass self._state.following.append(self.FOLLOW_stimulus_in_inputlist7745) stimulus320 = self.stimulus() self._state.following.pop() if self._state.backtracking == 0: stream_stimulus.add(stimulus320.tree) # sdl92.g:713:29: ( ',' stimulus )* while True: #loop108 alt108 = 2 LA108_0 = self.input.LA(1) if (LA108_0 == COMMA) : alt108 = 1 if alt108 == 1: # sdl92.g:713:30: ',' stimulus pass char_literal321=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_inputlist7748) if self._state.backtracking == 0: stream_COMMA.add(char_literal321) self._state.following.append(self.FOLLOW_stimulus_in_inputlist7750) stimulus322 = self.stimulus() self._state.following.pop() if self._state.backtracking == 0: stream_stimulus.add(stimulus322.tree) else: break #loop108 # AST Rewrite # elements: stimulus # 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() # 714:9: -> ^( INPUTLIST ( stimulus )+ ) # sdl92.g:714:17: ^( INPUTLIST ( stimulus )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(INPUTLIST, "INPUTLIST"), root_1) # sdl92.g:714:29: ( stimulus )+ if not (stream_stimulus.hasNext()): raise RewriteEarlyExitException() while stream_stimulus.hasNext(): self._adaptor.addChild(root_1, stream_stimulus.nextTree()) stream_stimulus.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, 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 "inputlist" class stimulus_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.stimulus_return, self).__init__() self.tree = None # $ANTLR start "stimulus" # sdl92.g:718:1: stimulus : stimulus_id ( input_params )? ; def stimulus(self, ): retval = self.stimulus_return() retval.start = self.input.LT(1) root_0 = None stimulus_id323 = None input_params324 = None try: try: # sdl92.g:719:9: ( stimulus_id ( input_params )? ) # sdl92.g:719:17: stimulus_id ( input_params )? pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_stimulus_id_in_stimulus7807) stimulus_id323 = self.stimulus_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, stimulus_id323.tree) # sdl92.g:719:29: ( input_params )? alt110 = 2 LA110_0 = self.input.LA(1) if (LA110_0 == L_PAREN) : alt110 = 1 if alt110 == 1: # sdl92.g:0:0: input_params pass self._state.following.append(self.FOLLOW_input_params_in_stimulus7809) input_params324 = self.input_params() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, input_params324.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, 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 "stimulus" class input_params_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.input_params_return, self).__init__() self.tree = None # $ANTLR start "input_params" # sdl92.g:723:1: input_params : L_PAREN variable_id ( ',' variable_id )* R_PAREN -> ^( PARAMS ( variable_id )+ ) ; def input_params(self, ): retval = self.input_params_return() retval.start = self.input.LT(1) root_0 = None L_PAREN325 = None char_literal327 = None R_PAREN329 = None variable_id326 = None variable_id328 = None L_PAREN325_tree = None char_literal327_tree = None R_PAREN329_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_variable_id = RewriteRuleSubtreeStream(self._adaptor, "rule variable_id") try: try: # sdl92.g:724:9: ( L_PAREN variable_id ( ',' variable_id )* R_PAREN -> ^( PARAMS ( variable_id )+ ) ) # sdl92.g:724:17: L_PAREN variable_id ( ',' variable_id )* R_PAREN pass L_PAREN325=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_input_params7842) if self._state.backtracking == 0: stream_L_PAREN.add(L_PAREN325) self._state.following.append(self.FOLLOW_variable_id_in_input_params7844) variable_id326 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id326.tree) # sdl92.g:724:37: ( ',' variable_id )* while True: #loop111 alt111 = 2 LA111_0 = self.input.LA(1) if (LA111_0 == COMMA) : alt111 = 1 if alt111 == 1: # sdl92.g:724:38: ',' variable_id pass char_literal327=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_input_params7847) if self._state.backtracking == 0: stream_COMMA.add(char_literal327) self._state.following.append(self.FOLLOW_variable_id_in_input_params7849) variable_id328 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id328.tree) else: break #loop111 R_PAREN329=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_input_params7853) if self._state.backtracking == 0: stream_R_PAREN.add(R_PAREN329) # AST Rewrite # elements: variable_id # 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() # 725:9: -> ^( PARAMS ( variable_id )+ ) # sdl92.g:725:17: ^( PARAMS ( variable_id )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(PARAMS, "PARAMS"), root_1) # sdl92.g:725:26: ( variable_id )+ if not (stream_variable_id.hasNext()): raise RewriteEarlyExitException() while stream_variable_id.hasNext(): self._adaptor.addChild(root_1, stream_variable_id.nextTree()) stream_variable_id.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, 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 "input_params" class transition_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.transition_return, self).__init__() self.tree = None # $ANTLR start "transition" # sdl92.g:729:1: transition : ( ( action )+ ( label )? ( terminator_statement )? -> ^( TRANSITION ( action )+ ( label )? ( terminator_statement )? ) | terminator_statement -> ^( TRANSITION terminator_statement ) ); def transition(self, ): retval = self.transition_return() retval.start = self.input.LT(1) root_0 = None action330 = None label331 = None terminator_statement332 = None terminator_statement333 = None stream_terminator_statement = RewriteRuleSubtreeStream(self._adaptor, "rule terminator_statement") stream_action = RewriteRuleSubtreeStream(self._adaptor, "rule action") stream_label = RewriteRuleSubtreeStream(self._adaptor, "rule label") try: try: # sdl92.g:730:9: ( ( action )+ ( label )? ( terminator_statement )? -> ^( TRANSITION ( action )+ ( label )? ( terminator_statement )? ) | terminator_statement -> ^( TRANSITION terminator_statement ) ) alt115 = 2 alt115 = self.dfa115.predict(self.input) if alt115 == 1: # sdl92.g:730:17: ( action )+ ( label )? ( terminator_statement )? pass # sdl92.g:730:17: ( action )+ cnt112 = 0 while True: #loop112 alt112 = 2 alt112 = self.dfa112.predict(self.input) if alt112 == 1: # sdl92.g:0:0: action pass self._state.following.append(self.FOLLOW_action_in_transition7907) action330 = self.action() self._state.following.pop() if self._state.backtracking == 0: stream_action.add(action330.tree) else: if cnt112 >= 1: break #loop112 if self._state.backtracking > 0: raise BacktrackingFailed eee = EarlyExitException(112, self.input) raise eee cnt112 += 1 # sdl92.g:730:25: ( label )? alt113 = 2 alt113 = self.dfa113.predict(self.input) if alt113 == 1: # sdl92.g:0:0: label pass self._state.following.append(self.FOLLOW_label_in_transition7910) label331 = self.label() self._state.following.pop() if self._state.backtracking == 0: stream_label.add(label331.tree) # sdl92.g:730:32: ( terminator_statement )? alt114 = 2 alt114 = self.dfa114.predict(self.input) if alt114 == 1: # sdl92.g:0:0: terminator_statement pass self._state.following.append(self.FOLLOW_terminator_statement_in_transition7913) terminator_statement332 = self.terminator_statement() self._state.following.pop() if self._state.backtracking == 0: stream_terminator_statement.add(terminator_statement332.tree) # AST Rewrite # elements: label, terminator_statement, action # 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() # 731:9: -> ^( TRANSITION ( action )+ ( label )? ( terminator_statement )? ) # sdl92.g:731:17: ^( TRANSITION ( action )+ ( label )? ( terminator_statement )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(TRANSITION, "TRANSITION"), root_1) # sdl92.g:731:30: ( action )+ if not (stream_action.hasNext()): raise RewriteEarlyExitException() while stream_action.hasNext(): self._adaptor.addChild(root_1, stream_action.nextTree()) stream_action.reset() # sdl92.g:731:38: ( label )? if stream_label.hasNext(): self._adaptor.addChild(root_1, stream_label.nextTree()) stream_label.reset(); # sdl92.g:731:45: ( terminator_statement )? if stream_terminator_statement.hasNext(): self._adaptor.addChild(root_1, stream_terminator_statement.nextTree()) stream_terminator_statement.reset(); self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt115 == 2: # sdl92.g:732:19: terminator_statement pass self._state.following.append(self.FOLLOW_terminator_statement_in_transition7962) terminator_statement333 = self.terminator_statement() self._state.following.pop() if self._state.backtracking == 0: stream_terminator_statement.add(terminator_statement333.tree) # AST Rewrite # elements: terminator_statement # 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() # 733:9: -> ^( TRANSITION terminator_statement ) # sdl92.g:733:17: ^( TRANSITION terminator_statement ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(TRANSITION, "TRANSITION"), root_1) self._adaptor.addChild(root_1, stream_terminator_statement.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, 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 "transition" class action_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.action_return, self).__init__() self.tree = None # $ANTLR start "action" # sdl92.g:737:1: action : ( label )? ( task | task_body | output | create_request | decision | transition_option | set_timer | reset_timer | export | procedure_call ) ; def action(self, ): retval = self.action_return() retval.start = self.input.LT(1) root_0 = None label334 = None task335 = None task_body336 = None output337 = None create_request338 = None decision339 = None transition_option340 = None set_timer341 = None reset_timer342 = None export343 = None procedure_call344 = None try: try: # sdl92.g:738:9: ( ( label )? ( task | task_body | output | create_request | decision | transition_option | set_timer | reset_timer | export | procedure_call ) ) # sdl92.g:738:17: ( label )? ( task | task_body | output | create_request | decision | transition_option | set_timer | reset_timer | export | procedure_call ) pass root_0 = self._adaptor.nil() # sdl92.g:738:17: ( label )? alt116 = 2 alt116 = self.dfa116.predict(self.input) if alt116 == 1: # sdl92.g:0:0: label pass self._state.following.append(self.FOLLOW_label_in_action8015) label334 = self.label() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, label334.tree) # sdl92.g:739:17: ( task | task_body | output | create_request | decision | transition_option | set_timer | reset_timer | export | procedure_call ) alt117 = 10 alt117 = self.dfa117.predict(self.input) if alt117 == 1: # sdl92.g:739:18: task pass self._state.following.append(self.FOLLOW_task_in_action8035) task335 = self.task() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, task335.tree) elif alt117 == 2: # sdl92.g:740:19: task_body pass self._state.following.append(self.FOLLOW_task_body_in_action8055) task_body336 = self.task_body() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, task_body336.tree) elif alt117 == 3: # sdl92.g:741:19: output pass self._state.following.append(self.FOLLOW_output_in_action8075) output337 = self.output() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, output337.tree) elif alt117 == 4: # sdl92.g:742:19: create_request pass self._state.following.append(self.FOLLOW_create_request_in_action8095) create_request338 = self.create_request() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, create_request338.tree) elif alt117 == 5: # sdl92.g:743:19: decision pass self._state.following.append(self.FOLLOW_decision_in_action8115) decision339 = self.decision() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, decision339.tree) elif alt117 == 6: # sdl92.g:744:19: transition_option pass self._state.following.append(self.FOLLOW_transition_option_in_action8135) transition_option340 = self.transition_option() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, transition_option340.tree) elif alt117 == 7: # sdl92.g:745:19: set_timer pass self._state.following.append(self.FOLLOW_set_timer_in_action8155) set_timer341 = self.set_timer() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, set_timer341.tree) elif alt117 == 8: # sdl92.g:746:19: reset_timer pass self._state.following.append(self.FOLLOW_reset_timer_in_action8175) reset_timer342 = self.reset_timer() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, reset_timer342.tree) elif alt117 == 9: # sdl92.g:747:19: export pass self._state.following.append(self.FOLLOW_export_in_action8195) export343 = self.export() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, export343.tree) elif alt117 == 10: # sdl92.g:748:19: procedure_call pass self._state.following.append(self.FOLLOW_procedure_call_in_action8220) procedure_call344 = self.procedure_call() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, procedure_call344.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, 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 "action" class export_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.export_return, self).__init__() self.tree = None # $ANTLR start "export" # sdl92.g:752:1: export : EXPORT L_PAREN variable_id ( COMMA variable_id )* R_PAREN end -> ^( EXPORT ( variable_id )+ ) ; def export(self, ): retval = self.export_return() retval.start = self.input.LT(1) root_0 = None EXPORT345 = None L_PAREN346 = None COMMA348 = None R_PAREN350 = None variable_id347 = None variable_id349 = None end351 = None EXPORT345_tree = None L_PAREN346_tree = None COMMA348_tree = None R_PAREN350_tree = None stream_EXPORT = RewriteRuleTokenStream(self._adaptor, "token EXPORT") stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_variable_id = RewriteRuleSubtreeStream(self._adaptor, "rule variable_id") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:753:9: ( EXPORT L_PAREN variable_id ( COMMA variable_id )* R_PAREN end -> ^( EXPORT ( variable_id )+ ) ) # sdl92.g:753:17: EXPORT L_PAREN variable_id ( COMMA variable_id )* R_PAREN end pass EXPORT345=self.match(self.input, EXPORT, self.FOLLOW_EXPORT_in_export8253) if self._state.backtracking == 0: stream_EXPORT.add(EXPORT345) L_PAREN346=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_export8271) if self._state.backtracking == 0: stream_L_PAREN.add(L_PAREN346) self._state.following.append(self.FOLLOW_variable_id_in_export8273) variable_id347 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id347.tree) # sdl92.g:754:37: ( COMMA variable_id )* while True: #loop118 alt118 = 2 LA118_0 = self.input.LA(1) if (LA118_0 == COMMA) : alt118 = 1 if alt118 == 1: # sdl92.g:754:38: COMMA variable_id pass COMMA348=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_export8276) if self._state.backtracking == 0: stream_COMMA.add(COMMA348) self._state.following.append(self.FOLLOW_variable_id_in_export8278) variable_id349 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id349.tree) else: break #loop118 R_PAREN350=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_export8282) if self._state.backtracking == 0: stream_R_PAREN.add(R_PAREN350) self._state.following.append(self.FOLLOW_end_in_export8300) end351 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end351.tree) # AST Rewrite # elements: variable_id, EXPORT # 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() # 756:9: -> ^( EXPORT ( variable_id )+ ) # sdl92.g:756:17: ^( EXPORT ( variable_id )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_EXPORT.nextNode(), root_1) # sdl92.g:756:26: ( variable_id )+ if not (stream_variable_id.hasNext()): raise RewriteEarlyExitException() while stream_variable_id.hasNext(): self._adaptor.addChild(root_1, stream_variable_id.nextTree()) stream_variable_id.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, 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 "export" class procedure_call_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.procedure_call_return, self).__init__() self.tree = None # $ANTLR start "procedure_call" # sdl92.g:767:1: procedure_call : ( cif )? ( hyperlink )? CALL procedure_call_body end -> ^( PROCEDURE_CALL ( cif )? ( hyperlink )? ( end )? procedure_call_body ) ; def procedure_call(self, ): retval = self.procedure_call_return() retval.start = self.input.LT(1) root_0 = None CALL354 = None cif352 = None hyperlink353 = None procedure_call_body355 = None end356 = None CALL354_tree = None stream_CALL = RewriteRuleTokenStream(self._adaptor, "token CALL") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_procedure_call_body = RewriteRuleSubtreeStream(self._adaptor, "rule procedure_call_body") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:768:9: ( ( cif )? ( hyperlink )? CALL procedure_call_body end -> ^( PROCEDURE_CALL ( cif )? ( hyperlink )? ( end )? procedure_call_body ) ) # sdl92.g:768:17: ( cif )? ( hyperlink )? CALL procedure_call_body end pass # sdl92.g:768:17: ( cif )? alt119 = 2 LA119_0 = self.input.LA(1) if (LA119_0 == 229) : LA119_1 = self.input.LA(2) if (LA119_1 == ANSWER or LA119_1 == COMMENT or LA119_1 == CONNECT or LA119_1 == DECISION or LA119_1 == INPUT or (JOIN <= LA119_1 <= LABEL) or LA119_1 == NEXTSTATE or LA119_1 == OUTPUT or (PROCEDURE <= LA119_1 <= PROCEDURE_CALL) or (PROCESS <= LA119_1 <= PROVIDED) or LA119_1 == RETURN or LA119_1 == STATE or LA119_1 == STOP or LA119_1 == TASK or LA119_1 == TEXT or LA119_1 == START) : alt119 = 1 if alt119 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_procedure_call8356) cif352 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif352.tree) # sdl92.g:769:17: ( hyperlink )? alt120 = 2 LA120_0 = self.input.LA(1) if (LA120_0 == 229) : alt120 = 1 if alt120 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_procedure_call8375) hyperlink353 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink353.tree) CALL354=self.match(self.input, CALL, self.FOLLOW_CALL_in_procedure_call8394) if self._state.backtracking == 0: stream_CALL.add(CALL354) self._state.following.append(self.FOLLOW_procedure_call_body_in_procedure_call8396) procedure_call_body355 = self.procedure_call_body() self._state.following.pop() if self._state.backtracking == 0: stream_procedure_call_body.add(procedure_call_body355.tree) self._state.following.append(self.FOLLOW_end_in_procedure_call8398) end356 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end356.tree) # AST Rewrite # elements: cif, procedure_call_body, hyperlink, end # 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() # 771:9: -> ^( PROCEDURE_CALL ( cif )? ( hyperlink )? ( end )? procedure_call_body ) # sdl92.g:771:17: ^( PROCEDURE_CALL ( cif )? ( hyperlink )? ( end )? procedure_call_body ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(PROCEDURE_CALL, "PROCEDURE_CALL"), root_1) # sdl92.g:771:34: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:771:39: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:771:50: ( end )? if stream_end.hasNext(): self._adaptor.addChild(root_1, stream_end.nextTree()) stream_end.reset(); self._adaptor.addChild(root_1, stream_procedure_call_body.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, 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 "procedure_call" class procedure_call_body_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.procedure_call_body_return, self).__init__() self.tree = None # $ANTLR start "procedure_call_body" # sdl92.g:775:1: procedure_call_body : procedure_id ( actual_parameters )? -> ^( OUTPUT_BODY procedure_id ( actual_parameters )? ) ; def procedure_call_body(self, ): retval = self.procedure_call_body_return() retval.start = self.input.LT(1) root_0 = None procedure_id357 = None actual_parameters358 = None stream_procedure_id = RewriteRuleSubtreeStream(self._adaptor, "rule procedure_id") stream_actual_parameters = RewriteRuleSubtreeStream(self._adaptor, "rule actual_parameters") try: try: # sdl92.g:776:9: ( procedure_id ( actual_parameters )? -> ^( OUTPUT_BODY procedure_id ( actual_parameters )? ) ) # sdl92.g:776:17: procedure_id ( actual_parameters )? pass self._state.following.append(self.FOLLOW_procedure_id_in_procedure_call_body8460) procedure_id357 = self.procedure_id() self._state.following.pop() if self._state.backtracking == 0: stream_procedure_id.add(procedure_id357.tree) # sdl92.g:776:30: ( actual_parameters )? alt121 = 2 LA121_0 = self.input.LA(1) if (LA121_0 == L_PAREN) : alt121 = 1 if alt121 == 1: # sdl92.g:0:0: actual_parameters pass self._state.following.append(self.FOLLOW_actual_parameters_in_procedure_call_body8462) actual_parameters358 = self.actual_parameters() self._state.following.pop() if self._state.backtracking == 0: stream_actual_parameters.add(actual_parameters358.tree) # AST Rewrite # elements: procedure_id, actual_parameters # 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() # 777:9: -> ^( OUTPUT_BODY procedure_id ( actual_parameters )? ) # sdl92.g:777:17: ^( OUTPUT_BODY procedure_id ( actual_parameters )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(OUTPUT_BODY, "OUTPUT_BODY"), root_1) self._adaptor.addChild(root_1, stream_procedure_id.nextTree()) # sdl92.g:777:44: ( actual_parameters )? if stream_actual_parameters.hasNext(): self._adaptor.addChild(root_1, stream_actual_parameters.nextTree()) stream_actual_parameters.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, 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 "procedure_call_body" class set_timer_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.set_timer_return, self).__init__() self.tree = None # $ANTLR start "set_timer" # sdl92.g:781:1: set_timer : SET set_statement ( COMMA set_statement )* end -> ( set_statement )+ ; def set_timer(self, ): retval = self.set_timer_return() retval.start = self.input.LT(1) root_0 = None SET359 = None COMMA361 = None set_statement360 = None set_statement362 = None end363 = None SET359_tree = None COMMA361_tree = None stream_SET = RewriteRuleTokenStream(self._adaptor, "token SET") stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_set_statement = RewriteRuleSubtreeStream(self._adaptor, "rule set_statement") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:782:9: ( SET set_statement ( COMMA set_statement )* end -> ( set_statement )+ ) # sdl92.g:782:17: SET set_statement ( COMMA set_statement )* end pass SET359=self.match(self.input, SET, self.FOLLOW_SET_in_set_timer8519) if self._state.backtracking == 0: stream_SET.add(SET359) self._state.following.append(self.FOLLOW_set_statement_in_set_timer8521) set_statement360 = self.set_statement() self._state.following.pop() if self._state.backtracking == 0: stream_set_statement.add(set_statement360.tree) # sdl92.g:782:35: ( COMMA set_statement )* while True: #loop122 alt122 = 2 LA122_0 = self.input.LA(1) if (LA122_0 == COMMA) : alt122 = 1 if alt122 == 1: # sdl92.g:782:36: COMMA set_statement pass COMMA361=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_set_timer8524) if self._state.backtracking == 0: stream_COMMA.add(COMMA361) self._state.following.append(self.FOLLOW_set_statement_in_set_timer8526) set_statement362 = self.set_statement() self._state.following.pop() if self._state.backtracking == 0: stream_set_statement.add(set_statement362.tree) else: break #loop122 self._state.following.append(self.FOLLOW_end_in_set_timer8546) end363 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end363.tree) # AST Rewrite # elements: set_statement # 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() # 784:9: -> ( set_statement )+ # sdl92.g:784:17: ( set_statement )+ if not (stream_set_statement.hasNext()): raise RewriteEarlyExitException() while stream_set_statement.hasNext(): self._adaptor.addChild(root_0, stream_set_statement.nextTree()) stream_set_statement.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, 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 "set_timer" class set_statement_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.set_statement_return, self).__init__() self.tree = None # $ANTLR start "set_statement" # sdl92.g:788:1: set_statement : L_PAREN ( expression COMMA )? timer_id R_PAREN -> ^( SET ( expression )? timer_id ) ; def set_statement(self, ): retval = self.set_statement_return() retval.start = self.input.LT(1) root_0 = None L_PAREN364 = None COMMA366 = None R_PAREN368 = None expression365 = None timer_id367 = None L_PAREN364_tree = None COMMA366_tree = None R_PAREN368_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") stream_timer_id = RewriteRuleSubtreeStream(self._adaptor, "rule timer_id") try: try: # sdl92.g:789:9: ( L_PAREN ( expression COMMA )? timer_id R_PAREN -> ^( SET ( expression )? timer_id ) ) # sdl92.g:789:17: L_PAREN ( expression COMMA )? timer_id R_PAREN pass L_PAREN364=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_set_statement8596) if self._state.backtracking == 0: stream_L_PAREN.add(L_PAREN364) # sdl92.g:789:25: ( expression COMMA )? alt123 = 2 LA123_0 = self.input.LA(1) if (LA123_0 == ID) : LA123_1 = self.input.LA(2) if (LA123_1 == IN or LA123_1 == AND or LA123_1 == ASTERISK or LA123_1 == L_PAREN or LA123_1 == COMMA or (EQ <= LA123_1 <= GE) or (IMPLIES <= LA123_1 <= REM) or LA123_1 == 223 or LA123_1 == 225) : alt123 = 1 elif (LA123_0 == FLOAT or LA123_0 == IF or LA123_0 == STATE or LA123_0 == STRING or LA123_0 == INT or LA123_0 == L_PAREN or LA123_0 == DASH or (NOT <= LA123_0 <= MINUS_INFINITY) or LA123_0 == L_BRACKET) : alt123 = 1 if alt123 == 1: # sdl92.g:789:26: expression COMMA pass self._state.following.append(self.FOLLOW_expression_in_set_statement8599) expression365 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression365.tree) COMMA366=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_set_statement8601) if self._state.backtracking == 0: stream_COMMA.add(COMMA366) self._state.following.append(self.FOLLOW_timer_id_in_set_statement8605) timer_id367 = self.timer_id() self._state.following.pop() if self._state.backtracking == 0: stream_timer_id.add(timer_id367.tree) R_PAREN368=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_set_statement8607) if self._state.backtracking == 0: stream_R_PAREN.add(R_PAREN368) # AST Rewrite # elements: expression, timer_id # 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() # 790:9: -> ^( SET ( expression )? timer_id ) # sdl92.g:790:17: ^( SET ( expression )? timer_id ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(SET, "SET"), root_1) # sdl92.g:790:23: ( expression )? if stream_expression.hasNext(): self._adaptor.addChild(root_1, stream_expression.nextTree()) stream_expression.reset(); self._adaptor.addChild(root_1, stream_timer_id.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, 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 "set_statement" class reset_timer_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.reset_timer_return, self).__init__() self.tree = None # $ANTLR start "reset_timer" # sdl92.g:795:1: reset_timer : RESET reset_statement ( ',' reset_statement )* end -> ( reset_statement )+ ; def reset_timer(self, ): retval = self.reset_timer_return() retval.start = self.input.LT(1) root_0 = None RESET369 = None char_literal371 = None reset_statement370 = None reset_statement372 = None end373 = None RESET369_tree = None char_literal371_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_RESET = RewriteRuleTokenStream(self._adaptor, "token RESET") stream_reset_statement = RewriteRuleSubtreeStream(self._adaptor, "rule reset_statement") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:796:9: ( RESET reset_statement ( ',' reset_statement )* end -> ( reset_statement )+ ) # sdl92.g:796:17: RESET reset_statement ( ',' reset_statement )* end pass RESET369=self.match(self.input, RESET, self.FOLLOW_RESET_in_reset_timer8672) if self._state.backtracking == 0: stream_RESET.add(RESET369) self._state.following.append(self.FOLLOW_reset_statement_in_reset_timer8674) reset_statement370 = self.reset_statement() self._state.following.pop() if self._state.backtracking == 0: stream_reset_statement.add(reset_statement370.tree) # sdl92.g:796:39: ( ',' reset_statement )* while True: #loop124 alt124 = 2 LA124_0 = self.input.LA(1) if (LA124_0 == COMMA) : alt124 = 1 if alt124 == 1: # sdl92.g:796:40: ',' reset_statement pass char_literal371=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_reset_timer8677) if self._state.backtracking == 0: stream_COMMA.add(char_literal371) self._state.following.append(self.FOLLOW_reset_statement_in_reset_timer8679) reset_statement372 = self.reset_statement() self._state.following.pop() if self._state.backtracking == 0: stream_reset_statement.add(reset_statement372.tree) else: break #loop124 self._state.following.append(self.FOLLOW_end_in_reset_timer8699) end373 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end373.tree) # AST Rewrite # elements: reset_statement # 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() # 798:9: -> ( reset_statement )+ # sdl92.g:798:17: ( reset_statement )+ if not (stream_reset_statement.hasNext()): raise RewriteEarlyExitException() while stream_reset_statement.hasNext(): self._adaptor.addChild(root_0, stream_reset_statement.nextTree()) stream_reset_statement.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, 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 "reset_timer" class reset_statement_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.reset_statement_return, self).__init__() self.tree = None # $ANTLR start "reset_statement" # sdl92.g:802:1: reset_statement : timer_id ( '(' expression_list ')' )? -> ^( RESET timer_id ( expression_list )? ) ; def reset_statement(self, ): retval = self.reset_statement_return() retval.start = self.input.LT(1) root_0 = None char_literal375 = None char_literal377 = None timer_id374 = None expression_list376 = None char_literal375_tree = None char_literal377_tree = None stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_expression_list = RewriteRuleSubtreeStream(self._adaptor, "rule expression_list") stream_timer_id = RewriteRuleSubtreeStream(self._adaptor, "rule timer_id") try: try: # sdl92.g:803:9: ( timer_id ( '(' expression_list ')' )? -> ^( RESET timer_id ( expression_list )? ) ) # sdl92.g:803:17: timer_id ( '(' expression_list ')' )? pass self._state.following.append(self.FOLLOW_timer_id_in_reset_statement8749) timer_id374 = self.timer_id() self._state.following.pop() if self._state.backtracking == 0: stream_timer_id.add(timer_id374.tree) # sdl92.g:803:26: ( '(' expression_list ')' )? alt125 = 2 LA125_0 = self.input.LA(1) if (LA125_0 == L_PAREN) : alt125 = 1 if alt125 == 1: # sdl92.g:803:27: '(' expression_list ')' pass char_literal375=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_reset_statement8752) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal375) self._state.following.append(self.FOLLOW_expression_list_in_reset_statement8754) expression_list376 = self.expression_list() self._state.following.pop() if self._state.backtracking == 0: stream_expression_list.add(expression_list376.tree) char_literal377=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_reset_statement8756) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal377) # AST Rewrite # elements: expression_list, timer_id # 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() # 804:9: -> ^( RESET timer_id ( expression_list )? ) # sdl92.g:804:17: ^( RESET timer_id ( expression_list )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(RESET, "RESET"), root_1) self._adaptor.addChild(root_1, stream_timer_id.nextTree()) # sdl92.g:804:34: ( expression_list )? if stream_expression_list.hasNext(): self._adaptor.addChild(root_1, stream_expression_list.nextTree()) stream_expression_list.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, 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 "reset_statement" class transition_option_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.transition_option_return, self).__init__() self.tree = None # $ANTLR start "transition_option" # sdl92.g:808:1: transition_option : ALTERNATIVE alternative_question e= end answer_part alternative_part ENDALTERNATIVE f= end -> ^( ALTERNATIVE answer_part alternative_part ) ; def transition_option(self, ): retval = self.transition_option_return() retval.start = self.input.LT(1) root_0 = None ALTERNATIVE378 = None ENDALTERNATIVE382 = None e = None f = None alternative_question379 = None answer_part380 = None alternative_part381 = None ALTERNATIVE378_tree = None ENDALTERNATIVE382_tree = None stream_ALTERNATIVE = RewriteRuleTokenStream(self._adaptor, "token ALTERNATIVE") stream_ENDALTERNATIVE = RewriteRuleTokenStream(self._adaptor, "token ENDALTERNATIVE") stream_alternative_question = RewriteRuleSubtreeStream(self._adaptor, "rule alternative_question") stream_answer_part = RewriteRuleSubtreeStream(self._adaptor, "rule answer_part") stream_alternative_part = RewriteRuleSubtreeStream(self._adaptor, "rule alternative_part") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:809:9: ( ALTERNATIVE alternative_question e= end answer_part alternative_part ENDALTERNATIVE f= end -> ^( ALTERNATIVE answer_part alternative_part ) ) # sdl92.g:809:17: ALTERNATIVE alternative_question e= end answer_part alternative_part ENDALTERNATIVE f= end pass ALTERNATIVE378=self.match(self.input, ALTERNATIVE, self.FOLLOW_ALTERNATIVE_in_transition_option8814) if self._state.backtracking == 0: stream_ALTERNATIVE.add(ALTERNATIVE378) self._state.following.append(self.FOLLOW_alternative_question_in_transition_option8816) alternative_question379 = self.alternative_question() self._state.following.pop() if self._state.backtracking == 0: stream_alternative_question.add(alternative_question379.tree) self._state.following.append(self.FOLLOW_end_in_transition_option8820) e = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(e.tree) self._state.following.append(self.FOLLOW_answer_part_in_transition_option8838) answer_part380 = self.answer_part() self._state.following.pop() if self._state.backtracking == 0: stream_answer_part.add(answer_part380.tree) self._state.following.append(self.FOLLOW_alternative_part_in_transition_option8856) alternative_part381 = self.alternative_part() self._state.following.pop() if self._state.backtracking == 0: stream_alternative_part.add(alternative_part381.tree) ENDALTERNATIVE382=self.match(self.input, ENDALTERNATIVE, self.FOLLOW_ENDALTERNATIVE_in_transition_option8874) if self._state.backtracking == 0: stream_ENDALTERNATIVE.add(ENDALTERNATIVE382) self._state.following.append(self.FOLLOW_end_in_transition_option8878) f = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(f.tree) # AST Rewrite # elements: answer_part, alternative_part, ALTERNATIVE # 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() # 813:9: -> ^( ALTERNATIVE answer_part alternative_part ) # sdl92.g:813:17: ^( ALTERNATIVE answer_part alternative_part ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_ALTERNATIVE.nextNode(), root_1) self._adaptor.addChild(root_1, stream_answer_part.nextTree()) self._adaptor.addChild(root_1, stream_alternative_part.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, 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 "transition_option" class alternative_part_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.alternative_part_return, self).__init__() self.tree = None # $ANTLR start "alternative_part" # sdl92.g:817:1: alternative_part : ( ( ( answer_part )+ ( else_part )? ) -> ( answer_part )+ ( else_part )? | else_part -> else_part ); def alternative_part(self, ): retval = self.alternative_part_return() retval.start = self.input.LT(1) root_0 = None answer_part383 = None else_part384 = None else_part385 = None stream_answer_part = RewriteRuleSubtreeStream(self._adaptor, "rule answer_part") stream_else_part = RewriteRuleSubtreeStream(self._adaptor, "rule else_part") try: try: # sdl92.g:818:9: ( ( ( answer_part )+ ( else_part )? ) -> ( answer_part )+ ( else_part )? | else_part -> else_part ) alt128 = 2 alt128 = self.dfa128.predict(self.input) if alt128 == 1: # sdl92.g:818:17: ( ( answer_part )+ ( else_part )? ) pass # sdl92.g:818:17: ( ( answer_part )+ ( else_part )? ) # sdl92.g:818:18: ( answer_part )+ ( else_part )? pass # sdl92.g:818:18: ( answer_part )+ cnt126 = 0 while True: #loop126 alt126 = 2 alt126 = self.dfa126.predict(self.input) if alt126 == 1: # sdl92.g:0:0: answer_part pass self._state.following.append(self.FOLLOW_answer_part_in_alternative_part8934) answer_part383 = self.answer_part() self._state.following.pop() if self._state.backtracking == 0: stream_answer_part.add(answer_part383.tree) else: if cnt126 >= 1: break #loop126 if self._state.backtracking > 0: raise BacktrackingFailed eee = EarlyExitException(126, self.input) raise eee cnt126 += 1 # sdl92.g:818:31: ( else_part )? alt127 = 2 LA127_0 = self.input.LA(1) if (LA127_0 == ELSE or LA127_0 == 229) : alt127 = 1 if alt127 == 1: # sdl92.g:0:0: else_part pass self._state.following.append(self.FOLLOW_else_part_in_alternative_part8937) else_part384 = self.else_part() self._state.following.pop() if self._state.backtracking == 0: stream_else_part.add(else_part384.tree) # AST Rewrite # elements: else_part, answer_part # 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() # 819:9: -> ( answer_part )+ ( else_part )? # sdl92.g:819:17: ( answer_part )+ if not (stream_answer_part.hasNext()): raise RewriteEarlyExitException() while stream_answer_part.hasNext(): self._adaptor.addChild(root_0, stream_answer_part.nextTree()) stream_answer_part.reset() # sdl92.g:819:30: ( else_part )? if stream_else_part.hasNext(): self._adaptor.addChild(root_0, stream_else_part.nextTree()) stream_else_part.reset(); retval.tree = root_0 elif alt128 == 2: # sdl92.g:820:19: else_part pass self._state.following.append(self.FOLLOW_else_part_in_alternative_part8980) else_part385 = self.else_part() self._state.following.pop() if self._state.backtracking == 0: stream_else_part.add(else_part385.tree) # AST Rewrite # elements: else_part # 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() # 821:9: -> else_part self._adaptor.addChild(root_0, stream_else_part.nextTree()) 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, 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 "alternative_part" class alternative_question_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.alternative_question_return, self).__init__() self.tree = None # $ANTLR start "alternative_question" # sdl92.g:825:1: alternative_question : ( expression | informal_text ); def alternative_question(self, ): retval = self.alternative_question_return() retval.start = self.input.LT(1) root_0 = None expression386 = None informal_text387 = None try: try: # sdl92.g:826:9: ( expression | informal_text ) alt129 = 2 LA129_0 = self.input.LA(1) if (LA129_0 == FLOAT or LA129_0 == IF or LA129_0 == STATE or LA129_0 == ID or LA129_0 == INT or LA129_0 == L_PAREN or LA129_0 == DASH or (NOT <= LA129_0 <= MINUS_INFINITY) or LA129_0 == L_BRACKET) : alt129 = 1 elif (LA129_0 == STRING) : LA129_2 = self.input.LA(2) if (self.synpred168_sdl92()) : alt129 = 1 elif (True) : alt129 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 129, 2, self.input) raise nvae else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 129, 0, self.input) raise nvae if alt129 == 1: # sdl92.g:826:17: expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_expression_in_alternative_question9029) expression386 = self.expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, expression386.tree) elif alt129 == 2: # sdl92.g:827:19: informal_text pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_informal_text_in_alternative_question9049) informal_text387 = self.informal_text() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, informal_text387.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, 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 "alternative_question" class decision_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.decision_return, self).__init__() self.tree = None # $ANTLR start "decision" # sdl92.g:831:1: decision : ( cif )? ( hyperlink )? DECISION question e= end ( answer_part )? ( alternative_part )? ENDDECISION f= end -> ^( DECISION ( cif )? ( hyperlink )? ( $e)? question ( answer_part )? ( alternative_part )? ) ; def decision(self, ): retval = self.decision_return() retval.start = self.input.LT(1) root_0 = None DECISION390 = None ENDDECISION394 = None e = None f = None cif388 = None hyperlink389 = None question391 = None answer_part392 = None alternative_part393 = None DECISION390_tree = None ENDDECISION394_tree = None stream_DECISION = RewriteRuleTokenStream(self._adaptor, "token DECISION") stream_ENDDECISION = RewriteRuleTokenStream(self._adaptor, "token ENDDECISION") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_answer_part = RewriteRuleSubtreeStream(self._adaptor, "rule answer_part") stream_question = RewriteRuleSubtreeStream(self._adaptor, "rule question") stream_alternative_part = RewriteRuleSubtreeStream(self._adaptor, "rule alternative_part") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:832:9: ( ( cif )? ( hyperlink )? DECISION question e= end ( answer_part )? ( alternative_part )? ENDDECISION f= end -> ^( DECISION ( cif )? ( hyperlink )? ( $e)? question ( answer_part )? ( alternative_part )? ) ) # sdl92.g:832:17: ( cif )? ( hyperlink )? DECISION question e= end ( answer_part )? ( alternative_part )? ENDDECISION f= end pass # sdl92.g:832:17: ( cif )? alt130 = 2 LA130_0 = self.input.LA(1) if (LA130_0 == 229) : LA130_1 = self.input.LA(2) if (LA130_1 == ANSWER or LA130_1 == COMMENT or LA130_1 == CONNECT or LA130_1 == DECISION or LA130_1 == INPUT or (JOIN <= LA130_1 <= LABEL) or LA130_1 == NEXTSTATE or LA130_1 == OUTPUT or (PROCEDURE <= LA130_1 <= PROCEDURE_CALL) or (PROCESS <= LA130_1 <= PROVIDED) or LA130_1 == RETURN or LA130_1 == STATE or LA130_1 == STOP or LA130_1 == TASK or LA130_1 == TEXT or LA130_1 == START) : alt130 = 1 if alt130 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_decision9081) cif388 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif388.tree) # sdl92.g:833:17: ( hyperlink )? alt131 = 2 LA131_0 = self.input.LA(1) if (LA131_0 == 229) : alt131 = 1 if alt131 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_decision9100) hyperlink389 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink389.tree) DECISION390=self.match(self.input, DECISION, self.FOLLOW_DECISION_in_decision9119) if self._state.backtracking == 0: stream_DECISION.add(DECISION390) self._state.following.append(self.FOLLOW_question_in_decision9121) question391 = self.question() self._state.following.pop() if self._state.backtracking == 0: stream_question.add(question391.tree) self._state.following.append(self.FOLLOW_end_in_decision9125) e = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(e.tree) # sdl92.g:835:17: ( answer_part )? alt132 = 2 LA132_0 = self.input.LA(1) if (LA132_0 == 229) : LA132_1 = self.input.LA(2) if (self.synpred171_sdl92()) : alt132 = 1 elif (LA132_0 == L_PAREN) : LA132_2 = self.input.LA(2) if (self.synpred171_sdl92()) : alt132 = 1 if alt132 == 1: # sdl92.g:0:0: answer_part pass self._state.following.append(self.FOLLOW_answer_part_in_decision9143) answer_part392 = self.answer_part() self._state.following.pop() if self._state.backtracking == 0: stream_answer_part.add(answer_part392.tree) # sdl92.g:836:17: ( alternative_part )? alt133 = 2 LA133_0 = self.input.LA(1) if (LA133_0 == ELSE or LA133_0 == L_PAREN or LA133_0 == 229) : alt133 = 1 if alt133 == 1: # sdl92.g:0:0: alternative_part pass self._state.following.append(self.FOLLOW_alternative_part_in_decision9162) alternative_part393 = self.alternative_part() self._state.following.pop() if self._state.backtracking == 0: stream_alternative_part.add(alternative_part393.tree) ENDDECISION394=self.match(self.input, ENDDECISION, self.FOLLOW_ENDDECISION_in_decision9181) if self._state.backtracking == 0: stream_ENDDECISION.add(ENDDECISION394) self._state.following.append(self.FOLLOW_end_in_decision9185) f = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(f.tree) # AST Rewrite # elements: hyperlink, alternative_part, DECISION, answer_part, question, e, cif # token labels: # rule labels: retval, e # 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) if e is not None: stream_e = RewriteRuleSubtreeStream(self._adaptor, "rule e", e.tree) else: stream_e = RewriteRuleSubtreeStream(self._adaptor, "token e", None) root_0 = self._adaptor.nil() # 838:9: -> ^( DECISION ( cif )? ( hyperlink )? ( $e)? question ( answer_part )? ( alternative_part )? ) # sdl92.g:838:17: ^( DECISION ( cif )? ( hyperlink )? ( $e)? question ( answer_part )? ( alternative_part )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_DECISION.nextNode(), root_1) # sdl92.g:838:28: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:838:33: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:838:44: ( $e)? if stream_e.hasNext(): self._adaptor.addChild(root_1, stream_e.nextTree()) stream_e.reset(); self._adaptor.addChild(root_1, stream_question.nextTree()) # sdl92.g:839:17: ( answer_part )? if stream_answer_part.hasNext(): self._adaptor.addChild(root_1, stream_answer_part.nextTree()) stream_answer_part.reset(); # sdl92.g:839:30: ( alternative_part )? if stream_alternative_part.hasNext(): self._adaptor.addChild(root_1, stream_alternative_part.nextTree()) stream_alternative_part.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, 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 "decision" class answer_part_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.answer_part_return, self).__init__() self.tree = None # $ANTLR start "answer_part" # sdl92.g:843:1: answer_part : ( cif )? ( hyperlink )? L_PAREN answer R_PAREN ':' ( transition )? -> ^( ANSWER ( cif )? ( hyperlink )? answer ( transition )? ) ; def answer_part(self, ): retval = self.answer_part_return() retval.start = self.input.LT(1) root_0 = None L_PAREN397 = None R_PAREN399 = None char_literal400 = None cif395 = None hyperlink396 = None answer398 = None transition401 = None L_PAREN397_tree = None R_PAREN399_tree = None char_literal400_tree = None stream_223 = RewriteRuleTokenStream(self._adaptor, "token 223") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_answer = RewriteRuleSubtreeStream(self._adaptor, "rule answer") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") try: try: # sdl92.g:844:9: ( ( cif )? ( hyperlink )? L_PAREN answer R_PAREN ':' ( transition )? -> ^( ANSWER ( cif )? ( hyperlink )? answer ( transition )? ) ) # sdl92.g:844:17: ( cif )? ( hyperlink )? L_PAREN answer R_PAREN ':' ( transition )? pass # sdl92.g:844:17: ( cif )? alt134 = 2 LA134_0 = self.input.LA(1) if (LA134_0 == 229) : LA134_1 = self.input.LA(2) if (LA134_1 == ANSWER or LA134_1 == COMMENT or LA134_1 == CONNECT or LA134_1 == DECISION or LA134_1 == INPUT or (JOIN <= LA134_1 <= LABEL) or LA134_1 == NEXTSTATE or LA134_1 == OUTPUT or (PROCEDURE <= LA134_1 <= PROCEDURE_CALL) or (PROCESS <= LA134_1 <= PROVIDED) or LA134_1 == RETURN or LA134_1 == STATE or LA134_1 == STOP or LA134_1 == TASK or LA134_1 == TEXT or LA134_1 == START) : alt134 = 1 if alt134 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_answer_part9270) cif395 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif395.tree) # sdl92.g:845:17: ( hyperlink )? alt135 = 2 LA135_0 = self.input.LA(1) if (LA135_0 == 229) : alt135 = 1 if alt135 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_answer_part9289) hyperlink396 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink396.tree) L_PAREN397=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_answer_part9308) if self._state.backtracking == 0: stream_L_PAREN.add(L_PAREN397) self._state.following.append(self.FOLLOW_answer_in_answer_part9310) answer398 = self.answer() self._state.following.pop() if self._state.backtracking == 0: stream_answer.add(answer398.tree) R_PAREN399=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_answer_part9312) if self._state.backtracking == 0: stream_R_PAREN.add(R_PAREN399) char_literal400=self.match(self.input, 223, self.FOLLOW_223_in_answer_part9314) if self._state.backtracking == 0: stream_223.add(char_literal400) # sdl92.g:846:44: ( transition )? alt136 = 2 alt136 = self.dfa136.predict(self.input) if alt136 == 1: # sdl92.g:0:0: transition pass self._state.following.append(self.FOLLOW_transition_in_answer_part9316) transition401 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition401.tree) # AST Rewrite # elements: cif, answer, transition, hyperlink # 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() # 847:9: -> ^( ANSWER ( cif )? ( hyperlink )? answer ( transition )? ) # sdl92.g:847:17: ^( ANSWER ( cif )? ( hyperlink )? answer ( transition )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(ANSWER, "ANSWER"), root_1) # sdl92.g:847:26: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:847:31: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); self._adaptor.addChild(root_1, stream_answer.nextTree()) # sdl92.g:847:49: ( transition )? if stream_transition.hasNext(): self._adaptor.addChild(root_1, stream_transition.nextTree()) stream_transition.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, 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 "answer_part" class answer_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.answer_return, self).__init__() self.tree = None # $ANTLR start "answer" # sdl92.g:851:1: answer : ( range_condition | informal_text ); def answer(self, ): retval = self.answer_return() retval.start = self.input.LT(1) root_0 = None range_condition402 = None informal_text403 = None try: try: # sdl92.g:852:9: ( range_condition | informal_text ) alt137 = 2 LA137_0 = self.input.LA(1) if (LA137_0 == FLOAT or LA137_0 == IF or LA137_0 == STATE or LA137_0 == ID or LA137_0 == INT or LA137_0 == L_PAREN or (EQ <= LA137_0 <= GE) or LA137_0 == DASH or (NOT <= LA137_0 <= MINUS_INFINITY) or LA137_0 == L_BRACKET) : alt137 = 1 elif (LA137_0 == STRING) : LA137_2 = self.input.LA(2) if (self.synpred176_sdl92()) : alt137 = 1 elif (True) : alt137 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 137, 2, self.input) raise nvae else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 137, 0, self.input) raise nvae if alt137 == 1: # sdl92.g:852:17: range_condition pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_range_condition_in_answer9379) range_condition402 = self.range_condition() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, range_condition402.tree) elif alt137 == 2: # sdl92.g:853:19: informal_text pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_informal_text_in_answer9399) informal_text403 = self.informal_text() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, informal_text403.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, 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 "answer" class else_part_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.else_part_return, self).__init__() self.tree = None # $ANTLR start "else_part" # sdl92.g:857:1: else_part : ( cif )? ( hyperlink )? ELSE ':' ( transition )? -> ^( ELSE ( cif )? ( hyperlink )? ( transition )? ) ; def else_part(self, ): retval = self.else_part_return() retval.start = self.input.LT(1) root_0 = None ELSE406 = None char_literal407 = None cif404 = None hyperlink405 = None transition408 = None ELSE406_tree = None char_literal407_tree = None stream_223 = RewriteRuleTokenStream(self._adaptor, "token 223") stream_ELSE = RewriteRuleTokenStream(self._adaptor, "token ELSE") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") try: try: # sdl92.g:858:9: ( ( cif )? ( hyperlink )? ELSE ':' ( transition )? -> ^( ELSE ( cif )? ( hyperlink )? ( transition )? ) ) # sdl92.g:858:17: ( cif )? ( hyperlink )? ELSE ':' ( transition )? pass # sdl92.g:858:17: ( cif )? alt138 = 2 LA138_0 = self.input.LA(1) if (LA138_0 == 229) : LA138_1 = self.input.LA(2) if (LA138_1 == ANSWER or LA138_1 == COMMENT or LA138_1 == CONNECT or LA138_1 == DECISION or LA138_1 == INPUT or (JOIN <= LA138_1 <= LABEL) or LA138_1 == NEXTSTATE or LA138_1 == OUTPUT or (PROCEDURE <= LA138_1 <= PROCEDURE_CALL) or (PROCESS <= LA138_1 <= PROVIDED) or LA138_1 == RETURN or LA138_1 == STATE or LA138_1 == STOP or LA138_1 == TASK or LA138_1 == TEXT or LA138_1 == START) : alt138 = 1 if alt138 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_else_part9431) cif404 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif404.tree) # sdl92.g:859:17: ( hyperlink )? alt139 = 2 LA139_0 = self.input.LA(1) if (LA139_0 == 229) : alt139 = 1 if alt139 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_else_part9450) hyperlink405 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink405.tree) ELSE406=self.match(self.input, ELSE, self.FOLLOW_ELSE_in_else_part9469) if self._state.backtracking == 0: stream_ELSE.add(ELSE406) char_literal407=self.match(self.input, 223, self.FOLLOW_223_in_else_part9471) if self._state.backtracking == 0: stream_223.add(char_literal407) # sdl92.g:860:26: ( transition )? alt140 = 2 LA140_0 = self.input.LA(1) if (LA140_0 == ALTERNATIVE or LA140_0 == DECISION or LA140_0 == EXPORT or LA140_0 == FOR or LA140_0 == JOIN or LA140_0 == NEXTSTATE or LA140_0 == OUTPUT or (RESET <= LA140_0 <= RETURN) or LA140_0 == SET or LA140_0 == STOP or LA140_0 == STRING or LA140_0 == TASK or LA140_0 == ID or LA140_0 == CALL or LA140_0 == CREATE or LA140_0 == 229) : alt140 = 1 if alt140 == 1: # sdl92.g:0:0: transition pass self._state.following.append(self.FOLLOW_transition_in_else_part9473) transition408 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition408.tree) # AST Rewrite # elements: hyperlink, ELSE, transition, cif # 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() # 861:9: -> ^( ELSE ( cif )? ( hyperlink )? ( transition )? ) # sdl92.g:861:17: ^( ELSE ( cif )? ( hyperlink )? ( transition )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_ELSE.nextNode(), root_1) # sdl92.g:861:24: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:861:29: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:861:40: ( transition )? if stream_transition.hasNext(): self._adaptor.addChild(root_1, stream_transition.nextTree()) stream_transition.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, 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 "else_part" class question_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.question_return, self).__init__() self.tree = None # $ANTLR start "question" # sdl92.g:865:1: question : ( informal_text | expression -> ^( QUESTION expression ) | ANY -> ^( ANY ) ); def question(self, ): retval = self.question_return() retval.start = self.input.LT(1) root_0 = None ANY411 = None informal_text409 = None expression410 = None ANY411_tree = None stream_ANY = RewriteRuleTokenStream(self._adaptor, "token ANY") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:866:9: ( informal_text | expression -> ^( QUESTION expression ) | ANY -> ^( ANY ) ) alt141 = 3 LA141 = self.input.LA(1) if LA141 == STRING: LA141_1 = self.input.LA(2) if (self.synpred180_sdl92()) : alt141 = 1 elif (self.synpred181_sdl92()) : alt141 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 141, 1, self.input) raise nvae elif LA141 == FLOAT or LA141 == IF or LA141 == STATE or LA141 == ID or LA141 == INT or LA141 == L_PAREN or LA141 == DASH or LA141 == NOT or LA141 == TRUE or LA141 == FALSE or LA141 == NULL or LA141 == PLUS_INFINITY or LA141 == MINUS_INFINITY or LA141 == L_BRACKET: alt141 = 2 elif LA141 == ANY: alt141 = 3 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 141, 0, self.input) raise nvae if alt141 == 1: # sdl92.g:866:17: informal_text pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_informal_text_in_question9534) informal_text409 = self.informal_text() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, informal_text409.tree) elif alt141 == 2: # sdl92.g:867:19: expression pass self._state.following.append(self.FOLLOW_expression_in_question9554) expression410 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression410.tree) # AST Rewrite # elements: expression # 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() # 868:9: -> ^( QUESTION expression ) # sdl92.g:868:17: ^( QUESTION expression ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(QUESTION, "QUESTION"), root_1) self._adaptor.addChild(root_1, stream_expression.nextTree()) self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt141 == 3: # sdl92.g:869:19: ANY pass ANY411=self.match(self.input, ANY, self.FOLLOW_ANY_in_question9595) if self._state.backtracking == 0: stream_ANY.add(ANY411) # AST Rewrite # elements: ANY # 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() # 870:9: -> ^( ANY ) # sdl92.g:870:17: ^( ANY ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_ANY.nextNode(), root_1) 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, 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 "question" class range_condition_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.range_condition_return, self).__init__() self.tree = None # $ANTLR start "range_condition" # sdl92.g:874:1: range_condition : ( closed_range | open_range ) ; def range_condition(self, ): retval = self.range_condition_return() retval.start = self.input.LT(1) root_0 = None closed_range412 = None open_range413 = None try: try: # sdl92.g:875:9: ( ( closed_range | open_range ) ) # sdl92.g:875:17: ( closed_range | open_range ) pass root_0 = self._adaptor.nil() # sdl92.g:875:17: ( closed_range | open_range ) alt142 = 2 alt142 = self.dfa142.predict(self.input) if alt142 == 1: # sdl92.g:875:18: closed_range pass self._state.following.append(self.FOLLOW_closed_range_in_range_condition9647) closed_range412 = self.closed_range() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, closed_range412.tree) elif alt142 == 2: # sdl92.g:875:33: open_range pass self._state.following.append(self.FOLLOW_open_range_in_range_condition9651) open_range413 = self.open_range() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, open_range413.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, 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 "range_condition" class closed_range_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.closed_range_return, self).__init__() self.tree = None # $ANTLR start "closed_range" # sdl92.g:880:1: closed_range : a= expression ':' b= expression -> ^( CLOSED_RANGE $a $b) ; def closed_range(self, ): retval = self.closed_range_return() retval.start = self.input.LT(1) root_0 = None char_literal414 = None a = None b = None char_literal414_tree = None stream_223 = RewriteRuleTokenStream(self._adaptor, "token 223") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:881:9: (a= expression ':' b= expression -> ^( CLOSED_RANGE $a $b) ) # sdl92.g:881:17: a= expression ':' b= expression pass self._state.following.append(self.FOLLOW_expression_in_closed_range9703) a = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(a.tree) char_literal414=self.match(self.input, 223, self.FOLLOW_223_in_closed_range9705) if self._state.backtracking == 0: stream_223.add(char_literal414) self._state.following.append(self.FOLLOW_expression_in_closed_range9709) b = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(b.tree) # AST Rewrite # elements: b, a # token labels: # rule labels: retval, b, a # 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) if b is not None: stream_b = RewriteRuleSubtreeStream(self._adaptor, "rule b", b.tree) else: stream_b = RewriteRuleSubtreeStream(self._adaptor, "token b", None) if a is not None: stream_a = RewriteRuleSubtreeStream(self._adaptor, "rule a", a.tree) else: stream_a = RewriteRuleSubtreeStream(self._adaptor, "token a", None) root_0 = self._adaptor.nil() # 882:9: -> ^( CLOSED_RANGE $a $b) # sdl92.g:882:17: ^( CLOSED_RANGE $a $b) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(CLOSED_RANGE, "CLOSED_RANGE"), root_1) self._adaptor.addChild(root_1, stream_a.nextTree()) self._adaptor.addChild(root_1, stream_b.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, 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 "closed_range" class open_range_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.open_range_return, self).__init__() self.tree = None # $ANTLR start "open_range" # sdl92.g:886:1: open_range : ( constant -> constant | ( ( EQ | NEQ | GT | LT | LE | GE ) constant ) -> ^( OPEN_RANGE ( EQ )? ( NEQ )? ( GT )? ( LT )? ( LE )? ( GE )? constant ) ); def open_range(self, ): retval = self.open_range_return() retval.start = self.input.LT(1) root_0 = None EQ416 = None NEQ417 = None GT418 = None LT419 = None LE420 = None GE421 = None constant415 = None constant422 = None EQ416_tree = None NEQ417_tree = None GT418_tree = None LT419_tree = None LE420_tree = None GE421_tree = None stream_GT = RewriteRuleTokenStream(self._adaptor, "token GT") stream_GE = RewriteRuleTokenStream(self._adaptor, "token GE") stream_LT = RewriteRuleTokenStream(self._adaptor, "token LT") stream_NEQ = RewriteRuleTokenStream(self._adaptor, "token NEQ") stream_EQ = RewriteRuleTokenStream(self._adaptor, "token EQ") stream_LE = RewriteRuleTokenStream(self._adaptor, "token LE") stream_constant = RewriteRuleSubtreeStream(self._adaptor, "rule constant") try: try: # sdl92.g:887:9: ( constant -> constant | ( ( EQ | NEQ | GT | LT | LE | GE ) constant ) -> ^( OPEN_RANGE ( EQ )? ( NEQ )? ( GT )? ( LT )? ( LE )? ( GE )? constant ) ) alt144 = 2 LA144_0 = self.input.LA(1) if (LA144_0 == FLOAT or LA144_0 == IF or LA144_0 == STATE or LA144_0 == STRING or LA144_0 == ID or LA144_0 == INT or LA144_0 == L_PAREN or LA144_0 == DASH or (NOT <= LA144_0 <= MINUS_INFINITY) or LA144_0 == L_BRACKET) : alt144 = 1 elif ((EQ <= LA144_0 <= GE)) : alt144 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 144, 0, self.input) raise nvae if alt144 == 1: # sdl92.g:887:17: constant pass self._state.following.append(self.FOLLOW_constant_in_open_range9766) constant415 = self.constant() self._state.following.pop() if self._state.backtracking == 0: stream_constant.add(constant415.tree) # AST Rewrite # elements: constant # 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() # 888:9: -> constant self._adaptor.addChild(root_0, stream_constant.nextTree()) retval.tree = root_0 elif alt144 == 2: # sdl92.g:889:19: ( ( EQ | NEQ | GT | LT | LE | GE ) constant ) pass # sdl92.g:889:19: ( ( EQ | NEQ | GT | LT | LE | GE ) constant ) # sdl92.g:889:21: ( EQ | NEQ | GT | LT | LE | GE ) constant pass # sdl92.g:889:21: ( EQ | NEQ | GT | LT | LE | GE ) alt143 = 6 LA143 = self.input.LA(1) if LA143 == EQ: alt143 = 1 elif LA143 == NEQ: alt143 = 2 elif LA143 == GT: alt143 = 3 elif LA143 == LT: alt143 = 4 elif LA143 == LE: alt143 = 5 elif LA143 == GE: alt143 = 6 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 143, 0, self.input) raise nvae if alt143 == 1: # sdl92.g:889:22: EQ pass EQ416=self.match(self.input, EQ, self.FOLLOW_EQ_in_open_range9806) if self._state.backtracking == 0: stream_EQ.add(EQ416) elif alt143 == 2: # sdl92.g:889:25: NEQ pass NEQ417=self.match(self.input, NEQ, self.FOLLOW_NEQ_in_open_range9808) if self._state.backtracking == 0: stream_NEQ.add(NEQ417) elif alt143 == 3: # sdl92.g:889:29: GT pass GT418=self.match(self.input, GT, self.FOLLOW_GT_in_open_range9810) if self._state.backtracking == 0: stream_GT.add(GT418) elif alt143 == 4: # sdl92.g:889:32: LT pass LT419=self.match(self.input, LT, self.FOLLOW_LT_in_open_range9812) if self._state.backtracking == 0: stream_LT.add(LT419) elif alt143 == 5: # sdl92.g:889:35: LE pass LE420=self.match(self.input, LE, self.FOLLOW_LE_in_open_range9814) if self._state.backtracking == 0: stream_LE.add(LE420) elif alt143 == 6: # sdl92.g:889:38: GE pass GE421=self.match(self.input, GE, self.FOLLOW_GE_in_open_range9816) if self._state.backtracking == 0: stream_GE.add(GE421) self._state.following.append(self.FOLLOW_constant_in_open_range9819) constant422 = self.constant() self._state.following.pop() if self._state.backtracking == 0: stream_constant.add(constant422.tree) # AST Rewrite # elements: GT, LE, constant, NEQ, LT, EQ, GE # 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() # 890:9: -> ^( OPEN_RANGE ( EQ )? ( NEQ )? ( GT )? ( LT )? ( LE )? ( GE )? constant ) # sdl92.g:890:17: ^( OPEN_RANGE ( EQ )? ( NEQ )? ( GT )? ( LT )? ( LE )? ( GE )? constant ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(OPEN_RANGE, "OPEN_RANGE"), root_1) # sdl92.g:890:30: ( EQ )? if stream_EQ.hasNext(): self._adaptor.addChild(root_1, stream_EQ.nextNode()) stream_EQ.reset(); # sdl92.g:890:34: ( NEQ )? if stream_NEQ.hasNext(): self._adaptor.addChild(root_1, stream_NEQ.nextNode()) stream_NEQ.reset(); # sdl92.g:890:39: ( GT )? if stream_GT.hasNext(): self._adaptor.addChild(root_1, stream_GT.nextNode()) stream_GT.reset(); # sdl92.g:890:43: ( LT )? if stream_LT.hasNext(): self._adaptor.addChild(root_1, stream_LT.nextNode()) stream_LT.reset(); # sdl92.g:890:47: ( LE )? if stream_LE.hasNext(): self._adaptor.addChild(root_1, stream_LE.nextNode()) stream_LE.reset(); # sdl92.g:890:51: ( GE )? if stream_GE.hasNext(): self._adaptor.addChild(root_1, stream_GE.nextNode()) stream_GE.reset(); self._adaptor.addChild(root_1, stream_constant.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, 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 "open_range" class constant_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.constant_return, self).__init__() self.tree = None # $ANTLR start "constant" # sdl92.g:894:1: constant : expression -> ^( CONSTANT expression ) ; def constant(self, ): retval = self.constant_return() retval.start = self.input.LT(1) root_0 = None expression423 = None stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:895:9: ( expression -> ^( CONSTANT expression ) ) # sdl92.g:895:17: expression pass self._state.following.append(self.FOLLOW_expression_in_constant9891) expression423 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression423.tree) # AST Rewrite # elements: expression # 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() # 896:9: -> ^( CONSTANT expression ) # sdl92.g:896:17: ^( CONSTANT expression ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(CONSTANT, "CONSTANT"), root_1) self._adaptor.addChild(root_1, stream_expression.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, 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 "constant" class create_request_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.create_request_return, self).__init__() self.tree = None # $ANTLR start "create_request" # sdl92.g:900:1: create_request : CREATE createbody ( actual_parameters )? end -> ^( CREATE createbody ( actual_parameters )? ) ; def create_request(self, ): retval = self.create_request_return() retval.start = self.input.LT(1) root_0 = None CREATE424 = None createbody425 = None actual_parameters426 = None end427 = None CREATE424_tree = None stream_CREATE = RewriteRuleTokenStream(self._adaptor, "token CREATE") stream_createbody = RewriteRuleSubtreeStream(self._adaptor, "rule createbody") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_actual_parameters = RewriteRuleSubtreeStream(self._adaptor, "rule actual_parameters") try: try: # sdl92.g:901:9: ( CREATE createbody ( actual_parameters )? end -> ^( CREATE createbody ( actual_parameters )? ) ) # sdl92.g:901:17: CREATE createbody ( actual_parameters )? end pass CREATE424=self.match(self.input, CREATE, self.FOLLOW_CREATE_in_create_request9944) if self._state.backtracking == 0: stream_CREATE.add(CREATE424) self._state.following.append(self.FOLLOW_createbody_in_create_request9962) createbody425 = self.createbody() self._state.following.pop() if self._state.backtracking == 0: stream_createbody.add(createbody425.tree) # sdl92.g:903:17: ( actual_parameters )? alt145 = 2 LA145_0 = self.input.LA(1) if (LA145_0 == L_PAREN) : alt145 = 1 if alt145 == 1: # sdl92.g:0:0: actual_parameters pass self._state.following.append(self.FOLLOW_actual_parameters_in_create_request9980) actual_parameters426 = self.actual_parameters() self._state.following.pop() if self._state.backtracking == 0: stream_actual_parameters.add(actual_parameters426.tree) self._state.following.append(self.FOLLOW_end_in_create_request9999) end427 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end427.tree) # AST Rewrite # elements: actual_parameters, CREATE, createbody # 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() # 905:9: -> ^( CREATE createbody ( actual_parameters )? ) # sdl92.g:905:17: ^( CREATE createbody ( actual_parameters )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_CREATE.nextNode(), root_1) self._adaptor.addChild(root_1, stream_createbody.nextTree()) # sdl92.g:905:37: ( actual_parameters )? if stream_actual_parameters.hasNext(): self._adaptor.addChild(root_1, stream_actual_parameters.nextTree()) stream_actual_parameters.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, 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 "create_request" class createbody_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.createbody_return, self).__init__() self.tree = None # $ANTLR start "createbody" # sdl92.g:909:1: createbody : ( process_id | THIS ); def createbody(self, ): retval = self.createbody_return() retval.start = self.input.LT(1) root_0 = None THIS429 = None process_id428 = None THIS429_tree = None try: try: # sdl92.g:910:9: ( process_id | THIS ) alt146 = 2 LA146_0 = self.input.LA(1) if (LA146_0 == ID) : alt146 = 1 elif (LA146_0 == THIS) : alt146 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 146, 0, self.input) raise nvae if alt146 == 1: # sdl92.g:910:17: process_id pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_process_id_in_createbody10055) process_id428 = self.process_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, process_id428.tree) elif alt146 == 2: # sdl92.g:911:19: THIS pass root_0 = self._adaptor.nil() THIS429=self.match(self.input, THIS, self.FOLLOW_THIS_in_createbody10075) if self._state.backtracking == 0: THIS429_tree = self._adaptor.createWithPayload(THIS429) self._adaptor.addChild(root_0, THIS429_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, 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 "createbody" class output_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.output_return, self).__init__() self.tree = None # $ANTLR start "output" # sdl92.g:915:1: output : ( cif )? ( hyperlink )? OUTPUT outputbody end -> ^( OUTPUT ( cif )? ( hyperlink )? ( end )? outputbody ) ; def output(self, ): retval = self.output_return() retval.start = self.input.LT(1) root_0 = None OUTPUT432 = None cif430 = None hyperlink431 = None outputbody433 = None end434 = None OUTPUT432_tree = None stream_OUTPUT = RewriteRuleTokenStream(self._adaptor, "token OUTPUT") stream_outputbody = RewriteRuleSubtreeStream(self._adaptor, "rule outputbody") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:916:9: ( ( cif )? ( hyperlink )? OUTPUT outputbody end -> ^( OUTPUT ( cif )? ( hyperlink )? ( end )? outputbody ) ) # sdl92.g:916:17: ( cif )? ( hyperlink )? OUTPUT outputbody end pass # sdl92.g:916:17: ( cif )? alt147 = 2 LA147_0 = self.input.LA(1) if (LA147_0 == 229) : LA147_1 = self.input.LA(2) if (LA147_1 == ANSWER or LA147_1 == COMMENT or LA147_1 == CONNECT or LA147_1 == DECISION or LA147_1 == INPUT or (JOIN <= LA147_1 <= LABEL) or LA147_1 == NEXTSTATE or LA147_1 == OUTPUT or (PROCEDURE <= LA147_1 <= PROCEDURE_CALL) or (PROCESS <= LA147_1 <= PROVIDED) or LA147_1 == RETURN or LA147_1 == STATE or LA147_1 == STOP or LA147_1 == TASK or LA147_1 == TEXT or LA147_1 == START) : alt147 = 1 if alt147 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_output10107) cif430 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif430.tree) # sdl92.g:917:17: ( hyperlink )? alt148 = 2 LA148_0 = self.input.LA(1) if (LA148_0 == 229) : alt148 = 1 if alt148 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_output10126) hyperlink431 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink431.tree) OUTPUT432=self.match(self.input, OUTPUT, self.FOLLOW_OUTPUT_in_output10145) if self._state.backtracking == 0: stream_OUTPUT.add(OUTPUT432) self._state.following.append(self.FOLLOW_outputbody_in_output10147) outputbody433 = self.outputbody() self._state.following.pop() if self._state.backtracking == 0: stream_outputbody.add(outputbody433.tree) self._state.following.append(self.FOLLOW_end_in_output10149) end434 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end434.tree) # AST Rewrite # elements: hyperlink, end, outputbody, cif, OUTPUT # 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() # 919:9: -> ^( OUTPUT ( cif )? ( hyperlink )? ( end )? outputbody ) # sdl92.g:919:17: ^( OUTPUT ( cif )? ( hyperlink )? ( end )? outputbody ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_OUTPUT.nextNode(), root_1) # sdl92.g:919:26: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:919:31: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:919:42: ( end )? if stream_end.hasNext(): self._adaptor.addChild(root_1, stream_end.nextTree()) stream_end.reset(); self._adaptor.addChild(root_1, stream_outputbody.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, 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 "output" class outputbody_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.outputbody_return, self).__init__() self.tree = None # $ANTLR start "outputbody" # sdl92.g:923:1: outputbody : outputstmt ( ',' outputstmt )* ( to_part )? -> ^( OUTPUT_BODY ( outputstmt )+ ( to_part )? ) ; def outputbody(self, ): retval = self.outputbody_return() retval.start = self.input.LT(1) root_0 = None char_literal436 = None outputstmt435 = None outputstmt437 = None to_part438 = None char_literal436_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_outputstmt = RewriteRuleSubtreeStream(self._adaptor, "rule outputstmt") stream_to_part = RewriteRuleSubtreeStream(self._adaptor, "rule to_part") try: try: # sdl92.g:924:9: ( outputstmt ( ',' outputstmt )* ( to_part )? -> ^( OUTPUT_BODY ( outputstmt )+ ( to_part )? ) ) # sdl92.g:924:17: outputstmt ( ',' outputstmt )* ( to_part )? pass self._state.following.append(self.FOLLOW_outputstmt_in_outputbody10211) outputstmt435 = self.outputstmt() self._state.following.pop() if self._state.backtracking == 0: stream_outputstmt.add(outputstmt435.tree) # sdl92.g:924:28: ( ',' outputstmt )* while True: #loop149 alt149 = 2 LA149_0 = self.input.LA(1) if (LA149_0 == COMMA) : alt149 = 1 if alt149 == 1: # sdl92.g:924:29: ',' outputstmt pass char_literal436=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_outputbody10214) if self._state.backtracking == 0: stream_COMMA.add(char_literal436) self._state.following.append(self.FOLLOW_outputstmt_in_outputbody10216) outputstmt437 = self.outputstmt() self._state.following.pop() if self._state.backtracking == 0: stream_outputstmt.add(outputstmt437.tree) else: break #loop149 # sdl92.g:924:46: ( to_part )? alt150 = 2 LA150_0 = self.input.LA(1) if (LA150_0 == TO) : alt150 = 1 if alt150 == 1: # sdl92.g:0:0: to_part pass self._state.following.append(self.FOLLOW_to_part_in_outputbody10220) to_part438 = self.to_part() self._state.following.pop() if self._state.backtracking == 0: stream_to_part.add(to_part438.tree) # AST Rewrite # elements: outputstmt, to_part # 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() # 925:9: -> ^( OUTPUT_BODY ( outputstmt )+ ( to_part )? ) # sdl92.g:925:17: ^( OUTPUT_BODY ( outputstmt )+ ( to_part )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(OUTPUT_BODY, "OUTPUT_BODY"), root_1) # sdl92.g:925:31: ( outputstmt )+ if not (stream_outputstmt.hasNext()): raise RewriteEarlyExitException() while stream_outputstmt.hasNext(): self._adaptor.addChild(root_1, stream_outputstmt.nextTree()) stream_outputstmt.reset() # sdl92.g:925:43: ( to_part )? if stream_to_part.hasNext(): self._adaptor.addChild(root_1, stream_to_part.nextTree()) stream_to_part.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, 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 "outputbody" class outputstmt_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.outputstmt_return, self).__init__() self.tree = None # $ANTLR start "outputstmt" # sdl92.g:931:1: outputstmt : signal_id ( actual_parameters )? ; def outputstmt(self, ): retval = self.outputstmt_return() retval.start = self.input.LT(1) root_0 = None signal_id439 = None actual_parameters440 = None try: try: # sdl92.g:932:9: ( signal_id ( actual_parameters )? ) # sdl92.g:932:17: signal_id ( actual_parameters )? pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_signal_id_in_outputstmt10282) signal_id439 = self.signal_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, signal_id439.tree) # sdl92.g:933:17: ( actual_parameters )? alt151 = 2 LA151_0 = self.input.LA(1) if (LA151_0 == L_PAREN) : alt151 = 1 if alt151 == 1: # sdl92.g:0:0: actual_parameters pass self._state.following.append(self.FOLLOW_actual_parameters_in_outputstmt10300) actual_parameters440 = self.actual_parameters() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, actual_parameters440.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, 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 "outputstmt" class to_part_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.to_part_return, self).__init__() self.tree = None # $ANTLR start "to_part" # sdl92.g:936:1: to_part : ( TO destination ) -> ^( TO destination ) ; def to_part(self, ): retval = self.to_part_return() retval.start = self.input.LT(1) root_0 = None TO441 = None destination442 = None TO441_tree = None stream_TO = RewriteRuleTokenStream(self._adaptor, "token TO") stream_destination = RewriteRuleSubtreeStream(self._adaptor, "rule destination") try: try: # sdl92.g:937:9: ( ( TO destination ) -> ^( TO destination ) ) # sdl92.g:937:17: ( TO destination ) pass # sdl92.g:937:17: ( TO destination ) # sdl92.g:937:18: TO destination pass TO441=self.match(self.input, TO, self.FOLLOW_TO_in_to_part10333) if self._state.backtracking == 0: stream_TO.add(TO441) self._state.following.append(self.FOLLOW_destination_in_to_part10335) destination442 = self.destination() self._state.following.pop() if self._state.backtracking == 0: stream_destination.add(destination442.tree) # AST Rewrite # elements: destination, TO # 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() # 938:9: -> ^( TO destination ) # sdl92.g:938:17: ^( TO destination ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_TO.nextNode(), root_1) self._adaptor.addChild(root_1, stream_destination.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, 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 "to_part" class via_part_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.via_part_return, self).__init__() self.tree = None # $ANTLR start "via_part" # sdl92.g:941:1: via_part : VIA viabody -> ^( VIA viabody ) ; def via_part(self, ): retval = self.via_part_return() retval.start = self.input.LT(1) root_0 = None VIA443 = None viabody444 = None VIA443_tree = None stream_VIA = RewriteRuleTokenStream(self._adaptor, "token VIA") stream_viabody = RewriteRuleSubtreeStream(self._adaptor, "rule viabody") try: try: # sdl92.g:942:9: ( VIA viabody -> ^( VIA viabody ) ) # sdl92.g:942:17: VIA viabody pass VIA443=self.match(self.input, VIA, self.FOLLOW_VIA_in_via_part10388) if self._state.backtracking == 0: stream_VIA.add(VIA443) self._state.following.append(self.FOLLOW_viabody_in_via_part10390) viabody444 = self.viabody() self._state.following.pop() if self._state.backtracking == 0: stream_viabody.add(viabody444.tree) # AST Rewrite # elements: VIA, viabody # 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() # 943:9: -> ^( VIA viabody ) # sdl92.g:943:17: ^( VIA viabody ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_VIA.nextNode(), root_1) self._adaptor.addChild(root_1, stream_viabody.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, 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 "via_part" class viabody_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.viabody_return, self).__init__() self.tree = None # $ANTLR start "viabody" # sdl92.g:948:1: viabody : ( ALL -> ^( ALL ) | via_path -> ^( VIAPATH via_path ) ); def viabody(self, ): retval = self.viabody_return() retval.start = self.input.LT(1) root_0 = None ALL445 = None via_path446 = None ALL445_tree = None stream_ALL = RewriteRuleTokenStream(self._adaptor, "token ALL") stream_via_path = RewriteRuleSubtreeStream(self._adaptor, "rule via_path") try: try: # sdl92.g:949:9: ( ALL -> ^( ALL ) | via_path -> ^( VIAPATH via_path ) ) alt152 = 2 LA152_0 = self.input.LA(1) if (LA152_0 == ALL) : alt152 = 1 elif (LA152_0 == ID) : alt152 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 152, 0, self.input) raise nvae if alt152 == 1: # sdl92.g:949:17: ALL pass ALL445=self.match(self.input, ALL, self.FOLLOW_ALL_in_viabody10444) if self._state.backtracking == 0: stream_ALL.add(ALL445) # AST Rewrite # elements: ALL # 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() # 950:9: -> ^( ALL ) # sdl92.g:950:17: ^( ALL ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_ALL.nextNode(), root_1) self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt152 == 2: # sdl92.g:951:19: via_path pass self._state.following.append(self.FOLLOW_via_path_in_viabody10483) via_path446 = self.via_path() self._state.following.pop() if self._state.backtracking == 0: stream_via_path.add(via_path446.tree) # AST Rewrite # elements: via_path # 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() # 952:9: -> ^( VIAPATH via_path ) # sdl92.g:952:17: ^( VIAPATH via_path ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(VIAPATH, "VIAPATH"), root_1) self._adaptor.addChild(root_1, stream_via_path.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, 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 "viabody" class destination_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.destination_return, self).__init__() self.tree = None # $ANTLR start "destination" # sdl92.g:956:1: destination : ( pid_expression | process_id | THIS ); def destination(self, ): retval = self.destination_return() retval.start = self.input.LT(1) root_0 = None THIS449 = None pid_expression447 = None process_id448 = None THIS449_tree = None try: try: # sdl92.g:957:9: ( pid_expression | process_id | THIS ) alt153 = 3 LA153 = self.input.LA(1) if LA153 == P or LA153 == S or LA153 == O: alt153 = 1 elif LA153 == ID: alt153 = 2 elif LA153 == THIS: alt153 = 3 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 153, 0, self.input) raise nvae if alt153 == 1: # sdl92.g:957:17: pid_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_pid_expression_in_destination10536) pid_expression447 = self.pid_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, pid_expression447.tree) elif alt153 == 2: # sdl92.g:958:19: process_id pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_process_id_in_destination10556) process_id448 = self.process_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, process_id448.tree) elif alt153 == 3: # sdl92.g:959:19: THIS pass root_0 = self._adaptor.nil() THIS449=self.match(self.input, THIS, self.FOLLOW_THIS_in_destination10576) if self._state.backtracking == 0: THIS449_tree = self._adaptor.createWithPayload(THIS449) self._adaptor.addChild(root_0, THIS449_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, 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 "destination" class via_path_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.via_path_return, self).__init__() self.tree = None # $ANTLR start "via_path" # sdl92.g:963:1: via_path : via_path_element ( ',' via_path_element )* -> ( via_path_element )+ ; def via_path(self, ): retval = self.via_path_return() retval.start = self.input.LT(1) root_0 = None char_literal451 = None via_path_element450 = None via_path_element452 = None char_literal451_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_via_path_element = RewriteRuleSubtreeStream(self._adaptor, "rule via_path_element") try: try: # sdl92.g:964:9: ( via_path_element ( ',' via_path_element )* -> ( via_path_element )+ ) # sdl92.g:964:17: via_path_element ( ',' via_path_element )* pass self._state.following.append(self.FOLLOW_via_path_element_in_via_path10608) via_path_element450 = self.via_path_element() self._state.following.pop() if self._state.backtracking == 0: stream_via_path_element.add(via_path_element450.tree) # sdl92.g:964:34: ( ',' via_path_element )* while True: #loop154 alt154 = 2 LA154_0 = self.input.LA(1) if (LA154_0 == COMMA) : alt154 = 1 if alt154 == 1: # sdl92.g:964:35: ',' via_path_element pass char_literal451=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_via_path10611) if self._state.backtracking == 0: stream_COMMA.add(char_literal451) self._state.following.append(self.FOLLOW_via_path_element_in_via_path10613) via_path_element452 = self.via_path_element() self._state.following.pop() if self._state.backtracking == 0: stream_via_path_element.add(via_path_element452.tree) else: break #loop154 # AST Rewrite # elements: via_path_element # 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() # 965:9: -> ( via_path_element )+ # sdl92.g:965:17: ( via_path_element )+ if not (stream_via_path_element.hasNext()): raise RewriteEarlyExitException() while stream_via_path_element.hasNext(): self._adaptor.addChild(root_0, stream_via_path_element.nextTree()) stream_via_path_element.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, 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 "via_path" class via_path_element_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.via_path_element_return, self).__init__() self.tree = None # $ANTLR start "via_path_element" # sdl92.g:969:1: via_path_element : ID ; def via_path_element(self, ): retval = self.via_path_element_return() retval.start = self.input.LT(1) root_0 = None ID453 = None ID453_tree = None try: try: # sdl92.g:970:9: ( ID ) # sdl92.g:970:17: ID pass root_0 = self._adaptor.nil() ID453=self.match(self.input, ID, self.FOLLOW_ID_in_via_path_element10665) if self._state.backtracking == 0: ID453_tree = self._adaptor.createWithPayload(ID453) self._adaptor.addChild(root_0, ID453_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, 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 "via_path_element" class actual_parameters_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.actual_parameters_return, self).__init__() self.tree = None # $ANTLR start "actual_parameters" # sdl92.g:974:1: actual_parameters : '(' expression ( ',' expression )* ')' -> ^( PARAMS ( expression )+ ) ; def actual_parameters(self, ): retval = self.actual_parameters_return() retval.start = self.input.LT(1) root_0 = None char_literal454 = None char_literal456 = None char_literal458 = None expression455 = None expression457 = None char_literal454_tree = None char_literal456_tree = None char_literal458_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:975:9: ( '(' expression ( ',' expression )* ')' -> ^( PARAMS ( expression )+ ) ) # sdl92.g:975:16: '(' expression ( ',' expression )* ')' pass char_literal454=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_actual_parameters10697) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal454) self._state.following.append(self.FOLLOW_expression_in_actual_parameters10699) expression455 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression455.tree) # sdl92.g:975:31: ( ',' expression )* while True: #loop155 alt155 = 2 LA155_0 = self.input.LA(1) if (LA155_0 == COMMA) : alt155 = 1 if alt155 == 1: # sdl92.g:975:32: ',' expression pass char_literal456=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_actual_parameters10702) if self._state.backtracking == 0: stream_COMMA.add(char_literal456) self._state.following.append(self.FOLLOW_expression_in_actual_parameters10704) expression457 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression457.tree) else: break #loop155 char_literal458=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_actual_parameters10708) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal458) # AST Rewrite # elements: expression # 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() # 976:9: -> ^( PARAMS ( expression )+ ) # sdl92.g:976:16: ^( PARAMS ( expression )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(PARAMS, "PARAMS"), root_1) # sdl92.g:976:25: ( expression )+ if not (stream_expression.hasNext()): raise RewriteEarlyExitException() while stream_expression.hasNext(): self._adaptor.addChild(root_1, stream_expression.nextTree()) stream_expression.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, 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 "actual_parameters" class task_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.task_return, self).__init__() self.tree = None # $ANTLR start "task" # sdl92.g:980:1: task : ( cif )? ( hyperlink )? TASK ( task_body )? end -> ^( TASK ( cif )? ( hyperlink )? ( end )? ( task_body )? ) ; def task(self, ): retval = self.task_return() retval.start = self.input.LT(1) root_0 = None TASK461 = None cif459 = None hyperlink460 = None task_body462 = None end463 = None TASK461_tree = None stream_TASK = RewriteRuleTokenStream(self._adaptor, "token TASK") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_task_body = RewriteRuleSubtreeStream(self._adaptor, "rule task_body") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:981:9: ( ( cif )? ( hyperlink )? TASK ( task_body )? end -> ^( TASK ( cif )? ( hyperlink )? ( end )? ( task_body )? ) ) # sdl92.g:981:17: ( cif )? ( hyperlink )? TASK ( task_body )? end pass # sdl92.g:981:17: ( cif )? alt156 = 2 LA156_0 = self.input.LA(1) if (LA156_0 == 229) : LA156_1 = self.input.LA(2) if (LA156_1 == ANSWER or LA156_1 == COMMENT or LA156_1 == CONNECT or LA156_1 == DECISION or LA156_1 == INPUT or (JOIN <= LA156_1 <= LABEL) or LA156_1 == NEXTSTATE or LA156_1 == OUTPUT or (PROCEDURE <= LA156_1 <= PROCEDURE_CALL) or (PROCESS <= LA156_1 <= PROVIDED) or LA156_1 == RETURN or LA156_1 == STATE or LA156_1 == STOP or LA156_1 == TASK or LA156_1 == TEXT or LA156_1 == START) : alt156 = 1 if alt156 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_task10761) cif459 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif459.tree) # sdl92.g:982:17: ( hyperlink )? alt157 = 2 LA157_0 = self.input.LA(1) if (LA157_0 == 229) : alt157 = 1 if alt157 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_task10780) hyperlink460 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink460.tree) TASK461=self.match(self.input, TASK, self.FOLLOW_TASK_in_task10799) if self._state.backtracking == 0: stream_TASK.add(TASK461) # sdl92.g:983:22: ( task_body )? alt158 = 2 LA158_0 = self.input.LA(1) if (LA158_0 == FOR or LA158_0 == STRING or LA158_0 == ID) : alt158 = 1 if alt158 == 1: # sdl92.g:0:0: task_body pass self._state.following.append(self.FOLLOW_task_body_in_task10801) task_body462 = self.task_body() self._state.following.pop() if self._state.backtracking == 0: stream_task_body.add(task_body462.tree) self._state.following.append(self.FOLLOW_end_in_task10804) end463 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end463.tree) # AST Rewrite # elements: hyperlink, task_body, cif, end, TASK # 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() # 984:9: -> ^( TASK ( cif )? ( hyperlink )? ( end )? ( task_body )? ) # sdl92.g:984:17: ^( TASK ( cif )? ( hyperlink )? ( end )? ( task_body )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_TASK.nextNode(), root_1) # sdl92.g:984:24: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:984:29: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:984:40: ( end )? if stream_end.hasNext(): self._adaptor.addChild(root_1, stream_end.nextTree()) stream_end.reset(); # sdl92.g:984:45: ( task_body )? if stream_task_body.hasNext(): self._adaptor.addChild(root_1, stream_task_body.nextTree()) stream_task_body.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, 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 "task" class task_body_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.task_body_return, self).__init__() self.tree = None # $ANTLR start "task_body" # sdl92.g:988:1: task_body : ( ( assignement_statement ( ',' assignement_statement )* ) -> ^( TASK_BODY ( assignement_statement )+ ) | ( informal_text ( ',' informal_text )* ) -> ^( TASK_BODY ( informal_text )+ ) | ( forloop ( ',' forloop )* ) -> ^( TASK_BODY ( forloop )+ ) ); def task_body(self, ): retval = self.task_body_return() retval.start = self.input.LT(1) root_0 = None char_literal465 = None char_literal468 = None char_literal471 = None assignement_statement464 = None assignement_statement466 = None informal_text467 = None informal_text469 = None forloop470 = None forloop472 = None char_literal465_tree = None char_literal468_tree = None char_literal471_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_informal_text = RewriteRuleSubtreeStream(self._adaptor, "rule informal_text") stream_assignement_statement = RewriteRuleSubtreeStream(self._adaptor, "rule assignement_statement") stream_forloop = RewriteRuleSubtreeStream(self._adaptor, "rule forloop") try: try: # sdl92.g:989:9: ( ( assignement_statement ( ',' assignement_statement )* ) -> ^( TASK_BODY ( assignement_statement )+ ) | ( informal_text ( ',' informal_text )* ) -> ^( TASK_BODY ( informal_text )+ ) | ( forloop ( ',' forloop )* ) -> ^( TASK_BODY ( forloop )+ ) ) alt162 = 3 LA162 = self.input.LA(1) if LA162 == ID: alt162 = 1 elif LA162 == STRING: alt162 = 2 elif LA162 == FOR: alt162 = 3 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 162, 0, self.input) raise nvae if alt162 == 1: # sdl92.g:989:17: ( assignement_statement ( ',' assignement_statement )* ) pass # sdl92.g:989:17: ( assignement_statement ( ',' assignement_statement )* ) # sdl92.g:989:18: assignement_statement ( ',' assignement_statement )* pass self._state.following.append(self.FOLLOW_assignement_statement_in_task_body10868) assignement_statement464 = self.assignement_statement() self._state.following.pop() if self._state.backtracking == 0: stream_assignement_statement.add(assignement_statement464.tree) # sdl92.g:989:40: ( ',' assignement_statement )* while True: #loop159 alt159 = 2 LA159_0 = self.input.LA(1) if (LA159_0 == COMMA) : alt159 = 1 if alt159 == 1: # sdl92.g:989:41: ',' assignement_statement pass char_literal465=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_task_body10871) if self._state.backtracking == 0: stream_COMMA.add(char_literal465) self._state.following.append(self.FOLLOW_assignement_statement_in_task_body10873) assignement_statement466 = self.assignement_statement() self._state.following.pop() if self._state.backtracking == 0: stream_assignement_statement.add(assignement_statement466.tree) else: break #loop159 # AST Rewrite # elements: assignement_statement # 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() # 990:9: -> ^( TASK_BODY ( assignement_statement )+ ) # sdl92.g:990:17: ^( TASK_BODY ( assignement_statement )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(TASK_BODY, "TASK_BODY"), root_1) # sdl92.g:990:29: ( assignement_statement )+ if not (stream_assignement_statement.hasNext()): raise RewriteEarlyExitException() while stream_assignement_statement.hasNext(): self._adaptor.addChild(root_1, stream_assignement_statement.nextTree()) stream_assignement_statement.reset() self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt162 == 2: # sdl92.g:991:19: ( informal_text ( ',' informal_text )* ) pass # sdl92.g:991:19: ( informal_text ( ',' informal_text )* ) # sdl92.g:991:20: informal_text ( ',' informal_text )* pass self._state.following.append(self.FOLLOW_informal_text_in_task_body10919) informal_text467 = self.informal_text() self._state.following.pop() if self._state.backtracking == 0: stream_informal_text.add(informal_text467.tree) # sdl92.g:991:34: ( ',' informal_text )* while True: #loop160 alt160 = 2 LA160_0 = self.input.LA(1) if (LA160_0 == COMMA) : alt160 = 1 if alt160 == 1: # sdl92.g:991:35: ',' informal_text pass char_literal468=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_task_body10922) if self._state.backtracking == 0: stream_COMMA.add(char_literal468) self._state.following.append(self.FOLLOW_informal_text_in_task_body10924) informal_text469 = self.informal_text() self._state.following.pop() if self._state.backtracking == 0: stream_informal_text.add(informal_text469.tree) else: break #loop160 # AST Rewrite # elements: informal_text # 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() # 992:9: -> ^( TASK_BODY ( informal_text )+ ) # sdl92.g:992:17: ^( TASK_BODY ( informal_text )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(TASK_BODY, "TASK_BODY"), root_1) # sdl92.g:992:29: ( informal_text )+ if not (stream_informal_text.hasNext()): raise RewriteEarlyExitException() while stream_informal_text.hasNext(): self._adaptor.addChild(root_1, stream_informal_text.nextTree()) stream_informal_text.reset() self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt162 == 3: # sdl92.g:993:19: ( forloop ( ',' forloop )* ) pass # sdl92.g:993:19: ( forloop ( ',' forloop )* ) # sdl92.g:993:20: forloop ( ',' forloop )* pass self._state.following.append(self.FOLLOW_forloop_in_task_body10970) forloop470 = self.forloop() self._state.following.pop() if self._state.backtracking == 0: stream_forloop.add(forloop470.tree) # sdl92.g:993:28: ( ',' forloop )* while True: #loop161 alt161 = 2 LA161_0 = self.input.LA(1) if (LA161_0 == COMMA) : alt161 = 1 if alt161 == 1: # sdl92.g:993:29: ',' forloop pass char_literal471=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_task_body10973) if self._state.backtracking == 0: stream_COMMA.add(char_literal471) self._state.following.append(self.FOLLOW_forloop_in_task_body10975) forloop472 = self.forloop() self._state.following.pop() if self._state.backtracking == 0: stream_forloop.add(forloop472.tree) else: break #loop161 # AST Rewrite # elements: forloop # 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() # 994:9: -> ^( TASK_BODY ( forloop )+ ) # sdl92.g:994:17: ^( TASK_BODY ( forloop )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(TASK_BODY, "TASK_BODY"), root_1) # sdl92.g:994:29: ( forloop )+ if not (stream_forloop.hasNext()): raise RewriteEarlyExitException() while stream_forloop.hasNext(): self._adaptor.addChild(root_1, stream_forloop.nextTree()) stream_forloop.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, 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 "task_body" class forloop_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.forloop_return, self).__init__() self.tree = None # $ANTLR start "forloop" # sdl92.g:999:1: forloop : FOR variable_id IN ( range | variable ) ':' ( transition )? ENDFOR -> ^( FOR variable_id ( variable )? ( range )? ( transition )? ) ; def forloop(self, ): retval = self.forloop_return() retval.start = self.input.LT(1) root_0 = None FOR473 = None IN475 = None char_literal478 = None ENDFOR480 = None variable_id474 = None range476 = None variable477 = None transition479 = None FOR473_tree = None IN475_tree = None char_literal478_tree = None ENDFOR480_tree = None stream_ENDFOR = RewriteRuleTokenStream(self._adaptor, "token ENDFOR") stream_FOR = RewriteRuleTokenStream(self._adaptor, "token FOR") stream_223 = RewriteRuleTokenStream(self._adaptor, "token 223") stream_IN = RewriteRuleTokenStream(self._adaptor, "token IN") stream_range = RewriteRuleSubtreeStream(self._adaptor, "rule range") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") stream_variable_id = RewriteRuleSubtreeStream(self._adaptor, "rule variable_id") stream_variable = RewriteRuleSubtreeStream(self._adaptor, "rule variable") try: try: # sdl92.g:1000:9: ( FOR variable_id IN ( range | variable ) ':' ( transition )? ENDFOR -> ^( FOR variable_id ( variable )? ( range )? ( transition )? ) ) # sdl92.g:1000:17: FOR variable_id IN ( range | variable ) ':' ( transition )? ENDFOR pass FOR473=self.match(self.input, FOR, self.FOLLOW_FOR_in_forloop11033) if self._state.backtracking == 0: stream_FOR.add(FOR473) self._state.following.append(self.FOLLOW_variable_id_in_forloop11035) variable_id474 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id474.tree) IN475=self.match(self.input, IN, self.FOLLOW_IN_in_forloop11037) if self._state.backtracking == 0: stream_IN.add(IN475) # sdl92.g:1000:36: ( range | variable ) alt163 = 2 LA163_0 = self.input.LA(1) if (LA163_0 == RANGE) : alt163 = 1 elif (LA163_0 == ID) : alt163 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 163, 0, self.input) raise nvae if alt163 == 1: # sdl92.g:1000:37: range pass self._state.following.append(self.FOLLOW_range_in_forloop11040) range476 = self.range() self._state.following.pop() if self._state.backtracking == 0: stream_range.add(range476.tree) elif alt163 == 2: # sdl92.g:1000:45: variable pass self._state.following.append(self.FOLLOW_variable_in_forloop11044) variable477 = self.variable() self._state.following.pop() if self._state.backtracking == 0: stream_variable.add(variable477.tree) char_literal478=self.match(self.input, 223, self.FOLLOW_223_in_forloop11047) if self._state.backtracking == 0: stream_223.add(char_literal478) # sdl92.g:1001:17: ( transition )? alt164 = 2 LA164_0 = self.input.LA(1) if (LA164_0 == ALTERNATIVE or LA164_0 == DECISION or LA164_0 == EXPORT or LA164_0 == FOR or LA164_0 == JOIN or LA164_0 == NEXTSTATE or LA164_0 == OUTPUT or (RESET <= LA164_0 <= RETURN) or LA164_0 == SET or LA164_0 == STOP or LA164_0 == STRING or LA164_0 == TASK or LA164_0 == ID or LA164_0 == CALL or LA164_0 == CREATE or LA164_0 == 229) : alt164 = 1 if alt164 == 1: # sdl92.g:0:0: transition pass self._state.following.append(self.FOLLOW_transition_in_forloop11065) transition479 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition479.tree) ENDFOR480=self.match(self.input, ENDFOR, self.FOLLOW_ENDFOR_in_forloop11084) if self._state.backtracking == 0: stream_ENDFOR.add(ENDFOR480) # AST Rewrite # elements: variable, transition, FOR, range, variable_id # 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() # 1003:9: -> ^( FOR variable_id ( variable )? ( range )? ( transition )? ) # sdl92.g:1003:17: ^( FOR variable_id ( variable )? ( range )? ( transition )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_FOR.nextNode(), root_1) self._adaptor.addChild(root_1, stream_variable_id.nextTree()) # sdl92.g:1003:35: ( variable )? if stream_variable.hasNext(): self._adaptor.addChild(root_1, stream_variable.nextTree()) stream_variable.reset(); # sdl92.g:1003:45: ( range )? if stream_range.hasNext(): self._adaptor.addChild(root_1, stream_range.nextTree()) stream_range.reset(); # sdl92.g:1003:52: ( transition )? if stream_transition.hasNext(): self._adaptor.addChild(root_1, stream_transition.nextTree()) stream_transition.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, 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 "forloop" class range_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.range_return, self).__init__() self.tree = None # $ANTLR start "range" # sdl92.g:1005:1: range : RANGE L_PAREN a= ground_expression ( COMMA b= ground_expression )? ( COMMA step= INT )? R_PAREN -> ^( RANGE $a ( $b)? ( $step)? ) ; def range(self, ): retval = self.range_return() retval.start = self.input.LT(1) root_0 = None step = None RANGE481 = None L_PAREN482 = None COMMA483 = None COMMA484 = None R_PAREN485 = None a = None b = None step_tree = None RANGE481_tree = None L_PAREN482_tree = None COMMA483_tree = None COMMA484_tree = None R_PAREN485_tree = None stream_RANGE = RewriteRuleTokenStream(self._adaptor, "token RANGE") stream_INT = RewriteRuleTokenStream(self._adaptor, "token INT") stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_ground_expression = RewriteRuleSubtreeStream(self._adaptor, "rule ground_expression") try: try: # sdl92.g:1006:9: ( RANGE L_PAREN a= ground_expression ( COMMA b= ground_expression )? ( COMMA step= INT )? R_PAREN -> ^( RANGE $a ( $b)? ( $step)? ) ) # sdl92.g:1006:17: RANGE L_PAREN a= ground_expression ( COMMA b= ground_expression )? ( COMMA step= INT )? R_PAREN pass RANGE481=self.match(self.input, RANGE, self.FOLLOW_RANGE_in_range11136) if self._state.backtracking == 0: stream_RANGE.add(RANGE481) L_PAREN482=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_range11154) if self._state.backtracking == 0: stream_L_PAREN.add(L_PAREN482) self._state.following.append(self.FOLLOW_ground_expression_in_range11158) a = self.ground_expression() self._state.following.pop() if self._state.backtracking == 0: stream_ground_expression.add(a.tree) # sdl92.g:1008:17: ( COMMA b= ground_expression )? alt165 = 2 LA165_0 = self.input.LA(1) if (LA165_0 == COMMA) : LA165_1 = self.input.LA(2) if (LA165_1 == INT) : LA165_3 = self.input.LA(3) if (self.synpred211_sdl92()) : alt165 = 1 elif (LA165_1 == FLOAT or LA165_1 == IF or LA165_1 == STATE or LA165_1 == STRING or LA165_1 == ID or LA165_1 == L_PAREN or LA165_1 == DASH or (NOT <= LA165_1 <= MINUS_INFINITY) or LA165_1 == L_BRACKET) : alt165 = 1 if alt165 == 1: # sdl92.g:1008:18: COMMA b= ground_expression pass COMMA483=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_range11177) if self._state.backtracking == 0: stream_COMMA.add(COMMA483) self._state.following.append(self.FOLLOW_ground_expression_in_range11181) b = self.ground_expression() self._state.following.pop() if self._state.backtracking == 0: stream_ground_expression.add(b.tree) # sdl92.g:1008:46: ( COMMA step= INT )? alt166 = 2 LA166_0 = self.input.LA(1) if (LA166_0 == COMMA) : alt166 = 1 if alt166 == 1: # sdl92.g:1008:47: COMMA step= INT pass COMMA484=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_range11186) if self._state.backtracking == 0: stream_COMMA.add(COMMA484) step=self.match(self.input, INT, self.FOLLOW_INT_in_range11190) if self._state.backtracking == 0: stream_INT.add(step) R_PAREN485=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_range11210) if self._state.backtracking == 0: stream_R_PAREN.add(R_PAREN485) # AST Rewrite # elements: b, a, step, RANGE # token labels: step # rule labels: retval, b, a # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 stream_step = RewriteRuleTokenStream(self._adaptor, "token step", step) if retval is not None: stream_retval = RewriteRuleSubtreeStream(self._adaptor, "rule retval", retval.tree) else: stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None) if b is not None: stream_b = RewriteRuleSubtreeStream(self._adaptor, "rule b", b.tree) else: stream_b = RewriteRuleSubtreeStream(self._adaptor, "token b", None) if a is not None: stream_a = RewriteRuleSubtreeStream(self._adaptor, "rule a", a.tree) else: stream_a = RewriteRuleSubtreeStream(self._adaptor, "token a", None) root_0 = self._adaptor.nil() # 1010:9: -> ^( RANGE $a ( $b)? ( $step)? ) # sdl92.g:1010:17: ^( RANGE $a ( $b)? ( $step)? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_RANGE.nextNode(), root_1) self._adaptor.addChild(root_1, stream_a.nextTree()) # sdl92.g:1010:28: ( $b)? if stream_b.hasNext(): self._adaptor.addChild(root_1, stream_b.nextTree()) stream_b.reset(); # sdl92.g:1010:32: ( $step)? if stream_step.hasNext(): self._adaptor.addChild(root_1, stream_step.nextNode()) stream_step.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, 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 "range" class assignement_statement_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.assignement_statement_return, self).__init__() self.tree = None # $ANTLR start "assignement_statement" # sdl92.g:1012:1: assignement_statement : variable ':=' expression -> ^( ASSIGN variable expression ) ; def assignement_statement(self, ): retval = self.assignement_statement_return() retval.start = self.input.LT(1) root_0 = None string_literal487 = None variable486 = None expression488 = None string_literal487_tree = None stream_ASSIG_OP = RewriteRuleTokenStream(self._adaptor, "token ASSIG_OP") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") stream_variable = RewriteRuleSubtreeStream(self._adaptor, "rule variable") try: try: # sdl92.g:1013:9: ( variable ':=' expression -> ^( ASSIGN variable expression ) ) # sdl92.g:1013:17: variable ':=' expression pass self._state.following.append(self.FOLLOW_variable_in_assignement_statement11262) variable486 = self.variable() self._state.following.pop() if self._state.backtracking == 0: stream_variable.add(variable486.tree) string_literal487=self.match(self.input, ASSIG_OP, self.FOLLOW_ASSIG_OP_in_assignement_statement11264) if self._state.backtracking == 0: stream_ASSIG_OP.add(string_literal487) self._state.following.append(self.FOLLOW_expression_in_assignement_statement11266) expression488 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression488.tree) # AST Rewrite # elements: expression, variable # 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() # 1014:9: -> ^( ASSIGN variable expression ) # sdl92.g:1014:17: ^( ASSIGN variable expression ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(ASSIGN, "ASSIGN"), root_1) self._adaptor.addChild(root_1, stream_variable.nextTree()) self._adaptor.addChild(root_1, stream_expression.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, 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 "assignement_statement" class variable_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.variable_return, self).__init__() self.tree = None # $ANTLR start "variable" # sdl92.g:1018:1: variable : ( postfix_expression | ID -> ^( VARIABLE ID ) ); def variable(self, ): retval = self.variable_return() retval.start = self.input.LT(1) root_0 = None ID490 = None postfix_expression489 = None ID490_tree = None stream_ID = RewriteRuleTokenStream(self._adaptor, "token ID") try: try: # sdl92.g:1019:9: ( postfix_expression | ID -> ^( VARIABLE ID ) ) alt167 = 2 LA167_0 = self.input.LA(1) if (LA167_0 == ID) : LA167_1 = self.input.LA(2) if (LA167_1 == L_PAREN or LA167_1 == 225) : alt167 = 1 elif (LA167_1 == ASSIG_OP or LA167_1 == 223) : alt167 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 167, 1, self.input) raise nvae else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 167, 0, self.input) raise nvae if alt167 == 1: # sdl92.g:1019:17: postfix_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_postfix_expression_in_variable11313) postfix_expression489 = self.postfix_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, postfix_expression489.tree) elif alt167 == 2: # sdl92.g:1020:17: ID pass ID490=self.match(self.input, ID, self.FOLLOW_ID_in_variable11331) if self._state.backtracking == 0: stream_ID.add(ID490) # AST Rewrite # elements: ID # 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() # 1020:40: -> ^( VARIABLE ID ) # sdl92.g:1020:44: ^( VARIABLE ID ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(VARIABLE, "VARIABLE"), root_1) self._adaptor.addChild(root_1, stream_ID.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, 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 "variable" class field_selection_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.field_selection_return, self).__init__() self.tree = None # $ANTLR start "field_selection" # sdl92.g:1023:1: field_selection : ( ( '!' | '.' ) field_name ) ; def field_selection(self, ): retval = self.field_selection_return() retval.start = self.input.LT(1) root_0 = None set491 = None field_name492 = None set491_tree = None try: try: # sdl92.g:1024:9: ( ( ( '!' | '.' ) field_name ) ) # sdl92.g:1024:17: ( ( '!' | '.' ) field_name ) pass root_0 = self._adaptor.nil() # sdl92.g:1024:17: ( ( '!' | '.' ) field_name ) # sdl92.g:1024:18: ( '!' | '.' ) field_name pass set491 = self.input.LT(1) if self.input.LA(1) == DOT or self.input.LA(1) == 225: self.input.consume() if self._state.backtracking == 0: self._adaptor.addChild(root_0, self._adaptor.createWithPayload(set491)) self._state.errorRecovery = False else: if self._state.backtracking > 0: raise BacktrackingFailed mse = MismatchedSetException(None, self.input) raise mse self._state.following.append(self.FOLLOW_field_name_in_field_selection11390) field_name492 = self.field_name() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, field_name492.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, 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 "field_selection" class expression_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.expression_return, self).__init__() self.tree = None # $ANTLR start "expression" # sdl92.g:1027:1: expression : binary_expression ; def expression(self, ): retval = self.expression_return() retval.start = self.input.LT(1) root_0 = None binary_expression493 = None try: try: # sdl92.g:1028:9: ( binary_expression ) # sdl92.g:1028:17: binary_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_binary_expression_in_expression11414) binary_expression493 = self.binary_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression493.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, 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 "expression" class binary_expression_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.binary_expression_return, self).__init__() self.tree = None # $ANTLR start "binary_expression" # sdl92.g:1031:1: binary_expression : binary_expression_0 ( IMPLIES binary_expression_0 )* ; def binary_expression(self, ): retval = self.binary_expression_return() retval.start = self.input.LT(1) root_0 = None IMPLIES495 = None binary_expression_0494 = None binary_expression_0496 = None IMPLIES495_tree = None try: try: # sdl92.g:1032:9: ( binary_expression_0 ( IMPLIES binary_expression_0 )* ) # sdl92.g:1032:17: binary_expression_0 ( IMPLIES binary_expression_0 )* pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_binary_expression_0_in_binary_expression11437) binary_expression_0494 = self.binary_expression_0() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_0494.tree) # sdl92.g:1032:37: ( IMPLIES binary_expression_0 )* while True: #loop168 alt168 = 2 LA168_0 = self.input.LA(1) if (LA168_0 == IMPLIES) : LA168_2 = self.input.LA(2) if (self.synpred215_sdl92()) : alt168 = 1 if alt168 == 1: # sdl92.g:1032:39: IMPLIES binary_expression_0 pass IMPLIES495=self.match(self.input, IMPLIES, self.FOLLOW_IMPLIES_in_binary_expression11441) if self._state.backtracking == 0: IMPLIES495_tree = self._adaptor.createWithPayload(IMPLIES495) root_0 = self._adaptor.becomeRoot(IMPLIES495_tree, root_0) self._state.following.append(self.FOLLOW_binary_expression_0_in_binary_expression11444) binary_expression_0496 = self.binary_expression_0() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_0496.tree) else: break #loop168 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, 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 "binary_expression" class binary_expression_0_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.binary_expression_0_return, self).__init__() self.tree = None # $ANTLR start "binary_expression_0" # sdl92.g:1033:1: binary_expression_0 : binary_expression_1 ( ( ( OR ( ELSE )? ) | XOR ) binary_expression_1 )* ; def binary_expression_0(self, ): retval = self.binary_expression_0_return() retval.start = self.input.LT(1) root_0 = None OR498 = None ELSE499 = None XOR500 = None binary_expression_1497 = None binary_expression_1501 = None OR498_tree = None ELSE499_tree = None XOR500_tree = None try: try: # sdl92.g:1034:9: ( binary_expression_1 ( ( ( OR ( ELSE )? ) | XOR ) binary_expression_1 )* ) # sdl92.g:1034:17: binary_expression_1 ( ( ( OR ( ELSE )? ) | XOR ) binary_expression_1 )* pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_binary_expression_1_in_binary_expression_011467) binary_expression_1497 = self.binary_expression_1() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_1497.tree) # sdl92.g:1034:37: ( ( ( OR ( ELSE )? ) | XOR ) binary_expression_1 )* while True: #loop171 alt171 = 2 LA171_0 = self.input.LA(1) if (LA171_0 == OR) : LA171_2 = self.input.LA(2) if (self.synpred218_sdl92()) : alt171 = 1 elif (LA171_0 == XOR) : LA171_3 = self.input.LA(2) if (self.synpred218_sdl92()) : alt171 = 1 if alt171 == 1: # sdl92.g:1034:38: ( ( OR ( ELSE )? ) | XOR ) binary_expression_1 pass # sdl92.g:1034:38: ( ( OR ( ELSE )? ) | XOR ) alt170 = 2 LA170_0 = self.input.LA(1) if (LA170_0 == OR) : alt170 = 1 elif (LA170_0 == XOR) : alt170 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 170, 0, self.input) raise nvae if alt170 == 1: # sdl92.g:1034:40: ( OR ( ELSE )? ) pass # sdl92.g:1034:40: ( OR ( ELSE )? ) # sdl92.g:1034:41: OR ( ELSE )? pass OR498=self.match(self.input, OR, self.FOLLOW_OR_in_binary_expression_011473) if self._state.backtracking == 0: OR498_tree = self._adaptor.createWithPayload(OR498) root_0 = self._adaptor.becomeRoot(OR498_tree, root_0) # sdl92.g:1034:45: ( ELSE )? alt169 = 2 LA169_0 = self.input.LA(1) if (LA169_0 == ELSE) : alt169 = 1 if alt169 == 1: # sdl92.g:0:0: ELSE pass ELSE499=self.match(self.input, ELSE, self.FOLLOW_ELSE_in_binary_expression_011476) if self._state.backtracking == 0: ELSE499_tree = self._adaptor.createWithPayload(ELSE499) self._adaptor.addChild(root_0, ELSE499_tree) elif alt170 == 2: # sdl92.g:1034:54: XOR pass XOR500=self.match(self.input, XOR, self.FOLLOW_XOR_in_binary_expression_011482) if self._state.backtracking == 0: XOR500_tree = self._adaptor.createWithPayload(XOR500) root_0 = self._adaptor.becomeRoot(XOR500_tree, root_0) self._state.following.append(self.FOLLOW_binary_expression_1_in_binary_expression_011487) binary_expression_1501 = self.binary_expression_1() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_1501.tree) else: break #loop171 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, 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 "binary_expression_0" class binary_expression_1_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.binary_expression_1_return, self).__init__() self.tree = None # $ANTLR start "binary_expression_1" # sdl92.g:1035:1: binary_expression_1 : binary_expression_2 ( AND ( THEN )? binary_expression_2 )* ; def binary_expression_1(self, ): retval = self.binary_expression_1_return() retval.start = self.input.LT(1) root_0 = None AND503 = None THEN504 = None binary_expression_2502 = None binary_expression_2505 = None AND503_tree = None THEN504_tree = None try: try: # sdl92.g:1036:9: ( binary_expression_2 ( AND ( THEN )? binary_expression_2 )* ) # sdl92.g:1036:17: binary_expression_2 ( AND ( THEN )? binary_expression_2 )* pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_binary_expression_2_in_binary_expression_111510) binary_expression_2502 = self.binary_expression_2() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_2502.tree) # sdl92.g:1036:37: ( AND ( THEN )? binary_expression_2 )* while True: #loop173 alt173 = 2 LA173_0 = self.input.LA(1) if (LA173_0 == AND) : LA173_2 = self.input.LA(2) if (self.synpred220_sdl92()) : alt173 = 1 if alt173 == 1: # sdl92.g:1036:39: AND ( THEN )? binary_expression_2 pass AND503=self.match(self.input, AND, self.FOLLOW_AND_in_binary_expression_111514) if self._state.backtracking == 0: AND503_tree = self._adaptor.createWithPayload(AND503) root_0 = self._adaptor.becomeRoot(AND503_tree, root_0) # sdl92.g:1036:44: ( THEN )? alt172 = 2 LA172_0 = self.input.LA(1) if (LA172_0 == THEN) : alt172 = 1 if alt172 == 1: # sdl92.g:0:0: THEN pass THEN504=self.match(self.input, THEN, self.FOLLOW_THEN_in_binary_expression_111517) if self._state.backtracking == 0: THEN504_tree = self._adaptor.createWithPayload(THEN504) self._adaptor.addChild(root_0, THEN504_tree) self._state.following.append(self.FOLLOW_binary_expression_2_in_binary_expression_111520) binary_expression_2505 = self.binary_expression_2() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_2505.tree) else: break #loop173 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, 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 "binary_expression_1" class binary_expression_2_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.binary_expression_2_return, self).__init__() self.tree = None # $ANTLR start "binary_expression_2" # sdl92.g:1037:1: binary_expression_2 : binary_expression_3 ( ( EQ | NEQ | GT | GE | LT | LE | IN ) binary_expression_3 )* ; def binary_expression_2(self, ): retval = self.binary_expression_2_return() retval.start = self.input.LT(1) root_0 = None EQ507 = None NEQ508 = None GT509 = None GE510 = None LT511 = None LE512 = None IN513 = None binary_expression_3506 = None binary_expression_3514 = None EQ507_tree = None NEQ508_tree = None GT509_tree = None GE510_tree = None LT511_tree = None LE512_tree = None IN513_tree = None try: try: # sdl92.g:1038:9: ( binary_expression_3 ( ( EQ | NEQ | GT | GE | LT | LE | IN ) binary_expression_3 )* ) # sdl92.g:1038:17: binary_expression_3 ( ( EQ | NEQ | GT | GE | LT | LE | IN ) binary_expression_3 )* pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_binary_expression_3_in_binary_expression_211543) binary_expression_3506 = self.binary_expression_3() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_3506.tree) # sdl92.g:1038:37: ( ( EQ | NEQ | GT | GE | LT | LE | IN ) binary_expression_3 )* while True: #loop175 alt175 = 2 alt175 = self.dfa175.predict(self.input) if alt175 == 1: # sdl92.g:1038:38: ( EQ | NEQ | GT | GE | LT | LE | IN ) binary_expression_3 pass # sdl92.g:1038:38: ( EQ | NEQ | GT | GE | LT | LE | IN ) alt174 = 7 LA174 = self.input.LA(1) if LA174 == EQ: alt174 = 1 elif LA174 == NEQ: alt174 = 2 elif LA174 == GT: alt174 = 3 elif LA174 == GE: alt174 = 4 elif LA174 == LT: alt174 = 5 elif LA174 == LE: alt174 = 6 elif LA174 == IN: alt174 = 7 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 174, 0, self.input) raise nvae if alt174 == 1: # sdl92.g:1038:40: EQ pass EQ507=self.match(self.input, EQ, self.FOLLOW_EQ_in_binary_expression_211548) if self._state.backtracking == 0: EQ507_tree = self._adaptor.createWithPayload(EQ507) root_0 = self._adaptor.becomeRoot(EQ507_tree, root_0) elif alt174 == 2: # sdl92.g:1038:46: NEQ pass NEQ508=self.match(self.input, NEQ, self.FOLLOW_NEQ_in_binary_expression_211553) if self._state.backtracking == 0: NEQ508_tree = self._adaptor.createWithPayload(NEQ508) root_0 = self._adaptor.becomeRoot(NEQ508_tree, root_0) elif alt174 == 3: # sdl92.g:1038:53: GT pass GT509=self.match(self.input, GT, self.FOLLOW_GT_in_binary_expression_211558) if self._state.backtracking == 0: GT509_tree = self._adaptor.createWithPayload(GT509) root_0 = self._adaptor.becomeRoot(GT509_tree, root_0) elif alt174 == 4: # sdl92.g:1038:59: GE pass GE510=self.match(self.input, GE, self.FOLLOW_GE_in_binary_expression_211563) if self._state.backtracking == 0: GE510_tree = self._adaptor.createWithPayload(GE510) root_0 = self._adaptor.becomeRoot(GE510_tree, root_0) elif alt174 == 5: # sdl92.g:1038:65: LT pass LT511=self.match(self.input, LT, self.FOLLOW_LT_in_binary_expression_211568) if self._state.backtracking == 0: LT511_tree = self._adaptor.createWithPayload(LT511) root_0 = self._adaptor.becomeRoot(LT511_tree, root_0) elif alt174 == 6: # sdl92.g:1038:71: LE pass LE512=self.match(self.input, LE, self.FOLLOW_LE_in_binary_expression_211573) if self._state.backtracking == 0: LE512_tree = self._adaptor.createWithPayload(LE512) root_0 = self._adaptor.becomeRoot(LE512_tree, root_0) elif alt174 == 7: # sdl92.g:1038:77: IN pass IN513=self.match(self.input, IN, self.FOLLOW_IN_in_binary_expression_211578) if self._state.backtracking == 0: IN513_tree = self._adaptor.createWithPayload(IN513) root_0 = self._adaptor.becomeRoot(IN513_tree, root_0) self._state.following.append(self.FOLLOW_binary_expression_3_in_binary_expression_211583) binary_expression_3514 = self.binary_expression_3() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_3514.tree) else: break #loop175 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, 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 "binary_expression_2" class binary_expression_3_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.binary_expression_3_return, self).__init__() self.tree = None # $ANTLR start "binary_expression_3" # sdl92.g:1039:1: binary_expression_3 : binary_expression_4 ( ( PLUS | DASH | APPEND ) binary_expression_4 )* ; def binary_expression_3(self, ): retval = self.binary_expression_3_return() retval.start = self.input.LT(1) root_0 = None PLUS516 = None DASH517 = None APPEND518 = None binary_expression_4515 = None binary_expression_4519 = None PLUS516_tree = None DASH517_tree = None APPEND518_tree = None try: try: # sdl92.g:1040:9: ( binary_expression_4 ( ( PLUS | DASH | APPEND ) binary_expression_4 )* ) # sdl92.g:1040:17: binary_expression_4 ( ( PLUS | DASH | APPEND ) binary_expression_4 )* pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_binary_expression_4_in_binary_expression_311606) binary_expression_4515 = self.binary_expression_4() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_4515.tree) # sdl92.g:1040:37: ( ( PLUS | DASH | APPEND ) binary_expression_4 )* while True: #loop177 alt177 = 2 LA177 = self.input.LA(1) if LA177 == PLUS: LA177_2 = self.input.LA(2) if (self.synpred230_sdl92()) : alt177 = 1 elif LA177 == DASH: LA177_3 = self.input.LA(2) if (self.synpred230_sdl92()) : alt177 = 1 elif LA177 == APPEND: LA177_4 = self.input.LA(2) if (self.synpred230_sdl92()) : alt177 = 1 if alt177 == 1: # sdl92.g:1040:38: ( PLUS | DASH | APPEND ) binary_expression_4 pass # sdl92.g:1040:38: ( PLUS | DASH | APPEND ) alt176 = 3 LA176 = self.input.LA(1) if LA176 == PLUS: alt176 = 1 elif LA176 == DASH: alt176 = 2 elif LA176 == APPEND: alt176 = 3 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 176, 0, self.input) raise nvae if alt176 == 1: # sdl92.g:1040:40: PLUS pass PLUS516=self.match(self.input, PLUS, self.FOLLOW_PLUS_in_binary_expression_311611) if self._state.backtracking == 0: PLUS516_tree = self._adaptor.createWithPayload(PLUS516) root_0 = self._adaptor.becomeRoot(PLUS516_tree, root_0) elif alt176 == 2: # sdl92.g:1040:48: DASH pass DASH517=self.match(self.input, DASH, self.FOLLOW_DASH_in_binary_expression_311616) if self._state.backtracking == 0: DASH517_tree = self._adaptor.createWithPayload(DASH517) root_0 = self._adaptor.becomeRoot(DASH517_tree, root_0) elif alt176 == 3: # sdl92.g:1040:56: APPEND pass APPEND518=self.match(self.input, APPEND, self.FOLLOW_APPEND_in_binary_expression_311621) if self._state.backtracking == 0: APPEND518_tree = self._adaptor.createWithPayload(APPEND518) root_0 = self._adaptor.becomeRoot(APPEND518_tree, root_0) self._state.following.append(self.FOLLOW_binary_expression_4_in_binary_expression_311626) binary_expression_4519 = self.binary_expression_4() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_4519.tree) else: break #loop177 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, 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 "binary_expression_3" class binary_expression_4_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.binary_expression_4_return, self).__init__() self.tree = None # $ANTLR start "binary_expression_4" # sdl92.g:1041:1: binary_expression_4 : unary_expression ( ( ASTERISK | DIV | MOD | REM ) unary_expression )* ; def binary_expression_4(self, ): retval = self.binary_expression_4_return() retval.start = self.input.LT(1) root_0 = None ASTERISK521 = None DIV522 = None MOD523 = None REM524 = None unary_expression520 = None unary_expression525 = None ASTERISK521_tree = None DIV522_tree = None MOD523_tree = None REM524_tree = None try: try: # sdl92.g:1042:9: ( unary_expression ( ( ASTERISK | DIV | MOD | REM ) unary_expression )* ) # sdl92.g:1042:17: unary_expression ( ( ASTERISK | DIV | MOD | REM ) unary_expression )* pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_unary_expression_in_binary_expression_411649) unary_expression520 = self.unary_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, unary_expression520.tree) # sdl92.g:1042:34: ( ( ASTERISK | DIV | MOD | REM ) unary_expression )* while True: #loop179 alt179 = 2 LA179 = self.input.LA(1) if LA179 == ASTERISK: LA179_2 = self.input.LA(2) if (self.synpred234_sdl92()) : alt179 = 1 elif LA179 == DIV: LA179_3 = self.input.LA(2) if (self.synpred234_sdl92()) : alt179 = 1 elif LA179 == MOD: LA179_4 = self.input.LA(2) if (self.synpred234_sdl92()) : alt179 = 1 elif LA179 == REM: LA179_5 = self.input.LA(2) if (self.synpred234_sdl92()) : alt179 = 1 if alt179 == 1: # sdl92.g:1042:35: ( ASTERISK | DIV | MOD | REM ) unary_expression pass # sdl92.g:1042:35: ( ASTERISK | DIV | MOD | REM ) alt178 = 4 LA178 = self.input.LA(1) if LA178 == ASTERISK: alt178 = 1 elif LA178 == DIV: alt178 = 2 elif LA178 == MOD: alt178 = 3 elif LA178 == REM: alt178 = 4 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 178, 0, self.input) raise nvae if alt178 == 1: # sdl92.g:1042:37: ASTERISK pass ASTERISK521=self.match(self.input, ASTERISK, self.FOLLOW_ASTERISK_in_binary_expression_411654) if self._state.backtracking == 0: ASTERISK521_tree = self._adaptor.createWithPayload(ASTERISK521) root_0 = self._adaptor.becomeRoot(ASTERISK521_tree, root_0) elif alt178 == 2: # sdl92.g:1042:49: DIV pass DIV522=self.match(self.input, DIV, self.FOLLOW_DIV_in_binary_expression_411659) if self._state.backtracking == 0: DIV522_tree = self._adaptor.createWithPayload(DIV522) root_0 = self._adaptor.becomeRoot(DIV522_tree, root_0) elif alt178 == 3: # sdl92.g:1042:56: MOD pass MOD523=self.match(self.input, MOD, self.FOLLOW_MOD_in_binary_expression_411664) if self._state.backtracking == 0: MOD523_tree = self._adaptor.createWithPayload(MOD523) root_0 = self._adaptor.becomeRoot(MOD523_tree, root_0) elif alt178 == 4: # sdl92.g:1042:63: REM pass REM524=self.match(self.input, REM, self.FOLLOW_REM_in_binary_expression_411669) if self._state.backtracking == 0: REM524_tree = self._adaptor.createWithPayload(REM524) root_0 = self._adaptor.becomeRoot(REM524_tree, root_0) self._state.following.append(self.FOLLOW_unary_expression_in_binary_expression_411674) unary_expression525 = self.unary_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, unary_expression525.tree) else: break #loop179 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, 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 "binary_expression_4" class unary_expression_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.unary_expression_return, self).__init__() self.tree = None # $ANTLR start "unary_expression" # sdl92.g:1045:1: unary_expression : ( postfix_expression | primary_expression | NOT unary_expression | DASH unary_expression -> ^( NEG unary_expression ) ); def unary_expression(self, ): retval = self.unary_expression_return() retval.start = self.input.LT(1) root_0 = None NOT528 = None DASH530 = None postfix_expression526 = None primary_expression527 = None unary_expression529 = None unary_expression531 = None NOT528_tree = None DASH530_tree = None stream_DASH = RewriteRuleTokenStream(self._adaptor, "token DASH") stream_unary_expression = RewriteRuleSubtreeStream(self._adaptor, "rule unary_expression") try: try: # sdl92.g:1046:9: ( postfix_expression | primary_expression | NOT unary_expression | DASH unary_expression -> ^( NEG unary_expression ) ) alt180 = 4 alt180 = self.dfa180.predict(self.input) if alt180 == 1: # sdl92.g:1046:17: postfix_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_postfix_expression_in_unary_expression11699) postfix_expression526 = self.postfix_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, postfix_expression526.tree) elif alt180 == 2: # sdl92.g:1047:17: primary_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_primary_expression_in_unary_expression11717) primary_expression527 = self.primary_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, primary_expression527.tree) elif alt180 == 3: # sdl92.g:1048:17: NOT unary_expression pass root_0 = self._adaptor.nil() NOT528=self.match(self.input, NOT, self.FOLLOW_NOT_in_unary_expression11735) if self._state.backtracking == 0: NOT528_tree = self._adaptor.createWithPayload(NOT528) root_0 = self._adaptor.becomeRoot(NOT528_tree, root_0) self._state.following.append(self.FOLLOW_unary_expression_in_unary_expression11738) unary_expression529 = self.unary_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, unary_expression529.tree) elif alt180 == 4: # sdl92.g:1049:17: DASH unary_expression pass DASH530=self.match(self.input, DASH, self.FOLLOW_DASH_in_unary_expression11756) if self._state.backtracking == 0: stream_DASH.add(DASH530) self._state.following.append(self.FOLLOW_unary_expression_in_unary_expression11758) unary_expression531 = self.unary_expression() self._state.following.pop() if self._state.backtracking == 0: stream_unary_expression.add(unary_expression531.tree) # AST Rewrite # elements: unary_expression # 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() # 1049:39: -> ^( NEG unary_expression ) # sdl92.g:1049:42: ^( NEG unary_expression ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(NEG, "NEG"), root_1) self._adaptor.addChild(root_1, stream_unary_expression.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, 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 "unary_expression" class postfix_expression_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.postfix_expression_return, self).__init__() self.tree = None # $ANTLR start "postfix_expression" # sdl92.g:1053:1: postfix_expression : ( ID -> ^( PRIMARY ^( VARIABLE ID ) ) ) ( '(' params= expression_list ')' -> ^( CALL $postfix_expression ^( PARAMS $params) ) | '!' field_name -> ^( SELECTOR $postfix_expression field_name ) )+ ; def postfix_expression(self, ): retval = self.postfix_expression_return() retval.start = self.input.LT(1) root_0 = None ID532 = None char_literal533 = None char_literal534 = None char_literal535 = None params = None field_name536 = None ID532_tree = None char_literal533_tree = None char_literal534_tree = None char_literal535_tree = None stream_225 = RewriteRuleTokenStream(self._adaptor, "token 225") stream_ID = RewriteRuleTokenStream(self._adaptor, "token ID") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_field_name = RewriteRuleSubtreeStream(self._adaptor, "rule field_name") stream_expression_list = RewriteRuleSubtreeStream(self._adaptor, "rule expression_list") try: try: # sdl92.g:1054:9: ( ( ID -> ^( PRIMARY ^( VARIABLE ID ) ) ) ( '(' params= expression_list ')' -> ^( CALL $postfix_expression ^( PARAMS $params) ) | '!' field_name -> ^( SELECTOR $postfix_expression field_name ) )+ ) # sdl92.g:1054:17: ( ID -> ^( PRIMARY ^( VARIABLE ID ) ) ) ( '(' params= expression_list ')' -> ^( CALL $postfix_expression ^( PARAMS $params) ) | '!' field_name -> ^( SELECTOR $postfix_expression field_name ) )+ pass # sdl92.g:1054:17: ( ID -> ^( PRIMARY ^( VARIABLE ID ) ) ) # sdl92.g:1054:18: ID pass ID532=self.match(self.input, ID, self.FOLLOW_ID_in_postfix_expression11799) if self._state.backtracking == 0: stream_ID.add(ID532) # AST Rewrite # elements: ID # 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() # 1054:21: -> ^( PRIMARY ^( VARIABLE ID ) ) # sdl92.g:1054:24: ^( PRIMARY ^( VARIABLE ID ) ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(PRIMARY, "PRIMARY"), root_1) # sdl92.g:1054:34: ^( VARIABLE ID ) root_2 = self._adaptor.nil() root_2 = self._adaptor.becomeRoot(self._adaptor.createFromType(VARIABLE, "VARIABLE"), root_2) self._adaptor.addChild(root_2, stream_ID.nextNode()) self._adaptor.addChild(root_1, root_2) self._adaptor.addChild(root_0, root_1) retval.tree = root_0 # sdl92.g:1055:17: ( '(' params= expression_list ')' -> ^( CALL $postfix_expression ^( PARAMS $params) ) | '!' field_name -> ^( SELECTOR $postfix_expression field_name ) )+ cnt181 = 0 while True: #loop181 alt181 = 3 alt181 = self.dfa181.predict(self.input) if alt181 == 1: # sdl92.g:1055:21: '(' params= expression_list ')' pass char_literal533=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_postfix_expression11834) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal533) self._state.following.append(self.FOLLOW_expression_list_in_postfix_expression11838) params = self.expression_list() self._state.following.pop() if self._state.backtracking == 0: stream_expression_list.add(params.tree) char_literal534=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_postfix_expression11840) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal534) # AST Rewrite # elements: params, postfix_expression # token labels: # rule labels: retval, params # 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) if params is not None: stream_params = RewriteRuleSubtreeStream(self._adaptor, "rule params", params.tree) else: stream_params = RewriteRuleSubtreeStream(self._adaptor, "token params", None) root_0 = self._adaptor.nil() # 1055:52: -> ^( CALL $postfix_expression ^( PARAMS $params) ) # sdl92.g:1055:55: ^( CALL $postfix_expression ^( PARAMS $params) ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(CALL, "CALL"), root_1) self._adaptor.addChild(root_1, stream_retval.nextTree()) # sdl92.g:1055:82: ^( PARAMS $params) root_2 = self._adaptor.nil() root_2 = self._adaptor.becomeRoot(self._adaptor.createFromType(PARAMS, "PARAMS"), root_2) self._adaptor.addChild(root_2, stream_params.nextTree()) self._adaptor.addChild(root_1, root_2) self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt181 == 2: # sdl92.g:1056:21: '!' field_name pass char_literal535=self.match(self.input, 225, self.FOLLOW_225_in_postfix_expression11878) if self._state.backtracking == 0: stream_225.add(char_literal535) self._state.following.append(self.FOLLOW_field_name_in_postfix_expression11880) field_name536 = self.field_name() self._state.following.pop() if self._state.backtracking == 0: stream_field_name.add(field_name536.tree) # AST Rewrite # elements: field_name, postfix_expression # 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() # 1056:37: -> ^( SELECTOR $postfix_expression field_name ) # sdl92.g:1056:40: ^( SELECTOR $postfix_expression field_name ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(SELECTOR, "SELECTOR"), root_1) self._adaptor.addChild(root_1, stream_retval.nextTree()) self._adaptor.addChild(root_1, stream_field_name.nextTree()) self._adaptor.addChild(root_0, root_1) retval.tree = root_0 else: if cnt181 >= 1: break #loop181 if self._state.backtracking > 0: raise BacktrackingFailed eee = EarlyExitException(181, self.input) raise eee cnt181 += 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, 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 "postfix_expression" class primary_expression_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.primary_expression_return, self).__init__() self.tree = None # $ANTLR start "primary_expression" # sdl92.g:1061:1: primary_expression : ( primary -> ^( PRIMARY primary ) | '(' expression ')' -> ^( PAREN expression ) | conditional_expression ); def primary_expression(self, ): retval = self.primary_expression_return() retval.start = self.input.LT(1) root_0 = None char_literal538 = None char_literal540 = None primary537 = None expression539 = None conditional_expression541 = None char_literal538_tree = None char_literal540_tree = None stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") stream_primary = RewriteRuleSubtreeStream(self._adaptor, "rule primary") try: try: # sdl92.g:1062:9: ( primary -> ^( PRIMARY primary ) | '(' expression ')' -> ^( PAREN expression ) | conditional_expression ) alt182 = 3 LA182 = self.input.LA(1) if LA182 == FLOAT or LA182 == STATE or LA182 == STRING or LA182 == ID or LA182 == INT or LA182 == TRUE or LA182 == FALSE or LA182 == NULL or LA182 == PLUS_INFINITY or LA182 == MINUS_INFINITY or LA182 == L_BRACKET: alt182 = 1 elif LA182 == L_PAREN: alt182 = 2 elif LA182 == IF: alt182 = 3 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 182, 0, self.input) raise nvae if alt182 == 1: # sdl92.g:1062:17: primary pass self._state.following.append(self.FOLLOW_primary_in_primary_expression11943) primary537 = self.primary() self._state.following.pop() if self._state.backtracking == 0: stream_primary.add(primary537.tree) # AST Rewrite # elements: primary # 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() # 1062:47: -> ^( PRIMARY primary ) # sdl92.g:1062:50: ^( PRIMARY primary ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(PRIMARY, "PRIMARY"), root_1) self._adaptor.addChild(root_1, stream_primary.nextTree()) self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt182 == 2: # sdl92.g:1063:17: '(' expression ')' pass char_literal538=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_primary_expression11991) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal538) self._state.following.append(self.FOLLOW_expression_in_primary_expression11993) expression539 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression539.tree) char_literal540=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_primary_expression11995) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal540) # AST Rewrite # elements: expression # 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() # 1063:47: -> ^( PAREN expression ) # sdl92.g:1063:50: ^( PAREN expression ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(PAREN, "PAREN"), root_1) self._adaptor.addChild(root_1, stream_expression.nextTree()) self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt182 == 3: # sdl92.g:1064:17: conditional_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_conditional_expression_in_primary_expression12032) conditional_expression541 = self.conditional_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, conditional_expression541.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, 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 "primary_expression" class primary_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.primary_return, self).__init__() self.tree = None # $ANTLR start "primary" # sdl92.g:1068:1: primary : ( TRUE | FALSE | STRING | NULL | PLUS_INFINITY | MINUS_INFINITY | INT | FLOAT | ID ':' expression -> ^( CHOICE ID expression ) | ID -> ^( VARIABLE ID ) | '{' '}' -> ^( EMPTYSTR ) | '{' MANTISSA mant= INT COMMA BASE bas= INT COMMA EXPONENT exp= INT '}' -> ^( FLOAT2 $mant $bas $exp) | '{' named_value ( COMMA named_value )* '}' -> ^( SEQUENCE ( named_value )+ ) | '{' primary ( COMMA primary )* '}' -> ^( SEQOF ( primary )+ ) | STATE ); def primary(self, ): retval = self.primary_return() retval.start = self.input.LT(1) root_0 = None mant = None bas = None exp = None TRUE542 = None FALSE543 = None STRING544 = None NULL545 = None PLUS_INFINITY546 = None MINUS_INFINITY547 = None INT548 = None FLOAT549 = None ID550 = None char_literal551 = None ID553 = None char_literal554 = None char_literal555 = None char_literal556 = None MANTISSA557 = None COMMA558 = None BASE559 = None COMMA560 = None EXPONENT561 = None char_literal562 = None char_literal563 = None COMMA565 = None char_literal567 = None char_literal568 = None COMMA570 = None char_literal572 = None STATE573 = None expression552 = None named_value564 = None named_value566 = None primary569 = None primary571 = None mant_tree = None bas_tree = None exp_tree = None TRUE542_tree = None FALSE543_tree = None STRING544_tree = None NULL545_tree = None PLUS_INFINITY546_tree = None MINUS_INFINITY547_tree = None INT548_tree = None FLOAT549_tree = None ID550_tree = None char_literal551_tree = None ID553_tree = None char_literal554_tree = None char_literal555_tree = None char_literal556_tree = None MANTISSA557_tree = None COMMA558_tree = None BASE559_tree = None COMMA560_tree = None EXPONENT561_tree = None char_literal562_tree = None char_literal563_tree = None COMMA565_tree = None char_literal567_tree = None char_literal568_tree = None COMMA570_tree = None char_literal572_tree = None STATE573_tree = None stream_BASE = RewriteRuleTokenStream(self._adaptor, "token BASE") stream_MANTISSA = RewriteRuleTokenStream(self._adaptor, "token MANTISSA") stream_EXPONENT = RewriteRuleTokenStream(self._adaptor, "token EXPONENT") stream_223 = RewriteRuleTokenStream(self._adaptor, "token 223") stream_INT = RewriteRuleTokenStream(self._adaptor, "token INT") stream_L_BRACKET = RewriteRuleTokenStream(self._adaptor, "token L_BRACKET") stream_ID = RewriteRuleTokenStream(self._adaptor, "token ID") stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_R_BRACKET = RewriteRuleTokenStream(self._adaptor, "token R_BRACKET") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") stream_primary = RewriteRuleSubtreeStream(self._adaptor, "rule primary") stream_named_value = RewriteRuleSubtreeStream(self._adaptor, "rule named_value") try: try: # sdl92.g:1069:9: ( TRUE | FALSE | STRING | NULL | PLUS_INFINITY | MINUS_INFINITY | INT | FLOAT | ID ':' expression -> ^( CHOICE ID expression ) | ID -> ^( VARIABLE ID ) | '{' '}' -> ^( EMPTYSTR ) | '{' MANTISSA mant= INT COMMA BASE bas= INT COMMA EXPONENT exp= INT '}' -> ^( FLOAT2 $mant $bas $exp) | '{' named_value ( COMMA named_value )* '}' -> ^( SEQUENCE ( named_value )+ ) | '{' primary ( COMMA primary )* '}' -> ^( SEQOF ( primary )+ ) | STATE ) alt185 = 15 alt185 = self.dfa185.predict(self.input) if alt185 == 1: # sdl92.g:1069:17: TRUE pass root_0 = self._adaptor.nil() TRUE542=self.match(self.input, TRUE, self.FOLLOW_TRUE_in_primary12064) if self._state.backtracking == 0: TRUE542_tree = self._adaptor.createWithPayload(TRUE542) root_0 = self._adaptor.becomeRoot(TRUE542_tree, root_0) elif alt185 == 2: # sdl92.g:1070:17: FALSE pass root_0 = self._adaptor.nil() FALSE543=self.match(self.input, FALSE, self.FOLLOW_FALSE_in_primary12083) if self._state.backtracking == 0: FALSE543_tree = self._adaptor.createWithPayload(FALSE543) root_0 = self._adaptor.becomeRoot(FALSE543_tree, root_0) elif alt185 == 3: # sdl92.g:1071:17: STRING pass root_0 = self._adaptor.nil() STRING544=self.match(self.input, STRING, self.FOLLOW_STRING_in_primary12102) if self._state.backtracking == 0: STRING544_tree = self._adaptor.createWithPayload(STRING544) self._adaptor.addChild(root_0, STRING544_tree) elif alt185 == 4: # sdl92.g:1072:17: NULL pass root_0 = self._adaptor.nil() NULL545=self.match(self.input, NULL, self.FOLLOW_NULL_in_primary12120) if self._state.backtracking == 0: NULL545_tree = self._adaptor.createWithPayload(NULL545) root_0 = self._adaptor.becomeRoot(NULL545_tree, root_0) elif alt185 == 5: # sdl92.g:1073:17: PLUS_INFINITY pass root_0 = self._adaptor.nil() PLUS_INFINITY546=self.match(self.input, PLUS_INFINITY, self.FOLLOW_PLUS_INFINITY_in_primary12139) if self._state.backtracking == 0: PLUS_INFINITY546_tree = self._adaptor.createWithPayload(PLUS_INFINITY546) root_0 = self._adaptor.becomeRoot(PLUS_INFINITY546_tree, root_0) elif alt185 == 6: # sdl92.g:1074:17: MINUS_INFINITY pass root_0 = self._adaptor.nil() MINUS_INFINITY547=self.match(self.input, MINUS_INFINITY, self.FOLLOW_MINUS_INFINITY_in_primary12158) if self._state.backtracking == 0: MINUS_INFINITY547_tree = self._adaptor.createWithPayload(MINUS_INFINITY547) root_0 = self._adaptor.becomeRoot(MINUS_INFINITY547_tree, root_0) elif alt185 == 7: # sdl92.g:1075:17: INT pass root_0 = self._adaptor.nil() INT548=self.match(self.input, INT, self.FOLLOW_INT_in_primary12177) if self._state.backtracking == 0: INT548_tree = self._adaptor.createWithPayload(INT548) root_0 = self._adaptor.becomeRoot(INT548_tree, root_0) elif alt185 == 8: # sdl92.g:1076:17: FLOAT pass root_0 = self._adaptor.nil() FLOAT549=self.match(self.input, FLOAT, self.FOLLOW_FLOAT_in_primary12196) if self._state.backtracking == 0: FLOAT549_tree = self._adaptor.createWithPayload(FLOAT549) root_0 = self._adaptor.becomeRoot(FLOAT549_tree, root_0) elif alt185 == 9: # sdl92.g:1077:17: ID ':' expression pass ID550=self.match(self.input, ID, self.FOLLOW_ID_in_primary12215) if self._state.backtracking == 0: stream_ID.add(ID550) char_literal551=self.match(self.input, 223, self.FOLLOW_223_in_primary12217) if self._state.backtracking == 0: stream_223.add(char_literal551) self._state.following.append(self.FOLLOW_expression_in_primary12219) expression552 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression552.tree) # AST Rewrite # elements: ID, expression # 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() # 1077:45: -> ^( CHOICE ID expression ) # sdl92.g:1077:48: ^( CHOICE ID expression ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(CHOICE, "CHOICE"), root_1) self._adaptor.addChild(root_1, stream_ID.nextNode()) self._adaptor.addChild(root_1, stream_expression.nextTree()) self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt185 == 10: # sdl92.g:1078:17: ID pass ID553=self.match(self.input, ID, self.FOLLOW_ID_in_primary12257) if self._state.backtracking == 0: stream_ID.add(ID553) # AST Rewrite # elements: ID # 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() # 1078:45: -> ^( VARIABLE ID ) # sdl92.g:1078:48: ^( VARIABLE ID ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(VARIABLE, "VARIABLE"), root_1) self._adaptor.addChild(root_1, stream_ID.nextNode()) self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt185 == 11: # sdl92.g:1079:17: '{' '}' pass char_literal554=self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_primary12308) if self._state.backtracking == 0: stream_L_BRACKET.add(char_literal554) char_literal555=self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_primary12310) if self._state.backtracking == 0: stream_R_BRACKET.add(char_literal555) # 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() # 1079:45: -> ^( EMPTYSTR ) # sdl92.g:1079:48: ^( EMPTYSTR ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(EMPTYSTR, "EMPTYSTR"), root_1) self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt185 == 12: # sdl92.g:1080:17: '{' MANTISSA mant= INT COMMA BASE bas= INT COMMA EXPONENT exp= INT '}' pass char_literal556=self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_primary12354) if self._state.backtracking == 0: stream_L_BRACKET.add(char_literal556) MANTISSA557=self.match(self.input, MANTISSA, self.FOLLOW_MANTISSA_in_primary12372) if self._state.backtracking == 0: stream_MANTISSA.add(MANTISSA557) mant=self.match(self.input, INT, self.FOLLOW_INT_in_primary12376) if self._state.backtracking == 0: stream_INT.add(mant) COMMA558=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_primary12378) if self._state.backtracking == 0: stream_COMMA.add(COMMA558) BASE559=self.match(self.input, BASE, self.FOLLOW_BASE_in_primary12396) if self._state.backtracking == 0: stream_BASE.add(BASE559) bas=self.match(self.input, INT, self.FOLLOW_INT_in_primary12400) if self._state.backtracking == 0: stream_INT.add(bas) COMMA560=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_primary12402) if self._state.backtracking == 0: stream_COMMA.add(COMMA560) EXPONENT561=self.match(self.input, EXPONENT, self.FOLLOW_EXPONENT_in_primary12420) if self._state.backtracking == 0: stream_EXPONENT.add(EXPONENT561) exp=self.match(self.input, INT, self.FOLLOW_INT_in_primary12424) if self._state.backtracking == 0: stream_INT.add(exp) char_literal562=self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_primary12442) if self._state.backtracking == 0: stream_R_BRACKET.add(char_literal562) # AST Rewrite # elements: mant, exp, bas # token labels: exp, mant, bas # rule labels: retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 stream_exp = RewriteRuleTokenStream(self._adaptor, "token exp", exp) stream_mant = RewriteRuleTokenStream(self._adaptor, "token mant", mant) stream_bas = RewriteRuleTokenStream(self._adaptor, "token bas", bas) 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() # 1084:45: -> ^( FLOAT2 $mant $bas $exp) # sdl92.g:1084:48: ^( FLOAT2 $mant $bas $exp) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(FLOAT2, "FLOAT2"), root_1) self._adaptor.addChild(root_1, stream_mant.nextNode()) self._adaptor.addChild(root_1, stream_bas.nextNode()) self._adaptor.addChild(root_1, stream_exp.nextNode()) self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt185 == 13: # sdl92.g:1085:17: '{' named_value ( COMMA named_value )* '}' pass char_literal563=self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_primary12499) if self._state.backtracking == 0: stream_L_BRACKET.add(char_literal563) self._state.following.append(self.FOLLOW_named_value_in_primary12517) named_value564 = self.named_value() self._state.following.pop() if self._state.backtracking == 0: stream_named_value.add(named_value564.tree) # sdl92.g:1086:29: ( COMMA named_value )* while True: #loop183 alt183 = 2 LA183_0 = self.input.LA(1) if (LA183_0 == COMMA) : alt183 = 1 if alt183 == 1: # sdl92.g:1086:30: COMMA named_value pass COMMA565=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_primary12520) if self._state.backtracking == 0: stream_COMMA.add(COMMA565) self._state.following.append(self.FOLLOW_named_value_in_primary12522) named_value566 = self.named_value() self._state.following.pop() if self._state.backtracking == 0: stream_named_value.add(named_value566.tree) else: break #loop183 char_literal567=self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_primary12542) if self._state.backtracking == 0: stream_R_BRACKET.add(char_literal567) # AST Rewrite # elements: named_value # 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() # 1087:45: -> ^( SEQUENCE ( named_value )+ ) # sdl92.g:1087:48: ^( SEQUENCE ( named_value )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(SEQUENCE, "SEQUENCE"), root_1) # sdl92.g:1087:59: ( named_value )+ if not (stream_named_value.hasNext()): raise RewriteEarlyExitException() while stream_named_value.hasNext(): self._adaptor.addChild(root_1, stream_named_value.nextTree()) stream_named_value.reset() self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt185 == 14: # sdl92.g:1088:17: '{' primary ( COMMA primary )* '}' pass char_literal568=self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_primary12593) if self._state.backtracking == 0: stream_L_BRACKET.add(char_literal568) self._state.following.append(self.FOLLOW_primary_in_primary12611) primary569 = self.primary() self._state.following.pop() if self._state.backtracking == 0: stream_primary.add(primary569.tree) # sdl92.g:1089:25: ( COMMA primary )* while True: #loop184 alt184 = 2 LA184_0 = self.input.LA(1) if (LA184_0 == COMMA) : alt184 = 1 if alt184 == 1: # sdl92.g:1089:26: COMMA primary pass COMMA570=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_primary12614) if self._state.backtracking == 0: stream_COMMA.add(COMMA570) self._state.following.append(self.FOLLOW_primary_in_primary12616) primary571 = self.primary() self._state.following.pop() if self._state.backtracking == 0: stream_primary.add(primary571.tree) else: break #loop184 char_literal572=self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_primary12636) if self._state.backtracking == 0: stream_R_BRACKET.add(char_literal572) # AST Rewrite # elements: primary # 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() # 1090:45: -> ^( SEQOF ( primary )+ ) # sdl92.g:1090:48: ^( SEQOF ( primary )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(SEQOF, "SEQOF"), root_1) # sdl92.g:1090:56: ( primary )+ if not (stream_primary.hasNext()): raise RewriteEarlyExitException() while stream_primary.hasNext(): self._adaptor.addChild(root_1, stream_primary.nextTree()) stream_primary.reset() self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt185 == 15: # sdl92.g:1091:17: STATE pass root_0 = self._adaptor.nil() STATE573=self.match(self.input, STATE, self.FOLLOW_STATE_in_primary12687) if self._state.backtracking == 0: STATE573_tree = self._adaptor.createWithPayload(STATE573) root_0 = self._adaptor.becomeRoot(STATE573_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, 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 "primary" class informal_text_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.informal_text_return, self).__init__() self.tree = None # $ANTLR start "informal_text" # sdl92.g:1095:1: informal_text : STRING -> ^( INFORMAL_TEXT STRING ) ; def informal_text(self, ): retval = self.informal_text_return() retval.start = self.input.LT(1) root_0 = None STRING574 = None STRING574_tree = None stream_STRING = RewriteRuleTokenStream(self._adaptor, "token STRING") try: try: # sdl92.g:1096:9: ( STRING -> ^( INFORMAL_TEXT STRING ) ) # sdl92.g:1096:18: STRING pass STRING574=self.match(self.input, STRING, self.FOLLOW_STRING_in_informal_text12721) if self._state.backtracking == 0: stream_STRING.add(STRING574) # AST Rewrite # elements: STRING # 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() # 1097:9: -> ^( INFORMAL_TEXT STRING ) # sdl92.g:1097:18: ^( INFORMAL_TEXT STRING ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(INFORMAL_TEXT, "INFORMAL_TEXT"), root_1) self._adaptor.addChild(root_1, stream_STRING.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, 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 "informal_text" class named_value_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.named_value_return, self).__init__() self.tree = None # $ANTLR start "named_value" # sdl92.g:1102:1: named_value : ID expression ; def named_value(self, ): retval = self.named_value_return() retval.start = self.input.LT(1) root_0 = None ID575 = None expression576 = None ID575_tree = None try: try: # sdl92.g:1103:9: ( ID expression ) # sdl92.g:1103:17: ID expression pass root_0 = self._adaptor.nil() ID575=self.match(self.input, ID, self.FOLLOW_ID_in_named_value12776) if self._state.backtracking == 0: ID575_tree = self._adaptor.createWithPayload(ID575) self._adaptor.addChild(root_0, ID575_tree) self._state.following.append(self.FOLLOW_expression_in_named_value12778) expression576 = self.expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, expression576.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, 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 "named_value" class primary_params_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.primary_params_return, self).__init__() self.tree = None # $ANTLR start "primary_params" # sdl92.g:1107:1: primary_params : ( '(' expression_list ')' -> ^( PARAMS expression_list ) | '!' literal_id -> ^( FIELD_NAME literal_id ) ); def primary_params(self, ): retval = self.primary_params_return() retval.start = self.input.LT(1) root_0 = None char_literal577 = None char_literal579 = None char_literal580 = None expression_list578 = None literal_id581 = None char_literal577_tree = None char_literal579_tree = None char_literal580_tree = None stream_225 = RewriteRuleTokenStream(self._adaptor, "token 225") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_expression_list = RewriteRuleSubtreeStream(self._adaptor, "rule expression_list") stream_literal_id = RewriteRuleSubtreeStream(self._adaptor, "rule literal_id") try: try: # sdl92.g:1108:9: ( '(' expression_list ')' -> ^( PARAMS expression_list ) | '!' literal_id -> ^( FIELD_NAME literal_id ) ) alt186 = 2 LA186_0 = self.input.LA(1) if (LA186_0 == L_PAREN) : alt186 = 1 elif (LA186_0 == 225) : alt186 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 186, 0, self.input) raise nvae if alt186 == 1: # sdl92.g:1108:16: '(' expression_list ')' pass char_literal577=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_primary_params12809) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal577) self._state.following.append(self.FOLLOW_expression_list_in_primary_params12811) expression_list578 = self.expression_list() self._state.following.pop() if self._state.backtracking == 0: stream_expression_list.add(expression_list578.tree) char_literal579=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_primary_params12813) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal579) # AST Rewrite # elements: expression_list # 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() # 1109:9: -> ^( PARAMS expression_list ) # sdl92.g:1109:16: ^( PARAMS expression_list ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(PARAMS, "PARAMS"), root_1) self._adaptor.addChild(root_1, stream_expression_list.nextTree()) self._adaptor.addChild(root_0, root_1) retval.tree = root_0 elif alt186 == 2: # sdl92.g:1110:18: '!' literal_id pass char_literal580=self.match(self.input, 225, self.FOLLOW_225_in_primary_params12852) if self._state.backtracking == 0: stream_225.add(char_literal580) self._state.following.append(self.FOLLOW_literal_id_in_primary_params12854) literal_id581 = self.literal_id() self._state.following.pop() if self._state.backtracking == 0: stream_literal_id.add(literal_id581.tree) # AST Rewrite # elements: literal_id # 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() # 1111:9: -> ^( FIELD_NAME literal_id ) # sdl92.g:1111:16: ^( FIELD_NAME literal_id ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(FIELD_NAME, "FIELD_NAME"), root_1) self._adaptor.addChild(root_1, stream_literal_id.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, 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 "primary_params" class indexed_primary_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.indexed_primary_return, self).__init__() self.tree = None # $ANTLR start "indexed_primary" # sdl92.g:1126:1: indexed_primary : primary '(' expression_list ')' ; def indexed_primary(self, ): retval = self.indexed_primary_return() retval.start = self.input.LT(1) root_0 = None char_literal583 = None char_literal585 = None primary582 = None expression_list584 = None char_literal583_tree = None char_literal585_tree = None try: try: # sdl92.g:1127:9: ( primary '(' expression_list ')' ) # sdl92.g:1127:17: primary '(' expression_list ')' pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_primary_in_indexed_primary12910) primary582 = self.primary() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, primary582.tree) char_literal583=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_indexed_primary12912) if self._state.backtracking == 0: char_literal583_tree = self._adaptor.createWithPayload(char_literal583) self._adaptor.addChild(root_0, char_literal583_tree) self._state.following.append(self.FOLLOW_expression_list_in_indexed_primary12914) expression_list584 = self.expression_list() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, expression_list584.tree) char_literal585=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_indexed_primary12916) if self._state.backtracking == 0: char_literal585_tree = self._adaptor.createWithPayload(char_literal585) self._adaptor.addChild(root_0, char_literal585_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, 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 "indexed_primary" class field_primary_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.field_primary_return, self).__init__() self.tree = None # $ANTLR start "field_primary" # sdl92.g:1131:1: field_primary : primary field_selection ; def field_primary(self, ): retval = self.field_primary_return() retval.start = self.input.LT(1) root_0 = None primary586 = None field_selection587 = None try: try: # sdl92.g:1132:9: ( primary field_selection ) # sdl92.g:1132:17: primary field_selection pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_primary_in_field_primary12948) primary586 = self.primary() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, primary586.tree) self._state.following.append(self.FOLLOW_field_selection_in_field_primary12950) field_selection587 = self.field_selection() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, field_selection587.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, 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 "field_primary" class structure_primary_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.structure_primary_return, self).__init__() self.tree = None # $ANTLR start "structure_primary" # sdl92.g:1136:1: structure_primary : '(.' expression_list '.)' ; def structure_primary(self, ): retval = self.structure_primary_return() retval.start = self.input.LT(1) root_0 = None string_literal588 = None string_literal590 = None expression_list589 = None string_literal588_tree = None string_literal590_tree = None try: try: # sdl92.g:1137:9: ( '(.' expression_list '.)' ) # sdl92.g:1137:17: '(.' expression_list '.)' pass root_0 = self._adaptor.nil() string_literal588=self.match(self.input, 226, self.FOLLOW_226_in_structure_primary12982) if self._state.backtracking == 0: string_literal588_tree = self._adaptor.createWithPayload(string_literal588) self._adaptor.addChild(root_0, string_literal588_tree) self._state.following.append(self.FOLLOW_expression_list_in_structure_primary12984) expression_list589 = self.expression_list() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, expression_list589.tree) string_literal590=self.match(self.input, 227, self.FOLLOW_227_in_structure_primary12986) if self._state.backtracking == 0: string_literal590_tree = self._adaptor.createWithPayload(string_literal590) self._adaptor.addChild(root_0, string_literal590_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, 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 "structure_primary" class active_expression_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.active_expression_return, self).__init__() self.tree = None # $ANTLR start "active_expression" # sdl92.g:1143:1: active_expression : active_primary ; def active_expression(self, ): retval = self.active_expression_return() retval.start = self.input.LT(1) root_0 = None active_primary591 = None try: try: # sdl92.g:1144:9: ( active_primary ) # sdl92.g:1144:17: active_primary pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_active_primary_in_active_expression13020) active_primary591 = self.active_primary() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, active_primary591.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, 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 "active_expression" class active_primary_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.active_primary_return, self).__init__() self.tree = None # $ANTLR start "active_primary" # sdl92.g:1148:1: active_primary : ( variable_access | operator_application | conditional_expression | imperative_operator | '(' active_expression ')' | 'ERROR' ); def active_primary(self, ): retval = self.active_primary_return() retval.start = self.input.LT(1) root_0 = None char_literal596 = None char_literal598 = None string_literal599 = None variable_access592 = None operator_application593 = None conditional_expression594 = None imperative_operator595 = None active_expression597 = None char_literal596_tree = None char_literal598_tree = None string_literal599_tree = None try: try: # sdl92.g:1149:9: ( variable_access | operator_application | conditional_expression | imperative_operator | '(' active_expression ')' | 'ERROR' ) alt187 = 6 LA187 = self.input.LA(1) if LA187 == ID: LA187_1 = self.input.LA(2) if (LA187_1 == L_PAREN) : alt187 = 2 elif ((R_PAREN <= LA187_1 <= COMMA)) : alt187 = 1 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 187, 1, self.input) raise nvae elif LA187 == IF: alt187 = 3 elif LA187 == ANY or LA187 == ACTIVE or LA187 == IMPORT or LA187 == VIEW or LA187 == N or LA187 == P or LA187 == S or LA187 == O: alt187 = 4 elif LA187 == L_PAREN: alt187 = 5 elif LA187 == 228: alt187 = 6 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 187, 0, self.input) raise nvae if alt187 == 1: # sdl92.g:1149:17: variable_access pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_variable_access_in_active_primary13052) variable_access592 = self.variable_access() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, variable_access592.tree) elif alt187 == 2: # sdl92.g:1150:19: operator_application pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_operator_application_in_active_primary13072) operator_application593 = self.operator_application() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, operator_application593.tree) elif alt187 == 3: # sdl92.g:1151:19: conditional_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_conditional_expression_in_active_primary13092) conditional_expression594 = self.conditional_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, conditional_expression594.tree) elif alt187 == 4: # sdl92.g:1152:19: imperative_operator pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_imperative_operator_in_active_primary13112) imperative_operator595 = self.imperative_operator() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, imperative_operator595.tree) elif alt187 == 5: # sdl92.g:1153:19: '(' active_expression ')' pass root_0 = self._adaptor.nil() char_literal596=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_active_primary13132) if self._state.backtracking == 0: char_literal596_tree = self._adaptor.createWithPayload(char_literal596) self._adaptor.addChild(root_0, char_literal596_tree) self._state.following.append(self.FOLLOW_active_expression_in_active_primary13134) active_expression597 = self.active_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, active_expression597.tree) char_literal598=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_active_primary13136) if self._state.backtracking == 0: char_literal598_tree = self._adaptor.createWithPayload(char_literal598) self._adaptor.addChild(root_0, char_literal598_tree) elif alt187 == 6: # sdl92.g:1154:19: 'ERROR' pass root_0 = self._adaptor.nil() string_literal599=self.match(self.input, 228, self.FOLLOW_228_in_active_primary13156) if self._state.backtracking == 0: string_literal599_tree = self._adaptor.createWithPayload(string_literal599) self._adaptor.addChild(root_0, string_literal599_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, 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 "active_primary" class imperative_operator_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.imperative_operator_return, self).__init__() self.tree = None # $ANTLR start "imperative_operator" # sdl92.g:1159:1: imperative_operator : ( now_expression | import_expression | pid_expression | view_expression | timer_active_expression | anyvalue_expression ); def imperative_operator(self, ): retval = self.imperative_operator_return() retval.start = self.input.LT(1) root_0 = None now_expression600 = None import_expression601 = None pid_expression602 = None view_expression603 = None timer_active_expression604 = None anyvalue_expression605 = None try: try: # sdl92.g:1160:9: ( now_expression | import_expression | pid_expression | view_expression | timer_active_expression | anyvalue_expression ) alt188 = 6 LA188 = self.input.LA(1) if LA188 == N: alt188 = 1 elif LA188 == IMPORT: alt188 = 2 elif LA188 == P or LA188 == S or LA188 == O: alt188 = 3 elif LA188 == VIEW: alt188 = 4 elif LA188 == ACTIVE: alt188 = 5 elif LA188 == ANY: alt188 = 6 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 188, 0, self.input) raise nvae if alt188 == 1: # sdl92.g:1160:17: now_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_now_expression_in_imperative_operator13192) now_expression600 = self.now_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, now_expression600.tree) elif alt188 == 2: # sdl92.g:1161:19: import_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_import_expression_in_imperative_operator13212) import_expression601 = self.import_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, import_expression601.tree) elif alt188 == 3: # sdl92.g:1162:19: pid_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_pid_expression_in_imperative_operator13232) pid_expression602 = self.pid_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, pid_expression602.tree) elif alt188 == 4: # sdl92.g:1163:19: view_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_view_expression_in_imperative_operator13252) view_expression603 = self.view_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, view_expression603.tree) elif alt188 == 5: # sdl92.g:1164:19: timer_active_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_timer_active_expression_in_imperative_operator13272) timer_active_expression604 = self.timer_active_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, timer_active_expression604.tree) elif alt188 == 6: # sdl92.g:1165:19: anyvalue_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_anyvalue_expression_in_imperative_operator13292) anyvalue_expression605 = self.anyvalue_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, anyvalue_expression605.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, 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 "imperative_operator" class timer_active_expression_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.timer_active_expression_return, self).__init__() self.tree = None # $ANTLR start "timer_active_expression" # sdl92.g:1169:1: timer_active_expression : ACTIVE '(' timer_id ( '(' expression_list ')' )? ')' ; def timer_active_expression(self, ): retval = self.timer_active_expression_return() retval.start = self.input.LT(1) root_0 = None ACTIVE606 = None char_literal607 = None char_literal609 = None char_literal611 = None char_literal612 = None timer_id608 = None expression_list610 = None ACTIVE606_tree = None char_literal607_tree = None char_literal609_tree = None char_literal611_tree = None char_literal612_tree = None try: try: # sdl92.g:1170:9: ( ACTIVE '(' timer_id ( '(' expression_list ')' )? ')' ) # sdl92.g:1170:17: ACTIVE '(' timer_id ( '(' expression_list ')' )? ')' pass root_0 = self._adaptor.nil() ACTIVE606=self.match(self.input, ACTIVE, self.FOLLOW_ACTIVE_in_timer_active_expression13324) if self._state.backtracking == 0: ACTIVE606_tree = self._adaptor.createWithPayload(ACTIVE606) self._adaptor.addChild(root_0, ACTIVE606_tree) char_literal607=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_timer_active_expression13326) if self._state.backtracking == 0: char_literal607_tree = self._adaptor.createWithPayload(char_literal607) self._adaptor.addChild(root_0, char_literal607_tree) self._state.following.append(self.FOLLOW_timer_id_in_timer_active_expression13328) timer_id608 = self.timer_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, timer_id608.tree) # sdl92.g:1170:37: ( '(' expression_list ')' )? alt189 = 2 LA189_0 = self.input.LA(1) if (LA189_0 == L_PAREN) : alt189 = 1 if alt189 == 1: # sdl92.g:1170:38: '(' expression_list ')' pass char_literal609=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_timer_active_expression13331) if self._state.backtracking == 0: char_literal609_tree = self._adaptor.createWithPayload(char_literal609) self._adaptor.addChild(root_0, char_literal609_tree) self._state.following.append(self.FOLLOW_expression_list_in_timer_active_expression13333) expression_list610 = self.expression_list() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, expression_list610.tree) char_literal611=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_timer_active_expression13335) if self._state.backtracking == 0: char_literal611_tree = self._adaptor.createWithPayload(char_literal611) self._adaptor.addChild(root_0, char_literal611_tree) char_literal612=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_timer_active_expression13339) if self._state.backtracking == 0: char_literal612_tree = self._adaptor.createWithPayload(char_literal612) self._adaptor.addChild(root_0, char_literal612_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, 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 "timer_active_expression" class anyvalue_expression_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.anyvalue_expression_return, self).__init__() self.tree = None # $ANTLR start "anyvalue_expression" # sdl92.g:1174:1: anyvalue_expression : ANY '(' sort ')' ; def anyvalue_expression(self, ): retval = self.anyvalue_expression_return() retval.start = self.input.LT(1) root_0 = None ANY613 = None char_literal614 = None char_literal616 = None sort615 = None ANY613_tree = None char_literal614_tree = None char_literal616_tree = None try: try: # sdl92.g:1175:9: ( ANY '(' sort ')' ) # sdl92.g:1175:17: ANY '(' sort ')' pass root_0 = self._adaptor.nil() ANY613=self.match(self.input, ANY, self.FOLLOW_ANY_in_anyvalue_expression13371) if self._state.backtracking == 0: ANY613_tree = self._adaptor.createWithPayload(ANY613) self._adaptor.addChild(root_0, ANY613_tree) char_literal614=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_anyvalue_expression13373) if self._state.backtracking == 0: char_literal614_tree = self._adaptor.createWithPayload(char_literal614) self._adaptor.addChild(root_0, char_literal614_tree) self._state.following.append(self.FOLLOW_sort_in_anyvalue_expression13375) sort615 = self.sort() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, sort615.tree) char_literal616=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_anyvalue_expression13377) if self._state.backtracking == 0: char_literal616_tree = self._adaptor.createWithPayload(char_literal616) self._adaptor.addChild(root_0, char_literal616_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, 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 "anyvalue_expression" class sort_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.sort_return, self).__init__() self.tree = None # $ANTLR start "sort" # sdl92.g:1179:1: sort : sort_id -> ^( SORT sort_id ) ; def sort(self, ): retval = self.sort_return() retval.start = self.input.LT(1) root_0 = None sort_id617 = None stream_sort_id = RewriteRuleSubtreeStream(self._adaptor, "rule sort_id") try: try: # sdl92.g:1179:9: ( sort_id -> ^( SORT sort_id ) ) # sdl92.g:1179:17: sort_id pass self._state.following.append(self.FOLLOW_sort_id_in_sort13404) sort_id617 = self.sort_id() self._state.following.pop() if self._state.backtracking == 0: stream_sort_id.add(sort_id617.tree) # AST Rewrite # elements: sort_id # 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() # 1180:9: -> ^( SORT sort_id ) # sdl92.g:1180:17: ^( SORT sort_id ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(SORT, "SORT"), root_1) self._adaptor.addChild(root_1, stream_sort_id.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, 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 "sort" class type_inst_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.type_inst_return, self).__init__() self.tree = None # $ANTLR start "type_inst" # sdl92.g:1184:1: type_inst : type_id -> ^( TYPE_INSTANCE type_id ) ; def type_inst(self, ): retval = self.type_inst_return() retval.start = self.input.LT(1) root_0 = None type_id618 = None stream_type_id = RewriteRuleSubtreeStream(self._adaptor, "rule type_id") try: try: # sdl92.g:1185:9: ( type_id -> ^( TYPE_INSTANCE type_id ) ) # sdl92.g:1185:17: type_id pass self._state.following.append(self.FOLLOW_type_id_in_type_inst13457) type_id618 = self.type_id() self._state.following.pop() if self._state.backtracking == 0: stream_type_id.add(type_id618.tree) # AST Rewrite # elements: type_id # 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() # 1186:9: -> ^( TYPE_INSTANCE type_id ) # sdl92.g:1186:17: ^( TYPE_INSTANCE type_id ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(TYPE_INSTANCE, "TYPE_INSTANCE"), root_1) self._adaptor.addChild(root_1, stream_type_id.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, 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 "type_inst" class syntype_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.syntype_return, self).__init__() self.tree = None # $ANTLR start "syntype" # sdl92.g:1190:1: syntype : syntype_id ; def syntype(self, ): retval = self.syntype_return() retval.start = self.input.LT(1) root_0 = None syntype_id619 = None try: try: # sdl92.g:1190:9: ( syntype_id ) # sdl92.g:1190:17: syntype_id pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_syntype_id_in_syntype13502) syntype_id619 = self.syntype_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, syntype_id619.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, 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 "syntype" class import_expression_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.import_expression_return, self).__init__() self.tree = None # $ANTLR start "import_expression" # sdl92.g:1194:1: import_expression : IMPORT '(' remote_variable_id ( ',' destination )? ')' ; def import_expression(self, ): retval = self.import_expression_return() retval.start = self.input.LT(1) root_0 = None IMPORT620 = None char_literal621 = None char_literal623 = None char_literal625 = None remote_variable_id622 = None destination624 = None IMPORT620_tree = None char_literal621_tree = None char_literal623_tree = None char_literal625_tree = None try: try: # sdl92.g:1195:9: ( IMPORT '(' remote_variable_id ( ',' destination )? ')' ) # sdl92.g:1195:17: IMPORT '(' remote_variable_id ( ',' destination )? ')' pass root_0 = self._adaptor.nil() IMPORT620=self.match(self.input, IMPORT, self.FOLLOW_IMPORT_in_import_expression13534) if self._state.backtracking == 0: IMPORT620_tree = self._adaptor.createWithPayload(IMPORT620) self._adaptor.addChild(root_0, IMPORT620_tree) char_literal621=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_import_expression13536) if self._state.backtracking == 0: char_literal621_tree = self._adaptor.createWithPayload(char_literal621) self._adaptor.addChild(root_0, char_literal621_tree) self._state.following.append(self.FOLLOW_remote_variable_id_in_import_expression13538) remote_variable_id622 = self.remote_variable_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, remote_variable_id622.tree) # sdl92.g:1195:47: ( ',' destination )? alt190 = 2 LA190_0 = self.input.LA(1) if (LA190_0 == COMMA) : alt190 = 1 if alt190 == 1: # sdl92.g:1195:48: ',' destination pass char_literal623=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_import_expression13541) if self._state.backtracking == 0: char_literal623_tree = self._adaptor.createWithPayload(char_literal623) self._adaptor.addChild(root_0, char_literal623_tree) self._state.following.append(self.FOLLOW_destination_in_import_expression13543) destination624 = self.destination() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, destination624.tree) char_literal625=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_import_expression13547) if self._state.backtracking == 0: char_literal625_tree = self._adaptor.createWithPayload(char_literal625) self._adaptor.addChild(root_0, char_literal625_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, 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 "import_expression" class view_expression_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.view_expression_return, self).__init__() self.tree = None # $ANTLR start "view_expression" # sdl92.g:1199:1: view_expression : VIEW '(' view_id ( ',' pid_expression )? ')' ; def view_expression(self, ): retval = self.view_expression_return() retval.start = self.input.LT(1) root_0 = None VIEW626 = None char_literal627 = None char_literal629 = None char_literal631 = None view_id628 = None pid_expression630 = None VIEW626_tree = None char_literal627_tree = None char_literal629_tree = None char_literal631_tree = None try: try: # sdl92.g:1200:9: ( VIEW '(' view_id ( ',' pid_expression )? ')' ) # sdl92.g:1200:17: VIEW '(' view_id ( ',' pid_expression )? ')' pass root_0 = self._adaptor.nil() VIEW626=self.match(self.input, VIEW, self.FOLLOW_VIEW_in_view_expression13579) if self._state.backtracking == 0: VIEW626_tree = self._adaptor.createWithPayload(VIEW626) self._adaptor.addChild(root_0, VIEW626_tree) char_literal627=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_view_expression13581) if self._state.backtracking == 0: char_literal627_tree = self._adaptor.createWithPayload(char_literal627) self._adaptor.addChild(root_0, char_literal627_tree) self._state.following.append(self.FOLLOW_view_id_in_view_expression13583) view_id628 = self.view_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, view_id628.tree) # sdl92.g:1200:34: ( ',' pid_expression )? alt191 = 2 LA191_0 = self.input.LA(1) if (LA191_0 == COMMA) : alt191 = 1 if alt191 == 1: # sdl92.g:1200:35: ',' pid_expression pass char_literal629=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_view_expression13586) if self._state.backtracking == 0: char_literal629_tree = self._adaptor.createWithPayload(char_literal629) self._adaptor.addChild(root_0, char_literal629_tree) self._state.following.append(self.FOLLOW_pid_expression_in_view_expression13588) pid_expression630 = self.pid_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, pid_expression630.tree) char_literal631=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_view_expression13592) if self._state.backtracking == 0: char_literal631_tree = self._adaptor.createWithPayload(char_literal631) self._adaptor.addChild(root_0, char_literal631_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, 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 "view_expression" class variable_access_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.variable_access_return, self).__init__() self.tree = None # $ANTLR start "variable_access" # sdl92.g:1204:1: variable_access : variable_id ; def variable_access(self, ): retval = self.variable_access_return() retval.start = self.input.LT(1) root_0 = None variable_id632 = None try: try: # sdl92.g:1205:9: ( variable_id ) # sdl92.g:1205:17: variable_id pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_variable_id_in_variable_access13624) variable_id632 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, variable_id632.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, 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 "variable_access" class operator_application_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.operator_application_return, self).__init__() self.tree = None # $ANTLR start "operator_application" # sdl92.g:1209:1: operator_application : operator_id '(' active_expression_list ')' ; def operator_application(self, ): retval = self.operator_application_return() retval.start = self.input.LT(1) root_0 = None char_literal634 = None char_literal636 = None operator_id633 = None active_expression_list635 = None char_literal634_tree = None char_literal636_tree = None try: try: # sdl92.g:1210:9: ( operator_id '(' active_expression_list ')' ) # sdl92.g:1210:17: operator_id '(' active_expression_list ')' pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_operator_id_in_operator_application13656) operator_id633 = self.operator_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, operator_id633.tree) char_literal634=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_operator_application13658) if self._state.backtracking == 0: char_literal634_tree = self._adaptor.createWithPayload(char_literal634) self._adaptor.addChild(root_0, char_literal634_tree) self._state.following.append(self.FOLLOW_active_expression_list_in_operator_application13659) active_expression_list635 = self.active_expression_list() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, active_expression_list635.tree) char_literal636=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_operator_application13661) if self._state.backtracking == 0: char_literal636_tree = self._adaptor.createWithPayload(char_literal636) self._adaptor.addChild(root_0, char_literal636_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, 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 "operator_application" class active_expression_list_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.active_expression_list_return, self).__init__() self.tree = None # $ANTLR start "active_expression_list" # sdl92.g:1214:1: active_expression_list : active_expression ( ',' expression_list )? ; def active_expression_list(self, ): retval = self.active_expression_list_return() retval.start = self.input.LT(1) root_0 = None char_literal638 = None active_expression637 = None expression_list639 = None char_literal638_tree = None try: try: # sdl92.g:1215:9: ( active_expression ( ',' expression_list )? ) # sdl92.g:1215:17: active_expression ( ',' expression_list )? pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_active_expression_in_active_expression_list13693) active_expression637 = self.active_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, active_expression637.tree) # sdl92.g:1215:35: ( ',' expression_list )? alt192 = 2 LA192_0 = self.input.LA(1) if (LA192_0 == COMMA) : alt192 = 1 if alt192 == 1: # sdl92.g:1215:36: ',' expression_list pass char_literal638=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_active_expression_list13696) if self._state.backtracking == 0: char_literal638_tree = self._adaptor.createWithPayload(char_literal638) self._adaptor.addChild(root_0, char_literal638_tree) self._state.following.append(self.FOLLOW_expression_list_in_active_expression_list13698) expression_list639 = self.expression_list() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, expression_list639.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, 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 "active_expression_list" class external_synonym_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.external_synonym_return, self).__init__() self.tree = None # $ANTLR start "external_synonym" # sdl92.g:1223:1: external_synonym : external_synonym_id ; def external_synonym(self, ): retval = self.external_synonym_return() retval.start = self.input.LT(1) root_0 = None external_synonym_id640 = None try: try: # sdl92.g:1224:9: ( external_synonym_id ) # sdl92.g:1224:17: external_synonym_id pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_external_synonym_id_in_external_synonym13739) external_synonym_id640 = self.external_synonym_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, external_synonym_id640.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, 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 "external_synonym" class conditional_expression_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.conditional_expression_return, self).__init__() self.tree = None # $ANTLR start "conditional_expression" # sdl92.g:1228:1: conditional_expression : IF ifexpr= expression THEN thenexpr= expression ELSE elseexpr= expression FI -> ^( CONDITIONAL $ifexpr $thenexpr $elseexpr) ; def conditional_expression(self, ): retval = self.conditional_expression_return() retval.start = self.input.LT(1) root_0 = None IF641 = None THEN642 = None ELSE643 = None FI644 = None ifexpr = None thenexpr = None elseexpr = None IF641_tree = None THEN642_tree = None ELSE643_tree = None FI644_tree = None stream_THEN = RewriteRuleTokenStream(self._adaptor, "token THEN") stream_IF = RewriteRuleTokenStream(self._adaptor, "token IF") stream_ELSE = RewriteRuleTokenStream(self._adaptor, "token ELSE") stream_FI = RewriteRuleTokenStream(self._adaptor, "token FI") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:1229:9: ( IF ifexpr= expression THEN thenexpr= expression ELSE elseexpr= expression FI -> ^( CONDITIONAL $ifexpr $thenexpr $elseexpr) ) # sdl92.g:1229:17: IF ifexpr= expression THEN thenexpr= expression ELSE elseexpr= expression FI pass IF641=self.match(self.input, IF, self.FOLLOW_IF_in_conditional_expression13771) if self._state.backtracking == 0: stream_IF.add(IF641) self._state.following.append(self.FOLLOW_expression_in_conditional_expression13775) ifexpr = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(ifexpr.tree) THEN642=self.match(self.input, THEN, self.FOLLOW_THEN_in_conditional_expression13793) if self._state.backtracking == 0: stream_THEN.add(THEN642) self._state.following.append(self.FOLLOW_expression_in_conditional_expression13797) thenexpr = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(thenexpr.tree) ELSE643=self.match(self.input, ELSE, self.FOLLOW_ELSE_in_conditional_expression13815) if self._state.backtracking == 0: stream_ELSE.add(ELSE643) self._state.following.append(self.FOLLOW_expression_in_conditional_expression13819) elseexpr = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(elseexpr.tree) FI644=self.match(self.input, FI, self.FOLLOW_FI_in_conditional_expression13821) if self._state.backtracking == 0: stream_FI.add(FI644) # AST Rewrite # elements: ifexpr, elseexpr, thenexpr # token labels: # rule labels: elseexpr, retval, ifexpr, thenexpr # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 if elseexpr is not None: stream_elseexpr = RewriteRuleSubtreeStream(self._adaptor, "rule elseexpr", elseexpr.tree) else: stream_elseexpr = RewriteRuleSubtreeStream(self._adaptor, "token elseexpr", None) if retval is not None: stream_retval = RewriteRuleSubtreeStream(self._adaptor, "rule retval", retval.tree) else: stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None) if ifexpr is not None: stream_ifexpr = RewriteRuleSubtreeStream(self._adaptor, "rule ifexpr", ifexpr.tree) else: stream_ifexpr = RewriteRuleSubtreeStream(self._adaptor, "token ifexpr", None) if thenexpr is not None: stream_thenexpr = RewriteRuleSubtreeStream(self._adaptor, "rule thenexpr", thenexpr.tree) else: stream_thenexpr = RewriteRuleSubtreeStream(self._adaptor, "token thenexpr", None) root_0 = self._adaptor.nil() # 1232:9: -> ^( CONDITIONAL $ifexpr $thenexpr $elseexpr) # sdl92.g:1232:17: ^( CONDITIONAL $ifexpr $thenexpr $elseexpr) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(CONDITIONAL, "CONDITIONAL"), root_1) self._adaptor.addChild(root_1, stream_ifexpr.nextTree()) self._adaptor.addChild(root_1, stream_thenexpr.nextTree()) self._adaptor.addChild(root_1, stream_elseexpr.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, 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 "conditional_expression" class expression_list_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.expression_list_return, self).__init__() self.tree = None # $ANTLR start "expression_list" # sdl92.g:1236:1: expression_list : expression ( ',' expression )* -> ( expression )+ ; def expression_list(self, ): retval = self.expression_list_return() retval.start = self.input.LT(1) root_0 = None char_literal646 = None expression645 = None expression647 = None char_literal646_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:1237:9: ( expression ( ',' expression )* -> ( expression )+ ) # sdl92.g:1237:17: expression ( ',' expression )* pass self._state.following.append(self.FOLLOW_expression_in_expression_list13881) expression645 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression645.tree) # sdl92.g:1237:28: ( ',' expression )* while True: #loop193 alt193 = 2 LA193_0 = self.input.LA(1) if (LA193_0 == COMMA) : alt193 = 1 if alt193 == 1: # sdl92.g:1237:29: ',' expression pass char_literal646=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_expression_list13884) if self._state.backtracking == 0: stream_COMMA.add(char_literal646) self._state.following.append(self.FOLLOW_expression_in_expression_list13886) expression647 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression647.tree) else: break #loop193 # AST Rewrite # elements: expression # 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() # 1238:9: -> ( expression )+ # sdl92.g:1238:17: ( expression )+ if not (stream_expression.hasNext()): raise RewriteEarlyExitException() while stream_expression.hasNext(): self._adaptor.addChild(root_0, stream_expression.nextTree()) stream_expression.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, 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 "expression_list" class terminator_statement_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.terminator_statement_return, self).__init__() self.tree = None # $ANTLR start "terminator_statement" # sdl92.g:1242:1: terminator_statement : ( label )? ( cif )? ( hyperlink )? terminator end -> ^( TERMINATOR ( label )? ( cif )? ( hyperlink )? ( end )? terminator ) ; def terminator_statement(self, ): retval = self.terminator_statement_return() retval.start = self.input.LT(1) root_0 = None label648 = None cif649 = None hyperlink650 = None terminator651 = None end652 = None stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_terminator = RewriteRuleSubtreeStream(self._adaptor, "rule terminator") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_label = RewriteRuleSubtreeStream(self._adaptor, "rule label") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:1243:9: ( ( label )? ( cif )? ( hyperlink )? terminator end -> ^( TERMINATOR ( label )? ( cif )? ( hyperlink )? ( end )? terminator ) ) # sdl92.g:1243:17: ( label )? ( cif )? ( hyperlink )? terminator end pass # sdl92.g:1243:17: ( label )? alt194 = 2 alt194 = self.dfa194.predict(self.input) if alt194 == 1: # sdl92.g:0:0: label pass self._state.following.append(self.FOLLOW_label_in_terminator_statement13938) label648 = self.label() self._state.following.pop() if self._state.backtracking == 0: stream_label.add(label648.tree) # sdl92.g:1244:17: ( cif )? alt195 = 2 LA195_0 = self.input.LA(1) if (LA195_0 == 229) : LA195_1 = self.input.LA(2) if (LA195_1 == ANSWER or LA195_1 == COMMENT or LA195_1 == CONNECT or LA195_1 == DECISION or LA195_1 == INPUT or (JOIN <= LA195_1 <= LABEL) or LA195_1 == NEXTSTATE or LA195_1 == OUTPUT or (PROCEDURE <= LA195_1 <= PROCEDURE_CALL) or (PROCESS <= LA195_1 <= PROVIDED) or LA195_1 == RETURN or LA195_1 == STATE or LA195_1 == STOP or LA195_1 == TASK or LA195_1 == TEXT or LA195_1 == START) : alt195 = 1 if alt195 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_terminator_statement13957) cif649 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif649.tree) # sdl92.g:1245:17: ( hyperlink )? alt196 = 2 LA196_0 = self.input.LA(1) if (LA196_0 == 229) : alt196 = 1 if alt196 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_terminator_statement13976) hyperlink650 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink650.tree) self._state.following.append(self.FOLLOW_terminator_in_terminator_statement13995) terminator651 = self.terminator() self._state.following.pop() if self._state.backtracking == 0: stream_terminator.add(terminator651.tree) self._state.following.append(self.FOLLOW_end_in_terminator_statement14013) end652 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end652.tree) # AST Rewrite # elements: cif, label, end, hyperlink, terminator # 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() # 1248:9: -> ^( TERMINATOR ( label )? ( cif )? ( hyperlink )? ( end )? terminator ) # sdl92.g:1248:17: ^( TERMINATOR ( label )? ( cif )? ( hyperlink )? ( end )? terminator ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(TERMINATOR, "TERMINATOR"), root_1) # sdl92.g:1248:30: ( label )? if stream_label.hasNext(): self._adaptor.addChild(root_1, stream_label.nextTree()) stream_label.reset(); # sdl92.g:1248:37: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:1248:42: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:1248:53: ( end )? if stream_end.hasNext(): self._adaptor.addChild(root_1, stream_end.nextTree()) stream_end.reset(); self._adaptor.addChild(root_1, stream_terminator.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, 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 "terminator_statement" class label_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.label_return, self).__init__() self.tree = None # $ANTLR start "label" # sdl92.g:1251:1: label : ( cif )? connector_name ':' -> ^( LABEL ( cif )? connector_name ) ; def label(self, ): retval = self.label_return() retval.start = self.input.LT(1) root_0 = None char_literal655 = None cif653 = None connector_name654 = None char_literal655_tree = None stream_223 = RewriteRuleTokenStream(self._adaptor, "token 223") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_connector_name = RewriteRuleSubtreeStream(self._adaptor, "rule connector_name") try: try: # sdl92.g:1252:9: ( ( cif )? connector_name ':' -> ^( LABEL ( cif )? connector_name ) ) # sdl92.g:1252:17: ( cif )? connector_name ':' pass # sdl92.g:1252:17: ( cif )? alt197 = 2 LA197_0 = self.input.LA(1) if (LA197_0 == 229) : alt197 = 1 if alt197 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_label14077) cif653 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif653.tree) self._state.following.append(self.FOLLOW_connector_name_in_label14080) connector_name654 = self.connector_name() self._state.following.pop() if self._state.backtracking == 0: stream_connector_name.add(connector_name654.tree) char_literal655=self.match(self.input, 223, self.FOLLOW_223_in_label14082) if self._state.backtracking == 0: stream_223.add(char_literal655) # AST Rewrite # elements: connector_name, cif # 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() # 1253:9: -> ^( LABEL ( cif )? connector_name ) # sdl92.g:1253:17: ^( LABEL ( cif )? connector_name ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(LABEL, "LABEL"), root_1) # sdl92.g:1253:25: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); self._adaptor.addChild(root_1, stream_connector_name.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, 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 "label" class terminator_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.terminator_return, self).__init__() self.tree = None # $ANTLR start "terminator" # sdl92.g:1257:1: terminator : ( nextstate | join | stop | return_stmt ); def terminator(self, ): retval = self.terminator_return() retval.start = self.input.LT(1) root_0 = None nextstate656 = None join657 = None stop658 = None return_stmt659 = None try: try: # sdl92.g:1258:9: ( nextstate | join | stop | return_stmt ) alt198 = 4 LA198 = self.input.LA(1) if LA198 == NEXTSTATE: alt198 = 1 elif LA198 == JOIN: alt198 = 2 elif LA198 == STOP: alt198 = 3 elif LA198 == RETURN: alt198 = 4 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 198, 0, self.input) raise nvae if alt198 == 1: # sdl92.g:1258:17: nextstate pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_nextstate_in_terminator14138) nextstate656 = self.nextstate() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, nextstate656.tree) elif alt198 == 2: # sdl92.g:1258:29: join pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_join_in_terminator14142) join657 = self.join() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, join657.tree) elif alt198 == 3: # sdl92.g:1258:36: stop pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_stop_in_terminator14146) stop658 = self.stop() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, stop658.tree) elif alt198 == 4: # sdl92.g:1258:43: return_stmt pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_return_stmt_in_terminator14150) return_stmt659 = self.return_stmt() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, return_stmt659.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, 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 "terminator" class join_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.join_return, self).__init__() self.tree = None # $ANTLR start "join" # sdl92.g:1262:1: join : JOIN connector_name -> ^( JOIN connector_name ) ; def join(self, ): retval = self.join_return() retval.start = self.input.LT(1) root_0 = None JOIN660 = None connector_name661 = None JOIN660_tree = None stream_JOIN = RewriteRuleTokenStream(self._adaptor, "token JOIN") stream_connector_name = RewriteRuleSubtreeStream(self._adaptor, "rule connector_name") try: try: # sdl92.g:1263:9: ( JOIN connector_name -> ^( JOIN connector_name ) ) # sdl92.g:1263:18: JOIN connector_name pass JOIN660=self.match(self.input, JOIN, self.FOLLOW_JOIN_in_join14183) if self._state.backtracking == 0: stream_JOIN.add(JOIN660) self._state.following.append(self.FOLLOW_connector_name_in_join14185) connector_name661 = self.connector_name() self._state.following.pop() if self._state.backtracking == 0: stream_connector_name.add(connector_name661.tree) # AST Rewrite # elements: JOIN, connector_name # 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() # 1264:9: -> ^( JOIN connector_name ) # sdl92.g:1264:18: ^( JOIN connector_name ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_JOIN.nextNode(), root_1) self._adaptor.addChild(root_1, stream_connector_name.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, 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 "join" class stop_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.stop_return, self).__init__() self.tree = None # $ANTLR start "stop" # sdl92.g:1268:1: stop : STOP ; def stop(self, ): retval = self.stop_return() retval.start = self.input.LT(1) root_0 = None STOP662 = None STOP662_tree = None try: try: # sdl92.g:1268:9: ( STOP ) # sdl92.g:1268:17: STOP pass root_0 = self._adaptor.nil() STOP662=self.match(self.input, STOP, self.FOLLOW_STOP_in_stop14234) if self._state.backtracking == 0: STOP662_tree = self._adaptor.createWithPayload(STOP662) self._adaptor.addChild(root_0, STOP662_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, 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 "stop" class return_stmt_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.return_stmt_return, self).__init__() self.tree = None # $ANTLR start "return_stmt" # sdl92.g:1272:1: return_stmt : RETURN ( expression )? -> ^( RETURN ( expression )? ) ; def return_stmt(self, ): retval = self.return_stmt_return() retval.start = self.input.LT(1) root_0 = None RETURN663 = None expression664 = None RETURN663_tree = None stream_RETURN = RewriteRuleTokenStream(self._adaptor, "token RETURN") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:1273:9: ( RETURN ( expression )? -> ^( RETURN ( expression )? ) ) # sdl92.g:1273:17: RETURN ( expression )? pass RETURN663=self.match(self.input, RETURN, self.FOLLOW_RETURN_in_return_stmt14266) if self._state.backtracking == 0: stream_RETURN.add(RETURN663) # sdl92.g:1273:24: ( expression )? alt199 = 2 LA199_0 = self.input.LA(1) if (LA199_0 == FLOAT or LA199_0 == IF or LA199_0 == STATE or LA199_0 == STRING or LA199_0 == ID or LA199_0 == INT or LA199_0 == L_PAREN or LA199_0 == DASH or (NOT <= LA199_0 <= MINUS_INFINITY) or LA199_0 == L_BRACKET) : alt199 = 1 if alt199 == 1: # sdl92.g:0:0: expression pass self._state.following.append(self.FOLLOW_expression_in_return_stmt14268) expression664 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression664.tree) # AST Rewrite # elements: RETURN, expression # 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() # 1274:9: -> ^( RETURN ( expression )? ) # sdl92.g:1274:17: ^( RETURN ( expression )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_RETURN.nextNode(), root_1) # sdl92.g:1274:26: ( expression )? if stream_expression.hasNext(): self._adaptor.addChild(root_1, stream_expression.nextTree()) stream_expression.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, 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 "return_stmt" class nextstate_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.nextstate_return, self).__init__() self.tree = None # $ANTLR start "nextstate" # sdl92.g:1278:1: nextstate : NEXTSTATE nextstatebody -> ^( NEXTSTATE nextstatebody ) ; def nextstate(self, ): retval = self.nextstate_return() retval.start = self.input.LT(1) root_0 = None NEXTSTATE665 = None nextstatebody666 = None NEXTSTATE665_tree = None stream_NEXTSTATE = RewriteRuleTokenStream(self._adaptor, "token NEXTSTATE") stream_nextstatebody = RewriteRuleSubtreeStream(self._adaptor, "rule nextstatebody") try: try: # sdl92.g:1279:9: ( NEXTSTATE nextstatebody -> ^( NEXTSTATE nextstatebody ) ) # sdl92.g:1279:17: NEXTSTATE nextstatebody pass NEXTSTATE665=self.match(self.input, NEXTSTATE, self.FOLLOW_NEXTSTATE_in_nextstate14323) if self._state.backtracking == 0: stream_NEXTSTATE.add(NEXTSTATE665) self._state.following.append(self.FOLLOW_nextstatebody_in_nextstate14325) nextstatebody666 = self.nextstatebody() self._state.following.pop() if self._state.backtracking == 0: stream_nextstatebody.add(nextstatebody666.tree) # AST Rewrite # elements: nextstatebody, NEXTSTATE # 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() # 1280:9: -> ^( NEXTSTATE nextstatebody ) # sdl92.g:1280:17: ^( NEXTSTATE nextstatebody ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_NEXTSTATE.nextNode(), root_1) self._adaptor.addChild(root_1, stream_nextstatebody.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, 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 "nextstate" class nextstatebody_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.nextstatebody_return, self).__init__() self.tree = None # $ANTLR start "nextstatebody" # sdl92.g:1284:1: nextstatebody : ( statename ( via )? | dash_nextstate ); def nextstatebody(self, ): retval = self.nextstatebody_return() retval.start = self.input.LT(1) root_0 = None statename667 = None via668 = None dash_nextstate669 = None try: try: # sdl92.g:1285:9: ( statename ( via )? | dash_nextstate ) alt201 = 2 LA201_0 = self.input.LA(1) if (LA201_0 == ID) : alt201 = 1 elif (LA201_0 == DASH) : alt201 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 201, 0, self.input) raise nvae if alt201 == 1: # sdl92.g:1285:17: statename ( via )? pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_statename_in_nextstatebody14378) statename667 = self.statename() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, statename667.tree) # sdl92.g:1285:27: ( via )? alt200 = 2 LA200_0 = self.input.LA(1) if (LA200_0 == VIA) : alt200 = 1 if alt200 == 1: # sdl92.g:0:0: via pass self._state.following.append(self.FOLLOW_via_in_nextstatebody14380) via668 = self.via() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, via668.tree) elif alt201 == 2: # sdl92.g:1286:19: dash_nextstate pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_dash_nextstate_in_nextstatebody14401) dash_nextstate669 = self.dash_nextstate() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, dash_nextstate669.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, 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 "nextstatebody" class via_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.via_return, self).__init__() self.tree = None # $ANTLR start "via" # sdl92.g:1290:1: via : VIA state_entry_point_name -> ^( VIA state_entry_point_name ) ; def via(self, ): retval = self.via_return() retval.start = self.input.LT(1) root_0 = None VIA670 = None state_entry_point_name671 = None VIA670_tree = None stream_VIA = RewriteRuleTokenStream(self._adaptor, "token VIA") stream_state_entry_point_name = RewriteRuleSubtreeStream(self._adaptor, "rule state_entry_point_name") try: try: # sdl92.g:1290:9: ( VIA state_entry_point_name -> ^( VIA state_entry_point_name ) ) # sdl92.g:1290:17: VIA state_entry_point_name pass VIA670=self.match(self.input, VIA, self.FOLLOW_VIA_in_via14429) if self._state.backtracking == 0: stream_VIA.add(VIA670) self._state.following.append(self.FOLLOW_state_entry_point_name_in_via14431) state_entry_point_name671 = self.state_entry_point_name() self._state.following.pop() if self._state.backtracking == 0: stream_state_entry_point_name.add(state_entry_point_name671.tree) # AST Rewrite # elements: state_entry_point_name, VIA # 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() # 1291:9: -> ^( VIA state_entry_point_name ) # sdl92.g:1291:17: ^( VIA state_entry_point_name ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_VIA.nextNode(), root_1) self._adaptor.addChild(root_1, stream_state_entry_point_name.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, 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 "via" class end_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.end_return, self).__init__() self.tree = None # $ANTLR start "end" # sdl92.g:1295:1: end : ( ( cif )? ( hyperlink )? COMMENT STRING )? ( SEMI )+ -> ( ^( COMMENT ( cif )? ( hyperlink )? STRING ) )? ; def end(self, ): retval = self.end_return() retval.start = self.input.LT(1) root_0 = None COMMENT674 = None STRING675 = None SEMI676 = None cif672 = None hyperlink673 = None COMMENT674_tree = None STRING675_tree = None SEMI676_tree = None stream_COMMENT = RewriteRuleTokenStream(self._adaptor, "token COMMENT") stream_SEMI = RewriteRuleTokenStream(self._adaptor, "token SEMI") stream_STRING = RewriteRuleTokenStream(self._adaptor, "token STRING") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") try: try: # sdl92.g:1296:9: ( ( ( cif )? ( hyperlink )? COMMENT STRING )? ( SEMI )+ -> ( ^( COMMENT ( cif )? ( hyperlink )? STRING ) )? ) # sdl92.g:1296:13: ( ( cif )? ( hyperlink )? COMMENT STRING )? ( SEMI )+ pass # sdl92.g:1296:13: ( ( cif )? ( hyperlink )? COMMENT STRING )? alt204 = 2 LA204_0 = self.input.LA(1) if (LA204_0 == COMMENT or LA204_0 == 229) : alt204 = 1 if alt204 == 1: # sdl92.g:1296:14: ( cif )? ( hyperlink )? COMMENT STRING pass # sdl92.g:1296:14: ( cif )? alt202 = 2 LA202_0 = self.input.LA(1) if (LA202_0 == 229) : LA202_1 = self.input.LA(2) if (LA202_1 == ANSWER or LA202_1 == COMMENT or LA202_1 == CONNECT or LA202_1 == DECISION or LA202_1 == INPUT or (JOIN <= LA202_1 <= LABEL) or LA202_1 == NEXTSTATE or LA202_1 == OUTPUT or (PROCEDURE <= LA202_1 <= PROCEDURE_CALL) or (PROCESS <= LA202_1 <= PROVIDED) or LA202_1 == RETURN or LA202_1 == STATE or LA202_1 == STOP or LA202_1 == TASK or LA202_1 == TEXT or LA202_1 == START) : alt202 = 1 if alt202 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_end14481) cif672 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif672.tree) # sdl92.g:1296:19: ( hyperlink )? alt203 = 2 LA203_0 = self.input.LA(1) if (LA203_0 == 229) : alt203 = 1 if alt203 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_end14484) hyperlink673 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink673.tree) COMMENT674=self.match(self.input, COMMENT, self.FOLLOW_COMMENT_in_end14487) if self._state.backtracking == 0: stream_COMMENT.add(COMMENT674) STRING675=self.match(self.input, STRING, self.FOLLOW_STRING_in_end14489) if self._state.backtracking == 0: stream_STRING.add(STRING675) # sdl92.g:1296:47: ( SEMI )+ cnt205 = 0 while True: #loop205 alt205 = 2 LA205_0 = self.input.LA(1) if (LA205_0 == SEMI) : LA205_2 = self.input.LA(2) if (self.synpred287_sdl92()) : alt205 = 1 if alt205 == 1: # sdl92.g:0:0: SEMI pass SEMI676=self.match(self.input, SEMI, self.FOLLOW_SEMI_in_end14493) if self._state.backtracking == 0: stream_SEMI.add(SEMI676) else: if cnt205 >= 1: break #loop205 if self._state.backtracking > 0: raise BacktrackingFailed eee = EarlyExitException(205, self.input) raise eee cnt205 += 1 # AST Rewrite # elements: cif, STRING, COMMENT, hyperlink # 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() # 1297:9: -> ( ^( COMMENT ( cif )? ( hyperlink )? STRING ) )? # sdl92.g:1297:12: ( ^( COMMENT ( cif )? ( hyperlink )? STRING ) )? if stream_cif.hasNext() or stream_STRING.hasNext() or stream_COMMENT.hasNext() or stream_hyperlink.hasNext(): # sdl92.g:1297:12: ^( COMMENT ( cif )? ( hyperlink )? STRING ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_COMMENT.nextNode(), root_1) # sdl92.g:1297:22: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:1297:27: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); self._adaptor.addChild(root_1, stream_STRING.nextNode()) self._adaptor.addChild(root_0, root_1) stream_cif.reset(); stream_STRING.reset(); stream_COMMENT.reset(); stream_hyperlink.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, 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 "end" class cif_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.cif_return, self).__init__() self.tree = None # $ANTLR start "cif" # sdl92.g:1301:1: cif : cif_decl symbolname L_PAREN x= INT COMMA y= INT R_PAREN COMMA L_PAREN width= INT COMMA height= INT R_PAREN cif_end -> ^( CIF $x $y $width $height) ; def cif(self, ): retval = self.cif_return() retval.start = self.input.LT(1) root_0 = None x = None y = None width = None height = None L_PAREN679 = None COMMA680 = None R_PAREN681 = None COMMA682 = None L_PAREN683 = None COMMA684 = None R_PAREN685 = None cif_decl677 = None symbolname678 = None cif_end686 = None x_tree = None y_tree = None width_tree = None height_tree = None L_PAREN679_tree = None COMMA680_tree = None R_PAREN681_tree = None COMMA682_tree = None L_PAREN683_tree = None COMMA684_tree = None R_PAREN685_tree = None stream_INT = RewriteRuleTokenStream(self._adaptor, "token INT") stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_symbolname = RewriteRuleSubtreeStream(self._adaptor, "rule symbolname") stream_cif_end = RewriteRuleSubtreeStream(self._adaptor, "rule cif_end") stream_cif_decl = RewriteRuleSubtreeStream(self._adaptor, "rule cif_decl") try: try: # sdl92.g:1302:9: ( cif_decl symbolname L_PAREN x= INT COMMA y= INT R_PAREN COMMA L_PAREN width= INT COMMA height= INT R_PAREN cif_end -> ^( CIF $x $y $width $height) ) # sdl92.g:1302:17: cif_decl symbolname L_PAREN x= INT COMMA y= INT R_PAREN COMMA L_PAREN width= INT COMMA height= INT R_PAREN cif_end pass self._state.following.append(self.FOLLOW_cif_decl_in_cif14549) cif_decl677 = self.cif_decl() self._state.following.pop() if self._state.backtracking == 0: stream_cif_decl.add(cif_decl677.tree) self._state.following.append(self.FOLLOW_symbolname_in_cif14551) symbolname678 = self.symbolname() self._state.following.pop() if self._state.backtracking == 0: stream_symbolname.add(symbolname678.tree) L_PAREN679=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_cif14569) if self._state.backtracking == 0: stream_L_PAREN.add(L_PAREN679) x=self.match(self.input, INT, self.FOLLOW_INT_in_cif14573) if self._state.backtracking == 0: stream_INT.add(x) COMMA680=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_cif14575) if self._state.backtracking == 0: stream_COMMA.add(COMMA680) y=self.match(self.input, INT, self.FOLLOW_INT_in_cif14579) if self._state.backtracking == 0: stream_INT.add(y) R_PAREN681=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_cif14581) if self._state.backtracking == 0: stream_R_PAREN.add(R_PAREN681) COMMA682=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_cif14599) if self._state.backtracking == 0: stream_COMMA.add(COMMA682) L_PAREN683=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_cif14617) if self._state.backtracking == 0: stream_L_PAREN.add(L_PAREN683) width=self.match(self.input, INT, self.FOLLOW_INT_in_cif14621) if self._state.backtracking == 0: stream_INT.add(width) COMMA684=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_cif14623) if self._state.backtracking == 0: stream_COMMA.add(COMMA684) height=self.match(self.input, INT, self.FOLLOW_INT_in_cif14627) if self._state.backtracking == 0: stream_INT.add(height) R_PAREN685=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_cif14629) if self._state.backtracking == 0: stream_R_PAREN.add(R_PAREN685) self._state.following.append(self.FOLLOW_cif_end_in_cif14647) cif_end686 = self.cif_end() self._state.following.pop() if self._state.backtracking == 0: stream_cif_end.add(cif_end686.tree) # AST Rewrite # elements: y, width, x, height # token labels: height, width, y, x # rule labels: retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 stream_height = RewriteRuleTokenStream(self._adaptor, "token height", height) stream_width = RewriteRuleTokenStream(self._adaptor, "token width", width) stream_y = RewriteRuleTokenStream(self._adaptor, "token y", y) stream_x = RewriteRuleTokenStream(self._adaptor, "token x", x) 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() # 1307:9: -> ^( CIF $x $y $width $height) # sdl92.g:1307:17: ^( CIF $x $y $width $height) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(CIF, "CIF"), root_1) self._adaptor.addChild(root_1, stream_x.nextNode()) self._adaptor.addChild(root_1, stream_y.nextNode()) self._adaptor.addChild(root_1, stream_width.nextNode()) self._adaptor.addChild(root_1, stream_height.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, 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 "cif" class hyperlink_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.hyperlink_return, self).__init__() self.tree = None # $ANTLR start "hyperlink" # sdl92.g:1311:1: hyperlink : cif_decl KEEP SPECIFIC GEODE HYPERLINK STRING cif_end -> ^( HYPERLINK STRING ) ; def hyperlink(self, ): retval = self.hyperlink_return() retval.start = self.input.LT(1) root_0 = None KEEP688 = None SPECIFIC689 = None GEODE690 = None HYPERLINK691 = None STRING692 = None cif_decl687 = None cif_end693 = None KEEP688_tree = None SPECIFIC689_tree = None GEODE690_tree = None HYPERLINK691_tree = None STRING692_tree = None stream_SPECIFIC = RewriteRuleTokenStream(self._adaptor, "token SPECIFIC") stream_KEEP = RewriteRuleTokenStream(self._adaptor, "token KEEP") stream_HYPERLINK = RewriteRuleTokenStream(self._adaptor, "token HYPERLINK") stream_GEODE = RewriteRuleTokenStream(self._adaptor, "token GEODE") stream_STRING = RewriteRuleTokenStream(self._adaptor, "token STRING") stream_cif_end = RewriteRuleSubtreeStream(self._adaptor, "rule cif_end") stream_cif_decl = RewriteRuleSubtreeStream(self._adaptor, "rule cif_decl") try: try: # sdl92.g:1312:9: ( cif_decl KEEP SPECIFIC GEODE HYPERLINK STRING cif_end -> ^( HYPERLINK STRING ) ) # sdl92.g:1312:17: cif_decl KEEP SPECIFIC GEODE HYPERLINK STRING cif_end pass self._state.following.append(self.FOLLOW_cif_decl_in_hyperlink14710) cif_decl687 = self.cif_decl() self._state.following.pop() if self._state.backtracking == 0: stream_cif_decl.add(cif_decl687.tree) KEEP688=self.match(self.input, KEEP, self.FOLLOW_KEEP_in_hyperlink14712) if self._state.backtracking == 0: stream_KEEP.add(KEEP688) SPECIFIC689=self.match(self.input, SPECIFIC, self.FOLLOW_SPECIFIC_in_hyperlink14714) if self._state.backtracking == 0: stream_SPECIFIC.add(SPECIFIC689) GEODE690=self.match(self.input, GEODE, self.FOLLOW_GEODE_in_hyperlink14716) if self._state.backtracking == 0: stream_GEODE.add(GEODE690) HYPERLINK691=self.match(self.input, HYPERLINK, self.FOLLOW_HYPERLINK_in_hyperlink14718) if self._state.backtracking == 0: stream_HYPERLINK.add(HYPERLINK691) STRING692=self.match(self.input, STRING, self.FOLLOW_STRING_in_hyperlink14720) if self._state.backtracking == 0: stream_STRING.add(STRING692) self._state.following.append(self.FOLLOW_cif_end_in_hyperlink14738) cif_end693 = self.cif_end() self._state.following.pop() if self._state.backtracking == 0: stream_cif_end.add(cif_end693.tree) # AST Rewrite # elements: STRING, HYPERLINK # 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() # 1314:9: -> ^( HYPERLINK STRING ) # sdl92.g:1314:17: ^( HYPERLINK STRING ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_HYPERLINK.nextNode(), root_1) self._adaptor.addChild(root_1, stream_STRING.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, 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 "hyperlink" class paramnames_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.paramnames_return, self).__init__() self.tree = None # $ANTLR start "paramnames" # sdl92.g:1324:1: paramnames : cif_decl KEEP SPECIFIC GEODE PARAMNAMES ( field_name )+ cif_end -> ^( PARAMNAMES ( field_name )+ ) ; def paramnames(self, ): retval = self.paramnames_return() retval.start = self.input.LT(1) root_0 = None KEEP695 = None SPECIFIC696 = None GEODE697 = None PARAMNAMES698 = None cif_decl694 = None field_name699 = None cif_end700 = None KEEP695_tree = None SPECIFIC696_tree = None GEODE697_tree = None PARAMNAMES698_tree = None stream_SPECIFIC = RewriteRuleTokenStream(self._adaptor, "token SPECIFIC") stream_PARAMNAMES = RewriteRuleTokenStream(self._adaptor, "token PARAMNAMES") stream_KEEP = RewriteRuleTokenStream(self._adaptor, "token KEEP") stream_GEODE = RewriteRuleTokenStream(self._adaptor, "token GEODE") stream_field_name = RewriteRuleSubtreeStream(self._adaptor, "rule field_name") stream_cif_end = RewriteRuleSubtreeStream(self._adaptor, "rule cif_end") stream_cif_decl = RewriteRuleSubtreeStream(self._adaptor, "rule cif_decl") try: try: # sdl92.g:1325:9: ( cif_decl KEEP SPECIFIC GEODE PARAMNAMES ( field_name )+ cif_end -> ^( PARAMNAMES ( field_name )+ ) ) # sdl92.g:1325:17: cif_decl KEEP SPECIFIC GEODE PARAMNAMES ( field_name )+ cif_end pass self._state.following.append(self.FOLLOW_cif_decl_in_paramnames14792) cif_decl694 = self.cif_decl() self._state.following.pop() if self._state.backtracking == 0: stream_cif_decl.add(cif_decl694.tree) KEEP695=self.match(self.input, KEEP, self.FOLLOW_KEEP_in_paramnames14794) if self._state.backtracking == 0: stream_KEEP.add(KEEP695) SPECIFIC696=self.match(self.input, SPECIFIC, self.FOLLOW_SPECIFIC_in_paramnames14796) if self._state.backtracking == 0: stream_SPECIFIC.add(SPECIFIC696) GEODE697=self.match(self.input, GEODE, self.FOLLOW_GEODE_in_paramnames14798) if self._state.backtracking == 0: stream_GEODE.add(GEODE697) PARAMNAMES698=self.match(self.input, PARAMNAMES, self.FOLLOW_PARAMNAMES_in_paramnames14800) if self._state.backtracking == 0: stream_PARAMNAMES.add(PARAMNAMES698) # sdl92.g:1325:57: ( field_name )+ cnt206 = 0 while True: #loop206 alt206 = 2 LA206_0 = self.input.LA(1) if (LA206_0 == ID) : alt206 = 1 if alt206 == 1: # sdl92.g:0:0: field_name pass self._state.following.append(self.FOLLOW_field_name_in_paramnames14802) field_name699 = self.field_name() self._state.following.pop() if self._state.backtracking == 0: stream_field_name.add(field_name699.tree) else: if cnt206 >= 1: break #loop206 if self._state.backtracking > 0: raise BacktrackingFailed eee = EarlyExitException(206, self.input) raise eee cnt206 += 1 self._state.following.append(self.FOLLOW_cif_end_in_paramnames14805) cif_end700 = self.cif_end() self._state.following.pop() if self._state.backtracking == 0: stream_cif_end.add(cif_end700.tree) # AST Rewrite # elements: field_name, PARAMNAMES # 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() # 1326:9: -> ^( PARAMNAMES ( field_name )+ ) # sdl92.g:1326:17: ^( PARAMNAMES ( field_name )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_PARAMNAMES.nextNode(), root_1) # sdl92.g:1326:30: ( field_name )+ if not (stream_field_name.hasNext()): raise RewriteEarlyExitException() while stream_field_name.hasNext(): self._adaptor.addChild(root_1, stream_field_name.nextTree()) stream_field_name.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, 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 "paramnames" class use_asn1_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.use_asn1_return, self).__init__() self.tree = None # $ANTLR start "use_asn1" # sdl92.g:1334:1: use_asn1 : cif_decl KEEP SPECIFIC GEODE ASNFILENAME STRING cif_end -> ^( ASN1 STRING ) ; def use_asn1(self, ): retval = self.use_asn1_return() retval.start = self.input.LT(1) root_0 = None KEEP702 = None SPECIFIC703 = None GEODE704 = None ASNFILENAME705 = None STRING706 = None cif_decl701 = None cif_end707 = None KEEP702_tree = None SPECIFIC703_tree = None GEODE704_tree = None ASNFILENAME705_tree = None STRING706_tree = None stream_ASNFILENAME = RewriteRuleTokenStream(self._adaptor, "token ASNFILENAME") stream_SPECIFIC = RewriteRuleTokenStream(self._adaptor, "token SPECIFIC") stream_KEEP = RewriteRuleTokenStream(self._adaptor, "token KEEP") stream_GEODE = RewriteRuleTokenStream(self._adaptor, "token GEODE") stream_STRING = RewriteRuleTokenStream(self._adaptor, "token STRING") stream_cif_end = RewriteRuleSubtreeStream(self._adaptor, "rule cif_end") stream_cif_decl = RewriteRuleSubtreeStream(self._adaptor, "rule cif_decl") try: try: # sdl92.g:1335:9: ( cif_decl KEEP SPECIFIC GEODE ASNFILENAME STRING cif_end -> ^( ASN1 STRING ) ) # sdl92.g:1335:17: cif_decl KEEP SPECIFIC GEODE ASNFILENAME STRING cif_end pass self._state.following.append(self.FOLLOW_cif_decl_in_use_asn114861) cif_decl701 = self.cif_decl() self._state.following.pop() if self._state.backtracking == 0: stream_cif_decl.add(cif_decl701.tree) KEEP702=self.match(self.input, KEEP, self.FOLLOW_KEEP_in_use_asn114863) if self._state.backtracking == 0: stream_KEEP.add(KEEP702) SPECIFIC703=self.match(self.input, SPECIFIC, self.FOLLOW_SPECIFIC_in_use_asn114865) if self._state.backtracking == 0: stream_SPECIFIC.add(SPECIFIC703) GEODE704=self.match(self.input, GEODE, self.FOLLOW_GEODE_in_use_asn114867) if self._state.backtracking == 0: stream_GEODE.add(GEODE704) ASNFILENAME705=self.match(self.input, ASNFILENAME, self.FOLLOW_ASNFILENAME_in_use_asn114869) if self._state.backtracking == 0: stream_ASNFILENAME.add(ASNFILENAME705) STRING706=self.match(self.input, STRING, self.FOLLOW_STRING_in_use_asn114871) if self._state.backtracking == 0: stream_STRING.add(STRING706) self._state.following.append(self.FOLLOW_cif_end_in_use_asn114873) cif_end707 = self.cif_end() self._state.following.pop() if self._state.backtracking == 0: stream_cif_end.add(cif_end707.tree) # AST Rewrite # elements: STRING # 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() # 1336:9: -> ^( ASN1 STRING ) # sdl92.g:1336:17: ^( ASN1 STRING ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(ASN1, "ASN1"), root_1) self._adaptor.addChild(root_1, stream_STRING.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, 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 "use_asn1" class stop_if_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.stop_if_return, self).__init__() self.tree = None # $ANTLR start "stop_if" # sdl92.g:1342:1: stop_if : ( STOP IF expression end )+ -> ^( STOPIF ( expression )+ ) ; def stop_if(self, ): retval = self.stop_if_return() retval.start = self.input.LT(1) root_0 = None STOP708 = None IF709 = None expression710 = None end711 = None STOP708_tree = None IF709_tree = None stream_STOP = RewriteRuleTokenStream(self._adaptor, "token STOP") stream_IF = RewriteRuleTokenStream(self._adaptor, "token IF") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:1343:9: ( ( STOP IF expression end )+ -> ^( STOPIF ( expression )+ ) ) # sdl92.g:1343:17: ( STOP IF expression end )+ pass # sdl92.g:1343:17: ( STOP IF expression end )+ cnt207 = 0 while True: #loop207 alt207 = 2 LA207_0 = self.input.LA(1) if (LA207_0 == STOP) : alt207 = 1 if alt207 == 1: # sdl92.g:1343:18: STOP IF expression end pass STOP708=self.match(self.input, STOP, self.FOLLOW_STOP_in_stop_if14929) if self._state.backtracking == 0: stream_STOP.add(STOP708) IF709=self.match(self.input, IF, self.FOLLOW_IF_in_stop_if14931) if self._state.backtracking == 0: stream_IF.add(IF709) self._state.following.append(self.FOLLOW_expression_in_stop_if14933) expression710 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression710.tree) self._state.following.append(self.FOLLOW_end_in_stop_if14935) end711 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end711.tree) else: if cnt207 >= 1: break #loop207 if self._state.backtracking > 0: raise BacktrackingFailed eee = EarlyExitException(207, self.input) raise eee cnt207 += 1 # AST Rewrite # elements: expression # 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() # 1344:9: -> ^( STOPIF ( expression )+ ) # sdl92.g:1344:17: ^( STOPIF ( expression )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(STOPIF, "STOPIF"), root_1) # sdl92.g:1344:26: ( expression )+ if not (stream_expression.hasNext()): raise RewriteEarlyExitException() while stream_expression.hasNext(): self._adaptor.addChild(root_1, stream_expression.nextTree()) stream_expression.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, 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 "stop_if" class symbolname_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.symbolname_return, self).__init__() self.tree = None # $ANTLR start "symbolname" # sdl92.g:1348:1: symbolname : ( START | INPUT | OUTPUT | STATE | PROCEDURE | PROCESS | PROCEDURE_CALL | STOP | RETURN | DECISION | TEXT | TASK | NEXTSTATE | ANSWER | PROVIDED | COMMENT | LABEL | JOIN | CONNECT ); def symbolname(self, ): retval = self.symbolname_return() retval.start = self.input.LT(1) root_0 = None set712 = None set712_tree = None try: try: # sdl92.g:1349:9: ( START | INPUT | OUTPUT | STATE | PROCEDURE | PROCESS | PROCEDURE_CALL | STOP | RETURN | DECISION | TEXT | TASK | NEXTSTATE | ANSWER | PROVIDED | COMMENT | LABEL | JOIN | CONNECT ) # sdl92.g: pass root_0 = self._adaptor.nil() set712 = self.input.LT(1) if self.input.LA(1) == ANSWER or self.input.LA(1) == COMMENT or self.input.LA(1) == CONNECT or self.input.LA(1) == DECISION or self.input.LA(1) == INPUT or (JOIN <= self.input.LA(1) <= LABEL) or self.input.LA(1) == NEXTSTATE or self.input.LA(1) == OUTPUT or (PROCEDURE <= self.input.LA(1) <= PROCEDURE_CALL) or (PROCESS <= self.input.LA(1) <= PROVIDED) or self.input.LA(1) == RETURN or self.input.LA(1) == STATE or self.input.LA(1) == STOP or self.input.LA(1) == TASK or self.input.LA(1) == TEXT or self.input.LA(1) == START: self.input.consume() if self._state.backtracking == 0: self._adaptor.addChild(root_0, self._adaptor.createWithPayload(set712)) 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, 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 "symbolname" class cif_decl_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.cif_decl_return, self).__init__() self.tree = None # $ANTLR start "cif_decl" # sdl92.g:1371:1: cif_decl : '/* CIF' ; def cif_decl(self, ): retval = self.cif_decl_return() retval.start = self.input.LT(1) root_0 = None string_literal713 = None string_literal713_tree = None try: try: # sdl92.g:1372:9: ( '/* CIF' ) # sdl92.g:1372:17: '/* CIF' pass root_0 = self._adaptor.nil() string_literal713=self.match(self.input, 229, self.FOLLOW_229_in_cif_decl15383) if self._state.backtracking == 0: string_literal713_tree = self._adaptor.createWithPayload(string_literal713) self._adaptor.addChild(root_0, string_literal713_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, 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 "cif_decl" class cif_end_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.cif_end_return, self).__init__() self.tree = None # $ANTLR start "cif_end" # sdl92.g:1376:1: cif_end : '*/' ; def cif_end(self, ): retval = self.cif_end_return() retval.start = self.input.LT(1) root_0 = None string_literal714 = None string_literal714_tree = None try: try: # sdl92.g:1377:9: ( '*/' ) # sdl92.g:1377:17: '*/' pass root_0 = self._adaptor.nil() string_literal714=self.match(self.input, 230, self.FOLLOW_230_in_cif_end15415) if self._state.backtracking == 0: string_literal714_tree = self._adaptor.createWithPayload(string_literal714) self._adaptor.addChild(root_0, string_literal714_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, 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 "cif_end" class cif_end_text_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.cif_end_text_return, self).__init__() self.tree = None # $ANTLR start "cif_end_text" # sdl92.g:1381:1: cif_end_text : cif_decl ENDTEXT cif_end -> ^( ENDTEXT ) ; def cif_end_text(self, ): retval = self.cif_end_text_return() retval.start = self.input.LT(1) root_0 = None ENDTEXT716 = None cif_decl715 = None cif_end717 = None ENDTEXT716_tree = None stream_ENDTEXT = RewriteRuleTokenStream(self._adaptor, "token ENDTEXT") stream_cif_end = RewriteRuleSubtreeStream(self._adaptor, "rule cif_end") stream_cif_decl = RewriteRuleSubtreeStream(self._adaptor, "rule cif_decl") try: try: # sdl92.g:1382:9: ( cif_decl ENDTEXT cif_end -> ^( ENDTEXT ) ) # sdl92.g:1382:17: cif_decl ENDTEXT cif_end pass self._state.following.append(self.FOLLOW_cif_decl_in_cif_end_text15447) cif_decl715 = self.cif_decl() self._state.following.pop() if self._state.backtracking == 0: stream_cif_decl.add(cif_decl715.tree) ENDTEXT716=self.match(self.input, ENDTEXT, self.FOLLOW_ENDTEXT_in_cif_end_text15449) if self._state.backtracking == 0: stream_ENDTEXT.add(ENDTEXT716) self._state.following.append(self.FOLLOW_cif_end_in_cif_end_text15451) cif_end717 = self.cif_end() self._state.following.pop() if self._state.backtracking == 0: stream_cif_end.add(cif_end717.tree) # AST Rewrite # elements: ENDTEXT # 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() # 1383:9: -> ^( ENDTEXT ) # sdl92.g:1383:17: ^( ENDTEXT ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_ENDTEXT.nextNode(), root_1) 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, 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 "cif_end_text" class cif_end_label_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.cif_end_label_return, self).__init__() self.tree = None # $ANTLR start "cif_end_label" # sdl92.g:1387:1: cif_end_label : cif_decl END LABEL cif_end ; def cif_end_label(self, ): retval = self.cif_end_label_return() retval.start = self.input.LT(1) root_0 = None END719 = None LABEL720 = None cif_decl718 = None cif_end721 = None END719_tree = None LABEL720_tree = None try: try: # sdl92.g:1388:9: ( cif_decl END LABEL cif_end ) # sdl92.g:1388:17: cif_decl END LABEL cif_end pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_cif_decl_in_cif_end_label15502) cif_decl718 = self.cif_decl() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, cif_decl718.tree) END719=self.match(self.input, END, self.FOLLOW_END_in_cif_end_label15504) if self._state.backtracking == 0: END719_tree = self._adaptor.createWithPayload(END719) self._adaptor.addChild(root_0, END719_tree) LABEL720=self.match(self.input, LABEL, self.FOLLOW_LABEL_in_cif_end_label15506) if self._state.backtracking == 0: LABEL720_tree = self._adaptor.createWithPayload(LABEL720) self._adaptor.addChild(root_0, LABEL720_tree) self._state.following.append(self.FOLLOW_cif_end_in_cif_end_label15508) cif_end721 = self.cif_end() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, cif_end721.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, 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 "cif_end_label" class dash_nextstate_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.dash_nextstate_return, self).__init__() self.tree = None # $ANTLR start "dash_nextstate" # sdl92.g:1392:1: dash_nextstate : DASH ; def dash_nextstate(self, ): retval = self.dash_nextstate_return() retval.start = self.input.LT(1) root_0 = None DASH722 = None DASH722_tree = None try: try: # sdl92.g:1392:17: ( DASH ) # sdl92.g:1392:25: DASH pass root_0 = self._adaptor.nil() DASH722=self.match(self.input, DASH, self.FOLLOW_DASH_in_dash_nextstate15533) if self._state.backtracking == 0: DASH722_tree = self._adaptor.createWithPayload(DASH722) self._adaptor.addChild(root_0, DASH722_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, 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 "dash_nextstate" class connector_name_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.connector_name_return, self).__init__() self.tree = None # $ANTLR start "connector_name" # sdl92.g:1393:1: connector_name : ID ; def connector_name(self, ): retval = self.connector_name_return() retval.start = self.input.LT(1) root_0 = None ID723 = None ID723_tree = None try: try: # sdl92.g:1393:17: ( ID ) # sdl92.g:1393:25: ID pass root_0 = self._adaptor.nil() ID723=self.match(self.input, ID, self.FOLLOW_ID_in_connector_name15547) if self._state.backtracking == 0: ID723_tree = self._adaptor.createWithPayload(ID723) self._adaptor.addChild(root_0, ID723_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, 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 "connector_name" class signal_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.signal_id_return, self).__init__() self.tree = None # $ANTLR start "signal_id" # sdl92.g:1394:1: signal_id : ID ; def signal_id(self, ): retval = self.signal_id_return() retval.start = self.input.LT(1) root_0 = None ID724 = None ID724_tree = None try: try: # sdl92.g:1394:17: ( ID ) # sdl92.g:1394:25: ID pass root_0 = self._adaptor.nil() ID724=self.match(self.input, ID, self.FOLLOW_ID_in_signal_id15566) if self._state.backtracking == 0: ID724_tree = self._adaptor.createWithPayload(ID724) self._adaptor.addChild(root_0, ID724_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, 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 "signal_id" class statename_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.statename_return, self).__init__() self.tree = None # $ANTLR start "statename" # sdl92.g:1395:1: statename : ID ; def statename(self, ): retval = self.statename_return() retval.start = self.input.LT(1) root_0 = None ID725 = None ID725_tree = None try: try: # sdl92.g:1395:17: ( ID ) # sdl92.g:1395:25: ID pass root_0 = self._adaptor.nil() ID725=self.match(self.input, ID, self.FOLLOW_ID_in_statename15585) if self._state.backtracking == 0: ID725_tree = self._adaptor.createWithPayload(ID725) self._adaptor.addChild(root_0, ID725_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, 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 "statename" class state_exit_point_name_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.state_exit_point_name_return, self).__init__() self.tree = None # $ANTLR start "state_exit_point_name" # sdl92.g:1396:1: state_exit_point_name : ID ; def state_exit_point_name(self, ): retval = self.state_exit_point_name_return() retval.start = self.input.LT(1) root_0 = None ID726 = None ID726_tree = None try: try: # sdl92.g:1397:17: ( ID ) # sdl92.g:1397:25: ID pass root_0 = self._adaptor.nil() ID726=self.match(self.input, ID, self.FOLLOW_ID_in_state_exit_point_name15614) if self._state.backtracking == 0: ID726_tree = self._adaptor.createWithPayload(ID726) self._adaptor.addChild(root_0, ID726_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, 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 "state_exit_point_name" class state_entry_point_name_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.state_entry_point_name_return, self).__init__() self.tree = None # $ANTLR start "state_entry_point_name" # sdl92.g:1398:1: state_entry_point_name : ID ; def state_entry_point_name(self, ): retval = self.state_entry_point_name_return() retval.start = self.input.LT(1) root_0 = None ID727 = None ID727_tree = None try: try: # sdl92.g:1399:17: ( ID ) # sdl92.g:1399:25: ID pass root_0 = self._adaptor.nil() ID727=self.match(self.input, ID, self.FOLLOW_ID_in_state_entry_point_name15643) if self._state.backtracking == 0: ID727_tree = self._adaptor.createWithPayload(ID727) self._adaptor.addChild(root_0, ID727_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, 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 "state_entry_point_name" class variable_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.variable_id_return, self).__init__() self.tree = None # $ANTLR start "variable_id" # sdl92.g:1400:1: variable_id : ID ; def variable_id(self, ): retval = self.variable_id_return() retval.start = self.input.LT(1) root_0 = None ID728 = None ID728_tree = None try: try: # sdl92.g:1400:17: ( ID ) # sdl92.g:1400:25: ID pass root_0 = self._adaptor.nil() ID728=self.match(self.input, ID, self.FOLLOW_ID_in_variable_id15660) if self._state.backtracking == 0: ID728_tree = self._adaptor.createWithPayload(ID728) self._adaptor.addChild(root_0, ID728_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, 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 "variable_id" class literal_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.literal_id_return, self).__init__() self.tree = None # $ANTLR start "literal_id" # sdl92.g:1401:1: literal_id : ( ID | INT ); def literal_id(self, ): retval = self.literal_id_return() retval.start = self.input.LT(1) root_0 = None set729 = None set729_tree = None try: try: # sdl92.g:1401:17: ( ID | INT ) # sdl92.g: pass root_0 = self._adaptor.nil() set729 = self.input.LT(1) if self.input.LA(1) == ID or self.input.LA(1) == INT: self.input.consume() if self._state.backtracking == 0: self._adaptor.addChild(root_0, self._adaptor.createWithPayload(set729)) 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, 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 "literal_id" class process_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.process_id_return, self).__init__() self.tree = None # $ANTLR start "process_id" # sdl92.g:1402:1: process_id : ID ; def process_id(self, ): retval = self.process_id_return() retval.start = self.input.LT(1) root_0 = None ID730 = None ID730_tree = None try: try: # sdl92.g:1402:17: ( ID ) # sdl92.g:1402:25: ID pass root_0 = self._adaptor.nil() ID730=self.match(self.input, ID, self.FOLLOW_ID_in_process_id15700) if self._state.backtracking == 0: ID730_tree = self._adaptor.createWithPayload(ID730) self._adaptor.addChild(root_0, ID730_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, 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 "process_id" class system_name_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.system_name_return, self).__init__() self.tree = None # $ANTLR start "system_name" # sdl92.g:1403:1: system_name : ID ; def system_name(self, ): retval = self.system_name_return() retval.start = self.input.LT(1) root_0 = None ID731 = None ID731_tree = None try: try: # sdl92.g:1403:17: ( ID ) # sdl92.g:1403:25: ID pass root_0 = self._adaptor.nil() ID731=self.match(self.input, ID, self.FOLLOW_ID_in_system_name15717) if self._state.backtracking == 0: ID731_tree = self._adaptor.createWithPayload(ID731) self._adaptor.addChild(root_0, ID731_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, 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 "system_name" class package_name_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.package_name_return, self).__init__() self.tree = None # $ANTLR start "package_name" # sdl92.g:1404:1: package_name : ID ; def package_name(self, ): retval = self.package_name_return() retval.start = self.input.LT(1) root_0 = None ID732 = None ID732_tree = None try: try: # sdl92.g:1404:17: ( ID ) # sdl92.g:1404:25: ID pass root_0 = self._adaptor.nil() ID732=self.match(self.input, ID, self.FOLLOW_ID_in_package_name15733) if self._state.backtracking == 0: ID732_tree = self._adaptor.createWithPayload(ID732) self._adaptor.addChild(root_0, ID732_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, 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 "package_name" class priority_signal_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.priority_signal_id_return, self).__init__() self.tree = None # $ANTLR start "priority_signal_id" # sdl92.g:1405:1: priority_signal_id : ID ; def priority_signal_id(self, ): retval = self.priority_signal_id_return() retval.start = self.input.LT(1) root_0 = None ID733 = None ID733_tree = None try: try: # sdl92.g:1406:17: ( ID ) # sdl92.g:1406:25: ID pass root_0 = self._adaptor.nil() ID733=self.match(self.input, ID, self.FOLLOW_ID_in_priority_signal_id15762) if self._state.backtracking == 0: ID733_tree = self._adaptor.createWithPayload(ID733) self._adaptor.addChild(root_0, ID733_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, 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 "priority_signal_id" class signal_list_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.signal_list_id_return, self).__init__() self.tree = None # $ANTLR start "signal_list_id" # sdl92.g:1407:1: signal_list_id : ID ; def signal_list_id(self, ): retval = self.signal_list_id_return() retval.start = self.input.LT(1) root_0 = None ID734 = None ID734_tree = None try: try: # sdl92.g:1407:17: ( ID ) # sdl92.g:1407:25: ID pass root_0 = self._adaptor.nil() ID734=self.match(self.input, ID, self.FOLLOW_ID_in_signal_list_id15776) if self._state.backtracking == 0: ID734_tree = self._adaptor.createWithPayload(ID734) self._adaptor.addChild(root_0, ID734_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, 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 "signal_list_id" class timer_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.timer_id_return, self).__init__() self.tree = None # $ANTLR start "timer_id" # sdl92.g:1408:1: timer_id : ID ; def timer_id(self, ): retval = self.timer_id_return() retval.start = self.input.LT(1) root_0 = None ID735 = None ID735_tree = None try: try: # sdl92.g:1408:17: ( ID ) # sdl92.g:1408:25: ID pass root_0 = self._adaptor.nil() ID735=self.match(self.input, ID, self.FOLLOW_ID_in_timer_id15796) if self._state.backtracking == 0: ID735_tree = self._adaptor.createWithPayload(ID735) self._adaptor.addChild(root_0, ID735_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, 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 "timer_id" class field_name_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.field_name_return, self).__init__() self.tree = None # $ANTLR start "field_name" # sdl92.g:1409:1: field_name : ID ; def field_name(self, ): retval = self.field_name_return() retval.start = self.input.LT(1) root_0 = None ID736 = None ID736_tree = None try: try: # sdl92.g:1409:17: ( ID ) # sdl92.g:1409:25: ID pass root_0 = self._adaptor.nil() ID736=self.match(self.input, ID, self.FOLLOW_ID_in_field_name15814) if self._state.backtracking == 0: ID736_tree = self._adaptor.createWithPayload(ID736) self._adaptor.addChild(root_0, ID736_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, 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 "field_name" class signal_route_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.signal_route_id_return, self).__init__() self.tree = None # $ANTLR start "signal_route_id" # sdl92.g:1410:1: signal_route_id : ID ; def signal_route_id(self, ): retval = self.signal_route_id_return() retval.start = self.input.LT(1) root_0 = None ID737 = None ID737_tree = None try: try: # sdl92.g:1410:17: ( ID ) # sdl92.g:1410:25: ID pass root_0 = self._adaptor.nil() ID737=self.match(self.input, ID, self.FOLLOW_ID_in_signal_route_id15827) if self._state.backtracking == 0: ID737_tree = self._adaptor.createWithPayload(ID737) self._adaptor.addChild(root_0, ID737_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, 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 "signal_route_id" class channel_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.channel_id_return, self).__init__() self.tree = None # $ANTLR start "channel_id" # sdl92.g:1411:1: channel_id : ID ; def channel_id(self, ): retval = self.channel_id_return() retval.start = self.input.LT(1) root_0 = None ID738 = None ID738_tree = None try: try: # sdl92.g:1411:17: ( ID ) # sdl92.g:1411:25: ID pass root_0 = self._adaptor.nil() ID738=self.match(self.input, ID, self.FOLLOW_ID_in_channel_id15845) if self._state.backtracking == 0: ID738_tree = self._adaptor.createWithPayload(ID738) self._adaptor.addChild(root_0, ID738_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, 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 "channel_id" class route_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.route_id_return, self).__init__() self.tree = None # $ANTLR start "route_id" # sdl92.g:1412:1: route_id : ID ; def route_id(self, ): retval = self.route_id_return() retval.start = self.input.LT(1) root_0 = None ID739 = None ID739_tree = None try: try: # sdl92.g:1412:17: ( ID ) # sdl92.g:1412:25: ID pass root_0 = self._adaptor.nil() ID739=self.match(self.input, ID, self.FOLLOW_ID_in_route_id15865) if self._state.backtracking == 0: ID739_tree = self._adaptor.createWithPayload(ID739) self._adaptor.addChild(root_0, ID739_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, 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 "route_id" class block_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.block_id_return, self).__init__() self.tree = None # $ANTLR start "block_id" # sdl92.g:1413:1: block_id : ID ; def block_id(self, ): retval = self.block_id_return() retval.start = self.input.LT(1) root_0 = None ID740 = None ID740_tree = None try: try: # sdl92.g:1413:17: ( ID ) # sdl92.g:1413:25: ID pass root_0 = self._adaptor.nil() ID740=self.match(self.input, ID, self.FOLLOW_ID_in_block_id15885) if self._state.backtracking == 0: ID740_tree = self._adaptor.createWithPayload(ID740) self._adaptor.addChild(root_0, ID740_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, 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 "block_id" class source_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.source_id_return, self).__init__() self.tree = None # $ANTLR start "source_id" # sdl92.g:1414:1: source_id : ID ; def source_id(self, ): retval = self.source_id_return() retval.start = self.input.LT(1) root_0 = None ID741 = None ID741_tree = None try: try: # sdl92.g:1414:17: ( ID ) # sdl92.g:1414:25: ID pass root_0 = self._adaptor.nil() ID741=self.match(self.input, ID, self.FOLLOW_ID_in_source_id15904) if self._state.backtracking == 0: ID741_tree = self._adaptor.createWithPayload(ID741) self._adaptor.addChild(root_0, ID741_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, 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 "source_id" class dest_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.dest_id_return, self).__init__() self.tree = None # $ANTLR start "dest_id" # sdl92.g:1415:1: dest_id : ID ; def dest_id(self, ): retval = self.dest_id_return() retval.start = self.input.LT(1) root_0 = None ID742 = None ID742_tree = None try: try: # sdl92.g:1415:17: ( ID ) # sdl92.g:1415:25: ID pass root_0 = self._adaptor.nil() ID742=self.match(self.input, ID, self.FOLLOW_ID_in_dest_id15925) if self._state.backtracking == 0: ID742_tree = self._adaptor.createWithPayload(ID742) self._adaptor.addChild(root_0, ID742_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, 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 "dest_id" class gate_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.gate_id_return, self).__init__() self.tree = None # $ANTLR start "gate_id" # sdl92.g:1416:1: gate_id : ID ; def gate_id(self, ): retval = self.gate_id_return() retval.start = self.input.LT(1) root_0 = None ID743 = None ID743_tree = None try: try: # sdl92.g:1416:17: ( ID ) # sdl92.g:1416:25: ID pass root_0 = self._adaptor.nil() ID743=self.match(self.input, ID, self.FOLLOW_ID_in_gate_id15946) if self._state.backtracking == 0: ID743_tree = self._adaptor.createWithPayload(ID743) self._adaptor.addChild(root_0, ID743_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, 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 "gate_id" class procedure_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.procedure_id_return, self).__init__() self.tree = None # $ANTLR start "procedure_id" # sdl92.g:1417:1: procedure_id : ID ; def procedure_id(self, ): retval = self.procedure_id_return() retval.start = self.input.LT(1) root_0 = None ID744 = None ID744_tree = None try: try: # sdl92.g:1417:17: ( ID ) # sdl92.g:1417:25: ID pass root_0 = self._adaptor.nil() ID744=self.match(self.input, ID, self.FOLLOW_ID_in_procedure_id15962) if self._state.backtracking == 0: ID744_tree = self._adaptor.createWithPayload(ID744) self._adaptor.addChild(root_0, ID744_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, 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 "procedure_id" class remote_procedure_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.remote_procedure_id_return, self).__init__() self.tree = None # $ANTLR start "remote_procedure_id" # sdl92.g:1418:1: remote_procedure_id : ID ; def remote_procedure_id(self, ): retval = self.remote_procedure_id_return() retval.start = self.input.LT(1) root_0 = None ID745 = None ID745_tree = None try: try: # sdl92.g:1419:17: ( ID ) # sdl92.g:1419:25: ID pass root_0 = self._adaptor.nil() ID745=self.match(self.input, ID, self.FOLLOW_ID_in_remote_procedure_id15991) if self._state.backtracking == 0: ID745_tree = self._adaptor.createWithPayload(ID745) self._adaptor.addChild(root_0, ID745_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, 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 "remote_procedure_id" class operator_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.operator_id_return, self).__init__() self.tree = None # $ANTLR start "operator_id" # sdl92.g:1420:1: operator_id : ID ; def operator_id(self, ): retval = self.operator_id_return() retval.start = self.input.LT(1) root_0 = None ID746 = None ID746_tree = None try: try: # sdl92.g:1420:17: ( ID ) # sdl92.g:1420:25: ID pass root_0 = self._adaptor.nil() ID746=self.match(self.input, ID, self.FOLLOW_ID_in_operator_id16008) if self._state.backtracking == 0: ID746_tree = self._adaptor.createWithPayload(ID746) self._adaptor.addChild(root_0, ID746_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, 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 "operator_id" class synonym_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.synonym_id_return, self).__init__() self.tree = None # $ANTLR start "synonym_id" # sdl92.g:1421:1: synonym_id : ID ; def synonym_id(self, ): retval = self.synonym_id_return() retval.start = self.input.LT(1) root_0 = None ID747 = None ID747_tree = None try: try: # sdl92.g:1421:17: ( ID ) # sdl92.g:1421:25: ID pass root_0 = self._adaptor.nil() ID747=self.match(self.input, ID, self.FOLLOW_ID_in_synonym_id16026) if self._state.backtracking == 0: ID747_tree = self._adaptor.createWithPayload(ID747) self._adaptor.addChild(root_0, ID747_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, 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 "synonym_id" class external_synonym_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.external_synonym_id_return, self).__init__() self.tree = None # $ANTLR start "external_synonym_id" # sdl92.g:1422:1: external_synonym_id : ID ; def external_synonym_id(self, ): retval = self.external_synonym_id_return() retval.start = self.input.LT(1) root_0 = None ID748 = None ID748_tree = None try: try: # sdl92.g:1423:17: ( ID ) # sdl92.g:1423:25: ID pass root_0 = self._adaptor.nil() ID748=self.match(self.input, ID, self.FOLLOW_ID_in_external_synonym_id16055) if self._state.backtracking == 0: ID748_tree = self._adaptor.createWithPayload(ID748) self._adaptor.addChild(root_0, ID748_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, 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 "external_synonym_id" class remote_variable_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.remote_variable_id_return, self).__init__() self.tree = None # $ANTLR start "remote_variable_id" # sdl92.g:1424:1: remote_variable_id : ID ; def remote_variable_id(self, ): retval = self.remote_variable_id_return() retval.start = self.input.LT(1) root_0 = None ID749 = None ID749_tree = None try: try: # sdl92.g:1425:17: ( ID ) # sdl92.g:1425:25: ID pass root_0 = self._adaptor.nil() ID749=self.match(self.input, ID, self.FOLLOW_ID_in_remote_variable_id16084) if self._state.backtracking == 0: ID749_tree = self._adaptor.createWithPayload(ID749) self._adaptor.addChild(root_0, ID749_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, 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 "remote_variable_id" class view_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.view_id_return, self).__init__() self.tree = None # $ANTLR start "view_id" # sdl92.g:1426:1: view_id : ID ; def view_id(self, ): retval = self.view_id_return() retval.start = self.input.LT(1) root_0 = None ID750 = None ID750_tree = None try: try: # sdl92.g:1426:17: ( ID ) # sdl92.g:1426:25: ID pass root_0 = self._adaptor.nil() ID750=self.match(self.input, ID, self.FOLLOW_ID_in_view_id16105) if self._state.backtracking == 0: ID750_tree = self._adaptor.createWithPayload(ID750) self._adaptor.addChild(root_0, ID750_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, 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 "view_id" class sort_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.sort_id_return, self).__init__() self.tree = None # $ANTLR start "sort_id" # sdl92.g:1427:1: sort_id : ID ; def sort_id(self, ): retval = self.sort_id_return() retval.start = self.input.LT(1) root_0 = None ID751 = None ID751_tree = None try: try: # sdl92.g:1427:17: ( ID ) # sdl92.g:1427:25: ID pass root_0 = self._adaptor.nil() ID751=self.match(self.input, ID, self.FOLLOW_ID_in_sort_id16126) if self._state.backtracking == 0: ID751_tree = self._adaptor.createWithPayload(ID751) self._adaptor.addChild(root_0, ID751_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, 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 "sort_id" class type_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.type_id_return, self).__init__() self.tree = None # $ANTLR start "type_id" # sdl92.g:1428:1: type_id : ID ; def type_id(self, ): retval = self.type_id_return() retval.start = self.input.LT(1) root_0 = None ID752 = None ID752_tree = None try: try: # sdl92.g:1428:17: ( ID ) # sdl92.g:1428:25: ID pass root_0 = self._adaptor.nil() ID752=self.match(self.input, ID, self.FOLLOW_ID_in_type_id16147) if self._state.backtracking == 0: ID752_tree = self._adaptor.createWithPayload(ID752) self._adaptor.addChild(root_0, ID752_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, 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 "type_id" class syntype_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.syntype_id_return, self).__init__() self.tree = None # $ANTLR start "syntype_id" # sdl92.g:1429:1: syntype_id : ID ; def syntype_id(self, ): retval = self.syntype_id_return() retval.start = self.input.LT(1) root_0 = None ID753 = None ID753_tree = None try: try: # sdl92.g:1429:17: ( ID ) # sdl92.g:1429:25: ID pass root_0 = self._adaptor.nil() ID753=self.match(self.input, ID, self.FOLLOW_ID_in_syntype_id16165) if self._state.backtracking == 0: ID753_tree = self._adaptor.createWithPayload(ID753) self._adaptor.addChild(root_0, ID753_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, 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 "syntype_id" class stimulus_id_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.stimulus_id_return, self).__init__() self.tree = None # $ANTLR start "stimulus_id" # sdl92.g:1430:1: stimulus_id : ID ; def stimulus_id(self, ): retval = self.stimulus_id_return() retval.start = self.input.LT(1) root_0 = None ID754 = None ID754_tree = None try: try: # sdl92.g:1430:17: ( ID ) # sdl92.g:1430:25: ID pass root_0 = self._adaptor.nil() ID754=self.match(self.input, ID, self.FOLLOW_ID_in_stimulus_id16182) if self._state.backtracking == 0: ID754_tree = self._adaptor.createWithPayload(ID754) self._adaptor.addChild(root_0, ID754_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, 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 "stimulus_id" class pid_expression_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.pid_expression_return, self).__init__() self.tree = None # $ANTLR start "pid_expression" # sdl92.g:1466:1: pid_expression : ( S E L F | P A R E N T | O F F S P R I N G | S E N D E R ); def pid_expression(self, ): retval = self.pid_expression_return() retval.start = self.input.LT(1) root_0 = None S755 = None E756 = None L757 = None F758 = None P759 = None A760 = None R761 = None E762 = None N763 = None T764 = None O765 = None F766 = None F767 = None S768 = None P769 = None R770 = None I771 = None N772 = None G773 = None S774 = None E775 = None N776 = None D777 = None E778 = None R779 = None S755_tree = None E756_tree = None L757_tree = None F758_tree = None P759_tree = None A760_tree = None R761_tree = None E762_tree = None N763_tree = None T764_tree = None O765_tree = None F766_tree = None F767_tree = None S768_tree = None P769_tree = None R770_tree = None I771_tree = None N772_tree = None G773_tree = None S774_tree = None E775_tree = None N776_tree = None D777_tree = None E778_tree = None R779_tree = None try: try: # sdl92.g:1467:17: ( S E L F | P A R E N T | O F F S P R I N G | S E N D E R ) alt208 = 4 LA208 = self.input.LA(1) if LA208 == S: LA208_1 = self.input.LA(2) if (LA208_1 == E) : LA208_4 = self.input.LA(3) if (LA208_4 == L) : alt208 = 1 elif (LA208_4 == N) : alt208 = 4 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 208, 4, self.input) raise nvae else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 208, 1, self.input) raise nvae elif LA208 == P: alt208 = 2 elif LA208 == O: alt208 = 3 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 208, 0, self.input) raise nvae if alt208 == 1: # sdl92.g:1467:25: S E L F pass root_0 = self._adaptor.nil() S755=self.match(self.input, S, self.FOLLOW_S_in_pid_expression17249) if self._state.backtracking == 0: S755_tree = self._adaptor.createWithPayload(S755) self._adaptor.addChild(root_0, S755_tree) E756=self.match(self.input, E, self.FOLLOW_E_in_pid_expression17251) if self._state.backtracking == 0: E756_tree = self._adaptor.createWithPayload(E756) self._adaptor.addChild(root_0, E756_tree) L757=self.match(self.input, L, self.FOLLOW_L_in_pid_expression17253) if self._state.backtracking == 0: L757_tree = self._adaptor.createWithPayload(L757) self._adaptor.addChild(root_0, L757_tree) F758=self.match(self.input, F, self.FOLLOW_F_in_pid_expression17255) if self._state.backtracking == 0: F758_tree = self._adaptor.createWithPayload(F758) self._adaptor.addChild(root_0, F758_tree) elif alt208 == 2: # sdl92.g:1468:25: P A R E N T pass root_0 = self._adaptor.nil() P759=self.match(self.input, P, self.FOLLOW_P_in_pid_expression17281) if self._state.backtracking == 0: P759_tree = self._adaptor.createWithPayload(P759) self._adaptor.addChild(root_0, P759_tree) A760=self.match(self.input, A, self.FOLLOW_A_in_pid_expression17283) if self._state.backtracking == 0: A760_tree = self._adaptor.createWithPayload(A760) self._adaptor.addChild(root_0, A760_tree) R761=self.match(self.input, R, self.FOLLOW_R_in_pid_expression17285) if self._state.backtracking == 0: R761_tree = self._adaptor.createWithPayload(R761) self._adaptor.addChild(root_0, R761_tree) E762=self.match(self.input, E, self.FOLLOW_E_in_pid_expression17287) if self._state.backtracking == 0: E762_tree = self._adaptor.createWithPayload(E762) self._adaptor.addChild(root_0, E762_tree) N763=self.match(self.input, N, self.FOLLOW_N_in_pid_expression17289) if self._state.backtracking == 0: N763_tree = self._adaptor.createWithPayload(N763) self._adaptor.addChild(root_0, N763_tree) T764=self.match(self.input, T, self.FOLLOW_T_in_pid_expression17291) if self._state.backtracking == 0: T764_tree = self._adaptor.createWithPayload(T764) self._adaptor.addChild(root_0, T764_tree) elif alt208 == 3: # sdl92.g:1469:25: O F F S P R I N G pass root_0 = self._adaptor.nil() O765=self.match(self.input, O, self.FOLLOW_O_in_pid_expression17317) if self._state.backtracking == 0: O765_tree = self._adaptor.createWithPayload(O765) self._adaptor.addChild(root_0, O765_tree) F766=self.match(self.input, F, self.FOLLOW_F_in_pid_expression17319) if self._state.backtracking == 0: F766_tree = self._adaptor.createWithPayload(F766) self._adaptor.addChild(root_0, F766_tree) F767=self.match(self.input, F, self.FOLLOW_F_in_pid_expression17321) if self._state.backtracking == 0: F767_tree = self._adaptor.createWithPayload(F767) self._adaptor.addChild(root_0, F767_tree) S768=self.match(self.input, S, self.FOLLOW_S_in_pid_expression17323) if self._state.backtracking == 0: S768_tree = self._adaptor.createWithPayload(S768) self._adaptor.addChild(root_0, S768_tree) P769=self.match(self.input, P, self.FOLLOW_P_in_pid_expression17325) if self._state.backtracking == 0: P769_tree = self._adaptor.createWithPayload(P769) self._adaptor.addChild(root_0, P769_tree) R770=self.match(self.input, R, self.FOLLOW_R_in_pid_expression17327) if self._state.backtracking == 0: R770_tree = self._adaptor.createWithPayload(R770) self._adaptor.addChild(root_0, R770_tree) I771=self.match(self.input, I, self.FOLLOW_I_in_pid_expression17329) if self._state.backtracking == 0: I771_tree = self._adaptor.createWithPayload(I771) self._adaptor.addChild(root_0, I771_tree) N772=self.match(self.input, N, self.FOLLOW_N_in_pid_expression17331) if self._state.backtracking == 0: N772_tree = self._adaptor.createWithPayload(N772) self._adaptor.addChild(root_0, N772_tree) G773=self.match(self.input, G, self.FOLLOW_G_in_pid_expression17333) if self._state.backtracking == 0: G773_tree = self._adaptor.createWithPayload(G773) self._adaptor.addChild(root_0, G773_tree) elif alt208 == 4: # sdl92.g:1470:25: S E N D E R pass root_0 = self._adaptor.nil() S774=self.match(self.input, S, self.FOLLOW_S_in_pid_expression17359) if self._state.backtracking == 0: S774_tree = self._adaptor.createWithPayload(S774) self._adaptor.addChild(root_0, S774_tree) E775=self.match(self.input, E, self.FOLLOW_E_in_pid_expression17361) if self._state.backtracking == 0: E775_tree = self._adaptor.createWithPayload(E775) self._adaptor.addChild(root_0, E775_tree) N776=self.match(self.input, N, self.FOLLOW_N_in_pid_expression17363) if self._state.backtracking == 0: N776_tree = self._adaptor.createWithPayload(N776) self._adaptor.addChild(root_0, N776_tree) D777=self.match(self.input, D, self.FOLLOW_D_in_pid_expression17365) if self._state.backtracking == 0: D777_tree = self._adaptor.createWithPayload(D777) self._adaptor.addChild(root_0, D777_tree) E778=self.match(self.input, E, self.FOLLOW_E_in_pid_expression17367) if self._state.backtracking == 0: E778_tree = self._adaptor.createWithPayload(E778) self._adaptor.addChild(root_0, E778_tree) R779=self.match(self.input, R, self.FOLLOW_R_in_pid_expression17369) if self._state.backtracking == 0: R779_tree = self._adaptor.createWithPayload(R779) self._adaptor.addChild(root_0, R779_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, 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 "pid_expression" class now_expression_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.now_expression_return, self).__init__() self.tree = None # $ANTLR start "now_expression" # sdl92.g:1471:1: now_expression : N O W ; def now_expression(self, ): retval = self.now_expression_return() retval.start = self.input.LT(1) root_0 = None N780 = None O781 = None W782 = None N780_tree = None O781_tree = None W782_tree = None try: try: # sdl92.g:1471:17: ( N O W ) # sdl92.g:1471:25: N O W pass root_0 = self._adaptor.nil() N780=self.match(self.input, N, self.FOLLOW_N_in_now_expression17383) if self._state.backtracking == 0: N780_tree = self._adaptor.createWithPayload(N780) self._adaptor.addChild(root_0, N780_tree) O781=self.match(self.input, O, self.FOLLOW_O_in_now_expression17385) if self._state.backtracking == 0: O781_tree = self._adaptor.createWithPayload(O781) self._adaptor.addChild(root_0, O781_tree) W782=self.match(self.input, W, self.FOLLOW_W_in_now_expression17387) if self._state.backtracking == 0: W782_tree = self._adaptor.createWithPayload(W782) self._adaptor.addChild(root_0, W782_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, 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 "now_expression" # $ANTLR start "synpred9_sdl92" def synpred9_sdl92_fragment(self, ): # sdl92.g:182:17: ( signal_declaration ) # sdl92.g:182:17: signal_declaration pass self._state.following.append(self.FOLLOW_signal_declaration_in_synpred9_sdl921720) self.signal_declaration() self._state.following.pop() # $ANTLR end "synpred9_sdl92" # $ANTLR start "synpred10_sdl92" def synpred10_sdl92_fragment(self, ): # sdl92.g:183:19: ( text_area ) # sdl92.g:183:19: text_area pass self._state.following.append(self.FOLLOW_text_area_in_synpred10_sdl921740) self.text_area() self._state.following.pop() # $ANTLR end "synpred10_sdl92" # $ANTLR start "synpred11_sdl92" def synpred11_sdl92_fragment(self, ): # sdl92.g:184:19: ( procedure ) # sdl92.g:184:19: procedure pass self._state.following.append(self.FOLLOW_procedure_in_synpred11_sdl921760) self.procedure() self._state.following.pop() # $ANTLR end "synpred11_sdl92" # $ANTLR start "synpred28_sdl92" def synpred28_sdl92_fragment(self, ): # sdl92.g:260:18: ( text_area ) # sdl92.g:260:18: text_area pass self._state.following.append(self.FOLLOW_text_area_in_synpred28_sdl922539) self.text_area() self._state.following.pop() # $ANTLR end "synpred28_sdl92" # $ANTLR start "synpred29_sdl92" def synpred29_sdl92_fragment(self, ): # sdl92.g:260:30: ( procedure ) # sdl92.g:260:30: procedure pass self._state.following.append(self.FOLLOW_procedure_in_synpred29_sdl922543) self.procedure() self._state.following.pop() # $ANTLR end "synpred29_sdl92" # $ANTLR start "synpred30_sdl92" def synpred30_sdl92_fragment(self, ): # sdl92.g:260:42: ( composite_state ) # sdl92.g:260:42: composite_state pass self._state.following.append(self.FOLLOW_composite_state_in_synpred30_sdl922547) self.composite_state() self._state.following.pop() # $ANTLR end "synpred30_sdl92" # $ANTLR start "synpred31_sdl92" def synpred31_sdl92_fragment(self, ): # sdl92.g:261:17: ( processBody ) # sdl92.g:261:17: processBody pass self._state.following.append(self.FOLLOW_processBody_in_synpred31_sdl922567) self.processBody() self._state.following.pop() # $ANTLR end "synpred31_sdl92" # $ANTLR start "synpred36_sdl92" def synpred36_sdl92_fragment(self, ): # sdl92.g:273:17: ( end ) # sdl92.g:273:17: end pass self._state.following.append(self.FOLLOW_end_in_synpred36_sdl922753) self.end() self._state.following.pop() # $ANTLR end "synpred36_sdl92" # $ANTLR start "synpred41_sdl92" def synpred41_sdl92_fragment(self, ): # sdl92.g:291:18: ( text_area ) # sdl92.g:291:18: text_area pass self._state.following.append(self.FOLLOW_text_area_in_synpred41_sdl922959) self.text_area() self._state.following.pop() # $ANTLR end "synpred41_sdl92" # $ANTLR start "synpred42_sdl92" def synpred42_sdl92_fragment(self, ): # sdl92.g:291:30: ( procedure ) # sdl92.g:291:30: procedure pass self._state.following.append(self.FOLLOW_procedure_in_synpred42_sdl922963) self.procedure() self._state.following.pop() # $ANTLR end "synpred42_sdl92" # $ANTLR start "synpred43_sdl92" def synpred43_sdl92_fragment(self, ): # sdl92.g:292:19: ( processBody ) # sdl92.g:292:19: processBody pass self._state.following.append(self.FOLLOW_processBody_in_synpred43_sdl922985) self.processBody() self._state.following.pop() # $ANTLR end "synpred43_sdl92" # $ANTLR start "synpred54_sdl92" def synpred54_sdl92_fragment(self, ): # sdl92.g:325:17: ( content ) # sdl92.g:325:17: content pass self._state.following.append(self.FOLLOW_content_in_synpred54_sdl923435) self.content() self._state.following.pop() # $ANTLR end "synpred54_sdl92" # $ANTLR start "synpred103_sdl92" def synpred103_sdl92_fragment(self, ): # sdl92.g:537:18: ( text_area ) # sdl92.g:537:18: text_area pass self._state.following.append(self.FOLLOW_text_area_in_synpred103_sdl926034) self.text_area() self._state.following.pop() # $ANTLR end "synpred103_sdl92" # $ANTLR start "synpred110_sdl92" def synpred110_sdl92_fragment(self, ): # sdl92.g:593:18: ( text_area ) # sdl92.g:593:18: text_area pass self._state.following.append(self.FOLLOW_text_area_in_synpred110_sdl926539) self.text_area() self._state.following.pop() # $ANTLR end "synpred110_sdl92" # $ANTLR start "synpred111_sdl92" def synpred111_sdl92_fragment(self, ): # sdl92.g:593:30: ( procedure ) # sdl92.g:593:30: procedure pass self._state.following.append(self.FOLLOW_procedure_in_synpred111_sdl926543) self.procedure() self._state.following.pop() # $ANTLR end "synpred111_sdl92" # $ANTLR start "synpred112_sdl92" def synpred112_sdl92_fragment(self, ): # sdl92.g:593:42: ( composite_state ) # sdl92.g:593:42: composite_state pass self._state.following.append(self.FOLLOW_composite_state_in_synpred112_sdl926547) self.composite_state() self._state.following.pop() # $ANTLR end "synpred112_sdl92" # $ANTLR start "synpred137_sdl92" def synpred137_sdl92_fragment(self, ): # sdl92.g:702:17: ( enabling_condition ) # sdl92.g:702:17: enabling_condition pass self._state.following.append(self.FOLLOW_enabling_condition_in_synpred137_sdl927618) self.enabling_condition() self._state.following.pop() # $ANTLR end "synpred137_sdl92" # $ANTLR start "synpred144_sdl92" def synpred144_sdl92_fragment(self, ): # sdl92.g:730:25: ( label ) # sdl92.g:730:25: label pass self._state.following.append(self.FOLLOW_label_in_synpred144_sdl927910) self.label() self._state.following.pop() # $ANTLR end "synpred144_sdl92" # $ANTLR start "synpred168_sdl92" def synpred168_sdl92_fragment(self, ): # sdl92.g:826:17: ( expression ) # sdl92.g:826:17: expression pass self._state.following.append(self.FOLLOW_expression_in_synpred168_sdl929029) self.expression() self._state.following.pop() # $ANTLR end "synpred168_sdl92" # $ANTLR start "synpred171_sdl92" def synpred171_sdl92_fragment(self, ): # sdl92.g:835:17: ( answer_part ) # sdl92.g:835:17: answer_part pass self._state.following.append(self.FOLLOW_answer_part_in_synpred171_sdl929143) self.answer_part() self._state.following.pop() # $ANTLR end "synpred171_sdl92" # $ANTLR start "synpred176_sdl92" def synpred176_sdl92_fragment(self, ): # sdl92.g:852:17: ( range_condition ) # sdl92.g:852:17: range_condition pass self._state.following.append(self.FOLLOW_range_condition_in_synpred176_sdl929379) self.range_condition() self._state.following.pop() # $ANTLR end "synpred176_sdl92" # $ANTLR start "synpred180_sdl92" def synpred180_sdl92_fragment(self, ): # sdl92.g:866:17: ( informal_text ) # sdl92.g:866:17: informal_text pass self._state.following.append(self.FOLLOW_informal_text_in_synpred180_sdl929534) self.informal_text() self._state.following.pop() # $ANTLR end "synpred180_sdl92" # $ANTLR start "synpred181_sdl92" def synpred181_sdl92_fragment(self, ): # sdl92.g:867:19: ( expression ) # sdl92.g:867:19: expression pass self._state.following.append(self.FOLLOW_expression_in_synpred181_sdl929554) self.expression() self._state.following.pop() # $ANTLR end "synpred181_sdl92" # $ANTLR start "synpred182_sdl92" def synpred182_sdl92_fragment(self, ): # sdl92.g:875:18: ( closed_range ) # sdl92.g:875:18: closed_range pass self._state.following.append(self.FOLLOW_closed_range_in_synpred182_sdl929647) self.closed_range() self._state.following.pop() # $ANTLR end "synpred182_sdl92" # $ANTLR start "synpred211_sdl92" def synpred211_sdl92_fragment(self, ): # sdl92.g:1008:18: ( COMMA b= ground_expression ) # sdl92.g:1008:18: COMMA b= ground_expression pass self.match(self.input, COMMA, self.FOLLOW_COMMA_in_synpred211_sdl9211177) self._state.following.append(self.FOLLOW_ground_expression_in_synpred211_sdl9211181) b = self.ground_expression() self._state.following.pop() # $ANTLR end "synpred211_sdl92" # $ANTLR start "synpred215_sdl92" def synpred215_sdl92_fragment(self, ): # sdl92.g:1032:39: ( IMPLIES binary_expression_0 ) # sdl92.g:1032:39: IMPLIES binary_expression_0 pass self.match(self.input, IMPLIES, self.FOLLOW_IMPLIES_in_synpred215_sdl9211441) self._state.following.append(self.FOLLOW_binary_expression_0_in_synpred215_sdl9211444) self.binary_expression_0() self._state.following.pop() # $ANTLR end "synpred215_sdl92" # $ANTLR start "synpred218_sdl92" def synpred218_sdl92_fragment(self, ): # sdl92.g:1034:38: ( ( ( OR ( ELSE )? ) | XOR ) binary_expression_1 ) # sdl92.g:1034:38: ( ( OR ( ELSE )? ) | XOR ) binary_expression_1 pass # sdl92.g:1034:38: ( ( OR ( ELSE )? ) | XOR ) alt223 = 2 LA223_0 = self.input.LA(1) if (LA223_0 == OR) : alt223 = 1 elif (LA223_0 == XOR) : alt223 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 223, 0, self.input) raise nvae if alt223 == 1: # sdl92.g:1034:40: ( OR ( ELSE )? ) pass # sdl92.g:1034:40: ( OR ( ELSE )? ) # sdl92.g:1034:41: OR ( ELSE )? pass self.match(self.input, OR, self.FOLLOW_OR_in_synpred218_sdl9211473) # sdl92.g:1034:45: ( ELSE )? alt222 = 2 LA222_0 = self.input.LA(1) if (LA222_0 == ELSE) : alt222 = 1 if alt222 == 1: # sdl92.g:0:0: ELSE pass self.match(self.input, ELSE, self.FOLLOW_ELSE_in_synpred218_sdl9211476) elif alt223 == 2: # sdl92.g:1034:54: XOR pass self.match(self.input, XOR, self.FOLLOW_XOR_in_synpred218_sdl9211482) self._state.following.append(self.FOLLOW_binary_expression_1_in_synpred218_sdl9211487) self.binary_expression_1() self._state.following.pop() # $ANTLR end "synpred218_sdl92" # $ANTLR start "synpred220_sdl92" def synpred220_sdl92_fragment(self, ): # sdl92.g:1036:39: ( AND ( THEN )? binary_expression_2 ) # sdl92.g:1036:39: AND ( THEN )? binary_expression_2 pass self.match(self.input, AND, self.FOLLOW_AND_in_synpred220_sdl9211514) # sdl92.g:1036:44: ( THEN )? alt224 = 2 LA224_0 = self.input.LA(1) if (LA224_0 == THEN) : alt224 = 1 if alt224 == 1: # sdl92.g:0:0: THEN pass self.match(self.input, THEN, self.FOLLOW_THEN_in_synpred220_sdl9211517) self._state.following.append(self.FOLLOW_binary_expression_2_in_synpred220_sdl9211520) self.binary_expression_2() self._state.following.pop() # $ANTLR end "synpred220_sdl92" # $ANTLR start "synpred227_sdl92" def synpred227_sdl92_fragment(self, ): # sdl92.g:1038:38: ( ( EQ | NEQ | GT | GE | LT | LE | IN ) binary_expression_3 ) # sdl92.g:1038:38: ( EQ | NEQ | GT | GE | LT | LE | IN ) binary_expression_3 pass if self.input.LA(1) == IN or (EQ <= self.input.LA(1) <= GE): self.input.consume() self._state.errorRecovery = False else: if self._state.backtracking > 0: raise BacktrackingFailed mse = MismatchedSetException(None, self.input) raise mse self._state.following.append(self.FOLLOW_binary_expression_3_in_synpred227_sdl9211583) self.binary_expression_3() self._state.following.pop() # $ANTLR end "synpred227_sdl92" # $ANTLR start "synpred230_sdl92" def synpred230_sdl92_fragment(self, ): # sdl92.g:1040:38: ( ( PLUS | DASH | APPEND ) binary_expression_4 ) # sdl92.g:1040:38: ( PLUS | DASH | APPEND ) binary_expression_4 pass if (PLUS <= self.input.LA(1) <= APPEND): self.input.consume() self._state.errorRecovery = False else: if self._state.backtracking > 0: raise BacktrackingFailed mse = MismatchedSetException(None, self.input) raise mse self._state.following.append(self.FOLLOW_binary_expression_4_in_synpred230_sdl9211626) self.binary_expression_4() self._state.following.pop() # $ANTLR end "synpred230_sdl92" # $ANTLR start "synpred234_sdl92" def synpred234_sdl92_fragment(self, ): # sdl92.g:1042:35: ( ( ASTERISK | DIV | MOD | REM ) unary_expression ) # sdl92.g:1042:35: ( ASTERISK | DIV | MOD | REM ) unary_expression pass if self.input.LA(1) == ASTERISK or (DIV <= self.input.LA(1) <= REM): self.input.consume() self._state.errorRecovery = False else: if self._state.backtracking > 0: raise BacktrackingFailed mse = MismatchedSetException(None, self.input) raise mse self._state.following.append(self.FOLLOW_unary_expression_in_synpred234_sdl9211674) self.unary_expression() self._state.following.pop() # $ANTLR end "synpred234_sdl92" # $ANTLR start "synpred235_sdl92" def synpred235_sdl92_fragment(self, ): # sdl92.g:1046:17: ( postfix_expression ) # sdl92.g:1046:17: postfix_expression pass self._state.following.append(self.FOLLOW_postfix_expression_in_synpred235_sdl9211699) self.postfix_expression() self._state.following.pop() # $ANTLR end "synpred235_sdl92" # $ANTLR start "synpred236_sdl92" def synpred236_sdl92_fragment(self, ): # sdl92.g:1047:17: ( primary_expression ) # sdl92.g:1047:17: primary_expression pass self._state.following.append(self.FOLLOW_primary_expression_in_synpred236_sdl9211717) self.primary_expression() self._state.following.pop() # $ANTLR end "synpred236_sdl92" # $ANTLR start "synpred238_sdl92" def synpred238_sdl92_fragment(self, ): # sdl92.g:1055:21: ( '(' params= expression_list ')' ) # sdl92.g:1055:21: '(' params= expression_list ')' pass self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_synpred238_sdl9211834) self._state.following.append(self.FOLLOW_expression_list_in_synpred238_sdl9211838) params = self.expression_list() self._state.following.pop() self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_synpred238_sdl9211840) # $ANTLR end "synpred238_sdl92" # $ANTLR start "synpred239_sdl92" def synpred239_sdl92_fragment(self, ): # sdl92.g:1056:21: ( '!' field_name ) # sdl92.g:1056:21: '!' field_name pass self.match(self.input, 225, self.FOLLOW_225_in_synpred239_sdl9211878) self._state.following.append(self.FOLLOW_field_name_in_synpred239_sdl9211880) self.field_name() self._state.following.pop() # $ANTLR end "synpred239_sdl92" # $ANTLR start "synpred250_sdl92" def synpred250_sdl92_fragment(self, ): # sdl92.g:1077:17: ( ID ':' expression ) # sdl92.g:1077:17: ID ':' expression pass self.match(self.input, ID, self.FOLLOW_ID_in_synpred250_sdl9212215) self.match(self.input, 223, self.FOLLOW_223_in_synpred250_sdl9212217) self._state.following.append(self.FOLLOW_expression_in_synpred250_sdl9212219) self.expression() self._state.following.pop() # $ANTLR end "synpred250_sdl92" # $ANTLR start "synpred251_sdl92" def synpred251_sdl92_fragment(self, ): # sdl92.g:1078:17: ( ID ) # sdl92.g:1078:17: ID pass self.match(self.input, ID, self.FOLLOW_ID_in_synpred251_sdl9212257) # $ANTLR end "synpred251_sdl92" # $ANTLR start "synpred252_sdl92" def synpred252_sdl92_fragment(self, ): # sdl92.g:1079:17: ( '{' '}' ) # sdl92.g:1079:17: '{' '}' pass self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_synpred252_sdl9212308) self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_synpred252_sdl9212310) # $ANTLR end "synpred252_sdl92" # $ANTLR start "synpred253_sdl92" def synpred253_sdl92_fragment(self, ): # sdl92.g:1080:17: ( '{' MANTISSA mant= INT COMMA BASE bas= INT COMMA EXPONENT exp= INT '}' ) # sdl92.g:1080:17: '{' MANTISSA mant= INT COMMA BASE bas= INT COMMA EXPONENT exp= INT '}' pass self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_synpred253_sdl9212354) self.match(self.input, MANTISSA, self.FOLLOW_MANTISSA_in_synpred253_sdl9212372) mant=self.match(self.input, INT, self.FOLLOW_INT_in_synpred253_sdl9212376) self.match(self.input, COMMA, self.FOLLOW_COMMA_in_synpred253_sdl9212378) self.match(self.input, BASE, self.FOLLOW_BASE_in_synpred253_sdl9212396) bas=self.match(self.input, INT, self.FOLLOW_INT_in_synpred253_sdl9212400) self.match(self.input, COMMA, self.FOLLOW_COMMA_in_synpred253_sdl9212402) self.match(self.input, EXPONENT, self.FOLLOW_EXPONENT_in_synpred253_sdl9212420) exp=self.match(self.input, INT, self.FOLLOW_INT_in_synpred253_sdl9212424) self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_synpred253_sdl9212442) # $ANTLR end "synpred253_sdl92" # $ANTLR start "synpred255_sdl92" def synpred255_sdl92_fragment(self, ): # sdl92.g:1085:17: ( '{' named_value ( COMMA named_value )* '}' ) # sdl92.g:1085:17: '{' named_value ( COMMA named_value )* '}' pass self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_synpred255_sdl9212499) self._state.following.append(self.FOLLOW_named_value_in_synpred255_sdl9212517) self.named_value() self._state.following.pop() # sdl92.g:1086:29: ( COMMA named_value )* while True: #loop225 alt225 = 2 LA225_0 = self.input.LA(1) if (LA225_0 == COMMA) : alt225 = 1 if alt225 == 1: # sdl92.g:1086:30: COMMA named_value pass self.match(self.input, COMMA, self.FOLLOW_COMMA_in_synpred255_sdl9212520) self._state.following.append(self.FOLLOW_named_value_in_synpred255_sdl9212522) self.named_value() self._state.following.pop() else: break #loop225 self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_synpred255_sdl9212542) # $ANTLR end "synpred255_sdl92" # $ANTLR start "synpred257_sdl92" def synpred257_sdl92_fragment(self, ): # sdl92.g:1088:17: ( '{' primary ( COMMA primary )* '}' ) # sdl92.g:1088:17: '{' primary ( COMMA primary )* '}' pass self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_synpred257_sdl9212593) self._state.following.append(self.FOLLOW_primary_in_synpred257_sdl9212611) self.primary() self._state.following.pop() # sdl92.g:1089:25: ( COMMA primary )* while True: #loop226 alt226 = 2 LA226_0 = self.input.LA(1) if (LA226_0 == COMMA) : alt226 = 1 if alt226 == 1: # sdl92.g:1089:26: COMMA primary pass self.match(self.input, COMMA, self.FOLLOW_COMMA_in_synpred257_sdl9212614) self._state.following.append(self.FOLLOW_primary_in_synpred257_sdl9212616) self.primary() self._state.following.pop() else: break #loop226 self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_synpred257_sdl9212636) # $ANTLR end "synpred257_sdl92" # $ANTLR start "synpred287_sdl92" def synpred287_sdl92_fragment(self, ): # sdl92.g:1296:47: ( SEMI ) # sdl92.g:1296:47: SEMI pass self.match(self.input, SEMI, self.FOLLOW_SEMI_in_synpred287_sdl9214493) # $ANTLR end "synpred287_sdl92" # Delegated rules def synpred9_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred9_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred28_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred28_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred137_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred137_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred180_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred180_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred43_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred43_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred252_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred252_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred235_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred235_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred110_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred110_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred42_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred42_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred253_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred253_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred220_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred220_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred171_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred171_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred236_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred236_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred218_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred218_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred103_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred103_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred31_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred31_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred182_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred182_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred287_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred287_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred176_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred176_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred54_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred54_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred144_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred144_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred168_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred168_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred238_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred238_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred257_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred257_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred11_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred11_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred239_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred239_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred30_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred30_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred215_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred215_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred36_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred36_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred211_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred211_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred251_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred251_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred41_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred41_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred250_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred250_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred230_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred230_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred29_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred29_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred181_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred181_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred227_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred227_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred111_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred111_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred112_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred112_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred255_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred255_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred234_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred234_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred10_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred10_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success # lookup tables for DFA #20 DFA20_eot = DFA.unpack( u"\25\uffff" ) DFA20_eof = DFA.unpack( u"\1\2\24\uffff" ) DFA20_min = DFA.unpack( u"\1\14\1\0\1\uffff\1\0\21\uffff" ) DFA20_max = DFA.unpack( u"\1\u00e5\1\0\1\uffff\1\0\21\uffff" ) DFA20_accept = DFA.unpack( u"\2\uffff\1\4\17\uffff\1\2\1\1\1\3" ) DFA20_special = DFA.unpack( u"\1\uffff\1\0\1\uffff\1\1\21\uffff" ) DFA20_transition = [ DFA.unpack(u"\1\2\4\uffff\1\2\2\uffff\2\2\63\uffff\1\22\2\uffff\1" u"\2\14\uffff\1\2\2\uffff\1\3\13\uffff\1\2\13\uffff\1\2\6\uffff\1" u"\2\3\uffff\2\2\2\uffff\1\2\3\uffff\1\2\1\uffff\1\2\133\uffff\1" u"\1"), DFA.unpack(u"\1\uffff"), DFA.unpack(u""), DFA.unpack(u"\1\uffff"), 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""), 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 #20 class DFA20(DFA): pass def specialStateTransition(self_, s, input): # convince pylint that my self_ magic is ok ;) # pylint: disable-msg=E0213 # pretend we are a member of the recognizer # thus semantic predicates can be evaluated self = self_.recognizer _s = s if s == 0: LA20_1 = input.LA(1) index20_1 = input.index() input.rewind() s = -1 if (self.synpred28_sdl92()): s = 19 elif (self.synpred29_sdl92()): s = 18 elif (True): s = 2 input.seek(index20_1) if s >= 0: return s elif s == 1: LA20_3 = input.LA(1) index20_3 = input.index() input.rewind() s = -1 if (self.synpred30_sdl92()): s = 20 elif (True): s = 2 input.seek(index20_3) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 20, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #21 DFA21_eot = DFA.unpack( u"\21\uffff" ) DFA21_eof = DFA.unpack( u"\1\7\20\uffff" ) DFA21_min = DFA.unpack( u"\1\14\1\0\1\uffff\15\0\1\uffff" ) DFA21_max = DFA.unpack( u"\1\u00e5\1\0\1\uffff\15\0\1\uffff" ) DFA21_accept = DFA.unpack( u"\2\uffff\1\1\15\uffff\1\2" ) DFA21_special = DFA.unpack( u"\1\uffff\1\13\1\uffff\1\6\1\3\1\0\1\1\1\15\1\7\1\14\1\4\1\5\1\2" u"\1\12\1\10\1\11\1\uffff" ) DFA21_transition = [ DFA.unpack(u"\1\17\4\uffff\1\5\2\uffff\1\16\1\2\66\uffff\1\12\14" u"\uffff\1\14\2\uffff\1\2\13\uffff\1\11\13\uffff\1\10\6\uffff\1\4" u"\3\uffff\1\13\1\15\2\uffff\1\3\3\uffff\1\2\1\uffff\1\6\133\uffff" u"\1\1"), DFA.unpack(u"\1\uffff"), DFA.unpack(u""), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"") ] # class definition for DFA #21 class DFA21(DFA): pass def specialStateTransition(self_, s, input): # convince pylint that my self_ magic is ok ;) # pylint: disable-msg=E0213 # pretend we are a member of the recognizer # thus semantic predicates can be evaluated self = self_.recognizer _s = s if s == 0: LA21_5 = input.LA(1) index21_5 = input.index() input.rewind() s = -1 if (self.synpred31_sdl92()): s = 2 elif (True): s = 16 input.seek(index21_5) if s >= 0: return s elif s == 1: LA21_6 = input.LA(1) index21_6 = input.index() input.rewind() s = -1 if (self.synpred31_sdl92()): s = 2 elif (True): s = 16 input.seek(index21_6) if s >= 0: return s elif s == 2: LA21_12 = input.LA(1) index21_12 = input.index() input.rewind() s = -1 if (self.synpred31_sdl92()): s = 2 elif (True): s = 16 input.seek(index21_12) if s >= 0: return s elif s == 3: LA21_4 = input.LA(1) index21_4 = input.index() input.rewind() s = -1 if (self.synpred31_sdl92()): s = 2 elif (True): s = 16 input.seek(index21_4) if s >= 0: return s elif s == 4: LA21_10 = input.LA(1) index21_10 = input.index() input.rewind() s = -1 if (self.synpred31_sdl92()): s = 2 elif (True): s = 16 input.seek(index21_10) if s >= 0: return s elif s == 5: LA21_11 = input.LA(1) index21_11 = input.index() input.rewind() s = -1 if (self.synpred31_sdl92()): s = 2 elif (True): s = 16 input.seek(index21_11) if s >= 0: return s elif s == 6: LA21_3 = input.LA(1) index21_3 = input.index() input.rewind() s = -1 if (self.synpred31_sdl92()): s = 2 elif (True): s = 16 input.seek(index21_3) if s >= 0: return s elif s == 7: LA21_8 = input.LA(1) index21_8 = input.index() input.rewind() s = -1 if (self.synpred31_sdl92()): s = 2 elif (True): s = 16 input.seek(index21_8) if s >= 0: return s elif s == 8: LA21_14 = input.LA(1) index21_14 = input.index() input.rewind() s = -1 if (self.synpred31_sdl92()): s = 2 elif (True): s = 16 input.seek(index21_14) if s >= 0: return s elif s == 9: LA21_15 = input.LA(1) index21_15 = input.index() input.rewind() s = -1 if (self.synpred31_sdl92()): s = 2 elif (True): s = 16 input.seek(index21_15) if s >= 0: return s elif s == 10: LA21_13 = input.LA(1) index21_13 = input.index() input.rewind() s = -1 if (self.synpred31_sdl92()): s = 2 elif (True): s = 16 input.seek(index21_13) if s >= 0: return s elif s == 11: LA21_1 = input.LA(1) index21_1 = input.index() input.rewind() s = -1 if (self.synpred31_sdl92()): s = 2 elif (True): s = 16 input.seek(index21_1) if s >= 0: return s elif s == 12: LA21_9 = input.LA(1) index21_9 = input.index() input.rewind() s = -1 if (self.synpred31_sdl92()): s = 2 elif (True): s = 16 input.seek(index21_9) if s >= 0: return s elif s == 13: LA21_7 = input.LA(1) index21_7 = input.index() input.rewind() s = -1 if (self.synpred31_sdl92()): s = 2 elif (True): s = 16 input.seek(index21_7) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 21, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #24 DFA24_eot = DFA.unpack( u"\24\uffff" ) DFA24_eof = DFA.unpack( u"\1\3\23\uffff" ) DFA24_min = DFA.unpack( u"\1\14\1\7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56\1\u0094" u"\1\u0086\1\u0093\1\u0094\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093" u"\1\u00e6\1\21" ) DFA24_max = DFA.unpack( u"\1\u00e5\1\u00b7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\u00ba" u"\1\u0094\1\u0086\1\u0093\1\u0094\1\u0092\1\u0086\1\u0094\1\u0086" u"\1\u0093\1\u00e6\1\u00e5" ) DFA24_accept = DFA.unpack( u"\2\uffff\1\1\1\2\20\uffff" ) DFA24_special = DFA.unpack( u"\24\uffff" ) DFA24_transition = [ DFA.unpack(u"\1\3\4\uffff\1\2\2\uffff\1\3\67\uffff\1\3\14\uffff\1" u"\3\16\uffff\1\3\13\uffff\1\3\12\uffff\2\3\10\uffff\1\2\133\uffff" u"\1\1"), DFA.unpack(u"\1\5\11\uffff\1\5\2\uffff\1\5\4\uffff\1\5\32\uffff" u"\1\5\2\uffff\2\5\3\uffff\1\5\3\uffff\1\5\10\uffff\2\5\1\uffff\2" u"\5\3\uffff\1\5\12\uffff\1\5\4\uffff\1\5\7\uffff\1\5\2\uffff\1\5" u"\32\uffff\1\5\57\uffff\1\4"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\2\24\uffff\1\3\166\uffff\1\3"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\2\72\uffff\1\3\u0098\uffff\1\2") ] # class definition for DFA #24 class DFA24(DFA): pass # lookup tables for DFA #26 DFA26_eot = DFA.unpack( u"\36\uffff" ) DFA26_eof = DFA.unpack( u"\1\4\35\uffff" ) DFA26_min = DFA.unpack( u"\1\14\1\7\1\143\1\0\1\uffff\1\u0092\1\u00b8\1\u0089\1\uffff\1\u0086" u"\1\u00b9\1\u0094\1\56\1\u0086\1\143\1\u0093\1\u00e6\1\u0094\1\21" u"\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\21\1\7\1\u00b8" u"\1\u00b9\1\56" ) DFA26_max = DFA.unpack( u"\1\u00e5\1\u00b7\1\143\1\0\1\uffff\1\u0092\1\u00b8\1\u0089\1\uffff" u"\1\u0086\1\u00b9\1\u0094\1\u00ba\1\u0086\1\143\1\u0093\1\u00e6" u"\1\u0094\1\u0087\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6" u"\1\u00e5\1\u00b7\1\u00b8\1\u00b9\1\u00ba" ) DFA26_accept = DFA.unpack( u"\4\uffff\1\2\3\uffff\1\1\25\uffff" ) DFA26_special = DFA.unpack( u"\3\uffff\1\0\32\uffff" ) DFA26_transition = [ DFA.unpack(u"\1\4\4\uffff\1\2\2\uffff\2\4\63\uffff\1\4\2\uffff\1" u"\4\14\uffff\1\4\2\uffff\1\4\13\uffff\1\4\13\uffff\1\4\6\uffff\1" u"\4\3\uffff\2\4\2\uffff\1\4\3\uffff\1\4\1\uffff\1\3\133\uffff\1" u"\1"), DFA.unpack(u"\1\5\11\uffff\1\5\2\uffff\1\5\4\uffff\1\5\32\uffff" u"\1\5\2\uffff\2\5\3\uffff\1\5\3\uffff\1\5\10\uffff\2\5\1\uffff\2" u"\5\3\uffff\1\5\12\uffff\1\5\4\uffff\1\5\7\uffff\1\5\2\uffff\1\5" u"\32\uffff\1\5\57\uffff\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\uffff"), DFA.unpack(u""), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\3"), DFA.unpack(u""), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16\24\uffff\1\4\166\uffff\1\4"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\2\3\uffff\1\4\106\uffff\1\4\52\uffff\1\4"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\27"), DFA.unpack(u"\1\30"), DFA.unpack(u"\1\31"), DFA.unpack(u"\1\2\3\uffff\1\4\2\uffff\1\4\23\uffff\1\4\16\uffff" u"\1\4\15\uffff\1\4\2\uffff\1\4\5\uffff\1\4\6\uffff\1\4\2\uffff\1" u"\4\10\uffff\1\4\1\uffff\1\4\10\uffff\1\4\3\uffff\1\4\22\uffff\1" u"\4\130\uffff\1\4\4\uffff\1\32"), DFA.unpack(u"\1\4\11\uffff\1\4\2\uffff\1\4\4\uffff\1\4\5\uffff\1" u"\4\24\uffff\1\4\2\uffff\2\4\3\uffff\1\4\3\uffff\1\4\10\uffff\2" u"\4\1\uffff\2\4\3\uffff\1\4\12\uffff\1\4\4\uffff\1\4\7\uffff\1\4" u"\2\uffff\1\4\32\uffff\1\4\57\uffff\1\33"), DFA.unpack(u"\1\34"), DFA.unpack(u"\1\35"), DFA.unpack(u"\1\16\24\uffff\1\4\166\uffff\1\4") ] # class definition for DFA #26 class DFA26(DFA): pass def specialStateTransition(self_, s, input): # convince pylint that my self_ magic is ok ;) # pylint: disable-msg=E0213 # pretend we are a member of the recognizer # thus semantic predicates can be evaluated self = self_.recognizer _s = s if s == 0: LA26_3 = input.LA(1) index26_3 = input.index() input.rewind() s = -1 if (self.synpred36_sdl92()): s = 8 elif (True): s = 4 input.seek(index26_3) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 26, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #38 DFA38_eot = DFA.unpack( u"\33\uffff" ) DFA38_eof = DFA.unpack( u"\1\3\32\uffff" ) DFA38_min = DFA.unpack( u"\1\21\1\7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56\1\u0094" u"\1\143\1\u0086\1\u00e6\1\u0093\1\21\1\u0094\1\u0092\1\u0086\1\u0094" u"\1\u0086\1\u0093\1\u00e6\1\21\1\7\1\u00b8\1\u00b9\1\56" ) DFA38_max = DFA.unpack( u"\1\u00e5\1\u00b7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\u00ba" u"\1\u0094\1\143\1\u0086\1\u00e6\1\u0093\1\u0087\1\u0094\1\u0092" u"\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\u00e5\1\u00b7\1\u00b8" u"\1\u00b9\1\u00ba" ) DFA38_accept = DFA.unpack( u"\2\uffff\1\1\1\2\27\uffff" ) DFA38_special = DFA.unpack( u"\33\uffff" ) DFA38_transition = [ DFA.unpack(u"\1\2\3\uffff\1\3\2\uffff\1\3\12\uffff\1\3\10\uffff\1" u"\3\16\uffff\1\3\15\uffff\1\3\10\uffff\1\3\6\uffff\1\3\2\uffff\1" u"\3\10\uffff\1\3\1\uffff\1\3\10\uffff\1\3\3\uffff\1\3\17\uffff\1" u"\3\2\uffff\1\3\1\uffff\1\2\126\uffff\1\3\4\uffff\1\1"), DFA.unpack(u"\1\5\11\uffff\1\5\2\uffff\1\5\4\uffff\1\5\5\uffff\1" u"\3\24\uffff\1\5\2\uffff\2\5\3\uffff\1\5\3\uffff\1\5\10\uffff\2" u"\5\1\uffff\2\5\3\uffff\1\5\12\uffff\1\5\4\uffff\1\5\7\uffff\1\5" u"\2\uffff\1\5\32\uffff\1\5\57\uffff\1\4"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12\24\uffff\1\3\166\uffff\1\3"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\2\3\uffff\1\3\106\uffff\1\3\52\uffff\1\3"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\2\3\uffff\1\3\2\uffff\1\3\23\uffff\1\3\16\uffff" u"\1\3\15\uffff\1\3\10\uffff\1\3\6\uffff\1\3\2\uffff\1\3\10\uffff" u"\1\3\1\uffff\1\3\10\uffff\1\3\3\uffff\1\3\22\uffff\1\3\130\uffff" u"\1\3\4\uffff\1\27"), DFA.unpack(u"\1\3\11\uffff\1\3\2\uffff\1\3\4\uffff\1\3\5\uffff\1" u"\3\24\uffff\1\3\2\uffff\2\3\3\uffff\1\3\3\uffff\1\3\10\uffff\2" u"\3\1\uffff\2\3\3\uffff\1\3\12\uffff\1\3\4\uffff\1\3\7\uffff\1\3" u"\2\uffff\1\3\32\uffff\1\3\57\uffff\1\30"), DFA.unpack(u"\1\31"), DFA.unpack(u"\1\32"), DFA.unpack(u"\1\12\24\uffff\1\3\166\uffff\1\3") ] # class definition for DFA #38 class DFA38(DFA): pass # lookup tables for DFA #42 DFA42_eot = DFA.unpack( u"\20\uffff" ) DFA42_eof = DFA.unpack( u"\1\2\17\uffff" ) DFA42_min = DFA.unpack( u"\1\30\1\7\13\uffff\1\u00b8\1\u00b9\1\103" ) DFA42_max = DFA.unpack( u"\1\u00e5\1\u00b7\13\uffff\1\u00b8\1\u00b9\1\u00ba" ) DFA42_accept = DFA.unpack( u"\2\uffff\1\13\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\3\uffff" ) DFA42_special = DFA.unpack( u"\20\uffff" ) DFA42_transition = [ DFA.unpack(u"\1\13\23\uffff\1\6\16\uffff\1\12\15\uffff\1\3\10\uffff" u"\1\7\6\uffff\1\5\13\uffff\1\14\1\uffff\1\11\10\uffff\1\10\3\uffff" u"\1\4\153\uffff\1\7\4\uffff\1\1"), DFA.unpack(u"\1\3\11\uffff\1\3\2\uffff\1\3\4\uffff\1\3\5\uffff\1" u"\2\24\uffff\1\3\2\uffff\2\3\3\uffff\1\3\3\uffff\1\3\10\uffff\2" u"\3\1\uffff\2\3\3\uffff\1\3\12\uffff\1\3\4\uffff\1\3\7\uffff\1\3" u"\2\uffff\1\3\32\uffff\1\3\57\uffff\1\15"), 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""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\5\166\uffff\1\4") ] # class definition for DFA #42 class DFA42(DFA): pass # lookup tables for DFA #49 DFA49_eot = DFA.unpack( u"\33\uffff" ) DFA49_eof = DFA.unpack( u"\3\uffff\1\7\27\uffff" ) DFA49_min = DFA.unpack( u"\1\21\1\7\1\143\1\35\1\u0092\1\u00b8\1\u0089\2\uffff\1\u0086\1" u"\u00b9\1\u0094\1\56\1\u0086\1\143\1\u0093\1\u00e6\1\u0094\1\21" u"\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\21\1\u00b7" ) DFA49_max = DFA.unpack( u"\1\u00e5\1\u00b7\1\143\1\u0089\1\u0092\1\u00b8\1\u0089\2\uffff" u"\1\u0086\1\u00b9\1\u0094\1\56\1\u0086\1\143\1\u0093\1\u00e6\1\u0094" u"\1\21\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\u00e5\1" u"\u00b7" ) DFA49_accept = DFA.unpack( u"\7\uffff\1\2\1\1\22\uffff" ) DFA49_special = DFA.unpack( u"\33\uffff" ) DFA49_transition = [ DFA.unpack(u"\1\2\167\uffff\1\3\133\uffff\1\1"), DFA.unpack(u"\1\4\11\uffff\1\4\2\uffff\1\4\4\uffff\1\4\32\uffff" u"\1\4\2\uffff\2\4\3\uffff\1\4\3\uffff\1\4\10\uffff\2\4\1\uffff\2" u"\4\3\uffff\1\4\12\uffff\1\4\4\uffff\1\4\7\uffff\1\4\2\uffff\1\4" u"\32\uffff\1\4\57\uffff\1\5"), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7\135\uffff\1\10\15\uffff\1\3"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\3"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\2"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\27"), DFA.unpack(u"\1\30"), DFA.unpack(u"\1\31"), DFA.unpack(u"\1\2\u00d3\uffff\1\32"), DFA.unpack(u"\1\5") ] # class definition for DFA #49 class DFA49(DFA): pass # lookup tables for DFA #55 DFA55_eot = DFA.unpack( u"\33\uffff" ) DFA55_eof = DFA.unpack( u"\1\3\32\uffff" ) DFA55_min = DFA.unpack( u"\1\14\1\7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56\1\u0094" u"\1\143\1\u0086\1\u00e6\1\u0093\1\21\1\u0094\1\u0092\1\u0086\1\u0094" u"\1\u0086\1\u0093\1\u00e6\1\21\1\u00b7\1\u00b8\1\u00b9\1\56" ) DFA55_max = DFA.unpack( u"\1\u00e5\1\u00b7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\u00ba" u"\1\u0094\1\143\1\u0086\1\u00e6\1\u0093\1\u0087\1\u0094\1\u0092" u"\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\u00e5\1\u00b7\1\u00b8" u"\1\u00b9\1\56" ) DFA55_accept = DFA.unpack( u"\2\uffff\1\1\1\2\27\uffff" ) DFA55_special = DFA.unpack( u"\33\uffff" ) DFA55_transition = [ DFA.unpack(u"\1\3\4\uffff\1\3\2\uffff\2\3\66\uffff\1\3\14\uffff\1" u"\3\2\uffff\1\3\13\uffff\1\3\13\uffff\1\3\6\uffff\1\3\3\uffff\2" u"\3\2\uffff\2\3\2\uffff\1\2\1\uffff\1\3\133\uffff\1\1"), DFA.unpack(u"\1\5\11\uffff\1\5\2\uffff\1\5\4\uffff\1\5\32\uffff" u"\1\5\2\uffff\2\5\3\uffff\1\5\3\uffff\1\5\10\uffff\2\5\1\uffff\2" u"\5\3\uffff\1\5\12\uffff\1\5\4\uffff\1\5\7\uffff\1\5\2\uffff\1\5" u"\32\uffff\1\5\57\uffff\1\4"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12\24\uffff\1\3\166\uffff\1\3"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\3\3\uffff\1\3\106\uffff\1\3\52\uffff\1\2"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\3\3\uffff\1\3\66\uffff\1\3\17\uffff\1\3\52\uffff" u"\1\2\135\uffff\1\27"), DFA.unpack(u"\1\30"), DFA.unpack(u"\1\31"), DFA.unpack(u"\1\32"), DFA.unpack(u"\1\12") ] # class definition for DFA #55 class DFA55(DFA): pass # lookup tables for DFA #56 DFA56_eot = DFA.unpack( u"\34\uffff" ) DFA56_eof = DFA.unpack( u"\1\1\33\uffff" ) DFA56_min = DFA.unpack( u"\1\14\1\uffff\1\7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56" u"\1\u0094\1\143\1\u0086\1\u00e6\1\u0093\1\21\1\u0094\1\u0092\1\u0086" u"\1\u0094\1\u0086\1\u0093\1\u00e6\1\21\1\u00b7\1\u00b8\1\u00b9\1" u"\56" ) DFA56_max = DFA.unpack( u"\1\u00e5\1\uffff\1\u00b7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086" u"\1\u00ba\1\u0094\1\143\1\u0086\1\u00e6\1\u0093\1\134\1\u0094\1" u"\u0092\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\u00e5\1\u00b7" u"\1\u00b8\1\u00b9\1\56" ) DFA56_accept = DFA.unpack( u"\1\uffff\1\3\1\uffff\1\1\1\2\27\uffff" ) DFA56_special = DFA.unpack( u"\34\uffff" ) DFA56_transition = [ DFA.unpack(u"\1\1\4\uffff\1\1\2\uffff\1\1\1\4\66\uffff\1\1\14\uffff" u"\1\1\2\uffff\1\3\13\uffff\1\1\13\uffff\1\1\6\uffff\1\1\3\uffff" u"\2\1\2\uffff\2\1\4\uffff\1\1\133\uffff\1\2"), DFA.unpack(u""), DFA.unpack(u"\1\6\11\uffff\1\6\2\uffff\1\6\4\uffff\1\6\32\uffff" u"\1\6\2\uffff\2\6\3\uffff\1\6\3\uffff\1\6\10\uffff\2\6\1\uffff\2" u"\6\3\uffff\1\6\12\uffff\1\6\4\uffff\1\6\7\uffff\1\6\2\uffff\1\6" u"\32\uffff\1\6\57\uffff\1\5"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13\24\uffff\1\1\166\uffff\1\1"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\1\3\uffff\1\4\106\uffff\1\3"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\27"), DFA.unpack(u"\1\1\3\uffff\1\4\66\uffff\1\1\17\uffff\1\3\u0088\uffff" u"\1\30"), DFA.unpack(u"\1\31"), DFA.unpack(u"\1\32"), DFA.unpack(u"\1\33"), DFA.unpack(u"\1\13") ] # class definition for DFA #56 class DFA56(DFA): pass # lookup tables for DFA #60 DFA60_eot = DFA.unpack( u"\34\uffff" ) DFA60_eof = DFA.unpack( u"\1\4\1\uffff\1\4\31\uffff" ) DFA60_min = DFA.unpack( u"\1\6\1\7\1\14\2\uffff\1\u0092\1\u00b8\1\u0086\1\u00b9\1\u0094\1" u"\56\1\u0086\1\143\1\u0093\1\u00e6\1\u0094\1\21\1\u0092\1\u0086" u"\1\u0094\1\u0086\1\u0093\1\u00e6\1\21\1\u00b7\1\u00b8\1\u00b9\1" u"\56" ) DFA60_max = DFA.unpack( u"\1\u00e5\1\u00b7\1\u00e5\2\uffff\1\u0092\1\u00b8\1\u0086\1\u00b9" u"\1\u0094\1\u00ba\1\u0086\1\143\1\u0093\1\u00e6\1\u0094\1\u0095" u"\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\u00e5\1\u00b7" u"\1\u00b8\1\u00b9\1\56" ) DFA60_accept = DFA.unpack( u"\3\uffff\1\1\1\2\27\uffff" ) DFA60_special = DFA.unpack( u"\34\uffff" ) DFA60_transition = [ DFA.unpack(u"\1\3\5\uffff\1\4\4\uffff\1\4\2\uffff\2\4\3\uffff\1\3" u"\7\uffff\1\3\11\uffff\1\3\13\uffff\1\3\4\uffff\1\3\3\uffff\1\3" u"\13\uffff\1\4\3\uffff\2\3\6\uffff\1\3\1\4\2\uffff\1\4\4\uffff\1" u"\3\1\uffff\1\3\4\uffff\1\4\1\3\12\uffff\1\4\6\uffff\1\2\3\uffff" u"\2\4\2\uffff\2\4\2\uffff\1\4\1\uffff\1\4\3\uffff\1\4\7\uffff\1" u"\3\11\uffff\1\3\105\uffff\1\1"), DFA.unpack(u"\1\5\11\uffff\1\5\2\uffff\1\5\4\uffff\1\5\32\uffff" u"\1\5\2\uffff\2\5\3\uffff\1\5\3\uffff\1\5\10\uffff\2\5\1\uffff\2" u"\5\3\uffff\1\5\12\uffff\1\5\4\uffff\1\5\7\uffff\1\5\2\uffff\1\5" u"\32\uffff\1\5\57\uffff\1\6"), DFA.unpack(u"\1\4\4\uffff\1\4\2\uffff\1\4\67\uffff\1\4\14\uffff" u"\1\4\16\uffff\1\4\13\uffff\1\4\12\uffff\2\4\10\uffff\1\4\10\uffff" u"\1\3\51\uffff\1\3\42\uffff\1\3\1\uffff\1\3\3\uffff\1\4"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14\24\uffff\1\4\166\uffff\1\4"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\4\3\uffff\1\4\3\uffff\1\3\35\uffff\1\3\4\uffff\1" u"\3\3\uffff\1\3\20\uffff\1\3\12\uffff\1\4\4\uffff\1\3\7\uffff\1" u"\3\35\uffff\1\4\15\uffff\1\3"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\27"), DFA.unpack(u"\1\4\3\uffff\1\4\3\uffff\1\3\35\uffff\1\3\4\uffff\1" u"\3\3\uffff\1\3\13\uffff\1\4\4\uffff\1\3\12\uffff\1\4\4\uffff\1" u"\3\7\uffff\1\3\21\uffff\1\3\13\uffff\1\4\15\uffff\1\3\117\uffff" u"\1\30"), DFA.unpack(u"\1\31"), DFA.unpack(u"\1\32"), DFA.unpack(u"\1\33"), DFA.unpack(u"\1\14") ] # class definition for DFA #60 class DFA60(DFA): pass # lookup tables for DFA #77 DFA77_eot = DFA.unpack( u"\25\uffff" ) DFA77_eof = DFA.unpack( u"\25\uffff" ) DFA77_min = DFA.unpack( u"\1\24\1\uffff\1\7\1\uffff\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093" u"\1\u0094\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\30\1" u"\7\1\u00b8\1\u00b9\1\56" ) DFA77_max = DFA.unpack( u"\1\u00e5\1\uffff\1\u00b7\1\uffff\1\u0092\1\u0086\1\u0094\1\u0086" u"\1\u0093\1\u0094\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6" u"\1\u00e5\1\u00b7\1\u00b8\1\u00b9\1\u00ba" ) DFA77_accept = DFA.unpack( u"\1\uffff\1\2\1\uffff\1\1\21\uffff" ) DFA77_special = DFA.unpack( u"\25\uffff" ) DFA77_transition = [ DFA.unpack(u"\1\1\64\uffff\1\3\22\uffff\1\1\60\uffff\1\1\127\uffff" u"\1\2"), DFA.unpack(u""), DFA.unpack(u"\1\4\11\uffff\1\4\2\uffff\1\4\4\uffff\1\4\32\uffff" u"\1\4\2\uffff\2\4\3\uffff\1\4\3\uffff\1\4\10\uffff\2\4\1\uffff\2" u"\4\3\uffff\1\4\12\uffff\1\4\4\uffff\1\4\7\uffff\1\4\2\uffff\1\4" u"\32\uffff\1\4\57\uffff\1\1"), DFA.unpack(u""), DFA.unpack(u"\1\5"), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\3\23\uffff\1\3\16\uffff\1\3\15\uffff\1\3\10\uffff" u"\1\3\6\uffff\1\3\2\uffff\1\1\10\uffff\1\3\1\uffff\1\3\10\uffff" u"\1\3\3\uffff\1\3\153\uffff\1\3\4\uffff\1\21"), DFA.unpack(u"\1\3\11\uffff\1\3\2\uffff\1\3\4\uffff\1\3\5\uffff\1" u"\3\24\uffff\1\3\2\uffff\2\3\3\uffff\1\3\3\uffff\1\3\10\uffff\2" u"\3\1\uffff\2\3\3\uffff\1\3\12\uffff\1\3\4\uffff\1\3\7\uffff\1\3" u"\2\uffff\1\3\32\uffff\1\3\57\uffff\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\1\24\uffff\1\3\166\uffff\1\3") ] # class definition for DFA #77 class DFA77(DFA): pass # lookup tables for DFA #80 DFA80_eot = DFA.unpack( u"\36\uffff" ) DFA80_eof = DFA.unpack( u"\36\uffff" ) DFA80_min = DFA.unpack( u"\1\24\1\uffff\1\173\2\uffff\1\21\1\7\1\143\1\24\1\u0092\1\u00b8" u"\1\u0089\1\u0086\1\u00b9\1\u0094\1\56\1\u0086\1\143\1\u0093\1\u00e6" u"\1\u0094\1\21\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1" u"\21\1\u00b7" ) DFA80_max = DFA.unpack( u"\1\u00e5\1\uffff\1\u008e\2\uffff\1\u00e5\1\u00b7\1\143\1\u00e5" u"\1\u0092\1\u00b8\1\u0089\1\u0086\1\u00b9\1\u0094\1\56\1\u0086\1" u"\143\1\u0093\1\u00e6\1\u0094\1\21\1\u0092\1\u0086\1\u0094\1\u0086" u"\1\u0093\1\u00e6\1\u00e5\1\u00b7" ) DFA80_accept = DFA.unpack( u"\1\uffff\1\3\1\uffff\1\2\1\1\31\uffff" ) DFA80_special = DFA.unpack( u"\36\uffff" ) DFA80_transition = [ DFA.unpack(u"\1\3\107\uffff\1\2\60\uffff\1\1\127\uffff\1\1"), DFA.unpack(u""), DFA.unpack(u"\1\5\17\uffff\1\1\2\uffff\1\4"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\7\167\uffff\1\10\12\uffff\1\1\120\uffff\1\6"), DFA.unpack(u"\1\11\11\uffff\1\11\2\uffff\1\11\4\uffff\1\11\32\uffff" u"\1\11\2\uffff\2\11\3\uffff\1\11\3\uffff\1\11\10\uffff\2\11\1\uffff" u"\2\11\3\uffff\1\11\12\uffff\1\11\4\uffff\1\11\7\uffff\1\11\2\uffff" u"\1\11\32\uffff\1\11\57\uffff\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\1\37\uffff\1\1\30\uffff\1\1\6\uffff\1\1\64\uffff" u"\1\10\1\1\1\uffff\1\4\130\uffff\1\1"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\27"), DFA.unpack(u"\1\30"), DFA.unpack(u"\1\31"), DFA.unpack(u"\1\32"), DFA.unpack(u"\1\33"), DFA.unpack(u"\1\34"), DFA.unpack(u"\1\7\u00d3\uffff\1\35"), DFA.unpack(u"\1\12") ] # class definition for DFA #80 class DFA80(DFA): pass # lookup tables for DFA #86 DFA86_eot = DFA.unpack( u"\30\uffff" ) DFA86_eof = DFA.unpack( u"\30\uffff" ) DFA86_min = DFA.unpack( u"\1\25\1\7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56\1\u0094" u"\1\143\1\u0086\1\u00e6\1\u0093\1\25\1\u0094\1\u0092\1\u0086\1\u0094" u"\1\u0086\1\u0093\1\u00e6\1\25\1\u00b7" ) DFA86_max = DFA.unpack( u"\1\u00e5\1\u00b7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56\1" u"\u0094\1\143\1\u0086\1\u00e6\1\u0093\1\u0087\1\u0094\1\u0092\1" u"\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\u00e5\1\u00b7" ) DFA86_accept = DFA.unpack( u"\2\uffff\1\2\1\1\24\uffff" ) DFA86_special = DFA.unpack( u"\30\uffff" ) DFA86_transition = [ DFA.unpack(u"\1\2\106\uffff\1\2\52\uffff\1\3\5\uffff\1\2\127\uffff" u"\1\1"), DFA.unpack(u"\1\5\11\uffff\1\5\2\uffff\1\5\4\uffff\1\5\32\uffff" u"\1\5\2\uffff\2\5\3\uffff\1\5\3\uffff\1\5\10\uffff\2\5\1\uffff\2" u"\5\3\uffff\1\5\12\uffff\1\5\4\uffff\1\5\7\uffff\1\5\2\uffff\1\5" u"\32\uffff\1\5\57\uffff\1\4"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\2\106\uffff\1\2\52\uffff\1\3"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\2\106\uffff\1\2\52\uffff\1\3\135\uffff\1\27"), DFA.unpack(u"\1\4") ] # class definition for DFA #86 class DFA86(DFA): pass # lookup tables for DFA #87 DFA87_eot = DFA.unpack( u"\31\uffff" ) DFA87_eof = DFA.unpack( u"\31\uffff" ) DFA87_min = DFA.unpack( u"\1\25\1\uffff\1\7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56" u"\1\u0094\1\143\1\u0086\1\u00e6\1\u0093\1\25\1\u0094\1\u0092\1\u0086" u"\1\u0094\1\u0086\1\u0093\1\u00e6\1\25\1\u00b7" ) DFA87_max = DFA.unpack( u"\1\u00e5\1\uffff\1\u00b7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086" u"\1\56\1\u0094\1\143\1\u0086\1\u00e6\1\u0093\1\134\1\u0094\1\u0092" u"\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\u00e5\1\u00b7" ) DFA87_accept = DFA.unpack( u"\1\uffff\1\3\1\uffff\1\1\1\2\24\uffff" ) DFA87_special = DFA.unpack( u"\31\uffff" ) DFA87_transition = [ DFA.unpack(u"\1\4\106\uffff\1\3\60\uffff\1\1\127\uffff\1\2"), DFA.unpack(u""), DFA.unpack(u"\1\6\11\uffff\1\6\2\uffff\1\6\4\uffff\1\6\32\uffff" u"\1\6\2\uffff\2\6\3\uffff\1\6\3\uffff\1\6\10\uffff\2\6\1\uffff\2" u"\6\3\uffff\1\6\12\uffff\1\6\4\uffff\1\6\7\uffff\1\6\2\uffff\1\6" u"\32\uffff\1\6\57\uffff\1\5"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\4\106\uffff\1\3"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\27"), DFA.unpack(u"\1\4\106\uffff\1\3\u0088\uffff\1\30"), DFA.unpack(u"\1\5") ] # class definition for DFA #87 class DFA87(DFA): pass # lookup tables for DFA #88 DFA88_eot = DFA.unpack( u"\34\uffff" ) DFA88_eof = DFA.unpack( u"\34\uffff" ) DFA88_min = DFA.unpack( u"\1\24\1\7\1\173\3\uffff\1\u00b8\1\u0092\2\uffff\1\u00b9\1\u0086" u"\1\56\1\u0094\1\143\1\u0086\1\u00e6\1\u0093\1\24\1\u0094\1\u0092" u"\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\24\1\u00b7" ) DFA88_max = DFA.unpack( u"\1\u00e5\1\u00b7\1\u0090\3\uffff\1\u00b8\1\u0092\2\uffff\1\u00b9" u"\1\u0086\1\56\1\u0094\1\143\1\u0086\1\u00e6\1\u0093\1\115\1\u0094" u"\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\u00e5\1\u00b7" ) DFA88_accept = DFA.unpack( u"\3\uffff\1\2\1\4\1\5\2\uffff\1\3\1\1\22\uffff" ) DFA88_special = DFA.unpack( u"\34\uffff" ) DFA88_transition = [ DFA.unpack(u"\1\5\37\uffff\1\2\30\uffff\1\4\6\uffff\1\3\u0090\uffff" u"\1\1"), DFA.unpack(u"\1\7\11\uffff\1\7\2\uffff\1\7\4\uffff\1\7\32\uffff" u"\1\7\2\uffff\2\7\3\uffff\1\7\3\uffff\1\7\10\uffff\2\7\1\uffff\2" u"\7\3\uffff\1\7\12\uffff\1\7\4\uffff\1\7\7\uffff\1\7\2\uffff\1\7" u"\32\uffff\1\7\57\uffff\1\6"), DFA.unpack(u"\1\11\17\uffff\1\11\4\uffff\1\10"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\5\37\uffff\1\2\30\uffff\1\4"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\27"), DFA.unpack(u"\1\30"), DFA.unpack(u"\1\31"), DFA.unpack(u"\1\32"), DFA.unpack(u"\1\5\37\uffff\1\2\30\uffff\1\4\u0097\uffff\1\33"), DFA.unpack(u"\1\6") ] # class definition for DFA #88 class DFA88(DFA): pass # lookup tables for DFA #92 DFA92_eot = DFA.unpack( u"\30\uffff" ) DFA92_eof = DFA.unpack( u"\1\3\27\uffff" ) DFA92_min = DFA.unpack( u"\1\6\1\7\2\uffff\1\u0092\1\u00b8\1\u0086\1\u00b9\1\u0094\1\56\1" u"\u0086\1\143\1\u0093\1\u00e6\1\u0094\1\24\1\u0092\1\u0086\1\u0094" u"\1\u0086\1\u0093\1\u00e6\1\24\1\u00b7" ) DFA92_max = DFA.unpack( u"\1\u00e5\1\u00b7\2\uffff\1\u0092\1\u00b8\1\u0086\1\u00b9\1\u0094" u"\1\56\1\u0086\1\143\1\u0093\1\u00e6\1\u0094\1\u0095\1\u0092\1\u0086" u"\1\u0094\1\u0086\1\u0093\1\u00e6\1\u00e5\1\u00b7" ) DFA92_accept = DFA.unpack( u"\2\uffff\1\1\1\2\24\uffff" ) DFA92_special = DFA.unpack( u"\30\uffff" ) DFA92_transition = [ DFA.unpack(u"\1\2\15\uffff\1\3\4\uffff\1\2\7\uffff\1\2\11\uffff\1" u"\2\10\uffff\1\3\2\uffff\1\2\4\uffff\1\2\3\uffff\1\2\14\uffff\1" u"\3\2\uffff\2\2\2\uffff\1\3\3\uffff\1\2\10\uffff\1\2\1\uffff\1\2" u"\5\uffff\1\2\21\uffff\1\2\16\uffff\1\3\12\uffff\1\2\11\uffff\1" u"\2\105\uffff\1\1"), DFA.unpack(u"\1\4\11\uffff\1\4\2\uffff\1\4\4\uffff\1\4\32\uffff" u"\1\4\2\uffff\2\4\3\uffff\1\4\3\uffff\1\4\10\uffff\2\4\1\uffff\2" u"\4\3\uffff\1\4\12\uffff\1\4\4\uffff\1\4\7\uffff\1\4\2\uffff\1\4" u"\32\uffff\1\4\57\uffff\1\5"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\3\4\uffff\1\2\32\uffff\1\3\2\uffff\1\2\4\uffff\1" u"\2\3\uffff\1\2\14\uffff\1\3\3\uffff\1\2\17\uffff\1\2\7\uffff\1" u"\2\53\uffff\1\2"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\3\4\uffff\1\2\32\uffff\1\3\2\uffff\1\2\4\uffff\1" u"\2\3\uffff\1\2\14\uffff\1\3\3\uffff\1\2\17\uffff\1\2\7\uffff\1" u"\2\21\uffff\1\2\31\uffff\1\2\117\uffff\1\27"), DFA.unpack(u"\1\5") ] # class definition for DFA #92 class DFA92(DFA): pass # lookup tables for DFA #101 DFA101_eot = DFA.unpack( u"\30\uffff" ) DFA101_eof = DFA.unpack( u"\1\3\27\uffff" ) DFA101_min = DFA.unpack( u"\1\6\1\7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56\1\u0094\1" u"\143\1\u0086\1\u00e6\1\u0093\1\24\1\u0094\1\u0092\1\u0086\1\u0094" u"\1\u0086\1\u0093\1\u00e6\1\24\1\u00b7" ) DFA101_max = DFA.unpack( u"\1\u00e5\1\u00b7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56\1" u"\u0094\1\143\1\u0086\1\u00e6\1\u0093\1\u0095\1\u0094\1\u0092\1" u"\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\u00e5\1\u00b7" ) DFA101_accept = DFA.unpack( u"\2\uffff\1\1\1\2\24\uffff" ) DFA101_special = DFA.unpack( u"\30\uffff" ) DFA101_transition = [ DFA.unpack(u"\1\2\15\uffff\1\3\4\uffff\1\2\7\uffff\1\2\11\uffff\1" u"\2\10\uffff\1\3\2\uffff\1\2\4\uffff\1\2\3\uffff\1\2\14\uffff\1" u"\3\2\uffff\2\2\2\uffff\1\3\3\uffff\1\2\10\uffff\1\2\1\uffff\1\2" u"\5\uffff\1\2\21\uffff\1\2\16\uffff\1\3\12\uffff\1\2\11\uffff\1" u"\2\105\uffff\1\1"), DFA.unpack(u"\1\5\11\uffff\1\5\2\uffff\1\5\4\uffff\1\5\32\uffff" u"\1\5\2\uffff\2\5\3\uffff\1\5\3\uffff\1\5\10\uffff\2\5\1\uffff\2" u"\5\3\uffff\1\5\12\uffff\1\5\4\uffff\1\5\7\uffff\1\5\2\uffff\1\5" u"\32\uffff\1\5\57\uffff\1\4"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\3\4\uffff\1\2\32\uffff\1\3\2\uffff\1\2\4\uffff\1" u"\2\3\uffff\1\2\14\uffff\1\3\3\uffff\1\2\17\uffff\1\2\7\uffff\1" u"\2\53\uffff\1\2"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\3\4\uffff\1\2\32\uffff\1\3\2\uffff\1\2\4\uffff\1" u"\2\3\uffff\1\2\14\uffff\1\3\3\uffff\1\2\17\uffff\1\2\7\uffff\1" u"\2\21\uffff\1\2\31\uffff\1\2\117\uffff\1\27"), DFA.unpack(u"\1\4") ] # class definition for DFA #101 class DFA101(DFA): pass # lookup tables for DFA #106 DFA106_eot = DFA.unpack( u"\31\uffff" ) DFA106_eof = DFA.unpack( u"\1\2\30\uffff" ) DFA106_min = DFA.unpack( u"\1\6\1\0\27\uffff" ) DFA106_max = DFA.unpack( u"\1\u00e5\1\0\27\uffff" ) DFA106_accept = DFA.unpack( u"\2\uffff\1\2\25\uffff\1\1" ) DFA106_special = DFA.unpack( u"\1\uffff\1\0\27\uffff" ) DFA106_transition = [ DFA.unpack(u"\1\2\15\uffff\1\2\4\uffff\1\2\7\uffff\1\2\11\uffff\1" u"\2\10\uffff\1\2\2\uffff\1\2\4\uffff\1\2\3\uffff\1\2\14\uffff\1" u"\1\2\uffff\2\2\2\uffff\1\2\3\uffff\1\2\10\uffff\1\2\1\uffff\1\2" u"\5\uffff\1\2\21\uffff\1\2\16\uffff\1\2\12\uffff\1\2\11\uffff\1" u"\2\105\uffff\1\2"), DFA.unpack(u"\1\uffff"), 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""), 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""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"") ] # class definition for DFA #106 class DFA106(DFA): pass def specialStateTransition(self_, s, input): # convince pylint that my self_ magic is ok ;) # pylint: disable-msg=E0213 # pretend we are a member of the recognizer # thus semantic predicates can be evaluated self = self_.recognizer _s = s if s == 0: LA106_1 = input.LA(1) index106_1 = input.index() input.rewind() s = -1 if (self.synpred137_sdl92()): s = 24 elif (True): s = 2 input.seek(index106_1) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 106, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #107 DFA107_eot = DFA.unpack( u"\30\uffff" ) DFA107_eof = DFA.unpack( u"\1\3\27\uffff" ) DFA107_min = DFA.unpack( u"\1\6\1\7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56\1\u0094\1" u"\143\1\u0086\1\u00e6\1\u0093\1\24\1\u0094\1\u0092\1\u0086\1\u0094" u"\1\u0086\1\u0093\1\u00e6\1\24\1\u00b7" ) DFA107_max = DFA.unpack( u"\1\u00e5\1\u00b7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56\1" u"\u0094\1\143\1\u0086\1\u00e6\1\u0093\1\u0095\1\u0094\1\u0092\1" u"\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\u00e5\1\u00b7" ) DFA107_accept = DFA.unpack( u"\2\uffff\1\1\1\2\24\uffff" ) DFA107_special = DFA.unpack( u"\30\uffff" ) DFA107_transition = [ DFA.unpack(u"\1\2\15\uffff\1\3\4\uffff\1\2\7\uffff\1\2\11\uffff\1" u"\2\10\uffff\1\3\2\uffff\1\2\4\uffff\1\2\3\uffff\1\2\14\uffff\1" u"\3\2\uffff\2\2\2\uffff\1\3\3\uffff\1\2\10\uffff\1\2\1\uffff\1\2" u"\5\uffff\1\2\21\uffff\1\2\16\uffff\1\3\12\uffff\1\2\11\uffff\1" u"\2\105\uffff\1\1"), DFA.unpack(u"\1\5\11\uffff\1\5\2\uffff\1\5\4\uffff\1\5\32\uffff" u"\1\5\2\uffff\2\5\3\uffff\1\5\3\uffff\1\5\10\uffff\2\5\1\uffff\2" u"\5\3\uffff\1\5\12\uffff\1\5\4\uffff\1\5\7\uffff\1\5\2\uffff\1\5" u"\32\uffff\1\5\57\uffff\1\4"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\3\4\uffff\1\2\32\uffff\1\3\2\uffff\1\2\4\uffff\1" u"\2\3\uffff\1\2\14\uffff\1\3\3\uffff\1\2\17\uffff\1\2\7\uffff\1" u"\2\53\uffff\1\2"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\3\4\uffff\1\2\32\uffff\1\3\2\uffff\1\2\4\uffff\1" u"\2\3\uffff\1\2\14\uffff\1\3\3\uffff\1\2\17\uffff\1\2\7\uffff\1" u"\2\21\uffff\1\2\31\uffff\1\2\117\uffff\1\27"), DFA.unpack(u"\1\4") ] # class definition for DFA #107 class DFA107(DFA): pass # lookup tables for DFA #115 DFA115_eot = DFA.unpack( u"\51\uffff" ) DFA115_eof = DFA.unpack( u"\51\uffff" ) DFA115_min = DFA.unpack( u"\1\6\1\7\1\u0092\2\uffff\1\u00b8\1\u0092\1\6\1\u00b9\1\u0086\1" u"\7\1\56\1\u0094\1\u0092\1\143\2\u0086\1\u00e6\1\u0093\1\u0094\1" u"\31\1\u0094\1\u0086\1\u0092\1\u0093\1\u0086\2\u0094\1\u0092\2\u0086" u"\1\u0093\1\u0094\1\u00e6\1\u0086\1\31\1\u0093\1\u00b7\1\u00df\1" u"\u00e6\1\31" ) DFA115_max = DFA.unpack( u"\1\u00e5\1\u00b7\1\u00e1\2\uffff\1\u00b8\1\u0092\1\u00e5\1\u00b9" u"\1\u0086\1\u00b7\1\56\1\u0094\1\u0092\1\143\2\u0086\1\u00e6\1\u0093" u"\1\u0094\1\u0095\1\u0094\1\u0086\1\u0092\1\u0093\1\u0086\2\u0094" u"\1\u0092\2\u0086\1\u0093\1\u0094\1\u00e6\1\u0086\1\u00e5\1\u0093" u"\1\u00b7\1\u00df\1\u00e6\1\u00e5" ) DFA115_accept = DFA.unpack( u"\3\uffff\1\1\1\2\44\uffff" ) DFA115_special = DFA.unpack( u"\51\uffff" ) DFA115_transition = [ DFA.unpack(u"\1\3\22\uffff\1\3\7\uffff\1\3\11\uffff\1\3\13\uffff" u"\1\4\4\uffff\1\4\3\uffff\1\3\17\uffff\1\3\1\4\6\uffff\1\3\10\uffff" u"\1\4\1\uffff\1\3\5\uffff\1\3\21\uffff\1\2\31\uffff\1\3\11\uffff" u"\1\3\105\uffff\1\1"), DFA.unpack(u"\1\6\11\uffff\1\6\2\uffff\1\6\4\uffff\1\6\32\uffff" u"\1\6\2\uffff\2\6\3\uffff\1\6\3\uffff\1\6\10\uffff\2\6\1\uffff\2" u"\6\3\uffff\1\6\12\uffff\1\6\4\uffff\1\6\7\uffff\1\6\2\uffff\1\6" u"\32\uffff\1\6\57\uffff\1\5"), DFA.unpack(u"\1\3\51\uffff\1\3\42\uffff\1\7\1\uffff\1\3"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\3\22\uffff\1\3\7\uffff\1\3\11\uffff\1\3\13\uffff" u"\1\4\4\uffff\1\4\3\uffff\1\3\17\uffff\1\3\1\4\6\uffff\1\3\10\uffff" u"\1\4\1\uffff\1\3\5\uffff\1\3\21\uffff\1\3\31\uffff\1\3\11\uffff" u"\1\3\105\uffff\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15\11\uffff\1\15\2\uffff\1\15\4\uffff\1\15\32\uffff" u"\1\15\2\uffff\2\15\3\uffff\1\15\3\uffff\1\15\10\uffff\2\15\1\uffff" u"\2\15\3\uffff\1\15\12\uffff\1\15\4\uffff\1\15\7\uffff\1\15\2\uffff" u"\1\15\32\uffff\1\15\57\uffff\1\5"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\3\35\uffff\1\4\4\uffff\1\4\3\uffff\1\3\20\uffff" u"\1\4\17\uffff\1\4\7\uffff\1\3\53\uffff\1\3"), DFA.unpack(u"\1\27"), DFA.unpack(u"\1\30"), DFA.unpack(u"\1\31"), DFA.unpack(u"\1\32"), DFA.unpack(u"\1\33"), DFA.unpack(u"\1\34"), DFA.unpack(u"\1\35"), DFA.unpack(u"\1\36"), DFA.unpack(u"\1\37"), DFA.unpack(u"\1\40"), DFA.unpack(u"\1\41"), DFA.unpack(u"\1\42"), DFA.unpack(u"\1\43"), DFA.unpack(u"\1\44"), DFA.unpack(u"\1\3\35\uffff\1\4\4\uffff\1\4\3\uffff\1\3\20\uffff" u"\1\4\17\uffff\1\4\7\uffff\1\3\21\uffff\1\46\31\uffff\1\3\117\uffff" u"\1\45"), DFA.unpack(u"\1\47"), DFA.unpack(u"\1\5"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\50"), DFA.unpack(u"\1\3\35\uffff\1\4\4\uffff\1\4\3\uffff\1\3\20\uffff" u"\1\4\17\uffff\1\4\7\uffff\1\3\53\uffff\1\3\117\uffff\1\45") ] # class definition for DFA #115 class DFA115(DFA): pass # lookup tables for DFA #112 DFA112_eot = DFA.unpack( u"\55\uffff" ) DFA112_eof = DFA.unpack( u"\1\3\1\uffff\1\3\4\uffff\1\3\3\uffff\1\3\41\uffff" ) DFA112_min = DFA.unpack( u"\1\6\1\7\1\14\2\uffff\1\u00b8\1\u0092\1\6\1\u00b9\1\u0086\1\7\1" u"\14\1\56\1\u0094\1\u0092\1\143\2\u0086\1\u00e6\1\u0093\1\u0094" u"\1\21\1\u0094\1\u0086\1\u0092\1\u0093\1\u0086\2\u0094\1\u0092\2" u"\u0086\1\u0093\1\u0094\1\u00e6\1\u0086\1\21\1\u0093\1\u00b7\1\u00df" u"\1\u00e6\1\u00b8\1\21\1\u00b9\1\56" ) DFA112_max = DFA.unpack( u"\1\u00e5\1\u00bb\1\u00e5\2\uffff\1\u00b8\1\u0092\1\u00e5\1\u00b9" u"\1\u0086\1\u00bb\1\u00e5\1\u00ba\1\u0094\1\u0092\1\143\2\u0086" u"\1\u00e6\1\u0093\1\u0094\1\u0095\1\u0094\1\u0086\1\u0092\1\u0093" u"\1\u0086\2\u0094\1\u0092\2\u0086\1\u0093\1\u0094\1\u00e6\1\u0086" u"\1\u00e5\1\u0093\1\u00b7\1\u00df\1\u00e6\1\u00b8\1\u00e5\1\u00b9" u"\1\56" ) DFA112_accept = DFA.unpack( u"\3\uffff\1\2\1\1\50\uffff" ) DFA112_special = DFA.unpack( u"\55\uffff" ) DFA112_transition = [ DFA.unpack(u"\1\4\5\uffff\1\3\4\uffff\1\3\2\uffff\2\3\3\uffff\1\4" u"\1\uffff\1\3\5\uffff\1\4\11\uffff\1\4\10\uffff\1\3\2\uffff\1\3" u"\4\uffff\1\3\3\uffff\1\4\13\uffff\2\3\2\uffff\1\4\1\3\2\uffff\1" u"\3\3\uffff\1\4\1\3\2\uffff\1\3\4\uffff\1\3\1\uffff\1\4\4\uffff" u"\1\3\1\4\12\uffff\1\3\6\uffff\1\2\3\uffff\2\3\2\uffff\2\3\2\uffff" u"\4\3\2\uffff\1\3\4\uffff\1\3\2\uffff\1\4\2\3\7\uffff\1\4\1\uffff" u"\1\3\103\uffff\1\1"), DFA.unpack(u"\1\6\11\uffff\1\6\2\uffff\1\6\4\uffff\1\6\32\uffff" u"\1\6\2\uffff\2\6\3\uffff\1\6\3\uffff\1\6\10\uffff\2\6\1\uffff\2" u"\6\3\uffff\1\6\12\uffff\1\6\4\uffff\1\6\7\uffff\1\6\2\uffff\1\6" u"\32\uffff\1\6\57\uffff\1\5\3\uffff\1\3"), DFA.unpack(u"\1\3\4\uffff\1\3\2\uffff\1\3\67\uffff\1\3\14\uffff" u"\1\3\16\uffff\1\3\13\uffff\1\3\12\uffff\2\3\10\uffff\1\3\10\uffff" u"\1\4\51\uffff\1\4\42\uffff\1\7\1\uffff\1\4\3\uffff\1\3"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\4\5\uffff\1\3\4\uffff\1\3\2\uffff\2\3\3\uffff\1" u"\4\1\uffff\1\3\5\uffff\1\4\11\uffff\1\4\10\uffff\1\3\2\uffff\1" u"\3\4\uffff\1\3\3\uffff\1\4\13\uffff\2\3\2\uffff\1\4\1\3\2\uffff" u"\1\3\3\uffff\1\4\1\3\2\uffff\1\3\4\uffff\1\3\1\uffff\1\4\4\uffff" u"\1\3\1\4\12\uffff\1\3\6\uffff\1\13\3\uffff\2\3\2\uffff\2\3\2\uffff" u"\4\3\2\uffff\1\3\4\uffff\1\3\2\uffff\1\4\2\3\7\uffff\1\4\1\uffff" u"\1\3\103\uffff\1\12"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16\11\uffff\1\16\2\uffff\1\16\4\uffff\1\16\32\uffff" u"\1\16\2\uffff\2\16\3\uffff\1\16\3\uffff\1\16\10\uffff\2\16\1\uffff" u"\2\16\3\uffff\1\16\12\uffff\1\16\4\uffff\1\16\7\uffff\1\16\2\uffff" u"\1\16\32\uffff\1\16\57\uffff\1\5\3\uffff\1\3"), DFA.unpack(u"\1\3\4\uffff\1\3\2\uffff\1\3\67\uffff\1\3\14\uffff" u"\1\3\16\uffff\1\3\13\uffff\1\3\12\uffff\2\3\10\uffff\1\3\10\uffff" u"\1\4\51\uffff\1\4\42\uffff\1\3\1\uffff\1\4\3\uffff\1\3"), DFA.unpack(u"\1\17\24\uffff\1\3\166\uffff\1\3"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\27"), DFA.unpack(u"\1\3\2\uffff\2\3\3\uffff\1\4\1\uffff\1\3\30\uffff\1" u"\3\2\uffff\1\3\4\uffff\1\3\3\uffff\1\4\14\uffff\1\3\3\uffff\1\3" u"\12\uffff\1\3\4\uffff\1\3\7\uffff\1\4\35\uffff\1\3\12\uffff\1\3" u"\2\uffff\1\4"), DFA.unpack(u"\1\30"), DFA.unpack(u"\1\31"), DFA.unpack(u"\1\32"), DFA.unpack(u"\1\33"), DFA.unpack(u"\1\34"), DFA.unpack(u"\1\35"), DFA.unpack(u"\1\36"), DFA.unpack(u"\1\37"), DFA.unpack(u"\1\40"), DFA.unpack(u"\1\41"), DFA.unpack(u"\1\42"), DFA.unpack(u"\1\43"), DFA.unpack(u"\1\44"), DFA.unpack(u"\1\45"), DFA.unpack(u"\1\3\2\uffff\2\3\3\uffff\1\4\1\uffff\1\3\30\uffff\1" u"\3\2\uffff\1\3\4\uffff\1\3\3\uffff\1\4\13\uffff\2\3\3\uffff\1\3" u"\12\uffff\1\3\4\uffff\1\3\7\uffff\1\4\21\uffff\1\47\13\uffff\1" u"\3\12\uffff\1\3\2\uffff\1\4\117\uffff\1\46"), DFA.unpack(u"\1\50"), DFA.unpack(u"\1\51"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\52"), DFA.unpack(u"\1\53"), DFA.unpack(u"\1\3\2\uffff\2\3\3\uffff\1\4\1\uffff\1\3\30\uffff\1" u"\3\2\uffff\1\3\4\uffff\1\3\3\uffff\1\4\13\uffff\2\3\3\uffff\1\3" u"\12\uffff\1\3\4\uffff\1\3\7\uffff\1\4\21\uffff\1\3\13\uffff\1\3" u"\12\uffff\1\3\2\uffff\1\4\117\uffff\1\46"), DFA.unpack(u"\1\54"), DFA.unpack(u"\1\17") ] # class definition for DFA #112 class DFA112(DFA): pass # lookup tables for DFA #113 DFA113_eot = DFA.unpack( u"\24\uffff" ) DFA113_eof = DFA.unpack( u"\1\3\1\uffff\1\3\21\uffff" ) DFA113_min = DFA.unpack( u"\1\14\1\7\1\14\1\uffff\1\u0092\1\0\1\u0086\1\uffff\1\u0094\1\u0086" u"\1\u0093\1\u0094\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6" u"\1\21\1\u00df" ) DFA113_max = DFA.unpack( u"\1\u00e5\1\u00bb\1\u00e5\1\uffff\1\u0092\1\0\1\u0086\1\uffff\1" u"\u0094\1\u0086\1\u0093\1\u0094\1\u0092\1\u0086\1\u0094\1\u0086" u"\1\u0093\1\u00e6\1\u00e5\1\u00df" ) DFA113_accept = DFA.unpack( u"\3\uffff\1\2\3\uffff\1\1\14\uffff" ) DFA113_special = DFA.unpack( u"\5\uffff\1\0\16\uffff" ) DFA113_transition = [ DFA.unpack(u"\1\3\4\uffff\1\3\2\uffff\2\3\5\uffff\1\3\30\uffff\1" u"\3\2\uffff\1\3\4\uffff\1\3\17\uffff\2\3\3\uffff\1\3\2\uffff\1\3" u"\4\uffff\1\3\2\uffff\1\3\4\uffff\1\3\6\uffff\1\3\13\uffff\1\3\6" u"\uffff\1\2\3\uffff\2\3\2\uffff\2\3\2\uffff\4\3\2\uffff\1\3\4\uffff" u"\1\3\3\uffff\2\3\11\uffff\1\3\103\uffff\1\1"), DFA.unpack(u"\1\4\11\uffff\1\4\2\uffff\1\4\4\uffff\1\4\32\uffff" u"\1\4\2\uffff\2\4\3\uffff\1\4\3\uffff\1\4\10\uffff\2\4\1\uffff\2" u"\4\3\uffff\1\4\12\uffff\1\4\4\uffff\1\4\7\uffff\1\4\2\uffff\1\4" u"\32\uffff\1\4\57\uffff\1\3\3\uffff\1\3"), DFA.unpack(u"\1\3\4\uffff\1\3\2\uffff\1\3\67\uffff\1\3\14\uffff" u"\1\3\16\uffff\1\3\13\uffff\1\3\12\uffff\2\3\10\uffff\1\3\125\uffff" u"\1\5\5\uffff\1\3"), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\10"), DFA.unpack(u""), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\3\2\uffff\2\3\5\uffff\1\3\30\uffff\1\3\2\uffff\1" u"\3\4\uffff\1\3\17\uffff\2\3\3\uffff\1\3\12\uffff\1\3\4\uffff\1" u"\3\31\uffff\1\23\13\uffff\1\3\12\uffff\1\3\122\uffff\1\3"), DFA.unpack(u"\1\5") ] # class definition for DFA #113 class DFA113(DFA): pass def specialStateTransition(self_, s, input): # convince pylint that my self_ magic is ok ;) # pylint: disable-msg=E0213 # pretend we are a member of the recognizer # thus semantic predicates can be evaluated self = self_.recognizer _s = s if s == 0: LA113_5 = input.LA(1) index113_5 = input.index() input.rewind() s = -1 if (self.synpred144_sdl92()): s = 7 elif (True): s = 3 input.seek(index113_5) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 113, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #114 DFA114_eot = DFA.unpack( u"\34\uffff" ) DFA114_eof = DFA.unpack( u"\1\4\1\uffff\1\4\31\uffff" ) DFA114_min = DFA.unpack( u"\1\14\1\7\1\14\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56\1\u0094" u"\1\143\1\u0086\1\u00e6\1\u0093\1\21\1\u0094\1\u0092\1\u0086\1\u0094" u"\1\u0086\1\u0093\1\u00e6\1\21\1\u00b7\1\u00b8\1\u00b9\1\56" ) DFA114_max = DFA.unpack( u"\1\u00e5\1\u00bb\1\u00e5\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086" u"\1\u00ba\1\u0094\1\143\1\u0086\1\u00e6\1\u0093\1\u0092\1\u0094" u"\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\u00e5\1\u00b7" u"\1\u00b8\1\u00b9\1\56" ) DFA114_accept = DFA.unpack( u"\3\uffff\1\1\1\2\27\uffff" ) DFA114_special = DFA.unpack( u"\34\uffff" ) DFA114_transition = [ DFA.unpack(u"\1\4\4\uffff\1\4\2\uffff\2\4\5\uffff\1\4\30\uffff\1" u"\4\2\uffff\1\3\4\uffff\1\3\17\uffff\2\4\3\uffff\1\3\2\uffff\1\4" u"\4\uffff\1\4\2\uffff\1\4\4\uffff\1\3\6\uffff\1\4\13\uffff\1\4\6" u"\uffff\1\2\3\uffff\2\4\2\uffff\2\4\2\uffff\4\4\2\uffff\1\4\4\uffff" u"\1\4\3\uffff\2\4\11\uffff\1\4\103\uffff\1\1"), DFA.unpack(u"\1\6\11\uffff\1\6\2\uffff\1\6\4\uffff\1\6\32\uffff" u"\1\6\2\uffff\2\6\3\uffff\1\6\3\uffff\1\6\10\uffff\2\6\1\uffff\2" u"\6\3\uffff\1\6\12\uffff\1\6\4\uffff\1\6\7\uffff\1\6\2\uffff\1\6" u"\32\uffff\1\6\57\uffff\1\5\3\uffff\1\4"), DFA.unpack(u"\1\4\4\uffff\1\4\2\uffff\1\4\67\uffff\1\4\14\uffff" u"\1\4\16\uffff\1\4\13\uffff\1\4\12\uffff\2\4\10\uffff\1\4\125\uffff" u"\1\3\5\uffff\1\4"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13\24\uffff\1\4\166\uffff\1\4"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\4\2\uffff\2\4\5\uffff\1\4\30\uffff\1\4\2\uffff\1" u"\3\4\uffff\1\3\20\uffff\1\4\3\uffff\1\3\12\uffff\1\4\4\uffff\1" u"\3\45\uffff\1\4\12\uffff\1\4"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\27"), DFA.unpack(u"\1\4\2\uffff\2\4\5\uffff\1\4\30\uffff\1\4\2\uffff\1" u"\3\4\uffff\1\3\17\uffff\2\4\3\uffff\1\3\12\uffff\1\4\4\uffff\1" u"\3\31\uffff\1\3\13\uffff\1\4\12\uffff\1\4\122\uffff\1\30"), DFA.unpack(u"\1\31"), DFA.unpack(u"\1\32"), DFA.unpack(u"\1\33"), DFA.unpack(u"\1\13") ] # class definition for DFA #114 class DFA114(DFA): pass # lookup tables for DFA #116 DFA116_eot = DFA.unpack( u"\22\uffff" ) DFA116_eof = DFA.unpack( u"\22\uffff" ) DFA116_min = DFA.unpack( u"\1\6\1\7\1\u0092\1\uffff\1\u0092\1\uffff\1\u0086\1\u0094\1\u0086" u"\1\u0093\1\u0094\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6" u"\1\31" ) DFA116_max = DFA.unpack( u"\1\u00e5\1\u00b7\1\u00e1\1\uffff\1\u0092\1\uffff\1\u0086\1\u0094" u"\1\u0086\1\u0093\1\u0094\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093" u"\1\u00e6\1\u00e5" ) DFA116_accept = DFA.unpack( u"\3\uffff\1\2\1\uffff\1\1\14\uffff" ) DFA116_special = DFA.unpack( u"\22\uffff" ) DFA116_transition = [ DFA.unpack(u"\1\3\22\uffff\1\3\7\uffff\1\3\11\uffff\1\3\24\uffff" u"\1\3\17\uffff\1\3\7\uffff\1\3\12\uffff\1\3\5\uffff\1\3\21\uffff" u"\1\2\31\uffff\1\3\11\uffff\1\3\105\uffff\1\1"), DFA.unpack(u"\1\4\11\uffff\1\4\2\uffff\1\4\4\uffff\1\4\32\uffff" u"\1\4\2\uffff\2\4\3\uffff\1\4\3\uffff\1\4\10\uffff\2\4\1\uffff\2" u"\4\3\uffff\1\4\12\uffff\1\4\4\uffff\1\4\7\uffff\1\4\2\uffff\1\4" u"\32\uffff\1\4\57\uffff\1\3"), DFA.unpack(u"\1\3\51\uffff\1\3\42\uffff\1\5\1\uffff\1\3"), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u""), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\3\46\uffff\1\3\50\uffff\1\3\21\uffff\1\5\31\uffff" u"\1\3\117\uffff\1\3") ] # class definition for DFA #116 class DFA116(DFA): pass # lookup tables for DFA #117 DFA117_eot = DFA.unpack( u"\40\uffff" ) DFA117_eof = DFA.unpack( u"\40\uffff" ) DFA117_min = DFA.unpack( u"\1\6\1\7\12\uffff\1\u0092\1\u00b8\1\u0086\1\u00b9\1\u0094\1\56" u"\1\u0086\1\143\1\u0093\1\u00e6\1\u0094\1\31\1\u0092\1\u0086\1\u0094" u"\1\u0086\1\u0093\1\u00e6\1\31\1\u00b7" ) DFA117_max = DFA.unpack( u"\1\u00e5\1\u00b7\12\uffff\1\u0092\1\u00b8\1\u0086\1\u00b9\1\u0094" u"\1\56\1\u0086\1\143\1\u0093\1\u00e6\1\u0094\1\u0095\1\u0092\1\u0086" u"\1\u0094\1\u0086\1\u0093\1\u00e6\1\u00e5\1\u00b7" ) DFA117_accept = DFA.unpack( u"\2\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\24\uffff" ) DFA117_special = DFA.unpack( u"\40\uffff" ) DFA117_transition = [ DFA.unpack(u"\1\7\22\uffff\1\6\7\uffff\1\12\11\uffff\1\3\24\uffff" u"\1\4\17\uffff\1\11\7\uffff\1\10\12\uffff\1\3\5\uffff\1\2\21\uffff" u"\1\3\31\uffff\1\13\11\uffff\1\5\105\uffff\1\1"), DFA.unpack(u"\1\14\11\uffff\1\14\2\uffff\1\14\4\uffff\1\14\32\uffff" u"\1\14\2\uffff\2\14\3\uffff\1\14\3\uffff\1\14\10\uffff\2\14\1\uffff" u"\2\14\3\uffff\1\14\12\uffff\1\14\4\uffff\1\14\7\uffff\1\14\2\uffff" u"\1\14\32\uffff\1\14\57\uffff\1\15"), 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""), DFA.unpack(u""), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\27"), DFA.unpack(u"\1\30"), DFA.unpack(u"\1\6\46\uffff\1\4\50\uffff\1\2\53\uffff\1\13"), DFA.unpack(u"\1\31"), DFA.unpack(u"\1\32"), DFA.unpack(u"\1\33"), DFA.unpack(u"\1\34"), DFA.unpack(u"\1\35"), DFA.unpack(u"\1\36"), DFA.unpack(u"\1\6\46\uffff\1\4\50\uffff\1\2\53\uffff\1\13\117\uffff" u"\1\37"), DFA.unpack(u"\1\15") ] # class definition for DFA #117 class DFA117(DFA): pass # lookup tables for DFA #128 DFA128_eot = DFA.unpack( u"\30\uffff" ) DFA128_eof = DFA.unpack( u"\30\uffff" ) DFA128_min = DFA.unpack( u"\1\33\1\7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56\1\u0094" u"\1\143\1\u0086\1\u00e6\1\u0093\1\33\1\u0094\1\u0092\1\u0086\1\u0094" u"\1\u0086\1\u0093\1\u00e6\1\33\1\u00b7" ) DFA128_max = DFA.unpack( u"\1\u00e5\1\u00b7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56\1" u"\u0094\1\143\1\u0086\1\u00e6\1\u0093\1\u0092\1\u0094\1\u0092\1" u"\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\u00e5\1\u00b7" ) DFA128_accept = DFA.unpack( u"\2\uffff\1\1\1\2\24\uffff" ) DFA128_special = DFA.unpack( u"\30\uffff" ) DFA128_transition = [ DFA.unpack(u"\1\3\166\uffff\1\2\122\uffff\1\1"), DFA.unpack(u"\1\5\11\uffff\1\5\2\uffff\1\5\4\uffff\1\5\32\uffff" u"\1\5\2\uffff\2\5\3\uffff\1\5\3\uffff\1\5\10\uffff\2\5\1\uffff\2" u"\5\3\uffff\1\5\12\uffff\1\5\4\uffff\1\5\7\uffff\1\5\2\uffff\1\5" u"\32\uffff\1\5\57\uffff\1\4"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\3\166\uffff\1\2"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\3\166\uffff\1\2\122\uffff\1\27"), DFA.unpack(u"\1\4") ] # class definition for DFA #128 class DFA128(DFA): pass # lookup tables for DFA #126 DFA126_eot = DFA.unpack( u"\30\uffff" ) DFA126_eof = DFA.unpack( u"\1\2\27\uffff" ) DFA126_min = DFA.unpack( u"\1\33\1\7\2\uffff\1\u0092\1\u00b8\1\u0086\1\u00b9\1\u0094\1\56" u"\1\u0086\1\143\1\u0093\1\u00e6\1\u0094\1\33\1\u0092\1\u0086\1\u0094" u"\1\u0086\1\u0093\1\u00e6\1\33\1\u00b7" ) DFA126_max = DFA.unpack( u"\1\u00e5\1\u00b7\2\uffff\1\u0092\1\u00b8\1\u0086\1\u00b9\1\u0094" u"\1\56\1\u0086\1\143\1\u0093\1\u00e6\1\u0094\2\u0092\1\u0086\1\u0094" u"\1\u0086\1\u0093\1\u00e6\1\u00e5\1\u00b7" ) DFA126_accept = DFA.unpack( u"\2\uffff\1\2\1\1\24\uffff" ) DFA126_special = DFA.unpack( u"\30\uffff" ) DFA126_transition = [ DFA.unpack(u"\1\2\166\uffff\1\3\3\uffff\2\2\115\uffff\1\1"), DFA.unpack(u"\1\4\11\uffff\1\4\2\uffff\1\4\4\uffff\1\4\32\uffff" u"\1\4\2\uffff\2\4\3\uffff\1\4\3\uffff\1\4\10\uffff\2\4\1\uffff\2" u"\4\3\uffff\1\4\12\uffff\1\4\4\uffff\1\4\7\uffff\1\4\2\uffff\1\4" u"\32\uffff\1\4\57\uffff\1\5"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\2\166\uffff\1\3"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\2\166\uffff\1\3\122\uffff\1\27"), DFA.unpack(u"\1\5") ] # class definition for DFA #126 class DFA126(DFA): pass # lookup tables for DFA #136 DFA136_eot = DFA.unpack( u"\30\uffff" ) DFA136_eof = DFA.unpack( u"\1\3\27\uffff" ) DFA136_min = DFA.unpack( u"\1\6\1\7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56\1\u0094\1" u"\143\1\u0086\1\u00e6\1\u0093\1\31\1\u0094\1\u0092\1\u0086\1\u0094" u"\1\u0086\1\u0093\1\u00e6\1\31\1\u00b7" ) DFA136_max = DFA.unpack( u"\1\u00e5\1\u00b7\2\uffff\1\u00b8\1\u0092\1\u00b9\1\u0086\1\56\1" u"\u0094\1\143\1\u0086\1\u00e6\1\u0093\1\u0095\1\u0094\1\u0092\1" u"\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\u00e5\1\u00b7" ) DFA136_accept = DFA.unpack( u"\2\uffff\1\1\1\2\24\uffff" ) DFA136_special = DFA.unpack( u"\30\uffff" ) DFA136_transition = [ DFA.unpack(u"\1\2\22\uffff\1\2\1\uffff\1\3\5\uffff\1\2\11\uffff\1" u"\2\13\uffff\1\2\4\uffff\1\2\3\uffff\1\2\17\uffff\2\2\6\uffff\1" u"\2\10\uffff\1\2\1\uffff\1\2\5\uffff\1\2\21\uffff\1\2\26\uffff\1" u"\3\2\uffff\1\2\2\3\7\uffff\1\2\105\uffff\1\1"), DFA.unpack(u"\1\5\11\uffff\1\5\2\uffff\1\5\4\uffff\1\5\32\uffff" u"\1\5\2\uffff\2\5\3\uffff\1\5\3\uffff\1\5\10\uffff\2\5\1\uffff\2" u"\5\3\uffff\1\5\12\uffff\1\5\4\uffff\1\5\7\uffff\1\5\2\uffff\1\5" u"\32\uffff\1\5\57\uffff\1\4"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\2\1\uffff\1\3\33\uffff\1\2\4\uffff\1\2\3\uffff\1" u"\2\20\uffff\1\2\17\uffff\1\2\7\uffff\1\2\50\uffff\1\3\2\uffff\1" u"\2"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\2\1\uffff\1\3\33\uffff\1\2\4\uffff\1\2\3\uffff\1" u"\2\20\uffff\1\2\17\uffff\1\2\7\uffff\1\2\21\uffff\1\2\26\uffff" u"\1\3\2\uffff\1\2\117\uffff\1\27"), DFA.unpack(u"\1\4") ] # class definition for DFA #136 class DFA136(DFA): pass # lookup tables for DFA #142 DFA142_eot = DFA.unpack( u"\27\uffff" ) DFA142_eof = DFA.unpack( u"\27\uffff" ) DFA142_min = DFA.unpack( u"\1\51\17\0\7\uffff" ) DFA142_max = DFA.unpack( u"\1\u00bd\17\0\7\uffff" ) DFA142_accept = DFA.unpack( u"\20\uffff\1\2\5\uffff\1\1" ) DFA142_special = DFA.unpack( u"\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1" u"\14\1\15\1\16\7\uffff" ) DFA142_transition = [ DFA.unpack(u"\1\11\5\uffff\1\15\54\uffff\1\13\6\uffff\1\4\27\uffff" u"\1\1\12\uffff\1\10\13\uffff\1\14\6\uffff\6\20\7\uffff\1\17\4\uffff" u"\1\16\1\2\1\3\1\5\1\6\1\7\14\uffff\1\12"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), 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 #142 class DFA142(DFA): pass def specialStateTransition(self_, s, input): # convince pylint that my self_ magic is ok ;) # pylint: disable-msg=E0213 # pretend we are a member of the recognizer # thus semantic predicates can be evaluated self = self_.recognizer _s = s if s == 0: LA142_1 = input.LA(1) index142_1 = input.index() input.rewind() s = -1 if (self.synpred182_sdl92()): s = 22 elif (True): s = 16 input.seek(index142_1) if s >= 0: return s elif s == 1: LA142_2 = input.LA(1) index142_2 = input.index() input.rewind() s = -1 if (self.synpred182_sdl92()): s = 22 elif (True): s = 16 input.seek(index142_2) if s >= 0: return s elif s == 2: LA142_3 = input.LA(1) index142_3 = input.index() input.rewind() s = -1 if (self.synpred182_sdl92()): s = 22 elif (True): s = 16 input.seek(index142_3) if s >= 0: return s elif s == 3: LA142_4 = input.LA(1) index142_4 = input.index() input.rewind() s = -1 if (self.synpred182_sdl92()): s = 22 elif (True): s = 16 input.seek(index142_4) if s >= 0: return s elif s == 4: LA142_5 = input.LA(1) index142_5 = input.index() input.rewind() s = -1 if (self.synpred182_sdl92()): s = 22 elif (True): s = 16 input.seek(index142_5) if s >= 0: return s elif s == 5: LA142_6 = input.LA(1) index142_6 = input.index() input.rewind() s = -1 if (self.synpred182_sdl92()): s = 22 elif (True): s = 16 input.seek(index142_6) if s >= 0: return s elif s == 6: LA142_7 = input.LA(1) index142_7 = input.index() input.rewind() s = -1 if (self.synpred182_sdl92()): s = 22 elif (True): s = 16 input.seek(index142_7) if s >= 0: return s elif s == 7: LA142_8 = input.LA(1) index142_8 = input.index() input.rewind() s = -1 if (self.synpred182_sdl92()): s = 22 elif (True): s = 16 input.seek(index142_8) if s >= 0: return s elif s == 8: LA142_9 = input.LA(1) index142_9 = input.index() input.rewind() s = -1 if (self.synpred182_sdl92()): s = 22 elif (True): s = 16 input.seek(index142_9) if s >= 0: return s elif s == 9: LA142_10 = input.LA(1) index142_10 = input.index() input.rewind() s = -1 if (self.synpred182_sdl92()): s = 22 elif (True): s = 16 input.seek(index142_10) if s >= 0: return s elif s == 10: LA142_11 = input.LA(1) index142_11 = input.index() input.rewind() s = -1 if (self.synpred182_sdl92()): s = 22 elif (True): s = 16 input.seek(index142_11) if s >= 0: return s elif s == 11: LA142_12 = input.LA(1) index142_12 = input.index() input.rewind() s = -1 if (self.synpred182_sdl92()): s = 22 elif (True): s = 16 input.seek(index142_12) if s >= 0: return s elif s == 12: LA142_13 = input.LA(1) index142_13 = input.index() input.rewind() s = -1 if (self.synpred182_sdl92()): s = 22 elif (True): s = 16 input.seek(index142_13) if s >= 0: return s elif s == 13: LA142_14 = input.LA(1) index142_14 = input.index() input.rewind() s = -1 if (self.synpred182_sdl92()): s = 22 elif (True): s = 16 input.seek(index142_14) if s >= 0: return s elif s == 14: LA142_15 = input.LA(1) index142_15 = input.index() input.rewind() s = -1 if (self.synpred182_sdl92()): s = 22 elif (True): s = 16 input.seek(index142_15) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 142, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #175 DFA175_eot = DFA.unpack( u"\12\uffff" ) DFA175_eof = DFA.unpack( u"\1\1\11\uffff" ) DFA175_min = DFA.unpack( u"\1\6\1\uffff\7\0\1\uffff" ) DFA175_max = DFA.unpack( u"\1\u00e5\1\uffff\7\0\1\uffff" ) DFA175_accept = DFA.unpack( u"\1\uffff\1\2\7\uffff\1\1" ) DFA175_special = DFA.unpack( u"\2\uffff\1\2\1\6\1\5\1\1\1\4\1\0\1\3\1\uffff" ) DFA175_transition = [ DFA.unpack(u"\1\1\5\uffff\1\1\4\uffff\1\1\2\uffff\2\1\3\uffff\1\1" u"\1\uffff\1\1\2\uffff\1\1\2\uffff\1\1\2\uffff\1\1\6\uffff\1\1\5" u"\uffff\1\10\2\uffff\1\1\2\uffff\1\1\4\uffff\1\1\3\uffff\1\1\13" u"\uffff\2\1\2\uffff\2\1\2\uffff\1\1\3\uffff\2\1\2\uffff\1\1\4\uffff" u"\1\1\1\uffff\1\1\4\uffff\2\1\5\uffff\1\1\4\uffff\1\1\6\uffff\1" u"\1\3\uffff\3\1\1\uffff\2\1\2\uffff\5\1\1\uffff\1\1\4\uffff\6\1" u"\1\uffff\1\2\1\3\1\4\1\6\1\7\1\5\1\1\1\uffff\12\1\23\uffff\1\1" u"\30\uffff\1\1\7\uffff\1\1\1\uffff\1\1\1\uffff\1\1\1\uffff\1\1"), DFA.unpack(u""), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"") ] # class definition for DFA #175 class DFA175(DFA): pass def specialStateTransition(self_, s, input): # convince pylint that my self_ magic is ok ;) # pylint: disable-msg=E0213 # pretend we are a member of the recognizer # thus semantic predicates can be evaluated self = self_.recognizer _s = s if s == 0: LA175_7 = input.LA(1) index175_7 = input.index() input.rewind() s = -1 if (self.synpred227_sdl92()): s = 9 elif (True): s = 1 input.seek(index175_7) if s >= 0: return s elif s == 1: LA175_5 = input.LA(1) index175_5 = input.index() input.rewind() s = -1 if (self.synpred227_sdl92()): s = 9 elif (True): s = 1 input.seek(index175_5) if s >= 0: return s elif s == 2: LA175_2 = input.LA(1) index175_2 = input.index() input.rewind() s = -1 if (self.synpred227_sdl92()): s = 9 elif (True): s = 1 input.seek(index175_2) if s >= 0: return s elif s == 3: LA175_8 = input.LA(1) index175_8 = input.index() input.rewind() s = -1 if (self.synpred227_sdl92()): s = 9 elif (True): s = 1 input.seek(index175_8) if s >= 0: return s elif s == 4: LA175_6 = input.LA(1) index175_6 = input.index() input.rewind() s = -1 if (self.synpred227_sdl92()): s = 9 elif (True): s = 1 input.seek(index175_6) if s >= 0: return s elif s == 5: LA175_4 = input.LA(1) index175_4 = input.index() input.rewind() s = -1 if (self.synpred227_sdl92()): s = 9 elif (True): s = 1 input.seek(index175_4) if s >= 0: return s elif s == 6: LA175_3 = input.LA(1) index175_3 = input.index() input.rewind() s = -1 if (self.synpred227_sdl92()): s = 9 elif (True): s = 1 input.seek(index175_3) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 175, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #180 DFA180_eot = DFA.unpack( u"\21\uffff" ) DFA180_eof = DFA.unpack( u"\21\uffff" ) DFA180_min = DFA.unpack( u"\1\51\1\0\17\uffff" ) DFA180_max = DFA.unpack( u"\1\u00bd\1\0\17\uffff" ) DFA180_accept = DFA.unpack( u"\2\uffff\1\2\13\uffff\1\3\1\4\1\1" ) DFA180_special = DFA.unpack( u"\1\uffff\1\0\17\uffff" ) DFA180_transition = [ DFA.unpack(u"\1\2\5\uffff\1\2\54\uffff\1\2\6\uffff\1\2\27\uffff\1" u"\1\12\uffff\1\2\13\uffff\1\2\23\uffff\1\17\4\uffff\1\16\5\2\14" u"\uffff\1\2"), DFA.unpack(u"\1\uffff"), 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""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"") ] # class definition for DFA #180 class DFA180(DFA): pass def specialStateTransition(self_, s, input): # convince pylint that my self_ magic is ok ;) # pylint: disable-msg=E0213 # pretend we are a member of the recognizer # thus semantic predicates can be evaluated self = self_.recognizer _s = s if s == 0: LA180_1 = input.LA(1) index180_1 = input.index() input.rewind() s = -1 if (self.synpred235_sdl92()): s = 16 elif (self.synpred236_sdl92()): s = 2 input.seek(index180_1) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 180, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #181 DFA181_eot = DFA.unpack( u"\114\uffff" ) DFA181_eof = DFA.unpack( u"\1\1\113\uffff" ) DFA181_min = DFA.unpack( u"\1\6\63\uffff\1\0\20\uffff\1\0\6\uffff" ) DFA181_max = DFA.unpack( u"\1\u00e5\63\uffff\1\0\20\uffff\1\0\6\uffff" ) DFA181_accept = DFA.unpack( u"\1\uffff\1\3\110\uffff\1\1\1\2" ) DFA181_special = DFA.unpack( u"\64\uffff\1\0\20\uffff\1\1\6\uffff" ) DFA181_transition = [ DFA.unpack(u"\1\1\5\uffff\1\1\4\uffff\1\1\2\uffff\2\1\3\uffff\1\1" u"\1\uffff\1\1\2\uffff\1\1\2\uffff\1\1\2\uffff\1\1\6\uffff\1\1\5" u"\uffff\1\1\2\uffff\1\1\2\uffff\1\1\4\uffff\1\1\3\uffff\1\1\13\uffff" u"\2\1\2\uffff\2\1\2\uffff\1\1\3\uffff\2\1\2\uffff\1\1\4\uffff\1" u"\1\1\uffff\1\1\4\uffff\2\1\5\uffff\1\1\4\uffff\1\1\6\uffff\1\1" u"\3\uffff\3\1\1\uffff\2\1\2\uffff\5\1\1\uffff\1\1\4\uffff\1\64\5" u"\1\1\uffff\7\1\1\uffff\12\1\21\uffff\1\1\1\uffff\1\1\30\uffff\1" u"\1\7\uffff\1\1\1\uffff\1\105\1\uffff\1\1\1\uffff\1\1"), 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""), 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""), 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""), 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""), 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""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\uffff"), 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""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\uffff"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"") ] # class definition for DFA #181 class DFA181(DFA): pass def specialStateTransition(self_, s, input): # convince pylint that my self_ magic is ok ;) # pylint: disable-msg=E0213 # pretend we are a member of the recognizer # thus semantic predicates can be evaluated self = self_.recognizer _s = s if s == 0: LA181_52 = input.LA(1) index181_52 = input.index() input.rewind() s = -1 if (self.synpred238_sdl92()): s = 74 elif (True): s = 1 input.seek(index181_52) if s >= 0: return s elif s == 1: LA181_69 = input.LA(1) index181_69 = input.index() input.rewind() s = -1 if (self.synpred239_sdl92()): s = 75 elif (True): s = 1 input.seek(index181_69) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 181, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #185 DFA185_eot = DFA.unpack( u"\22\uffff" ) DFA185_eof = DFA.unpack( u"\22\uffff" ) DFA185_min = DFA.unpack( u"\1\51\10\uffff\2\0\7\uffff" ) DFA185_max = DFA.unpack( u"\1\u00bd\10\uffff\2\0\7\uffff" ) DFA185_accept = DFA.unpack( u"\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\2\uffff\1\17\1\11\1\12" u"\1\13\1\14\1\15\1\16" ) DFA185_special = DFA.unpack( u"\11\uffff\1\0\1\1\7\uffff" ) DFA185_transition = [ DFA.unpack(u"\1\10\62\uffff\1\13\6\uffff\1\3\27\uffff\1\11\12\uffff" u"\1\7\45\uffff\1\1\1\2\1\4\1\5\1\6\14\uffff\1\12"), 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"\1\uffff"), DFA.unpack(u"\1\uffff"), 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 #185 class DFA185(DFA): pass def specialStateTransition(self_, s, input): # convince pylint that my self_ magic is ok ;) # pylint: disable-msg=E0213 # pretend we are a member of the recognizer # thus semantic predicates can be evaluated self = self_.recognizer _s = s if s == 0: LA185_9 = input.LA(1) index185_9 = input.index() input.rewind() s = -1 if (self.synpred250_sdl92()): s = 12 elif (self.synpred251_sdl92()): s = 13 input.seek(index185_9) if s >= 0: return s elif s == 1: LA185_10 = input.LA(1) index185_10 = input.index() input.rewind() s = -1 if (self.synpred252_sdl92()): s = 14 elif (self.synpred253_sdl92()): s = 15 elif (self.synpred255_sdl92()): s = 16 elif (self.synpred257_sdl92()): s = 17 input.seek(index185_10) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 185, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #194 DFA194_eot = DFA.unpack( u"\21\uffff" ) DFA194_eof = DFA.unpack( u"\21\uffff" ) DFA194_min = DFA.unpack( u"\1\67\1\7\2\uffff\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093\1\u0094" u"\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093\1\u00e6\1\67" ) DFA194_max = DFA.unpack( u"\1\u00e5\1\u00b7\2\uffff\1\u0092\1\u0086\1\u0094\1\u0086\1\u0093" u"\1\u0094\1\u0092\1\u008