# $ANTLR 3.1.3 Mar 17, 2009 19:23:44 sdl92.g 2017-03-20 14:35:42 import sys from antlr3 import * from antlr3.compat import set, frozenset from antlr3.tree import * # for convenience in actions HIDDEN = BaseRecognizer.HIDDEN # token types CREATE=160 ENTRY_POINT=32 ENDSTATE=139 STR=216 PROCESS=76 STOP=97 ENDFOR=162 PROVIDED=77 CONDITIONAL=19 CHANNEL=13 THEN=111 XOR=166 CALL=150 A=189 B=211 PFPAR=70 SET=88 C=193 D=192 E=195 F=202 G=203 H=205 L_BRACKET=187 I=201 OPEN_RANGE=63 J=212 K=196 L=194 M=199 ENDSYSTEM=122 N=190 O=204 P=197 Q=221 R=198 S=200 T=206 U=208 VARIABLE=118 V=209 GROUND=45 W=210 X=207 Y=191 FPAR=44 Z=222 PROCEDURE=73 PARAMNAMES=67 PAREN=69 APPEND=169 NEWTYPE=59 CONNECTION=21 DIV=170 SELECTOR=85 MINUS_INFINITY=177 STRING=99 VARIABLES=119 TO=113 REM=172 ASSIG_OP=186 SYSTEM=104 ROUTE=83 T__223=223 ENDCHANNEL=124 IFTHENELSE=48 TASK_BODY=106 ALPHA=217 PRIORITY=146 VIEW=214 HYPERLINK=46 LABEL=56 CIF=15 OUTPUT=64 FOR=43 INPUTLIST=54 EQ=154 FLOATING_LABEL=42 VIAPATH=121 FLOAT2=40 NOT=173 SPECIFIC=182 STIMULUS=96 THIS=161 ENDPROCEDURE=134 END=185 AGGREGATION=141 FI=36 DIGITS=26 STATE=92 OUTPUT_BODY=65 QUESTION=78 BITSTR=11 BASE=179 RETURN=81 STATE_AGGREGATION=93 ENDNEWTYPE=29 SEQUENCE=87 R_PAREN=148 WS=219 EOF=-1 GE=159 NEXTSTATE=60 ANSWER=7 MOD=171 SEQOF=86 PLUS_INFINITY=176 PARAM=66 R_BRACKET=188 GT=156 WITH=126 ACTION=4 T__229=229 STOPIF=98 T__228=228 START=137 FALSE=175 T__225=225 T__224=224 T__227=227 DEFAULT=144 T__226=226 IMPLIES=164 ENDCONNECTION=138 ENDDECISION=152 EXPORT=33 JOIN=55 TEXT=108 REFERENCED=131 ALTERNATIVE=6 SYNTYPE=103 ELSE=27 PROCEDURE_NAME=75 ID=123 NONE=145 IF=47 TYPE=130 SUBSTRUCTURE=142 FIELDS=39 LITERAL=57 IN=49 FIELD=37 DOT=163 SYNONYM=101 OUT=135 ENDBLOCK=127 STATELIST=95 SEMI=133 CONNECT=20 ASN1=9 ASSIGN=10 COMMENT=17 IMPORT=213 MANTISSA=178 SAVE=84 CLOSED_RANGE=16 SIGNAL=89 COMMA=149 ENDTEXT=31 NUMBER_OF_INSTANCES=61 USE=116 RETURNS=82 CONSTANT=22 ASTERISK=140 COMMENT2=220 TRANSITION=114 NEG=58 LE=158 EXPONENT=180 NEQ=155 GEODE=183 EXPRESSION=34 ALL=5 SYNONYM_LIST=102 TERMINATOR=107 DECISION=25 TEXTAREA_CONTENT=110 ARRAY=8 INPUT=52 LT=157 STATE_PARTITION_CONNECTION=94 ENDALTERNATIVE=151 RESET=80 VALUE=117 FROM=125 DASH=168 TASK=105 KEEP=181 BLOCK=12 TRUE=174 ENDSYNTYPE=30 DCL=24 OCTSTR=62 AND=129 SORT=91 PARAMS=68 STRUCT=100 RANGE=79 PLUS=167 INOUT=51 FLOAT=41 CONSTANTS=23 ACTIVE=215 Exponent=218 L_PAREN=147 ANY=153 INT=136 CHOICE=14 EXTERNAL=35 FIELD_NAME=38 TYPE_INSTANCE=115 ENDSUBSTRUCTURE=143 PROCEDURE_CALL=74 TEXTAREA=109 OR=165 SIGNAL_LIST=90 INFORMAL_TEXT=50 TIMER=112 PRIMARY=72 COMPOSITE_STATE=18 VIA=120 ASNFILENAME=184 ENDPROCESS=132 EMPTYSTR=28 SIGNALROUTE=128 INPUT_NONE=53 POINT=71 # 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", "TYPE", "REFERENCED", "ENDPROCESS", "SEMI", "ENDPROCEDURE", "OUT", "INT", "START", "ENDCONNECTION", "ENDSTATE", "ASTERISK", "AGGREGATION", "SUBSTRUCTURE", "ENDSUBSTRUCTURE", "DEFAULT", "NONE", "PRIORITY", "L_PAREN", "R_PAREN", "COMMA", "CALL", "ENDALTERNATIVE", "ENDDECISION", "ANY", "EQ", "NEQ", "GT", "LT", "LE", "GE", "CREATE", "THIS", "ENDFOR", "DOT", "IMPLIES", "OR", "XOR", "PLUS", "DASH", "APPEND", "DIV", "MOD", "REM", "NOT", "TRUE", "FALSE", "PLUS_INFINITY", "MINUS_INFINITY", "MANTISSA", "BASE", "EXPONENT", "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", "IMPORT", "VIEW", "ACTIVE", "STR", "ALPHA", "Exponent", "WS", "COMMENT2", "Q", "Z", "':'", "'->'", "'!'", "'(.'", "'.)'", "'/* 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.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.dfa22 = self.DFA22( self, 22, eot = self.DFA22_eot, eof = self.DFA22_eof, min = self.DFA22_min, max = self.DFA22_max, accept = self.DFA22_accept, special = self.DFA22_special, transition = self.DFA22_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.dfa28 = self.DFA28( self, 28, eot = self.DFA28_eot, eof = self.DFA28_eof, min = self.DFA28_min, max = self.DFA28_max, accept = self.DFA28_accept, special = self.DFA28_special, transition = self.DFA28_transition ) self.dfa40 = self.DFA40( self, 40, eot = self.DFA40_eot, eof = self.DFA40_eof, min = self.DFA40_min, max = self.DFA40_max, accept = self.DFA40_accept, special = self.DFA40_special, transition = self.DFA40_transition ) self.dfa45 = self.DFA45( self, 45, eot = self.DFA45_eot, eof = self.DFA45_eof, min = self.DFA45_min, max = self.DFA45_max, accept = self.DFA45_accept, special = self.DFA45_special, transition = self.DFA45_transition ) self.dfa52 = self.DFA52( self, 52, eot = self.DFA52_eot, eof = self.DFA52_eof, min = self.DFA52_min, max = self.DFA52_max, accept = self.DFA52_accept, special = self.DFA52_special, transition = self.DFA52_transition ) self.dfa58 = self.DFA58( self, 58, eot = self.DFA58_eot, eof = self.DFA58_eof, min = self.DFA58_min, max = self.DFA58_max, accept = self.DFA58_accept, special = self.DFA58_special, transition = self.DFA58_transition ) self.dfa59 = self.DFA59( self, 59, eot = self.DFA59_eot, eof = self.DFA59_eof, min = self.DFA59_min, max = self.DFA59_max, accept = self.DFA59_accept, special = self.DFA59_special, transition = self.DFA59_transition ) self.dfa63 = self.DFA63( self, 63, eot = self.DFA63_eot, eof = self.DFA63_eof, min = self.DFA63_min, max = self.DFA63_max, accept = self.DFA63_accept, special = self.DFA63_special, transition = self.DFA63_transition ) self.dfa82 = self.DFA82( self, 82, eot = self.DFA82_eot, eof = self.DFA82_eof, min = self.DFA82_min, max = self.DFA82_max, accept = self.DFA82_accept, special = self.DFA82_special, transition = self.DFA82_transition ) self.dfa85 = self.DFA85( self, 85, eot = self.DFA85_eot, eof = self.DFA85_eof, min = self.DFA85_min, max = self.DFA85_max, accept = self.DFA85_accept, special = self.DFA85_special, transition = self.DFA85_transition ) self.dfa90 = self.DFA90( self, 90, eot = self.DFA90_eot, eof = self.DFA90_eof, min = self.DFA90_min, max = self.DFA90_max, accept = self.DFA90_accept, special = self.DFA90_special, transition = self.DFA90_transition ) self.dfa91 = self.DFA91( self, 91, eot = self.DFA91_eot, eof = self.DFA91_eof, min = self.DFA91_min, max = self.DFA91_max, accept = self.DFA91_accept, special = self.DFA91_special, transition = self.DFA91_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.dfa94 = self.DFA94( self, 94, eot = self.DFA94_eot, eof = self.DFA94_eof, min = self.DFA94_min, max = self.DFA94_max, accept = self.DFA94_accept, special = self.DFA94_special, transition = self.DFA94_transition ) self.dfa98 = self.DFA98( self, 98, eot = self.DFA98_eot, eof = self.DFA98_eof, min = self.DFA98_min, max = self.DFA98_max, accept = self.DFA98_accept, special = self.DFA98_special, transition = self.DFA98_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.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.dfa121 = self.DFA121( self, 121, eot = self.DFA121_eot, eof = self.DFA121_eof, min = self.DFA121_min, max = self.DFA121_max, accept = self.DFA121_accept, special = self.DFA121_special, transition = self.DFA121_transition ) self.dfa118 = self.DFA118( self, 118, eot = self.DFA118_eot, eof = self.DFA118_eof, min = self.DFA118_min, max = self.DFA118_max, accept = self.DFA118_accept, special = self.DFA118_special, transition = self.DFA118_transition ) self.dfa119 = self.DFA119( self, 119, eot = self.DFA119_eot, eof = self.DFA119_eof, min = self.DFA119_min, max = self.DFA119_max, accept = self.DFA119_accept, special = self.DFA119_special, transition = self.DFA119_transition ) self.dfa120 = self.DFA120( self, 120, eot = self.DFA120_eot, eof = self.DFA120_eof, min = self.DFA120_min, max = self.DFA120_max, accept = self.DFA120_accept, special = self.DFA120_special, transition = self.DFA120_transition ) self.dfa122 = self.DFA122( self, 122, eot = self.DFA122_eot, eof = self.DFA122_eof, min = self.DFA122_min, max = self.DFA122_max, accept = self.DFA122_accept, special = self.DFA122_special, transition = self.DFA122_transition ) self.dfa123 = self.DFA123( self, 123, eot = self.DFA123_eot, eof = self.DFA123_eof, min = self.DFA123_min, max = self.DFA123_max, accept = self.DFA123_accept, special = self.DFA123_special, transition = self.DFA123_transition ) self.dfa134 = self.DFA134( self, 134, eot = self.DFA134_eot, eof = self.DFA134_eof, min = self.DFA134_min, max = self.DFA134_max, accept = self.DFA134_accept, special = self.DFA134_special, transition = self.DFA134_transition ) self.dfa132 = self.DFA132( self, 132, eot = self.DFA132_eot, eof = self.DFA132_eof, min = self.DFA132_min, max = self.DFA132_max, accept = self.DFA132_accept, special = self.DFA132_special, transition = self.DFA132_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.dfa148 = self.DFA148( self, 148, eot = self.DFA148_eot, eof = self.DFA148_eof, min = self.DFA148_min, max = self.DFA148_max, accept = self.DFA148_accept, special = self.DFA148_special, transition = self.DFA148_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.dfa186 = self.DFA186( self, 186, eot = self.DFA186_eot, eof = self.DFA186_eof, min = self.DFA186_min, max = self.DFA186_max, accept = self.DFA186_accept, special = self.DFA186_special, transition = self.DFA186_transition ) self.dfa188 = self.DFA188( self, 188, eot = self.DFA188_eot, eof = self.DFA188_eof, min = self.DFA188_min, max = self.DFA188_max, accept = self.DFA188_accept, special = self.DFA188_special, transition = self.DFA188_transition ) self.dfa192 = self.DFA192( self, 192, eot = self.DFA192_eot, eof = self.DFA192_eof, min = self.DFA192_min, max = self.DFA192_max, accept = self.DFA192_accept, special = self.DFA192_special, transition = self.DFA192_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 == 228: LA1_2 = self.input.LA(2) if (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_2 == KEEP) : alt1 = 1 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_SYSTEM = RewriteRuleTokenStream(self._adaptor, "token SYSTEM") stream_ENDSYSTEM = RewriteRuleTokenStream(self._adaptor, "token ENDSYSTEM") 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 == 228) : 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: entity_in_system, system_name, 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_DIV = RewriteRuleTokenStream(self._adaptor, "token DIV") stream_USE = RewriteRuleTokenStream(self._adaptor, "token USE") stream_use_asn1 = RewriteRuleSubtreeStream(self._adaptor, "rule use_asn1") stream_package_name = RewriteRuleSubtreeStream(self._adaptor, "rule package_name") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_def_selection_list = RewriteRuleSubtreeStream(self._adaptor, "rule def_selection_list") 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 == 228) : 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, package_name, end, def_selection_list, use_asn1 # 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 == 228: 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_paramnames = RewriteRuleSubtreeStream(self._adaptor, "rule paramnames") stream_input_params = RewriteRuleSubtreeStream(self._adaptor, "rule input_params") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_signal_id = RewriteRuleSubtreeStream(self._adaptor, "rule signal_id") 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 == 228) : 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, paramnames, input_params, signal_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() # 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_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_channel_id = RewriteRuleSubtreeStream(self._adaptor, "rule channel_id") 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: channel_id, route, 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_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_FROM = RewriteRuleTokenStream(self._adaptor, "token FROM") stream_TO = RewriteRuleTokenStream(self._adaptor, "token TO") stream_WITH = RewriteRuleTokenStream(self._adaptor, "token WITH") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") 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") 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_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_entity_in_block = RewriteRuleSubtreeStream(self._adaptor, "rule entity_in_block") 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 == 228) : 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, entity_in_block, block_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() # 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 == 228: 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: route_id, SIGNALROUTE, route # 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_AND = RewriteRuleTokenStream(self._adaptor, "token AND") stream_CONNECT = RewriteRuleTokenStream(self._adaptor, "token CONNECT") stream_route_id = RewriteRuleSubtreeStream(self._adaptor, "rule route_id") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_channel_id = RewriteRuleSubtreeStream(self._adaptor, "rule channel_id") 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 (t= TYPE )? process_id ( number_of_instances )? ( ':' type_inst )? ( REFERENCED )? a= end ( pfpar )? ( text_area | procedure | ( composite_state_preamble )=> composite_state )* ( processBody )? ( ENDPROCESS )? ( TYPE )? ( process_id )? ( end )? -> ^( PROCESS ( cif )? process_id ( number_of_instances )? ( type_inst )? ( $t)? ( 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 t = None PROCESS64 = None char_literal67 = None REFERENCED69 = None ENDPROCESS75 = None TYPE76 = 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_id77 = None end78 = None t_tree = None PROCESS64_tree = None char_literal67_tree = None REFERENCED69_tree = None ENDPROCESS75_tree = None TYPE76_tree = None stream_223 = RewriteRuleTokenStream(self._adaptor, "token 223") stream_PROCESS = RewriteRuleTokenStream(self._adaptor, "token PROCESS") stream_ENDPROCESS = RewriteRuleTokenStream(self._adaptor, "token ENDPROCESS") stream_TYPE = RewriteRuleTokenStream(self._adaptor, "token TYPE") stream_REFERENCED = RewriteRuleTokenStream(self._adaptor, "token REFERENCED") stream_text_area = RewriteRuleSubtreeStream(self._adaptor, "rule text_area") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_process_id = RewriteRuleSubtreeStream(self._adaptor, "rule process_id") stream_pfpar = RewriteRuleSubtreeStream(self._adaptor, "rule pfpar") stream_processBody = RewriteRuleSubtreeStream(self._adaptor, "rule processBody") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_type_inst = RewriteRuleSubtreeStream(self._adaptor, "rule type_inst") stream_procedure = RewriteRuleSubtreeStream(self._adaptor, "rule procedure") stream_composite_state = RewriteRuleSubtreeStream(self._adaptor, "rule composite_state") stream_number_of_instances = RewriteRuleSubtreeStream(self._adaptor, "rule number_of_instances") try: try: # sdl92.g:256:9: ( ( cif )? PROCESS (t= TYPE )? process_id ( number_of_instances )? ( ':' type_inst )? ( REFERENCED )? a= end ( pfpar )? ( text_area | procedure | ( composite_state_preamble )=> composite_state )* ( processBody )? ( ENDPROCESS )? ( TYPE )? ( process_id )? ( end )? -> ^( PROCESS ( cif )? process_id ( number_of_instances )? ( type_inst )? ( $t)? ( REFERENCED )? ( $a)? ( pfpar )? ( text_area )* ( procedure )* ( composite_state )* ( processBody )? ) ) # sdl92.g:256:17: ( cif )? PROCESS (t= TYPE )? process_id ( number_of_instances )? ( ':' type_inst )? ( REFERENCED )? a= end ( pfpar )? ( text_area | procedure | ( composite_state_preamble )=> composite_state )* ( processBody )? ( ENDPROCESS )? ( TYPE )? ( process_id )? ( end )? pass # sdl92.g:256:17: ( cif )? alt15 = 2 LA15_0 = self.input.LA(1) if (LA15_0 == 228) : 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) # sdl92.g:257:26: (t= TYPE )? alt16 = 2 LA16_0 = self.input.LA(1) if (LA16_0 == TYPE) : alt16 = 1 if alt16 == 1: # sdl92.g:0:0: t= TYPE pass t=self.match(self.input, TYPE, self.FOLLOW_TYPE_in_process_definition2470) if self._state.backtracking == 0: stream_TYPE.add(t) self._state.following.append(self.FOLLOW_process_id_in_process_definition2473) 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 )? alt17 = 2 LA17_0 = self.input.LA(1) if (LA17_0 == L_PAREN) : alt17 = 1 if alt17 == 1: # sdl92.g:0:0: number_of_instances pass self._state.following.append(self.FOLLOW_number_of_instances_in_process_definition2491) 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 )? alt18 = 2 LA18_0 = self.input.LA(1) if (LA18_0 == 223) : alt18 = 1 if alt18 == 1: # sdl92.g:258:39: ':' type_inst pass char_literal67=self.match(self.input, 223, self.FOLLOW_223_in_process_definition2495) if self._state.backtracking == 0: stream_223.add(char_literal67) self._state.following.append(self.FOLLOW_type_inst_in_process_definition2497) 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 )? alt19 = 2 LA19_0 = self.input.LA(1) if (LA19_0 == REFERENCED) : alt19 = 1 if alt19 == 1: # sdl92.g:0:0: REFERENCED pass REFERENCED69=self.match(self.input, REFERENCED, self.FOLLOW_REFERENCED_in_process_definition2501) if self._state.backtracking == 0: stream_REFERENCED.add(REFERENCED69) self._state.following.append(self.FOLLOW_end_in_process_definition2506) a = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(a.tree) # sdl92.g:259:17: ( pfpar )? alt20 = 2 LA20_0 = self.input.LA(1) if (LA20_0 == FPAR) : alt20 = 1 if alt20 == 1: # sdl92.g:0:0: pfpar pass self._state.following.append(self.FOLLOW_pfpar_in_process_definition2524) 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_preamble )=> composite_state )* while True: #loop21 alt21 = 4 alt21 = self.dfa21.predict(self.input) if alt21 == 1: # sdl92.g:260:18: text_area pass self._state.following.append(self.FOLLOW_text_area_in_process_definition2544) text_area71 = self.text_area() self._state.following.pop() if self._state.backtracking == 0: stream_text_area.add(text_area71.tree) elif alt21 == 2: # sdl92.g:260:30: procedure pass self._state.following.append(self.FOLLOW_procedure_in_process_definition2548) procedure72 = self.procedure() self._state.following.pop() if self._state.backtracking == 0: stream_procedure.add(procedure72.tree) elif alt21 == 3: # sdl92.g:260:42: ( composite_state_preamble )=> composite_state pass self._state.following.append(self.FOLLOW_composite_state_in_process_definition2557) composite_state73 = self.composite_state() self._state.following.pop() if self._state.backtracking == 0: stream_composite_state.add(composite_state73.tree) else: break #loop21 # sdl92.g:261:17: ( processBody )? alt22 = 2 alt22 = self.dfa22.predict(self.input) if alt22 == 1: # sdl92.g:0:0: processBody pass self._state.following.append(self.FOLLOW_processBody_in_process_definition2577) processBody74 = self.processBody() self._state.following.pop() if self._state.backtracking == 0: stream_processBody.add(processBody74.tree) # sdl92.g:261:30: ( ENDPROCESS )? alt23 = 2 LA23_0 = self.input.LA(1) if (LA23_0 == ENDPROCESS) : alt23 = 1 if alt23 == 1: # sdl92.g:0:0: ENDPROCESS pass ENDPROCESS75=self.match(self.input, ENDPROCESS, self.FOLLOW_ENDPROCESS_in_process_definition2580) if self._state.backtracking == 0: stream_ENDPROCESS.add(ENDPROCESS75) # sdl92.g:261:42: ( TYPE )? alt24 = 2 LA24_0 = self.input.LA(1) if (LA24_0 == TYPE) : alt24 = 1 if alt24 == 1: # sdl92.g:0:0: TYPE pass TYPE76=self.match(self.input, TYPE, self.FOLLOW_TYPE_in_process_definition2583) if self._state.backtracking == 0: stream_TYPE.add(TYPE76) # sdl92.g:261:48: ( process_id )? alt25 = 2 LA25_0 = self.input.LA(1) if (LA25_0 == ID) : alt25 = 1 if alt25 == 1: # sdl92.g:0:0: process_id pass self._state.following.append(self.FOLLOW_process_id_in_process_definition2586) process_id77 = self.process_id() self._state.following.pop() if self._state.backtracking == 0: stream_process_id.add(process_id77.tree) # sdl92.g:262: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_process_definition2605) end78 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end78.tree) # AST Rewrite # elements: a, processBody, text_area, PROCESS, cif, composite_state, REFERENCED, pfpar, number_of_instances, process_id, t, procedure, type_inst # token labels: t # rule labels: a, retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 stream_t = RewriteRuleTokenStream(self._adaptor, "token t", t) if a is not None: stream_a = RewriteRuleSubtreeStream(self._adaptor, "rule a", a.tree) else: stream_a = RewriteRuleSubtreeStream(self._adaptor, "token a", 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() # 263:9: -> ^( PROCESS ( cif )? process_id ( number_of_instances )? ( type_inst )? ( $t)? ( REFERENCED )? ( $a)? ( pfpar )? ( text_area )* ( procedure )* ( composite_state )* ( processBody )? ) # sdl92.g:263:17: ^( PROCESS ( cif )? process_id ( number_of_instances )? ( type_inst )? ( $t)? ( 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: ( $t)? if stream_t.hasNext(): self._adaptor.addChild(root_1, stream_t.nextNode()) stream_t.reset(); # sdl92.g:264:21: ( REFERENCED )? if stream_REFERENCED.hasNext(): self._adaptor.addChild(root_1, stream_REFERENCED.nextNode()) stream_REFERENCED.reset(); # sdl92.g:264:33: ( $a)? if stream_a.hasNext(): self._adaptor.addChild(root_1, stream_a.nextTree()) stream_a.reset(); # sdl92.g:264:37: ( pfpar )? if stream_pfpar.hasNext(): self._adaptor.addChild(root_1, stream_pfpar.nextTree()) stream_pfpar.reset(); # sdl92.g:264:44: ( text_area )* while stream_text_area.hasNext(): self._adaptor.addChild(root_1, stream_text_area.nextTree()) stream_text_area.reset(); # sdl92.g:264:55: ( 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 FPAR79 = None char_literal81 = None parameters_of_sort80 = None parameters_of_sort82 = None end83 = None FPAR79_tree = None char_literal81_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_FPAR = RewriteRuleTokenStream(self._adaptor, "token FPAR") 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 FPAR79=self.match(self.input, FPAR, self.FOLLOW_FPAR_in_pfpar2727) if self._state.backtracking == 0: stream_FPAR.add(FPAR79) self._state.following.append(self.FOLLOW_parameters_of_sort_in_pfpar2729) parameters_of_sort80 = self.parameters_of_sort() self._state.following.pop() if self._state.backtracking == 0: stream_parameters_of_sort.add(parameters_of_sort80.tree) # sdl92.g:272:17: ( ',' parameters_of_sort )* while True: #loop27 alt27 = 2 LA27_0 = self.input.LA(1) if (LA27_0 == COMMA) : alt27 = 1 if alt27 == 1: # sdl92.g:272:18: ',' parameters_of_sort pass char_literal81=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_pfpar2748) if self._state.backtracking == 0: stream_COMMA.add(char_literal81) self._state.following.append(self.FOLLOW_parameters_of_sort_in_pfpar2750) parameters_of_sort82 = self.parameters_of_sort() self._state.following.pop() if self._state.backtracking == 0: stream_parameters_of_sort.add(parameters_of_sort82.tree) else: break #loop27 # sdl92.g:273:17: ( end )? alt28 = 2 alt28 = self.dfa28.predict(self.input) if alt28 == 1: # sdl92.g:0:0: end pass self._state.following.append(self.FOLLOW_end_in_pfpar2770) end83 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end83.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_literal85 = None variable_id84 = None variable_id86 = None sort87 = None char_literal85_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_variable_id = RewriteRuleSubtreeStream(self._adaptor, "rule variable_id") stream_sort = RewriteRuleSubtreeStream(self._adaptor, "rule sort") 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_sort2825) variable_id84 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id84.tree) # sdl92.g:279:29: ( ',' variable_id )* while True: #loop29 alt29 = 2 LA29_0 = self.input.LA(1) if (LA29_0 == COMMA) : alt29 = 1 if alt29 == 1: # sdl92.g:279:30: ',' variable_id pass char_literal85=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_parameters_of_sort2828) if self._state.backtracking == 0: stream_COMMA.add(char_literal85) self._state.following.append(self.FOLLOW_variable_id_in_parameters_of_sort2830) variable_id86 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id86.tree) else: break #loop29 self._state.following.append(self.FOLLOW_sort_in_parameters_of_sort2834) sort87 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort87.tree) # AST Rewrite # elements: variable_id, 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() # 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:285:1: procedure : ( cif )? PROCEDURE procedure_id (e1= end | SEMI ) ( 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 PROCEDURE89 = None SEMI91 = None ENDPROCEDURE96 = None EXTERNAL98 = None e1 = None res = None e2 = None cif88 = None procedure_id90 = None fpar92 = None text_area93 = None procedure94 = None processBody95 = None procedure_id97 = None PROCEDURE89_tree = None SEMI91_tree = None ENDPROCEDURE96_tree = None EXTERNAL98_tree = None stream_PROCEDURE = RewriteRuleTokenStream(self._adaptor, "token PROCEDURE") stream_EXTERNAL = RewriteRuleTokenStream(self._adaptor, "token EXTERNAL") stream_SEMI = RewriteRuleTokenStream(self._adaptor, "token SEMI") stream_ENDPROCEDURE = RewriteRuleTokenStream(self._adaptor, "token ENDPROCEDURE") stream_text_area = RewriteRuleSubtreeStream(self._adaptor, "rule text_area") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_procedure_id = RewriteRuleSubtreeStream(self._adaptor, "rule procedure_id") stream_processBody = RewriteRuleSubtreeStream(self._adaptor, "rule processBody") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_fpar = RewriteRuleSubtreeStream(self._adaptor, "rule fpar") stream_procedure = RewriteRuleSubtreeStream(self._adaptor, "rule procedure") stream_procedure_result = RewriteRuleSubtreeStream(self._adaptor, "rule procedure_result") try: try: # sdl92.g:286:9: ( ( cif )? PROCEDURE procedure_id (e1= end | SEMI ) ( 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:286:17: ( cif )? PROCEDURE procedure_id (e1= end | SEMI ) ( fpar )? (res= procedure_result )? ( text_area | procedure )* ( ( ( processBody )? ENDPROCEDURE ( procedure_id )? ) | EXTERNAL ) e2= end pass # sdl92.g:286:17: ( cif )? alt30 = 2 LA30_0 = self.input.LA(1) if (LA30_0 == 228) : alt30 = 1 if alt30 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_procedure2891) cif88 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif88.tree) PROCEDURE89=self.match(self.input, PROCEDURE, self.FOLLOW_PROCEDURE_in_procedure2910) if self._state.backtracking == 0: stream_PROCEDURE.add(PROCEDURE89) self._state.following.append(self.FOLLOW_procedure_id_in_procedure2912) procedure_id90 = self.procedure_id() self._state.following.pop() if self._state.backtracking == 0: stream_procedure_id.add(procedure_id90.tree) # sdl92.g:287:40: (e1= end | SEMI ) alt31 = 2 LA31_0 = self.input.LA(1) if (LA31_0 == COMMENT or LA31_0 == 228) : alt31 = 1 elif (LA31_0 == SEMI) : LA31_2 = self.input.LA(2) if (self.synpred41_sdl92()) : alt31 = 1 elif (True) : alt31 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 31, 2, self.input) raise nvae else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 31, 0, self.input) raise nvae if alt31 == 1: # sdl92.g:287:41: e1= end pass self._state.following.append(self.FOLLOW_end_in_procedure2917) e1 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(e1.tree) elif alt31 == 2: # sdl92.g:287:50: SEMI pass SEMI91=self.match(self.input, SEMI, self.FOLLOW_SEMI_in_procedure2921) if self._state.backtracking == 0: stream_SEMI.add(SEMI91) # sdl92.g:288:17: ( fpar )? alt32 = 2 LA32_0 = self.input.LA(1) if (LA32_0 == FPAR) : alt32 = 1 if alt32 == 1: # sdl92.g:0:0: fpar pass self._state.following.append(self.FOLLOW_fpar_in_procedure2940) fpar92 = self.fpar() self._state.following.pop() if self._state.backtracking == 0: stream_fpar.add(fpar92.tree) # sdl92.g:289:20: (res= procedure_result )? alt33 = 2 LA33_0 = self.input.LA(1) if (LA33_0 == RETURNS or LA33_0 == 224) : alt33 = 1 if alt33 == 1: # sdl92.g:0:0: res= procedure_result pass self._state.following.append(self.FOLLOW_procedure_result_in_procedure2961) res = self.procedure_result() self._state.following.pop() if self._state.backtracking == 0: stream_procedure_result.add(res.tree) # sdl92.g:290:17: ( text_area | procedure )* while True: #loop34 alt34 = 3 LA34_0 = self.input.LA(1) if (LA34_0 == 228) : LA34_1 = self.input.LA(2) if (self.synpred44_sdl92()) : alt34 = 1 elif (self.synpred45_sdl92()) : alt34 = 2 elif (LA34_0 == PROCEDURE) : alt34 = 2 if alt34 == 1: # sdl92.g:290:18: text_area pass self._state.following.append(self.FOLLOW_text_area_in_procedure2981) text_area93 = self.text_area() self._state.following.pop() if self._state.backtracking == 0: stream_text_area.add(text_area93.tree) elif alt34 == 2: # sdl92.g:290:30: procedure pass self._state.following.append(self.FOLLOW_procedure_in_procedure2985) procedure94 = self.procedure() self._state.following.pop() if self._state.backtracking == 0: stream_procedure.add(procedure94.tree) else: break #loop34 # sdl92.g:291:17: ( ( ( processBody )? ENDPROCEDURE ( procedure_id )? ) | EXTERNAL ) alt37 = 2 LA37_0 = self.input.LA(1) if (LA37_0 == EOF or LA37_0 == BLOCK or LA37_0 == COMMENT or (CONNECT <= LA37_0 <= CONNECTION) or LA37_0 == PROCESS or LA37_0 == SIGNAL or LA37_0 == STATE or LA37_0 == SYSTEM or LA37_0 == USE or LA37_0 == ID or (ENDBLOCK <= LA37_0 <= SIGNALROUTE) or LA37_0 == TYPE or (ENDPROCESS <= LA37_0 <= ENDPROCEDURE) or LA37_0 == START or LA37_0 == 228) : alt37 = 1 elif (LA37_0 == EXTERNAL) : alt37 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 37, 0, self.input) raise nvae if alt37 == 1: # sdl92.g:291:18: ( ( processBody )? ENDPROCEDURE ( procedure_id )? ) pass # sdl92.g:291:18: ( ( processBody )? ENDPROCEDURE ( procedure_id )? ) # sdl92.g:291:19: ( processBody )? ENDPROCEDURE ( procedure_id )? pass # sdl92.g:291:19: ( processBody )? alt35 = 2 LA35_0 = self.input.LA(1) if (LA35_0 == CONNECTION or LA35_0 == STATE or LA35_0 == START or LA35_0 == 228) : alt35 = 1 elif (LA35_0 == ENDPROCEDURE) : LA35_2 = self.input.LA(2) if (self.synpred46_sdl92()) : alt35 = 1 if alt35 == 1: # sdl92.g:0:0: processBody pass self._state.following.append(self.FOLLOW_processBody_in_procedure3007) processBody95 = self.processBody() self._state.following.pop() if self._state.backtracking == 0: stream_processBody.add(processBody95.tree) ENDPROCEDURE96=self.match(self.input, ENDPROCEDURE, self.FOLLOW_ENDPROCEDURE_in_procedure3010) if self._state.backtracking == 0: stream_ENDPROCEDURE.add(ENDPROCEDURE96) # sdl92.g:291:45: ( procedure_id )? alt36 = 2 LA36_0 = self.input.LA(1) if (LA36_0 == ID) : alt36 = 1 if alt36 == 1: # sdl92.g:0:0: procedure_id pass self._state.following.append(self.FOLLOW_procedure_id_in_procedure3012) procedure_id97 = self.procedure_id() self._state.following.pop() if self._state.backtracking == 0: stream_procedure_id.add(procedure_id97.tree) elif alt37 == 2: # sdl92.g:291:62: EXTERNAL pass EXTERNAL98=self.match(self.input, EXTERNAL, self.FOLLOW_EXTERNAL_in_procedure3018) if self._state.backtracking == 0: stream_EXTERNAL.add(EXTERNAL98) self._state.following.append(self.FOLLOW_end_in_procedure3039) e2 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(e2.tree) # AST Rewrite # elements: e2, cif, e1, res, processBody, procedure_id, EXTERNAL, fpar, procedure, text_area, PROCEDURE # token labels: # rule labels: res, e1, e2, 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 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) 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() # 293:9: -> ^( PROCEDURE ( cif )? procedure_id ( $e1)? ( $e2)? ( fpar )? ( $res)? ( text_area )* ( procedure )* ( processBody )? ( EXTERNAL )? ) # sdl92.g:293: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:293: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:293:47: ( $e1)? if stream_e1.hasNext(): self._adaptor.addChild(root_1, stream_e1.nextTree()) stream_e1.reset(); # sdl92.g:293:52: ( $e2)? if stream_e2.hasNext(): self._adaptor.addChild(root_1, stream_e2.nextTree()) stream_e2.reset(); # sdl92.g:293:57: ( fpar )? if stream_fpar.hasNext(): self._adaptor.addChild(root_1, stream_fpar.nextTree()) stream_fpar.reset(); # sdl92.g:293:63: ( $res)? if stream_res.hasNext(): self._adaptor.addChild(root_1, stream_res.nextTree()) stream_res.reset(); # sdl92.g:294:17: ( text_area )* while stream_text_area.hasNext(): self._adaptor.addChild(root_1, stream_text_area.nextTree()) stream_text_area.reset(); # sdl92.g:294:28: ( procedure )* while stream_procedure.hasNext(): self._adaptor.addChild(root_1, stream_procedure.nextTree()) stream_procedure.reset(); # sdl92.g:294:39: ( processBody )? if stream_processBody.hasNext(): self._adaptor.addChild(root_1, stream_processBody.nextTree()) stream_processBody.reset(); # sdl92.g:294: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:298:1: procedure_result : ( '->' | RETURNS ) ( variable_id )? sort ( end )? -> ^( RETURNS ( variable_id )? sort ) ; def procedure_result(self, ): retval = self.procedure_result_return() retval.start = self.input.LT(1) root_0 = None string_literal99 = None RETURNS100 = None variable_id101 = None sort102 = None end103 = None string_literal99_tree = None RETURNS100_tree = None stream_224 = RewriteRuleTokenStream(self._adaptor, "token 224") stream_RETURNS = RewriteRuleTokenStream(self._adaptor, "token RETURNS") stream_variable_id = RewriteRuleSubtreeStream(self._adaptor, "rule variable_id") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_sort = RewriteRuleSubtreeStream(self._adaptor, "rule sort") try: try: # sdl92.g:299:9: ( ( '->' | RETURNS ) ( variable_id )? sort ( end )? -> ^( RETURNS ( variable_id )? sort ) ) # sdl92.g:299:17: ( '->' | RETURNS ) ( variable_id )? sort ( end )? pass # sdl92.g:299:17: ( '->' | RETURNS ) alt38 = 2 LA38_0 = self.input.LA(1) if (LA38_0 == 224) : alt38 = 1 elif (LA38_0 == RETURNS) : alt38 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 38, 0, self.input) raise nvae if alt38 == 1: # sdl92.g:299:18: '->' pass string_literal99=self.match(self.input, 224, self.FOLLOW_224_in_procedure_result3139) if self._state.backtracking == 0: stream_224.add(string_literal99) elif alt38 == 2: # sdl92.g:299:25: RETURNS pass RETURNS100=self.match(self.input, RETURNS, self.FOLLOW_RETURNS_in_procedure_result3143) if self._state.backtracking == 0: stream_RETURNS.add(RETURNS100) # sdl92.g:300:17: ( variable_id )? alt39 = 2 LA39_0 = self.input.LA(1) if (LA39_0 == ID) : LA39_1 = self.input.LA(2) if (LA39_1 == ID) : alt39 = 1 if alt39 == 1: # sdl92.g:0:0: variable_id pass self._state.following.append(self.FOLLOW_variable_id_in_procedure_result3162) variable_id101 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id101.tree) self._state.following.append(self.FOLLOW_sort_in_procedure_result3181) sort102 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort102.tree) # sdl92.g:301:22: ( end )? alt40 = 2 alt40 = self.dfa40.predict(self.input) if alt40 == 1: # sdl92.g:0:0: end pass self._state.following.append(self.FOLLOW_end_in_procedure_result3183) end103 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end103.tree) # AST Rewrite # elements: sort, variable_id, 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() # 302:9: -> ^( RETURNS ( variable_id )? sort ) # sdl92.g:302:17: ^( RETURNS ( variable_id )? sort ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_RETURNS.nextNode(), root_1) # sdl92.g:302: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:306: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 FPAR104 = None char_literal106 = None formal_variable_param105 = None formal_variable_param107 = None end108 = None FPAR104_tree = None char_literal106_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_FPAR = RewriteRuleTokenStream(self._adaptor, "token FPAR") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_formal_variable_param = RewriteRuleSubtreeStream(self._adaptor, "rule formal_variable_param") try: try: # sdl92.g:307:9: ( FPAR formal_variable_param ( ',' formal_variable_param )* end -> ^( FPAR ( formal_variable_param )+ ) ) # sdl92.g:307:17: FPAR formal_variable_param ( ',' formal_variable_param )* end pass FPAR104=self.match(self.input, FPAR, self.FOLLOW_FPAR_in_fpar3240) if self._state.backtracking == 0: stream_FPAR.add(FPAR104) self._state.following.append(self.FOLLOW_formal_variable_param_in_fpar3242) formal_variable_param105 = self.formal_variable_param() self._state.following.pop() if self._state.backtracking == 0: stream_formal_variable_param.add(formal_variable_param105.tree) # sdl92.g:308:17: ( ',' formal_variable_param )* while True: #loop41 alt41 = 2 LA41_0 = self.input.LA(1) if (LA41_0 == COMMA) : alt41 = 1 if alt41 == 1: # sdl92.g:308:18: ',' formal_variable_param pass char_literal106=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_fpar3261) if self._state.backtracking == 0: stream_COMMA.add(char_literal106) self._state.following.append(self.FOLLOW_formal_variable_param_in_fpar3263) formal_variable_param107 = self.formal_variable_param() self._state.following.pop() if self._state.backtracking == 0: stream_formal_variable_param.add(formal_variable_param107.tree) else: break #loop41 self._state.following.append(self.FOLLOW_end_in_fpar3283) end108 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end108.tree) # AST Rewrite # elements: FPAR, formal_variable_param # 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() # 310:9: -> ^( FPAR ( formal_variable_param )+ ) # sdl92.g:310:17: ^( FPAR ( formal_variable_param )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_FPAR.nextNode(), root_1) # sdl92.g:310: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:314: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 INOUT109 = None IN110 = None OUT111 = None char_literal113 = None variable_id112 = None variable_id114 = None sort115 = None INOUT109_tree = None IN110_tree = None OUT111_tree = None char_literal113_tree = None stream_INOUT = RewriteRuleTokenStream(self._adaptor, "token INOUT") stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_IN = RewriteRuleTokenStream(self._adaptor, "token IN") stream_OUT = RewriteRuleTokenStream(self._adaptor, "token OUT") stream_variable_id = RewriteRuleSubtreeStream(self._adaptor, "rule variable_id") stream_sort = RewriteRuleSubtreeStream(self._adaptor, "rule sort") try: try: # sdl92.g:315:9: ( ( INOUT | IN | OUT )? variable_id ( ',' variable_id )* sort -> ^( PARAM ( INOUT )? ( IN )? ( OUT )? ( variable_id )+ sort ) ) # sdl92.g:315:17: ( INOUT | IN | OUT )? variable_id ( ',' variable_id )* sort pass # sdl92.g:315:17: ( INOUT | IN | OUT )? alt42 = 4 LA42 = self.input.LA(1) if LA42 == INOUT: alt42 = 1 elif LA42 == IN: alt42 = 2 elif LA42 == OUT: alt42 = 3 if alt42 == 1: # sdl92.g:315:18: INOUT pass INOUT109=self.match(self.input, INOUT, self.FOLLOW_INOUT_in_formal_variable_param3338) if self._state.backtracking == 0: stream_INOUT.add(INOUT109) elif alt42 == 2: # sdl92.g:315:26: IN pass IN110=self.match(self.input, IN, self.FOLLOW_IN_in_formal_variable_param3342) if self._state.backtracking == 0: stream_IN.add(IN110) elif alt42 == 3: # sdl92.g:315:31: OUT pass OUT111=self.match(self.input, OUT, self.FOLLOW_OUT_in_formal_variable_param3346) if self._state.backtracking == 0: stream_OUT.add(OUT111) self._state.following.append(self.FOLLOW_variable_id_in_formal_variable_param3366) variable_id112 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id112.tree) # sdl92.g:316:29: ( ',' variable_id )* while True: #loop43 alt43 = 2 LA43_0 = self.input.LA(1) if (LA43_0 == COMMA) : alt43 = 1 if alt43 == 1: # sdl92.g:316:30: ',' variable_id pass char_literal113=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_formal_variable_param3369) if self._state.backtracking == 0: stream_COMMA.add(char_literal113) self._state.following.append(self.FOLLOW_variable_id_in_formal_variable_param3371) variable_id114 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id114.tree) else: break #loop43 self._state.following.append(self.FOLLOW_sort_in_formal_variable_param3375) sort115 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort115.tree) # AST Rewrite # elements: INOUT, variable_id, OUT, sort, IN # 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() # 317:9: -> ^( PARAM ( INOUT )? ( IN )? ( OUT )? ( variable_id )+ sort ) # sdl92.g:317: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:317:25: ( INOUT )? if stream_INOUT.hasNext(): self._adaptor.addChild(root_1, stream_INOUT.nextNode()) stream_INOUT.reset(); # sdl92.g:317:32: ( IN )? if stream_IN.hasNext(): self._adaptor.addChild(root_1, stream_IN.nextNode()) stream_IN.reset(); # sdl92.g:317:36: ( OUT )? if stream_OUT.hasNext(): self._adaptor.addChild(root_1, stream_OUT.nextNode()) stream_OUT.reset(); # sdl92.g:317: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:322: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 cif116 = None content117 = None cif_end_text118 = None stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_cif_end_text = RewriteRuleSubtreeStream(self._adaptor, "rule cif_end_text") stream_content = RewriteRuleSubtreeStream(self._adaptor, "rule content") try: try: # sdl92.g:323:9: ( cif ( content )? cif_end_text -> ^( TEXTAREA cif ( content )? cif_end_text ) ) # sdl92.g:323:17: cif ( content )? cif_end_text pass self._state.following.append(self.FOLLOW_cif_in_text_area3441) cif116 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif116.tree) # sdl92.g:324:17: ( content )? alt44 = 2 LA44_0 = self.input.LA(1) if (LA44_0 == 228) : LA44_1 = self.input.LA(2) if (self.synpred57_sdl92()) : alt44 = 1 elif (LA44_0 == DCL or LA44_0 == FPAR or LA44_0 == NEWTYPE or LA44_0 == PROCEDURE or LA44_0 == RETURNS or LA44_0 == SIGNAL or LA44_0 == SYNONYM or LA44_0 == SYNTYPE or LA44_0 == TIMER or LA44_0 == USE or LA44_0 == 224) : alt44 = 1 if alt44 == 1: # sdl92.g:0:0: content pass self._state.following.append(self.FOLLOW_content_in_text_area3459) content117 = self.content() self._state.following.pop() if self._state.backtracking == 0: stream_content.add(content117.tree) self._state.following.append(self.FOLLOW_cif_end_text_in_text_area3478) cif_end_text118 = self.cif_end_text() self._state.following.pop() if self._state.backtracking == 0: stream_cif_end_text.add(cif_end_text118.tree) # AST Rewrite # elements: cif, cif_end_text, content # 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() # 326:9: -> ^( TEXTAREA cif ( content )? cif_end_text ) # sdl92.g:326: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:326: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:332: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 procedure119 = None use_clause120 = None signal_declaration121 = None fpar122 = None timer_declaration123 = None syntype_definition124 = None newtype_definition125 = None variable_definition126 = None synonym_definition127 = None stream_syntype_definition = RewriteRuleSubtreeStream(self._adaptor, "rule syntype_definition") stream_variable_definition = RewriteRuleSubtreeStream(self._adaptor, "rule variable_definition") stream_use_clause = RewriteRuleSubtreeStream(self._adaptor, "rule use_clause") stream_signal_declaration = RewriteRuleSubtreeStream(self._adaptor, "rule signal_declaration") stream_timer_declaration = RewriteRuleSubtreeStream(self._adaptor, "rule timer_declaration") stream_newtype_definition = RewriteRuleSubtreeStream(self._adaptor, "rule newtype_definition") stream_procedure = RewriteRuleSubtreeStream(self._adaptor, "rule procedure") stream_fpar = RewriteRuleSubtreeStream(self._adaptor, "rule fpar") stream_procedure_result = RewriteRuleSubtreeStream(self._adaptor, "rule procedure_result") stream_synonym_definition = RewriteRuleSubtreeStream(self._adaptor, "rule synonym_definition") try: try: # sdl92.g:333: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:333:18: ( procedure | use_clause | signal_declaration | fpar | res= procedure_result | timer_declaration | syntype_definition | newtype_definition | variable_definition | synonym_definition )* pass # sdl92.g:333:18: ( procedure | use_clause | signal_declaration | fpar | res= procedure_result | timer_declaration | syntype_definition | newtype_definition | variable_definition | synonym_definition )* while True: #loop45 alt45 = 11 alt45 = self.dfa45.predict(self.input) if alt45 == 1: # sdl92.g:333:19: procedure pass self._state.following.append(self.FOLLOW_procedure_in_content3540) procedure119 = self.procedure() self._state.following.pop() if self._state.backtracking == 0: stream_procedure.add(procedure119.tree) elif alt45 == 2: # sdl92.g:334:20: use_clause pass self._state.following.append(self.FOLLOW_use_clause_in_content3561) use_clause120 = self.use_clause() self._state.following.pop() if self._state.backtracking == 0: stream_use_clause.add(use_clause120.tree) elif alt45 == 3: # sdl92.g:335:20: signal_declaration pass self._state.following.append(self.FOLLOW_signal_declaration_in_content3582) signal_declaration121 = self.signal_declaration() self._state.following.pop() if self._state.backtracking == 0: stream_signal_declaration.add(signal_declaration121.tree) elif alt45 == 4: # sdl92.g:336:20: fpar pass self._state.following.append(self.FOLLOW_fpar_in_content3603) fpar122 = self.fpar() self._state.following.pop() if self._state.backtracking == 0: stream_fpar.add(fpar122.tree) elif alt45 == 5: # sdl92.g:337:20: res= procedure_result pass self._state.following.append(self.FOLLOW_procedure_result_in_content3626) res = self.procedure_result() self._state.following.pop() if self._state.backtracking == 0: stream_procedure_result.add(res.tree) elif alt45 == 6: # sdl92.g:338:20: timer_declaration pass self._state.following.append(self.FOLLOW_timer_declaration_in_content3647) timer_declaration123 = self.timer_declaration() self._state.following.pop() if self._state.backtracking == 0: stream_timer_declaration.add(timer_declaration123.tree) elif alt45 == 7: # sdl92.g:339:20: syntype_definition pass self._state.following.append(self.FOLLOW_syntype_definition_in_content3668) syntype_definition124 = self.syntype_definition() self._state.following.pop() if self._state.backtracking == 0: stream_syntype_definition.add(syntype_definition124.tree) elif alt45 == 8: # sdl92.g:340:20: newtype_definition pass self._state.following.append(self.FOLLOW_newtype_definition_in_content3689) newtype_definition125 = self.newtype_definition() self._state.following.pop() if self._state.backtracking == 0: stream_newtype_definition.add(newtype_definition125.tree) elif alt45 == 9: # sdl92.g:341:20: variable_definition pass self._state.following.append(self.FOLLOW_variable_definition_in_content3710) variable_definition126 = self.variable_definition() self._state.following.pop() if self._state.backtracking == 0: stream_variable_definition.add(variable_definition126.tree) elif alt45 == 10: # sdl92.g:342:20: synonym_definition pass self._state.following.append(self.FOLLOW_synonym_definition_in_content3731) synonym_definition127 = self.synonym_definition() self._state.following.pop() if self._state.backtracking == 0: stream_synonym_definition.add(synonym_definition127.tree) else: break #loop45 # AST Rewrite # elements: timer_declaration, syntype_definition, res, fpar, newtype_definition, variable_definition, use_clause, procedure, signal_declaration, synonym_definition # 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() # 343:9: -> ^( TEXTAREA_CONTENT ( fpar )* ( $res)? ( procedure )* ( variable_definition )* ( syntype_definition )* ( newtype_definition )* ( timer_declaration )* ( signal_declaration )* ( use_clause )* ( synonym_definition )* ) # sdl92.g:343: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:343:37: ( fpar )* while stream_fpar.hasNext(): self._adaptor.addChild(root_1, stream_fpar.nextTree()) stream_fpar.reset(); # sdl92.g:343:43: ( $res)? if stream_res.hasNext(): self._adaptor.addChild(root_1, stream_res.nextTree()) stream_res.reset(); # sdl92.g:343:49: ( procedure )* while stream_procedure.hasNext(): self._adaptor.addChild(root_1, stream_procedure.nextTree()) stream_procedure.reset(); # sdl92.g:343:60: ( variable_definition )* while stream_variable_definition.hasNext(): self._adaptor.addChild(root_1, stream_variable_definition.nextTree()) stream_variable_definition.reset(); # sdl92.g:344:20: ( syntype_definition )* while stream_syntype_definition.hasNext(): self._adaptor.addChild(root_1, stream_syntype_definition.nextTree()) stream_syntype_definition.reset(); # sdl92.g:344:40: ( newtype_definition )* while stream_newtype_definition.hasNext(): self._adaptor.addChild(root_1, stream_newtype_definition.nextTree()) stream_newtype_definition.reset(); # sdl92.g:344:60: ( timer_declaration )* while stream_timer_declaration.hasNext(): self._adaptor.addChild(root_1, stream_timer_declaration.nextTree()) stream_timer_declaration.reset(); # sdl92.g:345:20: ( signal_declaration )* while stream_signal_declaration.hasNext(): self._adaptor.addChild(root_1, stream_signal_declaration.nextTree()) stream_signal_declaration.reset(); # sdl92.g:345:40: ( use_clause )* while stream_use_clause.hasNext(): self._adaptor.addChild(root_1, stream_use_clause.nextTree()) stream_use_clause.reset(); # sdl92.g:345: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:349: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 TIMER128 = None char_literal130 = None timer_id129 = None timer_id131 = None end132 = None TIMER128_tree = None char_literal130_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_TIMER = RewriteRuleTokenStream(self._adaptor, "token TIMER") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_timer_id = RewriteRuleSubtreeStream(self._adaptor, "rule timer_id") try: try: # sdl92.g:350:9: ( TIMER timer_id ( ',' timer_id )* end -> ^( TIMER ( timer_id )+ ) ) # sdl92.g:350:17: TIMER timer_id ( ',' timer_id )* end pass TIMER128=self.match(self.input, TIMER, self.FOLLOW_TIMER_in_timer_declaration3854) if self._state.backtracking == 0: stream_TIMER.add(TIMER128) self._state.following.append(self.FOLLOW_timer_id_in_timer_declaration3856) timer_id129 = self.timer_id() self._state.following.pop() if self._state.backtracking == 0: stream_timer_id.add(timer_id129.tree) # sdl92.g:351:17: ( ',' timer_id )* while True: #loop46 alt46 = 2 LA46_0 = self.input.LA(1) if (LA46_0 == COMMA) : alt46 = 1 if alt46 == 1: # sdl92.g:351:18: ',' timer_id pass char_literal130=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_timer_declaration3875) if self._state.backtracking == 0: stream_COMMA.add(char_literal130) self._state.following.append(self.FOLLOW_timer_id_in_timer_declaration3877) timer_id131 = self.timer_id() self._state.following.pop() if self._state.backtracking == 0: stream_timer_id.add(timer_id131.tree) else: break #loop46 self._state.following.append(self.FOLLOW_end_in_timer_declaration3897) end132 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end132.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() # 353:9: -> ^( TIMER ( timer_id )+ ) # sdl92.g:353:17: ^( TIMER ( timer_id )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_TIMER.nextNode(), root_1) # sdl92.g:353: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:357: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 SYNTYPE133 = None char_literal135 = None CONSTANTS137 = None char_literal139 = None ENDSYNTYPE141 = None syntype_name134 = None parent_sort136 = None range_condition138 = None range_condition140 = None syntype_name142 = None end143 = None SYNTYPE133_tree = None char_literal135_tree = None CONSTANTS137_tree = None char_literal139_tree = None ENDSYNTYPE141_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_CONSTANTS = RewriteRuleTokenStream(self._adaptor, "token CONSTANTS") stream_SYNTYPE = RewriteRuleTokenStream(self._adaptor, "token SYNTYPE") stream_ENDSYNTYPE = RewriteRuleTokenStream(self._adaptor, "token ENDSYNTYPE") stream_EQ = RewriteRuleTokenStream(self._adaptor, "token EQ") stream_range_condition = RewriteRuleSubtreeStream(self._adaptor, "rule range_condition") stream_parent_sort = RewriteRuleSubtreeStream(self._adaptor, "rule parent_sort") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_syntype_name = RewriteRuleSubtreeStream(self._adaptor, "rule syntype_name") try: try: # sdl92.g:358:9: ( SYNTYPE syntype_name '=' parent_sort ( CONSTANTS ( range_condition ( ',' range_condition )* ) )? ENDSYNTYPE ( syntype_name )? end -> ^( SYNTYPE syntype_name parent_sort ( range_condition )* ) ) # sdl92.g:358:17: SYNTYPE syntype_name '=' parent_sort ( CONSTANTS ( range_condition ( ',' range_condition )* ) )? ENDSYNTYPE ( syntype_name )? end pass SYNTYPE133=self.match(self.input, SYNTYPE, self.FOLLOW_SYNTYPE_in_syntype_definition3951) if self._state.backtracking == 0: stream_SYNTYPE.add(SYNTYPE133) self._state.following.append(self.FOLLOW_syntype_name_in_syntype_definition3953) syntype_name134 = self.syntype_name() self._state.following.pop() if self._state.backtracking == 0: stream_syntype_name.add(syntype_name134.tree) char_literal135=self.match(self.input, EQ, self.FOLLOW_EQ_in_syntype_definition3955) if self._state.backtracking == 0: stream_EQ.add(char_literal135) self._state.following.append(self.FOLLOW_parent_sort_in_syntype_definition3957) parent_sort136 = self.parent_sort() self._state.following.pop() if self._state.backtracking == 0: stream_parent_sort.add(parent_sort136.tree) # sdl92.g:359:17: ( CONSTANTS ( range_condition ( ',' range_condition )* ) )? alt48 = 2 LA48_0 = self.input.LA(1) if (LA48_0 == CONSTANTS) : alt48 = 1 if alt48 == 1: # sdl92.g:359:18: CONSTANTS ( range_condition ( ',' range_condition )* ) pass CONSTANTS137=self.match(self.input, CONSTANTS, self.FOLLOW_CONSTANTS_in_syntype_definition3976) if self._state.backtracking == 0: stream_CONSTANTS.add(CONSTANTS137) # sdl92.g:359:28: ( range_condition ( ',' range_condition )* ) # sdl92.g:359:29: range_condition ( ',' range_condition )* pass self._state.following.append(self.FOLLOW_range_condition_in_syntype_definition3979) range_condition138 = self.range_condition() self._state.following.pop() if self._state.backtracking == 0: stream_range_condition.add(range_condition138.tree) # sdl92.g:359:45: ( ',' range_condition )* while True: #loop47 alt47 = 2 LA47_0 = self.input.LA(1) if (LA47_0 == COMMA) : alt47 = 1 if alt47 == 1: # sdl92.g:359:46: ',' range_condition pass char_literal139=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_syntype_definition3982) if self._state.backtracking == 0: stream_COMMA.add(char_literal139) self._state.following.append(self.FOLLOW_range_condition_in_syntype_definition3984) range_condition140 = self.range_condition() self._state.following.pop() if self._state.backtracking == 0: stream_range_condition.add(range_condition140.tree) else: break #loop47 ENDSYNTYPE141=self.match(self.input, ENDSYNTYPE, self.FOLLOW_ENDSYNTYPE_in_syntype_definition4008) if self._state.backtracking == 0: stream_ENDSYNTYPE.add(ENDSYNTYPE141) # sdl92.g:360:28: ( syntype_name )? alt49 = 2 LA49_0 = self.input.LA(1) if (LA49_0 == ID) : alt49 = 1 if alt49 == 1: # sdl92.g:0:0: syntype_name pass self._state.following.append(self.FOLLOW_syntype_name_in_syntype_definition4010) syntype_name142 = self.syntype_name() self._state.following.pop() if self._state.backtracking == 0: stream_syntype_name.add(syntype_name142.tree) self._state.following.append(self.FOLLOW_end_in_syntype_definition4013) end143 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end143.tree) # AST Rewrite # elements: parent_sort, SYNTYPE, range_condition, syntype_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() # 361:9: -> ^( SYNTYPE syntype_name parent_sort ( range_condition )* ) # sdl92.g:361: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:361: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:365:1: syntype_name : sort ; def syntype_name(self, ): retval = self.syntype_name_return() retval.start = self.input.LT(1) root_0 = None sort144 = None try: try: # sdl92.g:366:9: ( sort ) # sdl92.g:366:17: sort pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_sort_in_syntype_name4071) sort144 = self.sort() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, sort144.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:370:1: parent_sort : sort ; def parent_sort(self, ): retval = self.parent_sort_return() retval.start = self.input.LT(1) root_0 = None sort145 = None try: try: # sdl92.g:371:9: ( sort ) # sdl92.g:371:17: sort pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_sort_in_parent_sort4103) sort145 = self.sort() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, sort145.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:375: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 NEWTYPE146 = None ENDNEWTYPE150 = None type_name147 = None array_definition148 = None structure_definition149 = None type_name151 = None end152 = None NEWTYPE146_tree = None ENDNEWTYPE150_tree = None stream_ENDNEWTYPE = RewriteRuleTokenStream(self._adaptor, "token ENDNEWTYPE") stream_NEWTYPE = RewriteRuleTokenStream(self._adaptor, "token NEWTYPE") stream_type_name = RewriteRuleSubtreeStream(self._adaptor, "rule type_name") stream_structure_definition = RewriteRuleSubtreeStream(self._adaptor, "rule structure_definition") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_array_definition = RewriteRuleSubtreeStream(self._adaptor, "rule array_definition") try: try: # sdl92.g:376:9: ( NEWTYPE type_name ( array_definition | structure_definition )? ENDNEWTYPE ( type_name )? end -> ^( NEWTYPE type_name ( array_definition )* ( structure_definition )* ) ) # sdl92.g:376:17: NEWTYPE type_name ( array_definition | structure_definition )? ENDNEWTYPE ( type_name )? end pass NEWTYPE146=self.match(self.input, NEWTYPE, self.FOLLOW_NEWTYPE_in_newtype_definition4135) if self._state.backtracking == 0: stream_NEWTYPE.add(NEWTYPE146) self._state.following.append(self.FOLLOW_type_name_in_newtype_definition4137) type_name147 = self.type_name() self._state.following.pop() if self._state.backtracking == 0: stream_type_name.add(type_name147.tree) # sdl92.g:376:35: ( array_definition | structure_definition )? alt50 = 3 LA50_0 = self.input.LA(1) if (LA50_0 == ARRAY) : alt50 = 1 elif (LA50_0 == STRUCT) : alt50 = 2 if alt50 == 1: # sdl92.g:376:36: array_definition pass self._state.following.append(self.FOLLOW_array_definition_in_newtype_definition4140) array_definition148 = self.array_definition() self._state.following.pop() if self._state.backtracking == 0: stream_array_definition.add(array_definition148.tree) elif alt50 == 2: # sdl92.g:376:53: structure_definition pass self._state.following.append(self.FOLLOW_structure_definition_in_newtype_definition4142) structure_definition149 = self.structure_definition() self._state.following.pop() if self._state.backtracking == 0: stream_structure_definition.add(structure_definition149.tree) ENDNEWTYPE150=self.match(self.input, ENDNEWTYPE, self.FOLLOW_ENDNEWTYPE_in_newtype_definition4162) if self._state.backtracking == 0: stream_ENDNEWTYPE.add(ENDNEWTYPE150) # sdl92.g:377:28: ( type_name )? alt51 = 2 LA51_0 = self.input.LA(1) if (LA51_0 == ID) : alt51 = 1 if alt51 == 1: # sdl92.g:0:0: type_name pass self._state.following.append(self.FOLLOW_type_name_in_newtype_definition4164) type_name151 = self.type_name() self._state.following.pop() if self._state.backtracking == 0: stream_type_name.add(type_name151.tree) self._state.following.append(self.FOLLOW_end_in_newtype_definition4167) end152 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end152.tree) # AST Rewrite # elements: NEWTYPE, type_name, array_definition, structure_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() # 378:9: -> ^( NEWTYPE type_name ( array_definition )* ( structure_definition )* ) # sdl92.g:378: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:378:37: ( array_definition )* while stream_array_definition.hasNext(): self._adaptor.addChild(root_1, stream_array_definition.nextTree()) stream_array_definition.reset(); # sdl92.g:378: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:382:1: type_name : sort ; def type_name(self, ): retval = self.type_name_return() retval.start = self.input.LT(1) root_0 = None sort153 = None try: try: # sdl92.g:383:9: ( sort ) # sdl92.g:383:17: sort pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_sort_in_type_name4226) sort153 = self.sort() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, sort153.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:387: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 ARRAY154 = None char_literal155 = None char_literal157 = None char_literal159 = None sort156 = None sort158 = None ARRAY154_tree = None char_literal155_tree = None char_literal157_tree = None char_literal159_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_ARRAY = RewriteRuleTokenStream(self._adaptor, "token ARRAY") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_sort = RewriteRuleSubtreeStream(self._adaptor, "rule sort") try: try: # sdl92.g:388:9: ( ARRAY '(' sort ',' sort ')' -> ^( ARRAY sort sort ) ) # sdl92.g:388:17: ARRAY '(' sort ',' sort ')' pass ARRAY154=self.match(self.input, ARRAY, self.FOLLOW_ARRAY_in_array_definition4258) if self._state.backtracking == 0: stream_ARRAY.add(ARRAY154) char_literal155=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_array_definition4260) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal155) self._state.following.append(self.FOLLOW_sort_in_array_definition4262) sort156 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort156.tree) char_literal157=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_array_definition4264) if self._state.backtracking == 0: stream_COMMA.add(char_literal157) self._state.following.append(self.FOLLOW_sort_in_array_definition4266) sort158 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort158.tree) char_literal159=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_array_definition4268) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal159) # AST Rewrite # elements: sort, ARRAY, 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() # 389:9: -> ^( ARRAY sort sort ) # sdl92.g:389: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:393: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 STRUCT160 = None field_list161 = None end162 = None STRUCT160_tree = None stream_STRUCT = RewriteRuleTokenStream(self._adaptor, "token STRUCT") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_field_list = RewriteRuleSubtreeStream(self._adaptor, "rule field_list") try: try: # sdl92.g:394:9: ( STRUCT field_list end -> ^( STRUCT field_list ) ) # sdl92.g:394:17: STRUCT field_list end pass STRUCT160=self.match(self.input, STRUCT, self.FOLLOW_STRUCT_in_structure_definition4323) if self._state.backtracking == 0: stream_STRUCT.add(STRUCT160) self._state.following.append(self.FOLLOW_field_list_in_structure_definition4325) field_list161 = self.field_list() self._state.following.pop() if self._state.backtracking == 0: stream_field_list.add(field_list161.tree) self._state.following.append(self.FOLLOW_end_in_structure_definition4327) end162 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end162.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() # 395:9: -> ^( STRUCT field_list ) # sdl92.g:395: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:399: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_definition163 = None end164 = None field_definition165 = None stream_field_definition = RewriteRuleSubtreeStream(self._adaptor, "rule field_definition") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:400:9: ( field_definition ( end field_definition )* -> ^( FIELDS ( field_definition )+ ) ) # sdl92.g:400:17: field_definition ( end field_definition )* pass self._state.following.append(self.FOLLOW_field_definition_in_field_list4380) field_definition163 = self.field_definition() self._state.following.pop() if self._state.backtracking == 0: stream_field_definition.add(field_definition163.tree) # sdl92.g:400:34: ( end field_definition )* while True: #loop52 alt52 = 2 alt52 = self.dfa52.predict(self.input) if alt52 == 1: # sdl92.g:400:35: end field_definition pass self._state.following.append(self.FOLLOW_end_in_field_list4383) end164 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end164.tree) self._state.following.append(self.FOLLOW_field_definition_in_field_list4385) field_definition165 = self.field_definition() self._state.following.pop() if self._state.backtracking == 0: stream_field_definition.add(field_definition165.tree) else: break #loop52 # 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() # 401:9: -> ^( FIELDS ( field_definition )+ ) # sdl92.g:401:17: ^( FIELDS ( field_definition )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(FIELDS, "FIELDS"), root_1) # sdl92.g:401: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:405: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_literal167 = None field_name166 = None field_name168 = None sort169 = None char_literal167_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_sort = RewriteRuleSubtreeStream(self._adaptor, "rule sort") stream_field_name = RewriteRuleSubtreeStream(self._adaptor, "rule field_name") try: try: # sdl92.g:406:9: ( field_name ( ',' field_name )* sort -> ^( FIELD ( field_name )+ sort ) ) # sdl92.g:406:17: field_name ( ',' field_name )* sort pass self._state.following.append(self.FOLLOW_field_name_in_field_definition4441) field_name166 = self.field_name() self._state.following.pop() if self._state.backtracking == 0: stream_field_name.add(field_name166.tree) # sdl92.g:406:28: ( ',' field_name )* while True: #loop53 alt53 = 2 LA53_0 = self.input.LA(1) if (LA53_0 == COMMA) : alt53 = 1 if alt53 == 1: # sdl92.g:406:29: ',' field_name pass char_literal167=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_field_definition4444) if self._state.backtracking == 0: stream_COMMA.add(char_literal167) self._state.following.append(self.FOLLOW_field_name_in_field_definition4446) field_name168 = self.field_name() self._state.following.pop() if self._state.backtracking == 0: stream_field_name.add(field_name168.tree) else: break #loop53 self._state.following.append(self.FOLLOW_sort_in_field_definition4450) sort169 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort169.tree) # AST Rewrite # elements: field_name, 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() # 407:9: -> ^( FIELD ( field_name )+ sort ) # sdl92.g:407:17: ^( FIELD ( field_name )+ sort ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(FIELD, "FIELD"), root_1) # sdl92.g:407: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:411: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 DCL170 = None char_literal172 = None variables_of_sort171 = None variables_of_sort173 = None end174 = None DCL170_tree = None char_literal172_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:412:9: ( DCL variables_of_sort ( ',' variables_of_sort )* end -> ^( DCL ( variables_of_sort )+ ) ) # sdl92.g:412:17: DCL variables_of_sort ( ',' variables_of_sort )* end pass DCL170=self.match(self.input, DCL, self.FOLLOW_DCL_in_variable_definition4506) if self._state.backtracking == 0: stream_DCL.add(DCL170) self._state.following.append(self.FOLLOW_variables_of_sort_in_variable_definition4508) variables_of_sort171 = self.variables_of_sort() self._state.following.pop() if self._state.backtracking == 0: stream_variables_of_sort.add(variables_of_sort171.tree) # sdl92.g:413:17: ( ',' variables_of_sort )* while True: #loop54 alt54 = 2 LA54_0 = self.input.LA(1) if (LA54_0 == COMMA) : alt54 = 1 if alt54 == 1: # sdl92.g:413:18: ',' variables_of_sort pass char_literal172=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_variable_definition4527) if self._state.backtracking == 0: stream_COMMA.add(char_literal172) self._state.following.append(self.FOLLOW_variables_of_sort_in_variable_definition4529) variables_of_sort173 = self.variables_of_sort() self._state.following.pop() if self._state.backtracking == 0: stream_variables_of_sort.add(variables_of_sort173.tree) else: break #loop54 self._state.following.append(self.FOLLOW_end_in_variable_definition4549) end174 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end174.tree) # AST Rewrite # elements: DCL, variables_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() # 415:9: -> ^( DCL ( variables_of_sort )+ ) # sdl92.g:415:17: ^( DCL ( variables_of_sort )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_DCL.nextNode(), root_1) # sdl92.g:415: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:419: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_definition175 = None try: try: # sdl92.g:420:9: ( internal_synonym_definition ) # sdl92.g:420:17: internal_synonym_definition pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_internal_synonym_definition_in_synonym_definition4603) internal_synonym_definition175 = self.internal_synonym_definition() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, internal_synonym_definition175.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:424: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 SYNONYM176 = None char_literal178 = None synonym_definition_item177 = None synonym_definition_item179 = None end180 = None SYNONYM176_tree = None char_literal178_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:425:9: ( SYNONYM synonym_definition_item ( ',' synonym_definition_item )* end -> ^( SYNONYM_LIST ( synonym_definition_item )+ ) ) # sdl92.g:425:17: SYNONYM synonym_definition_item ( ',' synonym_definition_item )* end pass SYNONYM176=self.match(self.input, SYNONYM, self.FOLLOW_SYNONYM_in_internal_synonym_definition4635) if self._state.backtracking == 0: stream_SYNONYM.add(SYNONYM176) self._state.following.append(self.FOLLOW_synonym_definition_item_in_internal_synonym_definition4637) synonym_definition_item177 = self.synonym_definition_item() self._state.following.pop() if self._state.backtracking == 0: stream_synonym_definition_item.add(synonym_definition_item177.tree) # sdl92.g:425:49: ( ',' synonym_definition_item )* while True: #loop55 alt55 = 2 LA55_0 = self.input.LA(1) if (LA55_0 == COMMA) : alt55 = 1 if alt55 == 1: # sdl92.g:425:50: ',' synonym_definition_item pass char_literal178=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_internal_synonym_definition4640) if self._state.backtracking == 0: stream_COMMA.add(char_literal178) self._state.following.append(self.FOLLOW_synonym_definition_item_in_internal_synonym_definition4642) synonym_definition_item179 = self.synonym_definition_item() self._state.following.pop() if self._state.backtracking == 0: stream_synonym_definition_item.add(synonym_definition_item179.tree) else: break #loop55 self._state.following.append(self.FOLLOW_end_in_internal_synonym_definition4662) end180 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end180.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() # 427:9: -> ^( SYNONYM_LIST ( synonym_definition_item )+ ) # sdl92.g:427: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:427: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:431: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_literal183 = None sort181 = None sort182 = None ground_expression184 = None char_literal183_tree = None stream_EQ = RewriteRuleTokenStream(self._adaptor, "token EQ") stream_ground_expression = RewriteRuleSubtreeStream(self._adaptor, "rule ground_expression") stream_sort = RewriteRuleSubtreeStream(self._adaptor, "rule sort") try: try: # sdl92.g:432:9: ( sort sort '=' ground_expression -> ^( SYNONYM sort sort ground_expression ) ) # sdl92.g:432:17: sort sort '=' ground_expression pass self._state.following.append(self.FOLLOW_sort_in_synonym_definition_item4716) sort181 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort181.tree) self._state.following.append(self.FOLLOW_sort_in_synonym_definition_item4718) sort182 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort182.tree) char_literal183=self.match(self.input, EQ, self.FOLLOW_EQ_in_synonym_definition_item4720) if self._state.backtracking == 0: stream_EQ.add(char_literal183) self._state.following.append(self.FOLLOW_ground_expression_in_synonym_definition_item4722) ground_expression184 = self.ground_expression() self._state.following.pop() if self._state.backtracking == 0: stream_ground_expression.add(ground_expression184.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() # 433:9: -> ^( SYNONYM sort sort ground_expression ) # sdl92.g:433: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:437: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_literal186 = None string_literal189 = None variable_id185 = None variable_id187 = None sort188 = None ground_expression190 = None char_literal186_tree = None string_literal189_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_ASSIG_OP = RewriteRuleTokenStream(self._adaptor, "token ASSIG_OP") stream_variable_id = RewriteRuleSubtreeStream(self._adaptor, "rule variable_id") stream_ground_expression = RewriteRuleSubtreeStream(self._adaptor, "rule ground_expression") stream_sort = RewriteRuleSubtreeStream(self._adaptor, "rule sort") try: try: # sdl92.g:438:9: ( variable_id ( ',' variable_id )* sort ( ':=' ground_expression )? -> ^( VARIABLES ( variable_id )+ sort ( ground_expression )? ) ) # sdl92.g:438:17: variable_id ( ',' variable_id )* sort ( ':=' ground_expression )? pass self._state.following.append(self.FOLLOW_variable_id_in_variables_of_sort4779) variable_id185 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id185.tree) # sdl92.g:438:29: ( ',' variable_id )* while True: #loop56 alt56 = 2 LA56_0 = self.input.LA(1) if (LA56_0 == COMMA) : alt56 = 1 if alt56 == 1: # sdl92.g:438:30: ',' variable_id pass char_literal186=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_variables_of_sort4782) if self._state.backtracking == 0: stream_COMMA.add(char_literal186) self._state.following.append(self.FOLLOW_variable_id_in_variables_of_sort4784) variable_id187 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id187.tree) else: break #loop56 self._state.following.append(self.FOLLOW_sort_in_variables_of_sort4788) sort188 = self.sort() self._state.following.pop() if self._state.backtracking == 0: stream_sort.add(sort188.tree) # sdl92.g:438:53: ( ':=' ground_expression )? alt57 = 2 LA57_0 = self.input.LA(1) if (LA57_0 == ASSIG_OP) : alt57 = 1 if alt57 == 1: # sdl92.g:438:54: ':=' ground_expression pass string_literal189=self.match(self.input, ASSIG_OP, self.FOLLOW_ASSIG_OP_in_variables_of_sort4791) if self._state.backtracking == 0: stream_ASSIG_OP.add(string_literal189) self._state.following.append(self.FOLLOW_ground_expression_in_variables_of_sort4793) ground_expression190 = self.ground_expression() self._state.following.pop() if self._state.backtracking == 0: stream_ground_expression.add(ground_expression190.tree) # AST Rewrite # elements: ground_expression, 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() # 439:9: -> ^( VARIABLES ( variable_id )+ sort ( ground_expression )? ) # sdl92.g:439: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:439: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:439: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:443:1: ground_expression : expression -> ^( GROUND expression ) ; def ground_expression(self, ): retval = self.ground_expression_return() retval.start = self.input.LT(1) root_0 = None expression191 = None stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:444:9: ( expression -> ^( GROUND expression ) ) # sdl92.g:444:17: expression pass self._state.following.append(self.FOLLOW_expression_in_ground_expression4854) expression191 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression191.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() # 445:9: -> ^( GROUND expression ) # sdl92.g:445: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:449: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_literal192 = None char_literal193 = None char_literal194 = None initial_number_tree = None maximum_number_tree = None char_literal192_tree = None char_literal193_tree = None char_literal194_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_INT = RewriteRuleTokenStream(self._adaptor, "token INT") try: try: # sdl92.g:450:9: ( '(' initial_number= INT ',' maximum_number= INT ')' -> ^( NUMBER_OF_INSTANCES $initial_number $maximum_number) ) # sdl92.g:450:17: '(' initial_number= INT ',' maximum_number= INT ')' pass char_literal192=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_number_of_instances4907) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal192) initial_number=self.match(self.input, INT, self.FOLLOW_INT_in_number_of_instances4911) if self._state.backtracking == 0: stream_INT.add(initial_number) char_literal193=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_number_of_instances4913) if self._state.backtracking == 0: stream_COMMA.add(char_literal193) maximum_number=self.match(self.input, INT, self.FOLLOW_INT_in_number_of_instances4917) if self._state.backtracking == 0: stream_INT.add(maximum_number) char_literal194=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_number_of_instances4919) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal194) # AST Rewrite # elements: maximum_number, initial_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() # 451:9: -> ^( NUMBER_OF_INSTANCES $initial_number $maximum_number) # sdl92.g:451: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:455:1: processBody : ( start )? ( state | floating_label )* ; def processBody(self, ): retval = self.processBody_return() retval.start = self.input.LT(1) root_0 = None start195 = None state196 = None floating_label197 = None try: try: # sdl92.g:456:9: ( ( start )? ( state | floating_label )* ) # sdl92.g:456:17: ( start )? ( state | floating_label )* pass root_0 = self._adaptor.nil() # sdl92.g:456:17: ( start )? alt58 = 2 alt58 = self.dfa58.predict(self.input) if alt58 == 1: # sdl92.g:0:0: start pass self._state.following.append(self.FOLLOW_start_in_processBody4976) start195 = self.start() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, start195.tree) # sdl92.g:456:24: ( state | floating_label )* while True: #loop59 alt59 = 3 alt59 = self.dfa59.predict(self.input) if alt59 == 1: # sdl92.g:456:25: state pass self._state.following.append(self.FOLLOW_state_in_processBody4980) state196 = self.state() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, state196.tree) elif alt59 == 2: # sdl92.g:456:33: floating_label pass self._state.following.append(self.FOLLOW_floating_label_in_processBody4984) floating_label197 = self.floating_label() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, floating_label197.tree) else: break #loop59 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:460: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 START200 = None name = None cif198 = None hyperlink199 = None end201 = None transition202 = None START200_tree = None stream_START = RewriteRuleTokenStream(self._adaptor, "token START") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_state_entry_point_name = RewriteRuleSubtreeStream(self._adaptor, "rule state_entry_point_name") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") try: try: # sdl92.g:461:9: ( ( cif )? ( hyperlink )? START (name= state_entry_point_name )? end ( transition )? -> ^( START ( cif )? ( hyperlink )? ( $name)? ( end )? ( transition )? ) ) # sdl92.g:461:17: ( cif )? ( hyperlink )? START (name= state_entry_point_name )? end ( transition )? pass # sdl92.g:461:17: ( cif )? alt60 = 2 LA60_0 = self.input.LA(1) if (LA60_0 == 228) : LA60_1 = self.input.LA(2) if (LA60_1 == ANSWER or LA60_1 == COMMENT or LA60_1 == CONNECT or LA60_1 == DECISION or LA60_1 == INPUT or (JOIN <= LA60_1 <= LABEL) or LA60_1 == NEXTSTATE or LA60_1 == OUTPUT or (PROCEDURE <= LA60_1 <= PROCEDURE_CALL) or (PROCESS <= LA60_1 <= PROVIDED) or LA60_1 == RETURN or LA60_1 == STATE or LA60_1 == STOP or LA60_1 == TASK or LA60_1 == TEXT or LA60_1 == START) : alt60 = 1 if alt60 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_start5018) cif198 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif198.tree) # sdl92.g:462:17: ( hyperlink )? alt61 = 2 LA61_0 = self.input.LA(1) if (LA61_0 == 228) : alt61 = 1 if alt61 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_start5037) hyperlink199 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink199.tree) START200=self.match(self.input, START, self.FOLLOW_START_in_start5056) if self._state.backtracking == 0: stream_START.add(START200) # sdl92.g:463:27: (name= state_entry_point_name )? alt62 = 2 LA62_0 = self.input.LA(1) if (LA62_0 == ID) : alt62 = 1 if alt62 == 1: # sdl92.g:0:0: name= state_entry_point_name pass self._state.following.append(self.FOLLOW_state_entry_point_name_in_start5060) 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_start5063) end201 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end201.tree) # sdl92.g:464:17: ( transition )? alt63 = 2 alt63 = self.dfa63.predict(self.input) if alt63 == 1: # sdl92.g:0:0: transition pass self._state.following.append(self.FOLLOW_transition_in_start5081) transition202 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition202.tree) # AST Rewrite # elements: hyperlink, cif, transition, end, name, START # token labels: # rule labels: name, retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 if name is not None: stream_name = RewriteRuleSubtreeStream(self._adaptor, "rule name", name.tree) else: stream_name = RewriteRuleSubtreeStream(self._adaptor, "token name", 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() # 465:9: -> ^( START ( cif )? ( hyperlink )? ( $name)? ( end )? ( transition )? ) # sdl92.g:465:17: ^( START ( cif )? ( hyperlink )? ( $name)? ( end )? ( transition )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_START.nextNode(), root_1) # sdl92.g:465:25: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:465:30: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:465:41: ( $name)? if stream_name.hasNext(): self._adaptor.addChild(root_1, stream_name.nextTree()) stream_name.reset(); # sdl92.g:465:48: ( end )? if stream_end.hasNext(): self._adaptor.addChild(root_1, stream_end.nextTree()) stream_end.reset(); # sdl92.g:465: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:469: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 CONNECTION205 = None char_literal207 = None ENDCONNECTION210 = None SEMI211 = None cif203 = None hyperlink204 = None connector_name206 = None transition208 = None cif_end_label209 = None CONNECTION205_tree = None char_literal207_tree = None ENDCONNECTION210_tree = None SEMI211_tree = None stream_CONNECTION = RewriteRuleTokenStream(self._adaptor, "token CONNECTION") stream_223 = RewriteRuleTokenStream(self._adaptor, "token 223") stream_ENDCONNECTION = RewriteRuleTokenStream(self._adaptor, "token ENDCONNECTION") stream_SEMI = RewriteRuleTokenStream(self._adaptor, "token SEMI") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_cif_end_label = RewriteRuleSubtreeStream(self._adaptor, "rule cif_end_label") stream_connector_name = RewriteRuleSubtreeStream(self._adaptor, "rule connector_name") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") try: try: # sdl92.g:470:9: ( ( cif )? ( hyperlink )? CONNECTION connector_name ':' ( transition )? ( cif_end_label )? ENDCONNECTION SEMI -> ^( FLOATING_LABEL ( cif )? ( hyperlink )? connector_name ( transition )? ) ) # sdl92.g:470:17: ( cif )? ( hyperlink )? CONNECTION connector_name ':' ( transition )? ( cif_end_label )? ENDCONNECTION SEMI pass # sdl92.g:470:17: ( cif )? alt64 = 2 LA64_0 = self.input.LA(1) if (LA64_0 == 228) : LA64_1 = self.input.LA(2) if (LA64_1 == ANSWER or LA64_1 == COMMENT or LA64_1 == CONNECT or LA64_1 == DECISION or LA64_1 == INPUT or (JOIN <= LA64_1 <= LABEL) or LA64_1 == NEXTSTATE or LA64_1 == OUTPUT or (PROCEDURE <= LA64_1 <= PROCEDURE_CALL) or (PROCESS <= LA64_1 <= PROVIDED) or LA64_1 == RETURN or LA64_1 == STATE or LA64_1 == STOP or LA64_1 == TASK or LA64_1 == TEXT or LA64_1 == START) : alt64 = 1 if alt64 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_floating_label5149) cif203 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif203.tree) # sdl92.g:471:17: ( hyperlink )? alt65 = 2 LA65_0 = self.input.LA(1) if (LA65_0 == 228) : alt65 = 1 if alt65 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_floating_label5168) hyperlink204 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink204.tree) CONNECTION205=self.match(self.input, CONNECTION, self.FOLLOW_CONNECTION_in_floating_label5187) if self._state.backtracking == 0: stream_CONNECTION.add(CONNECTION205) self._state.following.append(self.FOLLOW_connector_name_in_floating_label5189) connector_name206 = self.connector_name() self._state.following.pop() if self._state.backtracking == 0: stream_connector_name.add(connector_name206.tree) char_literal207=self.match(self.input, 223, self.FOLLOW_223_in_floating_label5191) if self._state.backtracking == 0: stream_223.add(char_literal207) # sdl92.g:473:17: ( transition )? alt66 = 2 LA66_0 = self.input.LA(1) if (LA66_0 == 228) : LA66_1 = self.input.LA(2) if (LA66_1 == ANSWER or LA66_1 == COMMENT or LA66_1 == CONNECT or LA66_1 == DECISION or LA66_1 == INPUT or (JOIN <= LA66_1 <= LABEL) or LA66_1 == NEXTSTATE or LA66_1 == OUTPUT or (PROCEDURE <= LA66_1 <= PROCEDURE_CALL) or (PROCESS <= LA66_1 <= PROVIDED) or LA66_1 == RETURN or LA66_1 == STATE or LA66_1 == STOP or LA66_1 == TASK or LA66_1 == TEXT or LA66_1 == START or LA66_1 == KEEP) : alt66 = 1 elif (LA66_0 == ALTERNATIVE or LA66_0 == DECISION or LA66_0 == EXPORT or LA66_0 == FOR or LA66_0 == JOIN or LA66_0 == NEXTSTATE or LA66_0 == OUTPUT or (RESET <= LA66_0 <= RETURN) or LA66_0 == SET or LA66_0 == STOP or LA66_0 == STRING or LA66_0 == TASK or LA66_0 == ID or LA66_0 == CALL or LA66_0 == CREATE) : alt66 = 1 if alt66 == 1: # sdl92.g:0:0: transition pass self._state.following.append(self.FOLLOW_transition_in_floating_label5209) transition208 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition208.tree) # sdl92.g:474:17: ( cif_end_label )? alt67 = 2 LA67_0 = self.input.LA(1) if (LA67_0 == 228) : alt67 = 1 if alt67 == 1: # sdl92.g:0:0: cif_end_label pass self._state.following.append(self.FOLLOW_cif_end_label_in_floating_label5228) cif_end_label209 = self.cif_end_label() self._state.following.pop() if self._state.backtracking == 0: stream_cif_end_label.add(cif_end_label209.tree) ENDCONNECTION210=self.match(self.input, ENDCONNECTION, self.FOLLOW_ENDCONNECTION_in_floating_label5247) if self._state.backtracking == 0: stream_ENDCONNECTION.add(ENDCONNECTION210) SEMI211=self.match(self.input, SEMI, self.FOLLOW_SEMI_in_floating_label5249) if self._state.backtracking == 0: stream_SEMI.add(SEMI211) # AST Rewrite # elements: cif, hyperlink, transition, 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() # 476:9: -> ^( FLOATING_LABEL ( cif )? ( hyperlink )? connector_name ( transition )? ) # sdl92.g:476: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:476:34: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:476: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:476: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:480:1: state : ( cif )? ( hyperlink )? STATE statelist (e= end | SEMI ) ( 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 STATE214 = None SEMI216 = None ENDSTATE218 = None e = None f = None cif212 = None hyperlink213 = None statelist215 = None state_part217 = None statename219 = None STATE214_tree = None SEMI216_tree = None ENDSTATE218_tree = None stream_SEMI = RewriteRuleTokenStream(self._adaptor, "token SEMI") 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_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_statename = RewriteRuleSubtreeStream(self._adaptor, "rule statename") stream_state_part = RewriteRuleSubtreeStream(self._adaptor, "rule state_part") try: try: # sdl92.g:481:9: ( ( cif )? ( hyperlink )? STATE statelist (e= end | SEMI ) ( state_part )* ENDSTATE ( statename )? f= end -> ^( STATE ( cif )? ( hyperlink )? ( $e)? statelist ( state_part )* ) ) # sdl92.g:481:17: ( cif )? ( hyperlink )? STATE statelist (e= end | SEMI ) ( state_part )* ENDSTATE ( statename )? f= end pass # sdl92.g:481:17: ( cif )? alt68 = 2 LA68_0 = self.input.LA(1) if (LA68_0 == 228) : LA68_1 = self.input.LA(2) if (LA68_1 == ANSWER or LA68_1 == COMMENT or LA68_1 == CONNECT or LA68_1 == DECISION or LA68_1 == INPUT or (JOIN <= LA68_1 <= LABEL) or LA68_1 == NEXTSTATE or LA68_1 == OUTPUT or (PROCEDURE <= LA68_1 <= PROCEDURE_CALL) or (PROCESS <= LA68_1 <= PROVIDED) or LA68_1 == RETURN or LA68_1 == STATE or LA68_1 == STOP or LA68_1 == TASK or LA68_1 == TEXT or LA68_1 == START) : alt68 = 1 if alt68 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_state5311) cif212 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif212.tree) # sdl92.g:482:17: ( hyperlink )? alt69 = 2 LA69_0 = self.input.LA(1) if (LA69_0 == 228) : alt69 = 1 if alt69 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_state5330) hyperlink213 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink213.tree) STATE214=self.match(self.input, STATE, self.FOLLOW_STATE_in_state5349) if self._state.backtracking == 0: stream_STATE.add(STATE214) self._state.following.append(self.FOLLOW_statelist_in_state5351) statelist215 = self.statelist() self._state.following.pop() if self._state.backtracking == 0: stream_statelist.add(statelist215.tree) # sdl92.g:483:33: (e= end | SEMI ) alt70 = 2 LA70_0 = self.input.LA(1) if (LA70_0 == COMMENT or LA70_0 == 228) : alt70 = 1 elif (LA70_0 == SEMI) : LA70_2 = self.input.LA(2) if (self.synpred94_sdl92()) : alt70 = 1 elif (True) : alt70 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 70, 2, self.input) raise nvae else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 70, 0, self.input) raise nvae if alt70 == 1: # sdl92.g:483:34: e= end pass self._state.following.append(self.FOLLOW_end_in_state5356) e = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(e.tree) elif alt70 == 2: # sdl92.g:483:42: SEMI pass SEMI216=self.match(self.input, SEMI, self.FOLLOW_SEMI_in_state5360) if self._state.backtracking == 0: stream_SEMI.add(SEMI216) # sdl92.g:484:17: ( state_part )* while True: #loop71 alt71 = 2 LA71_0 = self.input.LA(1) if (LA71_0 == CONNECT or LA71_0 == INPUT or LA71_0 == PROVIDED or LA71_0 == SAVE or LA71_0 == 228) : alt71 = 1 if alt71 == 1: # sdl92.g:484:18: state_part pass self._state.following.append(self.FOLLOW_state_part_in_state5380) state_part217 = self.state_part() self._state.following.pop() if self._state.backtracking == 0: stream_state_part.add(state_part217.tree) else: break #loop71 ENDSTATE218=self.match(self.input, ENDSTATE, self.FOLLOW_ENDSTATE_in_state5400) if self._state.backtracking == 0: stream_ENDSTATE.add(ENDSTATE218) # sdl92.g:485:26: ( statename )? alt72 = 2 LA72_0 = self.input.LA(1) if (LA72_0 == ID) : alt72 = 1 if alt72 == 1: # sdl92.g:0:0: statename pass self._state.following.append(self.FOLLOW_statename_in_state5402) statename219 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename219.tree) self._state.following.append(self.FOLLOW_end_in_state5407) f = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(f.tree) # AST Rewrite # elements: e, STATE, cif, hyperlink, state_part, statelist # token labels: # rule labels: e, retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 if e is not None: stream_e = RewriteRuleSubtreeStream(self._adaptor, "rule e", e.tree) else: stream_e = RewriteRuleSubtreeStream(self._adaptor, "token e", 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() # 486:9: -> ^( STATE ( cif )? ( hyperlink )? ( $e)? statelist ( state_part )* ) # sdl92.g:486: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:486:25: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:486:30: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:486: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:486: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:490: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_literal221 = None ASTERISK223 = None statename220 = None statename222 = None exception_state224 = None char_literal221_tree = None ASTERISK223_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:491:9: ( ( ( statename ) ( ',' statename )* ) -> ^( STATELIST ( statename )+ ) | ASTERISK ( exception_state )? -> ^( ASTERISK ( exception_state )? ) ) alt75 = 2 LA75_0 = self.input.LA(1) if (LA75_0 == ID) : alt75 = 1 elif (LA75_0 == ASTERISK) : alt75 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 75, 0, self.input) raise nvae if alt75 == 1: # sdl92.g:491:17: ( ( statename ) ( ',' statename )* ) pass # sdl92.g:491:17: ( ( statename ) ( ',' statename )* ) # sdl92.g:491:18: ( statename ) ( ',' statename )* pass # sdl92.g:491:18: ( statename ) # sdl92.g:491:19: statename pass self._state.following.append(self.FOLLOW_statename_in_statelist5475) statename220 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename220.tree) # sdl92.g:491:29: ( ',' statename )* while True: #loop73 alt73 = 2 LA73_0 = self.input.LA(1) if (LA73_0 == COMMA) : alt73 = 1 if alt73 == 1: # sdl92.g:491:30: ',' statename pass char_literal221=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_statelist5478) if self._state.backtracking == 0: stream_COMMA.add(char_literal221) self._state.following.append(self.FOLLOW_statename_in_statelist5480) statename222 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename222.tree) else: break #loop73 # 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() # 492:9: -> ^( STATELIST ( statename )+ ) # sdl92.g:492:17: ^( STATELIST ( statename )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(STATELIST, "STATELIST"), root_1) # sdl92.g:492: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 alt75 == 2: # sdl92.g:493:19: ASTERISK ( exception_state )? pass ASTERISK223=self.match(self.input, ASTERISK, self.FOLLOW_ASTERISK_in_statelist5525) if self._state.backtracking == 0: stream_ASTERISK.add(ASTERISK223) # sdl92.g:493:28: ( exception_state )? alt74 = 2 LA74_0 = self.input.LA(1) if (LA74_0 == L_PAREN) : alt74 = 1 if alt74 == 1: # sdl92.g:0:0: exception_state pass self._state.following.append(self.FOLLOW_exception_state_in_statelist5527) exception_state224 = self.exception_state() self._state.following.pop() if self._state.backtracking == 0: stream_exception_state.add(exception_state224.tree) # AST Rewrite # elements: exception_state, ASTERISK # 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() # 494:9: -> ^( ASTERISK ( exception_state )? ) # sdl92.g:494:17: ^( ASTERISK ( exception_state )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_ASTERISK.nextNode(), root_1) # sdl92.g:494: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:498: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_literal225 = None char_literal227 = None char_literal229 = None statename226 = None statename228 = None char_literal225_tree = None char_literal227_tree = None char_literal229_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_statename = RewriteRuleSubtreeStream(self._adaptor, "rule statename") try: try: # sdl92.g:499:9: ( '(' statename ( ',' statename )* ')' -> ( statename )+ ) # sdl92.g:499:17: '(' statename ( ',' statename )* ')' pass char_literal225=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_exception_state5582) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal225) self._state.following.append(self.FOLLOW_statename_in_exception_state5584) statename226 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename226.tree) # sdl92.g:499:31: ( ',' statename )* while True: #loop76 alt76 = 2 LA76_0 = self.input.LA(1) if (LA76_0 == COMMA) : alt76 = 1 if alt76 == 1: # sdl92.g:499:32: ',' statename pass char_literal227=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_exception_state5587) if self._state.backtracking == 0: stream_COMMA.add(char_literal227) self._state.following.append(self.FOLLOW_statename_in_exception_state5589) statename228 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename228.tree) else: break #loop76 char_literal229=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_exception_state5593) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal229) # 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() # 500:9: -> ( statename )+ # sdl92.g:500: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:505: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_graph230 = None state_aggregation231 = None try: try: # sdl92.g:506:9: ( composite_state_graph | state_aggregation ) alt77 = 2 LA77_0 = self.input.LA(1) if (LA77_0 == STATE) : LA77_1 = self.input.LA(2) if (LA77_1 == AGGREGATION) : alt77 = 2 elif (LA77_1 == ID) : alt77 = 1 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 77, 1, self.input) raise nvae else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 77, 0, self.input) raise nvae if alt77 == 1: # sdl92.g:506:17: composite_state_graph pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_composite_state_graph_in_composite_state5644) composite_state_graph230 = self.composite_state_graph() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, composite_state_graph230.tree) elif alt77 == 2: # sdl92.g:507:19: state_aggregation pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_state_aggregation_in_composite_state5664) state_aggregation231 = self.state_aggregation() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, state_aggregation231.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_preamble_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.composite_state_preamble_return, self).__init__() self.tree = None # $ANTLR start "composite_state_preamble" # sdl92.g:511:1: composite_state_preamble : STATE ( AGGREGATION )? statename end SUBSTRUCTURE ; def composite_state_preamble(self, ): retval = self.composite_state_preamble_return() retval.start = self.input.LT(1) root_0 = None STATE232 = None AGGREGATION233 = None SUBSTRUCTURE236 = None statename234 = None end235 = None STATE232_tree = None AGGREGATION233_tree = None SUBSTRUCTURE236_tree = None try: try: # sdl92.g:512:9: ( STATE ( AGGREGATION )? statename end SUBSTRUCTURE ) # sdl92.g:512:17: STATE ( AGGREGATION )? statename end SUBSTRUCTURE pass root_0 = self._adaptor.nil() STATE232=self.match(self.input, STATE, self.FOLLOW_STATE_in_composite_state_preamble5696) if self._state.backtracking == 0: STATE232_tree = self._adaptor.createWithPayload(STATE232) self._adaptor.addChild(root_0, STATE232_tree) # sdl92.g:512:23: ( AGGREGATION )? alt78 = 2 LA78_0 = self.input.LA(1) if (LA78_0 == AGGREGATION) : alt78 = 1 if alt78 == 1: # sdl92.g:0:0: AGGREGATION pass AGGREGATION233=self.match(self.input, AGGREGATION, self.FOLLOW_AGGREGATION_in_composite_state_preamble5698) if self._state.backtracking == 0: AGGREGATION233_tree = self._adaptor.createWithPayload(AGGREGATION233) self._adaptor.addChild(root_0, AGGREGATION233_tree) self._state.following.append(self.FOLLOW_statename_in_composite_state_preamble5701) statename234 = self.statename() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, statename234.tree) self._state.following.append(self.FOLLOW_end_in_composite_state_preamble5703) end235 = self.end() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, end235.tree) SUBSTRUCTURE236=self.match(self.input, SUBSTRUCTURE, self.FOLLOW_SUBSTRUCTURE_in_composite_state_preamble5721) if self._state.backtracking == 0: SUBSTRUCTURE236_tree = self._adaptor.createWithPayload(SUBSTRUCTURE236) self._adaptor.addChild(root_0, SUBSTRUCTURE236_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_preamble" 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:516: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 STATE237 = None SUBSTRUCTURE239 = None ENDSUBSTRUCTURE241 = None e = None body = None f = None statename238 = None connection_points240 = None statename242 = None STATE237_tree = None SUBSTRUCTURE239_tree = None ENDSUBSTRUCTURE241_tree = None stream_STATE = RewriteRuleTokenStream(self._adaptor, "token STATE") stream_SUBSTRUCTURE = RewriteRuleTokenStream(self._adaptor, "token SUBSTRUCTURE") stream_ENDSUBSTRUCTURE = RewriteRuleTokenStream(self._adaptor, "token ENDSUBSTRUCTURE") stream_connection_points = RewriteRuleSubtreeStream(self._adaptor, "rule connection_points") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_statename = RewriteRuleSubtreeStream(self._adaptor, "rule statename") stream_composite_state_body = RewriteRuleSubtreeStream(self._adaptor, "rule composite_state_body") try: try: # sdl92.g:517: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:517:17: STATE statename e= end SUBSTRUCTURE ( connection_points )* body= composite_state_body ENDSUBSTRUCTURE ( statename )? f= end pass STATE237=self.match(self.input, STATE, self.FOLLOW_STATE_in_composite_state_graph5752) if self._state.backtracking == 0: stream_STATE.add(STATE237) self._state.following.append(self.FOLLOW_statename_in_composite_state_graph5754) statename238 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename238.tree) self._state.following.append(self.FOLLOW_end_in_composite_state_graph5758) e = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(e.tree) SUBSTRUCTURE239=self.match(self.input, SUBSTRUCTURE, self.FOLLOW_SUBSTRUCTURE_in_composite_state_graph5776) if self._state.backtracking == 0: stream_SUBSTRUCTURE.add(SUBSTRUCTURE239) # sdl92.g:519:17: ( connection_points )* while True: #loop79 alt79 = 2 LA79_0 = self.input.LA(1) if (LA79_0 == IN or LA79_0 == OUT) : alt79 = 1 if alt79 == 1: # sdl92.g:0:0: connection_points pass self._state.following.append(self.FOLLOW_connection_points_in_composite_state_graph5794) connection_points240 = self.connection_points() self._state.following.pop() if self._state.backtracking == 0: stream_connection_points.add(connection_points240.tree) else: break #loop79 self._state.following.append(self.FOLLOW_composite_state_body_in_composite_state_graph5815) body = self.composite_state_body() self._state.following.pop() if self._state.backtracking == 0: stream_composite_state_body.add(body.tree) ENDSUBSTRUCTURE241=self.match(self.input, ENDSUBSTRUCTURE, self.FOLLOW_ENDSUBSTRUCTURE_in_composite_state_graph5833) if self._state.backtracking == 0: stream_ENDSUBSTRUCTURE.add(ENDSUBSTRUCTURE241) # sdl92.g:521:33: ( statename )? alt80 = 2 LA80_0 = self.input.LA(1) if (LA80_0 == ID) : alt80 = 1 if alt80 == 1: # sdl92.g:0:0: statename pass self._state.following.append(self.FOLLOW_statename_in_composite_state_graph5835) statename242 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename242.tree) self._state.following.append(self.FOLLOW_end_in_composite_state_graph5840) f = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(f.tree) # AST Rewrite # elements: e, statename, connection_points, body # token labels: # rule labels: e, body, retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 if e is not None: stream_e = RewriteRuleSubtreeStream(self._adaptor, "rule e", e.tree) else: stream_e = RewriteRuleSubtreeStream(self._adaptor, "token e", None) 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) root_0 = self._adaptor.nil() # 522:9: -> ^( COMPOSITE_STATE statename ( connection_points )* $body ( $e)? ) # sdl92.g:522: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:522: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:522: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:527: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 STATE243 = None AGGREGATION244 = None SUBSTRUCTURE246 = None ENDSUBSTRUCTURE248 = None e = None entities = None body = None f = None statename245 = None connection_points247 = None statename249 = None STATE243_tree = None AGGREGATION244_tree = None SUBSTRUCTURE246_tree = None ENDSUBSTRUCTURE248_tree = None stream_STATE = RewriteRuleTokenStream(self._adaptor, "token STATE") stream_AGGREGATION = RewriteRuleTokenStream(self._adaptor, "token AGGREGATION") stream_SUBSTRUCTURE = RewriteRuleTokenStream(self._adaptor, "token SUBSTRUCTURE") stream_ENDSUBSTRUCTURE = RewriteRuleTokenStream(self._adaptor, "token ENDSUBSTRUCTURE") stream_state_aggregation_body = RewriteRuleSubtreeStream(self._adaptor, "rule state_aggregation_body") stream_entity_in_composite_state = RewriteRuleSubtreeStream(self._adaptor, "rule entity_in_composite_state") stream_connection_points = RewriteRuleSubtreeStream(self._adaptor, "rule connection_points") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_statename = RewriteRuleSubtreeStream(self._adaptor, "rule statename") try: try: # sdl92.g:528: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:528:17: STATE AGGREGATION statename e= end SUBSTRUCTURE ( connection_points )* (entities= entity_in_composite_state )* body= state_aggregation_body ENDSUBSTRUCTURE ( statename )? f= end pass STATE243=self.match(self.input, STATE, self.FOLLOW_STATE_in_state_aggregation5904) if self._state.backtracking == 0: stream_STATE.add(STATE243) AGGREGATION244=self.match(self.input, AGGREGATION, self.FOLLOW_AGGREGATION_in_state_aggregation5906) if self._state.backtracking == 0: stream_AGGREGATION.add(AGGREGATION244) self._state.following.append(self.FOLLOW_statename_in_state_aggregation5908) statename245 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename245.tree) self._state.following.append(self.FOLLOW_end_in_state_aggregation5912) e = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(e.tree) SUBSTRUCTURE246=self.match(self.input, SUBSTRUCTURE, self.FOLLOW_SUBSTRUCTURE_in_state_aggregation5930) if self._state.backtracking == 0: stream_SUBSTRUCTURE.add(SUBSTRUCTURE246) # sdl92.g:530:17: ( connection_points )* while True: #loop81 alt81 = 2 LA81_0 = self.input.LA(1) if (LA81_0 == IN or LA81_0 == OUT) : alt81 = 1 if alt81 == 1: # sdl92.g:0:0: connection_points pass self._state.following.append(self.FOLLOW_connection_points_in_state_aggregation5948) connection_points247 = self.connection_points() self._state.following.pop() if self._state.backtracking == 0: stream_connection_points.add(connection_points247.tree) else: break #loop81 # sdl92.g:531:25: (entities= entity_in_composite_state )* while True: #loop82 alt82 = 2 alt82 = self.dfa82.predict(self.input) if alt82 == 1: # sdl92.g:0:0: entities= entity_in_composite_state pass self._state.following.append(self.FOLLOW_entity_in_composite_state_in_state_aggregation5969) 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 #loop82 self._state.following.append(self.FOLLOW_state_aggregation_body_in_state_aggregation5990) body = self.state_aggregation_body() self._state.following.pop() if self._state.backtracking == 0: stream_state_aggregation_body.add(body.tree) ENDSUBSTRUCTURE248=self.match(self.input, ENDSUBSTRUCTURE, self.FOLLOW_ENDSUBSTRUCTURE_in_state_aggregation6008) if self._state.backtracking == 0: stream_ENDSUBSTRUCTURE.add(ENDSUBSTRUCTURE248) # sdl92.g:533:33: ( statename )? alt83 = 2 LA83_0 = self.input.LA(1) if (LA83_0 == ID) : alt83 = 1 if alt83 == 1: # sdl92.g:0:0: statename pass self._state.following.append(self.FOLLOW_statename_in_state_aggregation6010) statename249 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename249.tree) self._state.following.append(self.FOLLOW_end_in_state_aggregation6015) f = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(f.tree) # AST Rewrite # elements: body, entities, connection_points, e, statename # token labels: # rule labels: entities, e, body, retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 if entities is not None: stream_entities = RewriteRuleSubtreeStream(self._adaptor, "rule entities", entities.tree) else: stream_entities = RewriteRuleSubtreeStream(self._adaptor, "token entities", 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 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) root_0 = self._adaptor.nil() # 534:9: -> ^( STATE_AGGREGATION statename ( connection_points )* ( $entities)* $body ( $e)? ) # sdl92.g:534: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:534:47: ( connection_points )* while stream_connection_points.hasNext(): self._adaptor.addChild(root_1, stream_connection_points.nextTree()) stream_connection_points.reset(); # sdl92.g:535: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:535: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:540: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_area250 = None procedure251 = None try: try: # sdl92.g:541:9: ( ( text_area | procedure ) ) # sdl92.g:541:17: ( text_area | procedure ) pass root_0 = self._adaptor.nil() # sdl92.g:541:17: ( text_area | procedure ) alt84 = 2 LA84_0 = self.input.LA(1) if (LA84_0 == 228) : LA84_1 = self.input.LA(2) if (self.synpred108_sdl92()) : alt84 = 1 elif (True) : alt84 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 84, 1, self.input) raise nvae elif (LA84_0 == PROCEDURE) : alt84 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 84, 0, self.input) raise nvae if alt84 == 1: # sdl92.g:541:18: text_area pass self._state.following.append(self.FOLLOW_text_area_in_entity_in_composite_state6120) text_area250 = self.text_area() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, text_area250.tree) elif alt84 == 2: # sdl92.g:541:30: procedure pass self._state.following.append(self.FOLLOW_procedure_in_entity_in_composite_state6124) procedure251 = self.procedure() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, procedure251.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:546: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_partitioning252 = None state_partition_connection253 = None state254 = None try: try: # sdl92.g:547:9: ( ( state_partitioning | state_partition_connection )* ( state )* ) # sdl92.g:547:17: ( state_partitioning | state_partition_connection )* ( state )* pass root_0 = self._adaptor.nil() # sdl92.g:547:17: ( state_partitioning | state_partition_connection )* while True: #loop85 alt85 = 3 alt85 = self.dfa85.predict(self.input) if alt85 == 1: # sdl92.g:547:18: state_partitioning pass self._state.following.append(self.FOLLOW_state_partitioning_in_state_aggregation_body6159) state_partitioning252 = self.state_partitioning() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, state_partitioning252.tree) elif alt85 == 2: # sdl92.g:547:39: state_partition_connection pass self._state.following.append(self.FOLLOW_state_partition_connection_in_state_aggregation_body6163) state_partition_connection253 = self.state_partition_connection() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, state_partition_connection253.tree) else: break #loop85 # sdl92.g:548:17: ( state )* while True: #loop86 alt86 = 2 LA86_0 = self.input.LA(1) if (LA86_0 == STATE or LA86_0 == 228) : alt86 = 1 if alt86 == 1: # sdl92.g:0:0: state pass self._state.following.append(self.FOLLOW_state_in_state_aggregation_body6183) state254 = self.state() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, state254.tree) else: break #loop86 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:553:1: state_partitioning : composite_state ; def state_partitioning(self, ): retval = self.state_partitioning_return() retval.start = self.input.LT(1) root_0 = None composite_state255 = None try: try: # sdl92.g:554:9: ( composite_state ) # sdl92.g:554:17: composite_state pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_composite_state_in_state_partitioning6217) composite_state255 = self.composite_state() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, composite_state255.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:559: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 CONNECT256 = None AND257 = None outer = None inner = None end258 = None CONNECT256_tree = None AND257_tree = None stream_AND = RewriteRuleTokenStream(self._adaptor, "token AND") stream_CONNECT = RewriteRuleTokenStream(self._adaptor, "token CONNECT") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_entry_point = RewriteRuleSubtreeStream(self._adaptor, "rule entry_point") try: try: # sdl92.g:560:9: ( CONNECT outer= entry_point AND inner= entry_point end -> ^( STATE_PARTITION_CONNECTION $outer $inner ( end )? ) ) # sdl92.g:560:17: CONNECT outer= entry_point AND inner= entry_point end pass CONNECT256=self.match(self.input, CONNECT, self.FOLLOW_CONNECT_in_state_partition_connection6250) if self._state.backtracking == 0: stream_CONNECT.add(CONNECT256) self._state.following.append(self.FOLLOW_entry_point_in_state_partition_connection6254) outer = self.entry_point() self._state.following.pop() if self._state.backtracking == 0: stream_entry_point.add(outer.tree) AND257=self.match(self.input, AND, self.FOLLOW_AND_in_state_partition_connection6256) if self._state.backtracking == 0: stream_AND.add(AND257) self._state.following.append(self.FOLLOW_entry_point_in_state_partition_connection6260) 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_connection6262) end258 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end258.tree) # AST Rewrite # elements: end, inner, outer # token labels: # rule labels: outer, inner, retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 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) 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() # 561:9: -> ^( STATE_PARTITION_CONNECTION $outer $inner ( end )? ) # sdl92.g:561: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:561: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:566: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 VIA259 = None point260 = None state_part_id_tree = None VIA259_tree = None stream_ID = RewriteRuleTokenStream(self._adaptor, "token ID") stream_VIA = RewriteRuleTokenStream(self._adaptor, "token VIA") stream_point = RewriteRuleSubtreeStream(self._adaptor, "rule point") try: try: # sdl92.g:567:9: (state_part_id= ID VIA point -> ^( ENTRY_POINT $state_part_id point ) ) # sdl92.g:567:17: state_part_id= ID VIA point pass state_part_id=self.match(self.input, ID, self.FOLLOW_ID_in_entry_point6325) if self._state.backtracking == 0: stream_ID.add(state_part_id) VIA259=self.match(self.input, VIA, self.FOLLOW_VIA_in_entry_point6327) if self._state.backtracking == 0: stream_VIA.add(VIA259) self._state.following.append(self.FOLLOW_point_in_entry_point6329) point260 = self.point() self._state.following.pop() if self._state.backtracking == 0: stream_point.add(point260.tree) # AST Rewrite # elements: state_part_id, point # 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() # 568:9: -> ^( ENTRY_POINT $state_part_id point ) # sdl92.g:568: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:573: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 DEFAULT261 = None state_point_tree = None DEFAULT261_tree = None stream_ID = RewriteRuleTokenStream(self._adaptor, "token ID") stream_DEFAULT = RewriteRuleTokenStream(self._adaptor, "token DEFAULT") try: try: # sdl92.g:574:9: ( (state_point= ID | DEFAULT ) -> ^( POINT ( $state_point)? ( DEFAULT )? ) ) # sdl92.g:574:17: (state_point= ID | DEFAULT ) pass # sdl92.g:574:17: (state_point= ID | DEFAULT ) alt87 = 2 LA87_0 = self.input.LA(1) if (LA87_0 == ID) : alt87 = 1 elif (LA87_0 == DEFAULT) : alt87 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 87, 0, self.input) raise nvae if alt87 == 1: # sdl92.g:574:18: state_point= ID pass state_point=self.match(self.input, ID, self.FOLLOW_ID_in_point6389) if self._state.backtracking == 0: stream_ID.add(state_point) elif alt87 == 2: # sdl92.g:574:35: DEFAULT pass DEFAULT261=self.match(self.input, DEFAULT, self.FOLLOW_DEFAULT_in_point6393) if self._state.backtracking == 0: stream_DEFAULT.add(DEFAULT261) # AST Rewrite # elements: state_point, DEFAULT # 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() # 575:9: -> ^( POINT ( $state_point)? ( DEFAULT )? ) # sdl92.g:575:17: ^( POINT ( $state_point)? ( DEFAULT )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(POINT, "POINT"), root_1) # sdl92.g:575:25: ( $state_point)? if stream_state_point.hasNext(): self._adaptor.addChild(root_1, stream_state_point.nextNode()) stream_state_point.reset(); # sdl92.g:575: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:580: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 IN262 = None OUT265 = None state_entry_exit_points263 = None end264 = None state_entry_exit_points266 = None end267 = None IN262_tree = None OUT265_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:581: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 )? ) ) alt88 = 2 LA88_0 = self.input.LA(1) if (LA88_0 == IN) : alt88 = 1 elif (LA88_0 == OUT) : alt88 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 88, 0, self.input) raise nvae if alt88 == 1: # sdl92.g:581:17: IN state_entry_exit_points end pass IN262=self.match(self.input, IN, self.FOLLOW_IN_in_connection_points6453) if self._state.backtracking == 0: stream_IN.add(IN262) self._state.following.append(self.FOLLOW_state_entry_exit_points_in_connection_points6455) state_entry_exit_points263 = self.state_entry_exit_points() self._state.following.pop() if self._state.backtracking == 0: stream_state_entry_exit_points.add(state_entry_exit_points263.tree) self._state.following.append(self.FOLLOW_end_in_connection_points6457) end264 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end264.tree) # AST Rewrite # elements: state_entry_exit_points, end, IN # 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() # 582:9: -> ^( IN state_entry_exit_points ( end )? ) # sdl92.g:582: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:582: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 alt88 == 2: # sdl92.g:583:19: OUT state_entry_exit_points end pass OUT265=self.match(self.input, OUT, self.FOLLOW_OUT_in_connection_points6501) if self._state.backtracking == 0: stream_OUT.add(OUT265) self._state.following.append(self.FOLLOW_state_entry_exit_points_in_connection_points6503) state_entry_exit_points266 = self.state_entry_exit_points() self._state.following.pop() if self._state.backtracking == 0: stream_state_entry_exit_points.add(state_entry_exit_points266.tree) self._state.following.append(self.FOLLOW_end_in_connection_points6505) end267 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end267.tree) # AST Rewrite # elements: end, OUT, 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() # 584:9: -> ^( OUT state_entry_exit_points ( end )? ) # sdl92.g:584: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:584: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:589: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_literal268 = None char_literal270 = None char_literal272 = None statename269 = None statename271 = None char_literal268_tree = None char_literal270_tree = None char_literal272_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_statename = RewriteRuleSubtreeStream(self._adaptor, "rule statename") try: try: # sdl92.g:590:9: ( '(' statename ( ',' statename )* ')' -> ( statename )+ ) # sdl92.g:590:17: '(' statename ( ',' statename )* ')' pass char_literal268=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_state_entry_exit_points6562) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal268) self._state.following.append(self.FOLLOW_statename_in_state_entry_exit_points6564) statename269 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename269.tree) # sdl92.g:590:31: ( ',' statename )* while True: #loop89 alt89 = 2 LA89_0 = self.input.LA(1) if (LA89_0 == COMMA) : alt89 = 1 if alt89 == 1: # sdl92.g:590:32: ',' statename pass char_literal270=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_state_entry_exit_points6567) if self._state.backtracking == 0: stream_COMMA.add(char_literal270) self._state.following.append(self.FOLLOW_statename_in_state_entry_exit_points6569) statename271 = self.statename() self._state.following.pop() if self._state.backtracking == 0: stream_statename.add(statename271.tree) else: break #loop89 char_literal272=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_state_entry_exit_points6573) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal272) # 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() # 591:9: -> ( statename )+ # sdl92.g:591: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:598:1: composite_state_body : ( text_area | procedure | ( composite_state_preamble )=> composite_state )* ( start )* ( state | floating_label )* ( EOF )? ; def composite_state_body(self, ): retval = self.composite_state_body_return() retval.start = self.input.LT(1) root_0 = None EOF279 = None text_area273 = None procedure274 = None composite_state275 = None start276 = None state277 = None floating_label278 = None EOF279_tree = None try: try: # sdl92.g:599:9: ( ( text_area | procedure | ( composite_state_preamble )=> composite_state )* ( start )* ( state | floating_label )* ( EOF )? ) # sdl92.g:599:12: ( text_area | procedure | ( composite_state_preamble )=> composite_state )* ( start )* ( state | floating_label )* ( EOF )? pass root_0 = self._adaptor.nil() # sdl92.g:599:12: ( text_area | procedure | ( composite_state_preamble )=> composite_state )* while True: #loop90 alt90 = 4 alt90 = self.dfa90.predict(self.input) if alt90 == 1: # sdl92.g:599:13: text_area pass self._state.following.append(self.FOLLOW_text_area_in_composite_state_body6622) text_area273 = self.text_area() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, text_area273.tree) elif alt90 == 2: # sdl92.g:600:15: procedure pass self._state.following.append(self.FOLLOW_procedure_in_composite_state_body6638) procedure274 = self.procedure() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, procedure274.tree) elif alt90 == 3: # sdl92.g:601:15: ( composite_state_preamble )=> composite_state pass self._state.following.append(self.FOLLOW_composite_state_in_composite_state_body6659) composite_state275 = self.composite_state() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, composite_state275.tree) else: break #loop90 # sdl92.g:602:12: ( start )* while True: #loop91 alt91 = 2 alt91 = self.dfa91.predict(self.input) if alt91 == 1: # sdl92.g:0:0: start pass self._state.following.append(self.FOLLOW_start_in_composite_state_body6674) start276 = self.start() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, start276.tree) else: break #loop91 # sdl92.g:602:19: ( state | floating_label )* while True: #loop92 alt92 = 3 alt92 = self.dfa92.predict(self.input) if alt92 == 1: # sdl92.g:602:20: state pass self._state.following.append(self.FOLLOW_state_in_composite_state_body6678) state277 = self.state() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, state277.tree) elif alt92 == 2: # sdl92.g:602:28: floating_label pass self._state.following.append(self.FOLLOW_floating_label_in_composite_state_body6682) floating_label278 = self.floating_label() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, floating_label278.tree) else: break #loop92 # sdl92.g:603:12: ( EOF )? alt93 = 2 LA93_0 = self.input.LA(1) if (LA93_0 == EOF) : alt93 = 1 if alt93 == 1: # sdl92.g:0:0: EOF pass EOF279=self.match(self.input, EOF, self.FOLLOW_EOF_in_composite_state_body6697) if self._state.backtracking == 0: EOF279_tree = self._adaptor.createWithPayload(EOF279) self._adaptor.addChild(root_0, EOF279_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_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:607: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_part280 = None save_part281 = None spontaneous_transition282 = None continuous_signal283 = None connect_part284 = None try: try: # sdl92.g:608:9: ( input_part | save_part | spontaneous_transition | continuous_signal | connect_part ) alt94 = 5 alt94 = self.dfa94.predict(self.input) if alt94 == 1: # sdl92.g:608:17: input_part pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_input_part_in_state_part6730) input_part280 = self.input_part() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, input_part280.tree) elif alt94 == 2: # sdl92.g:610:19: save_part pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_save_part_in_state_part6767) save_part281 = self.save_part() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, save_part281.tree) elif alt94 == 3: # sdl92.g:611:19: spontaneous_transition pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_spontaneous_transition_in_state_part6802) spontaneous_transition282 = self.spontaneous_transition() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, spontaneous_transition282.tree) elif alt94 == 4: # sdl92.g:612:19: continuous_signal pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_continuous_signal_in_state_part6822) continuous_signal283 = self.continuous_signal() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, continuous_signal283.tree) elif alt94 == 5: # sdl92.g:613:19: connect_part pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_connect_part_in_state_part6842) connect_part284 = self.connect_part() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, connect_part284.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:618: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 CONNECT287 = None cif285 = None hyperlink286 = None connect_list288 = None end289 = None transition290 = None CONNECT287_tree = None stream_CONNECT = RewriteRuleTokenStream(self._adaptor, "token CONNECT") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_connect_list = RewriteRuleSubtreeStream(self._adaptor, "rule connect_list") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") try: try: # sdl92.g:619:9: ( ( cif )? ( hyperlink )? CONNECT ( connect_list )? end ( transition )? -> ^( CONNECT ( cif )? ( hyperlink )? ( connect_list )? ( end )? ( transition )? ) ) # sdl92.g:619:17: ( cif )? ( hyperlink )? CONNECT ( connect_list )? end ( transition )? pass # sdl92.g:619:17: ( cif )? alt95 = 2 LA95_0 = self.input.LA(1) if (LA95_0 == 228) : 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_connect_part6875) cif285 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif285.tree) # sdl92.g:620:17: ( hyperlink )? alt96 = 2 LA96_0 = self.input.LA(1) if (LA96_0 == 228) : alt96 = 1 if alt96 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_connect_part6894) hyperlink286 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink286.tree) CONNECT287=self.match(self.input, CONNECT, self.FOLLOW_CONNECT_in_connect_part6913) if self._state.backtracking == 0: stream_CONNECT.add(CONNECT287) # sdl92.g:621:25: ( connect_list )? alt97 = 2 LA97_0 = self.input.LA(1) if (LA97_0 == ID or LA97_0 == ASTERISK) : alt97 = 1 if alt97 == 1: # sdl92.g:0:0: connect_list pass self._state.following.append(self.FOLLOW_connect_list_in_connect_part6915) connect_list288 = self.connect_list() self._state.following.pop() if self._state.backtracking == 0: stream_connect_list.add(connect_list288.tree) self._state.following.append(self.FOLLOW_end_in_connect_part6918) end289 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end289.tree) # sdl92.g:622:17: ( transition )? alt98 = 2 alt98 = self.dfa98.predict(self.input) if alt98 == 1: # sdl92.g:0:0: transition pass self._state.following.append(self.FOLLOW_transition_in_connect_part6936) transition290 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition290.tree) # AST Rewrite # elements: hyperlink, end, transition, connect_list, cif, CONNECT # 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() # 623:9: -> ^( CONNECT ( cif )? ( hyperlink )? ( connect_list )? ( end )? ( transition )? ) # sdl92.g:623: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:623:27: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:623:32: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:623:43: ( connect_list )? if stream_connect_list.hasNext(): self._adaptor.addChild(root_1, stream_connect_list.nextTree()) stream_connect_list.reset(); # sdl92.g:623:57: ( end )? if stream_end.hasNext(): self._adaptor.addChild(root_1, stream_end.nextTree()) stream_end.reset(); # sdl92.g:623: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:627: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_literal292 = None ASTERISK294 = None state_exit_point_name291 = None state_exit_point_name293 = None char_literal292_tree = None ASTERISK294_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:628:9: ( state_exit_point_name ( ',' state_exit_point_name )* -> ( state_exit_point_name )+ | ASTERISK ) alt100 = 2 LA100_0 = self.input.LA(1) if (LA100_0 == ID) : alt100 = 1 elif (LA100_0 == ASTERISK) : alt100 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 100, 0, self.input) raise nvae if alt100 == 1: # sdl92.g:628:17: state_exit_point_name ( ',' state_exit_point_name )* pass self._state.following.append(self.FOLLOW_state_exit_point_name_in_connect_list7003) state_exit_point_name291 = self.state_exit_point_name() self._state.following.pop() if self._state.backtracking == 0: stream_state_exit_point_name.add(state_exit_point_name291.tree) # sdl92.g:628:39: ( ',' state_exit_point_name )* while True: #loop99 alt99 = 2 LA99_0 = self.input.LA(1) if (LA99_0 == COMMA) : alt99 = 1 if alt99 == 1: # sdl92.g:628:40: ',' state_exit_point_name pass char_literal292=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_connect_list7006) if self._state.backtracking == 0: stream_COMMA.add(char_literal292) self._state.following.append(self.FOLLOW_state_exit_point_name_in_connect_list7008) state_exit_point_name293 = self.state_exit_point_name() self._state.following.pop() if self._state.backtracking == 0: stream_state_exit_point_name.add(state_exit_point_name293.tree) else: break #loop99 # 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() # 629:17: -> ( state_exit_point_name )+ # sdl92.g:629: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 alt100 == 2: # sdl92.g:630:19: ASTERISK pass root_0 = self._adaptor.nil() ASTERISK294=self.match(self.input, ASTERISK, self.FOLLOW_ASTERISK_in_connect_list7051) if self._state.backtracking == 0: ASTERISK294_tree = self._adaptor.createWithPayload(ASTERISK294) self._adaptor.addChild(root_0, ASTERISK294_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:634: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 INPUT297 = None NONE298 = None cif295 = None hyperlink296 = None end299 = None enabling_condition300 = None transition301 = None INPUT297_tree = None NONE298_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_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_enabling_condition = RewriteRuleSubtreeStream(self._adaptor, "rule enabling_condition") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") try: try: # sdl92.g:635:9: ( ( cif )? ( hyperlink )? INPUT NONE end ( enabling_condition )? transition -> ^( INPUT_NONE ( cif )? ( hyperlink )? transition ) ) # sdl92.g:635:17: ( cif )? ( hyperlink )? INPUT NONE end ( enabling_condition )? transition pass # sdl92.g:635:17: ( cif )? alt101 = 2 LA101_0 = self.input.LA(1) if (LA101_0 == 228) : LA101_1 = self.input.LA(2) if (LA101_1 == ANSWER or LA101_1 == COMMENT or LA101_1 == CONNECT or LA101_1 == DECISION or LA101_1 == INPUT or (JOIN <= LA101_1 <= LABEL) or LA101_1 == NEXTSTATE or LA101_1 == OUTPUT or (PROCEDURE <= LA101_1 <= PROCEDURE_CALL) or (PROCESS <= LA101_1 <= PROVIDED) or LA101_1 == RETURN or LA101_1 == STATE or LA101_1 == STOP or LA101_1 == TASK or LA101_1 == TEXT or LA101_1 == START) : alt101 = 1 if alt101 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_spontaneous_transition7083) cif295 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif295.tree) # sdl92.g:636:17: ( hyperlink )? alt102 = 2 LA102_0 = self.input.LA(1) if (LA102_0 == 228) : alt102 = 1 if alt102 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_spontaneous_transition7102) hyperlink296 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink296.tree) INPUT297=self.match(self.input, INPUT, self.FOLLOW_INPUT_in_spontaneous_transition7121) if self._state.backtracking == 0: stream_INPUT.add(INPUT297) NONE298=self.match(self.input, NONE, self.FOLLOW_NONE_in_spontaneous_transition7123) if self._state.backtracking == 0: stream_NONE.add(NONE298) self._state.following.append(self.FOLLOW_end_in_spontaneous_transition7125) end299 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end299.tree) # sdl92.g:638:17: ( enabling_condition )? alt103 = 2 LA103_0 = self.input.LA(1) if (LA103_0 == PROVIDED) : alt103 = 1 if alt103 == 1: # sdl92.g:0:0: enabling_condition pass self._state.following.append(self.FOLLOW_enabling_condition_in_spontaneous_transition7143) enabling_condition300 = self.enabling_condition() self._state.following.pop() if self._state.backtracking == 0: stream_enabling_condition.add(enabling_condition300.tree) self._state.following.append(self.FOLLOW_transition_in_spontaneous_transition7162) transition301 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition301.tree) # AST Rewrite # elements: cif, hyperlink, transition # 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() # 640:9: -> ^( INPUT_NONE ( cif )? ( hyperlink )? transition ) # sdl92.g:640: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:640:30: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:640: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:644: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 PROVIDED302 = None expression303 = None end304 = None PROVIDED302_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:645:9: ( PROVIDED expression end -> ^( PROVIDED expression ) ) # sdl92.g:645:17: PROVIDED expression end pass PROVIDED302=self.match(self.input, PROVIDED, self.FOLLOW_PROVIDED_in_enabling_condition7221) if self._state.backtracking == 0: stream_PROVIDED.add(PROVIDED302) self._state.following.append(self.FOLLOW_expression_in_enabling_condition7223) expression303 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression303.tree) self._state.following.append(self.FOLLOW_end_in_enabling_condition7225) end304 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end304.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() # 646:9: -> ^( PROVIDED expression ) # sdl92.g:646: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:650: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 PROVIDED307 = None PRIORITY309 = None e = None cif305 = None hyperlink306 = None expression308 = None end310 = None transition311 = None p_tree = None PROVIDED307_tree = None PRIORITY309_tree = None stream_PROVIDED = RewriteRuleTokenStream(self._adaptor, "token PROVIDED") stream_PRIORITY = RewriteRuleTokenStream(self._adaptor, "token PRIORITY") stream_INT = RewriteRuleTokenStream(self._adaptor, "token INT") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") try: try: # sdl92.g:651:9: ( ( cif )? ( hyperlink )? PROVIDED expression e= end ( PRIORITY p= INT end )? ( transition )? -> ^( PROVIDED expression ( cif )? ( hyperlink )? ( $p)? ( $e)? ( transition )? ) ) # sdl92.g:651:17: ( cif )? ( hyperlink )? PROVIDED expression e= end ( PRIORITY p= INT end )? ( transition )? pass # sdl92.g:651:17: ( cif )? alt104 = 2 LA104_0 = self.input.LA(1) if (LA104_0 == 228) : 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_continuous_signal7278) cif305 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif305.tree) # sdl92.g:652:17: ( hyperlink )? alt105 = 2 LA105_0 = self.input.LA(1) if (LA105_0 == 228) : alt105 = 1 if alt105 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_continuous_signal7297) hyperlink306 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink306.tree) PROVIDED307=self.match(self.input, PROVIDED, self.FOLLOW_PROVIDED_in_continuous_signal7316) if self._state.backtracking == 0: stream_PROVIDED.add(PROVIDED307) self._state.following.append(self.FOLLOW_expression_in_continuous_signal7318) expression308 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression308.tree) self._state.following.append(self.FOLLOW_end_in_continuous_signal7322) e = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(e.tree) # sdl92.g:654:17: ( PRIORITY p= INT end )? alt106 = 2 LA106_0 = self.input.LA(1) if (LA106_0 == PRIORITY) : alt106 = 1 if alt106 == 1: # sdl92.g:654:18: PRIORITY p= INT end pass PRIORITY309=self.match(self.input, PRIORITY, self.FOLLOW_PRIORITY_in_continuous_signal7341) if self._state.backtracking == 0: stream_PRIORITY.add(PRIORITY309) p=self.match(self.input, INT, self.FOLLOW_INT_in_continuous_signal7345) if self._state.backtracking == 0: stream_INT.add(p) self._state.following.append(self.FOLLOW_end_in_continuous_signal7347) end310 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end310.tree) # sdl92.g:655: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_continuous_signal7367) transition311 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition311.tree) # AST Rewrite # elements: p, transition, cif, expression, PROVIDED, e, hyperlink # token labels: p # rule labels: e, retval # 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 e is not None: stream_e = RewriteRuleSubtreeStream(self._adaptor, "rule e", e.tree) else: stream_e = RewriteRuleSubtreeStream(self._adaptor, "token e", 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() # 656:9: -> ^( PROVIDED expression ( cif )? ( hyperlink )? ( $p)? ( $e)? ( transition )? ) # sdl92.g:656: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:656:39: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:656:44: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:656:55: ( $p)? if stream_p.hasNext(): self._adaptor.addChild(root_1, stream_p.nextNode()) stream_p.reset(); # sdl92.g:656:59: ( $e)? if stream_e.hasNext(): self._adaptor.addChild(root_1, stream_e.nextTree()) stream_e.reset(); # sdl92.g:656: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:660: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 SAVE312 = None save_list313 = None end314 = None SAVE312_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:661:9: ( SAVE save_list end -> ^( SAVE save_list ) ) # sdl92.g:661:17: SAVE save_list end pass SAVE312=self.match(self.input, SAVE, self.FOLLOW_SAVE_in_save_part7438) if self._state.backtracking == 0: stream_SAVE.add(SAVE312) self._state.following.append(self.FOLLOW_save_list_in_save_part7440) save_list313 = self.save_list() self._state.following.pop() if self._state.backtracking == 0: stream_save_list.add(save_list313.tree) self._state.following.append(self.FOLLOW_end_in_save_part7458) end314 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end314.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() # 663:9: -> ^( SAVE save_list ) # sdl92.g:663: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:667: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_list315 = None asterisk_save_list316 = None try: try: # sdl92.g:668:9: ( signal_list | asterisk_save_list ) alt108 = 2 LA108_0 = self.input.LA(1) if (LA108_0 == ID) : alt108 = 1 elif (LA108_0 == ASTERISK) : alt108 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 108, 0, self.input) raise nvae if alt108 == 1: # sdl92.g:668:17: signal_list pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_signal_list_in_save_list7511) signal_list315 = self.signal_list() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, signal_list315.tree) elif alt108 == 2: # sdl92.g:669:19: asterisk_save_list pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_asterisk_save_list_in_save_list7531) asterisk_save_list316 = self.asterisk_save_list() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, asterisk_save_list316.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:673: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 ASTERISK317 = None ASTERISK317_tree = None try: try: # sdl92.g:674:9: ( ASTERISK ) # sdl92.g:674:17: ASTERISK pass root_0 = self._adaptor.nil() ASTERISK317=self.match(self.input, ASTERISK, self.FOLLOW_ASTERISK_in_asterisk_save_list7563) if self._state.backtracking == 0: ASTERISK317_tree = self._adaptor.createWithPayload(ASTERISK317) self._adaptor.addChild(root_0, ASTERISK317_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:677: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_literal319 = None signal_item318 = None signal_item320 = None char_literal319_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_signal_item = RewriteRuleSubtreeStream(self._adaptor, "rule signal_item") try: try: # sdl92.g:678:9: ( signal_item ( ',' signal_item )* -> ^( SIGNAL_LIST ( signal_item )+ ) ) # sdl92.g:678:17: signal_item ( ',' signal_item )* pass self._state.following.append(self.FOLLOW_signal_item_in_signal_list7586) signal_item318 = self.signal_item() self._state.following.pop() if self._state.backtracking == 0: stream_signal_item.add(signal_item318.tree) # sdl92.g:678:29: ( ',' signal_item )* while True: #loop109 alt109 = 2 LA109_0 = self.input.LA(1) if (LA109_0 == COMMA) : alt109 = 1 if alt109 == 1: # sdl92.g:678:30: ',' signal_item pass char_literal319=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_signal_list7589) if self._state.backtracking == 0: stream_COMMA.add(char_literal319) self._state.following.append(self.FOLLOW_signal_item_in_signal_list7591) signal_item320 = self.signal_item() self._state.following.pop() if self._state.backtracking == 0: stream_signal_item.add(signal_item320.tree) else: break #loop109 # 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() # 679:9: -> ^( SIGNAL_LIST ( signal_item )+ ) # sdl92.g:679: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:679: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:686:1: signal_item : signal_id ; def signal_item(self, ): retval = self.signal_item_return() retval.start = self.input.LT(1) root_0 = None signal_id321 = None try: try: # sdl92.g:687:9: ( signal_id ) # sdl92.g:687:17: signal_id pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_signal_id_in_signal_item7650) signal_id321 = self.signal_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, signal_id321.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:707: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 INPUT324 = None cif322 = None hyperlink323 = None inputlist325 = None end326 = None enabling_condition327 = None transition328 = None INPUT324_tree = None stream_INPUT = RewriteRuleTokenStream(self._adaptor, "token INPUT") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_inputlist = RewriteRuleSubtreeStream(self._adaptor, "rule inputlist") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_enabling_condition = RewriteRuleSubtreeStream(self._adaptor, "rule enabling_condition") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") try: try: # sdl92.g:708:9: ( ( cif )? ( hyperlink )? INPUT inputlist end ( enabling_condition )? ( transition )? -> ^( INPUT ( cif )? ( hyperlink )? ( end )? inputlist ( enabling_condition )? ( transition )? ) ) # sdl92.g:708:17: ( cif )? ( hyperlink )? INPUT inputlist end ( enabling_condition )? ( transition )? pass # sdl92.g:708:17: ( cif )? alt110 = 2 LA110_0 = self.input.LA(1) if (LA110_0 == 228) : LA110_1 = self.input.LA(2) if (LA110_1 == ANSWER or LA110_1 == COMMENT or LA110_1 == CONNECT or LA110_1 == DECISION or LA110_1 == INPUT or (JOIN <= LA110_1 <= LABEL) or LA110_1 == NEXTSTATE or LA110_1 == OUTPUT or (PROCEDURE <= LA110_1 <= PROCEDURE_CALL) or (PROCESS <= LA110_1 <= PROVIDED) or LA110_1 == RETURN or LA110_1 == STATE or LA110_1 == STOP or LA110_1 == TASK or LA110_1 == TEXT or LA110_1 == START) : alt110 = 1 if alt110 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_input_part7679) cif322 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif322.tree) # sdl92.g:709:17: ( hyperlink )? alt111 = 2 LA111_0 = self.input.LA(1) if (LA111_0 == 228) : alt111 = 1 if alt111 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_input_part7698) hyperlink323 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink323.tree) INPUT324=self.match(self.input, INPUT, self.FOLLOW_INPUT_in_input_part7717) if self._state.backtracking == 0: stream_INPUT.add(INPUT324) self._state.following.append(self.FOLLOW_inputlist_in_input_part7719) inputlist325 = self.inputlist() self._state.following.pop() if self._state.backtracking == 0: stream_inputlist.add(inputlist325.tree) self._state.following.append(self.FOLLOW_end_in_input_part7721) end326 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end326.tree) # sdl92.g:711:17: ( enabling_condition )? alt112 = 2 alt112 = self.dfa112.predict(self.input) if alt112 == 1: # sdl92.g:0:0: enabling_condition pass self._state.following.append(self.FOLLOW_enabling_condition_in_input_part7739) enabling_condition327 = self.enabling_condition() self._state.following.pop() if self._state.backtracking == 0: stream_enabling_condition.add(enabling_condition327.tree) # sdl92.g:712:17: ( transition )? alt113 = 2 alt113 = self.dfa113.predict(self.input) if alt113 == 1: # sdl92.g:0:0: transition pass self._state.following.append(self.FOLLOW_transition_in_input_part7758) transition328 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition328.tree) # AST Rewrite # elements: INPUT, inputlist, transition, hyperlink, enabling_condition, cif, 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() # 713:9: -> ^( INPUT ( cif )? ( hyperlink )? ( end )? inputlist ( enabling_condition )? ( transition )? ) # sdl92.g:713: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:713:25: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:713:30: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:713: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:714:27: ( enabling_condition )? if stream_enabling_condition.hasNext(): self._adaptor.addChild(root_1, stream_enabling_condition.nextTree()) stream_enabling_condition.reset(); # sdl92.g:714: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:720:1: inputlist : ( ASTERISK | ( stimulus ( ',' stimulus )* ) -> ^( INPUTLIST ( stimulus )+ ) ); def inputlist(self, ): retval = self.inputlist_return() retval.start = self.input.LT(1) root_0 = None ASTERISK329 = None char_literal331 = None stimulus330 = None stimulus332 = None ASTERISK329_tree = None char_literal331_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_stimulus = RewriteRuleSubtreeStream(self._adaptor, "rule stimulus") try: try: # sdl92.g:721:9: ( ASTERISK | ( stimulus ( ',' stimulus )* ) -> ^( INPUTLIST ( stimulus )+ ) ) alt115 = 2 LA115_0 = self.input.LA(1) if (LA115_0 == ASTERISK) : alt115 = 1 elif (LA115_0 == ID) : alt115 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 115, 0, self.input) raise nvae if alt115 == 1: # sdl92.g:721:17: ASTERISK pass root_0 = self._adaptor.nil() ASTERISK329=self.match(self.input, ASTERISK, self.FOLLOW_ASTERISK_in_inputlist7845) if self._state.backtracking == 0: ASTERISK329_tree = self._adaptor.createWithPayload(ASTERISK329) self._adaptor.addChild(root_0, ASTERISK329_tree) elif alt115 == 2: # sdl92.g:722:19: ( stimulus ( ',' stimulus )* ) pass # sdl92.g:722:19: ( stimulus ( ',' stimulus )* ) # sdl92.g:722:20: stimulus ( ',' stimulus )* pass self._state.following.append(self.FOLLOW_stimulus_in_inputlist7866) stimulus330 = self.stimulus() self._state.following.pop() if self._state.backtracking == 0: stream_stimulus.add(stimulus330.tree) # sdl92.g:722:29: ( ',' stimulus )* while True: #loop114 alt114 = 2 LA114_0 = self.input.LA(1) if (LA114_0 == COMMA) : alt114 = 1 if alt114 == 1: # sdl92.g:722:30: ',' stimulus pass char_literal331=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_inputlist7869) if self._state.backtracking == 0: stream_COMMA.add(char_literal331) self._state.following.append(self.FOLLOW_stimulus_in_inputlist7871) stimulus332 = self.stimulus() self._state.following.pop() if self._state.backtracking == 0: stream_stimulus.add(stimulus332.tree) else: break #loop114 # 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() # 723:9: -> ^( INPUTLIST ( stimulus )+ ) # sdl92.g:723:17: ^( INPUTLIST ( stimulus )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(INPUTLIST, "INPUTLIST"), root_1) # sdl92.g:723: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:727:1: stimulus : stimulus_id ( input_params )? ; def stimulus(self, ): retval = self.stimulus_return() retval.start = self.input.LT(1) root_0 = None stimulus_id333 = None input_params334 = None try: try: # sdl92.g:728:9: ( stimulus_id ( input_params )? ) # sdl92.g:728:17: stimulus_id ( input_params )? pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_stimulus_id_in_stimulus7928) stimulus_id333 = self.stimulus_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, stimulus_id333.tree) # sdl92.g:728:29: ( input_params )? alt116 = 2 LA116_0 = self.input.LA(1) if (LA116_0 == L_PAREN) : alt116 = 1 if alt116 == 1: # sdl92.g:0:0: input_params pass self._state.following.append(self.FOLLOW_input_params_in_stimulus7930) input_params334 = self.input_params() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, input_params334.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:732: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_PAREN335 = None char_literal337 = None R_PAREN339 = None variable_id336 = None variable_id338 = None L_PAREN335_tree = None char_literal337_tree = None R_PAREN339_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_variable_id = RewriteRuleSubtreeStream(self._adaptor, "rule variable_id") try: try: # sdl92.g:733:9: ( L_PAREN variable_id ( ',' variable_id )* R_PAREN -> ^( PARAMS ( variable_id )+ ) ) # sdl92.g:733:17: L_PAREN variable_id ( ',' variable_id )* R_PAREN pass L_PAREN335=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_input_params7963) if self._state.backtracking == 0: stream_L_PAREN.add(L_PAREN335) self._state.following.append(self.FOLLOW_variable_id_in_input_params7965) variable_id336 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id336.tree) # sdl92.g:733:37: ( ',' variable_id )* while True: #loop117 alt117 = 2 LA117_0 = self.input.LA(1) if (LA117_0 == COMMA) : alt117 = 1 if alt117 == 1: # sdl92.g:733:38: ',' variable_id pass char_literal337=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_input_params7968) if self._state.backtracking == 0: stream_COMMA.add(char_literal337) self._state.following.append(self.FOLLOW_variable_id_in_input_params7970) variable_id338 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id338.tree) else: break #loop117 R_PAREN339=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_input_params7974) if self._state.backtracking == 0: stream_R_PAREN.add(R_PAREN339) # 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() # 734:9: -> ^( PARAMS ( variable_id )+ ) # sdl92.g:734:17: ^( PARAMS ( variable_id )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(PARAMS, "PARAMS"), root_1) # sdl92.g:734: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:738: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 action340 = None label341 = None terminator_statement342 = None terminator_statement343 = 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:739:9: ( ( action )+ ( label )? ( terminator_statement )? -> ^( TRANSITION ( action )+ ( label )? ( terminator_statement )? ) | terminator_statement -> ^( TRANSITION terminator_statement ) ) alt121 = 2 alt121 = self.dfa121.predict(self.input) if alt121 == 1: # sdl92.g:739:17: ( action )+ ( label )? ( terminator_statement )? pass # sdl92.g:739:17: ( action )+ cnt118 = 0 while True: #loop118 alt118 = 2 alt118 = self.dfa118.predict(self.input) if alt118 == 1: # sdl92.g:0:0: action pass self._state.following.append(self.FOLLOW_action_in_transition8028) action340 = self.action() self._state.following.pop() if self._state.backtracking == 0: stream_action.add(action340.tree) else: if cnt118 >= 1: break #loop118 if self._state.backtracking > 0: raise BacktrackingFailed eee = EarlyExitException(118, self.input) raise eee cnt118 += 1 # sdl92.g:739:25: ( label )? alt119 = 2 alt119 = self.dfa119.predict(self.input) if alt119 == 1: # sdl92.g:0:0: label pass self._state.following.append(self.FOLLOW_label_in_transition8031) label341 = self.label() self._state.following.pop() if self._state.backtracking == 0: stream_label.add(label341.tree) # sdl92.g:739:32: ( terminator_statement )? alt120 = 2 alt120 = self.dfa120.predict(self.input) if alt120 == 1: # sdl92.g:0:0: terminator_statement pass self._state.following.append(self.FOLLOW_terminator_statement_in_transition8034) terminator_statement342 = self.terminator_statement() self._state.following.pop() if self._state.backtracking == 0: stream_terminator_statement.add(terminator_statement342.tree) # AST Rewrite # elements: action, terminator_statement, label # 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() # 740:9: -> ^( TRANSITION ( action )+ ( label )? ( terminator_statement )? ) # sdl92.g:740: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:740: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:740:38: ( label )? if stream_label.hasNext(): self._adaptor.addChild(root_1, stream_label.nextTree()) stream_label.reset(); # sdl92.g:740: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 alt121 == 2: # sdl92.g:741:19: terminator_statement pass self._state.following.append(self.FOLLOW_terminator_statement_in_transition8083) terminator_statement343 = self.terminator_statement() self._state.following.pop() if self._state.backtracking == 0: stream_terminator_statement.add(terminator_statement343.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() # 742:9: -> ^( TRANSITION terminator_statement ) # sdl92.g:742: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:746: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 label344 = None task345 = None task_body346 = None output347 = None create_request348 = None decision349 = None transition_option350 = None set_timer351 = None reset_timer352 = None export353 = None procedure_call354 = None try: try: # sdl92.g:747:9: ( ( label )? ( task | task_body | output | create_request | decision | transition_option | set_timer | reset_timer | export | procedure_call ) ) # sdl92.g:747: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:747:17: ( label )? alt122 = 2 alt122 = self.dfa122.predict(self.input) if alt122 == 1: # sdl92.g:0:0: label pass self._state.following.append(self.FOLLOW_label_in_action8136) label344 = self.label() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, label344.tree) # sdl92.g:748:17: ( task | task_body | output | create_request | decision | transition_option | set_timer | reset_timer | export | procedure_call ) alt123 = 10 alt123 = self.dfa123.predict(self.input) if alt123 == 1: # sdl92.g:748:18: task pass self._state.following.append(self.FOLLOW_task_in_action8156) task345 = self.task() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, task345.tree) elif alt123 == 2: # sdl92.g:749:19: task_body pass self._state.following.append(self.FOLLOW_task_body_in_action8176) task_body346 = self.task_body() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, task_body346.tree) elif alt123 == 3: # sdl92.g:750:19: output pass self._state.following.append(self.FOLLOW_output_in_action8196) output347 = self.output() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, output347.tree) elif alt123 == 4: # sdl92.g:751:19: create_request pass self._state.following.append(self.FOLLOW_create_request_in_action8216) create_request348 = self.create_request() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, create_request348.tree) elif alt123 == 5: # sdl92.g:752:19: decision pass self._state.following.append(self.FOLLOW_decision_in_action8236) decision349 = self.decision() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, decision349.tree) elif alt123 == 6: # sdl92.g:753:19: transition_option pass self._state.following.append(self.FOLLOW_transition_option_in_action8256) transition_option350 = self.transition_option() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, transition_option350.tree) elif alt123 == 7: # sdl92.g:754:19: set_timer pass self._state.following.append(self.FOLLOW_set_timer_in_action8276) set_timer351 = self.set_timer() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, set_timer351.tree) elif alt123 == 8: # sdl92.g:755:19: reset_timer pass self._state.following.append(self.FOLLOW_reset_timer_in_action8296) reset_timer352 = self.reset_timer() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, reset_timer352.tree) elif alt123 == 9: # sdl92.g:756:19: export pass self._state.following.append(self.FOLLOW_export_in_action8316) export353 = self.export() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, export353.tree) elif alt123 == 10: # sdl92.g:757:19: procedure_call pass self._state.following.append(self.FOLLOW_procedure_call_in_action8341) procedure_call354 = self.procedure_call() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, procedure_call354.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:761: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 EXPORT355 = None L_PAREN356 = None COMMA358 = None R_PAREN360 = None variable_id357 = None variable_id359 = None end361 = None EXPORT355_tree = None L_PAREN356_tree = None COMMA358_tree = None R_PAREN360_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_EXPORT = RewriteRuleTokenStream(self._adaptor, "token EXPORT") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_variable_id = RewriteRuleSubtreeStream(self._adaptor, "rule variable_id") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:762:9: ( EXPORT L_PAREN variable_id ( COMMA variable_id )* R_PAREN end -> ^( EXPORT ( variable_id )+ ) ) # sdl92.g:762:17: EXPORT L_PAREN variable_id ( COMMA variable_id )* R_PAREN end pass EXPORT355=self.match(self.input, EXPORT, self.FOLLOW_EXPORT_in_export8374) if self._state.backtracking == 0: stream_EXPORT.add(EXPORT355) L_PAREN356=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_export8392) if self._state.backtracking == 0: stream_L_PAREN.add(L_PAREN356) self._state.following.append(self.FOLLOW_variable_id_in_export8394) variable_id357 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id357.tree) # sdl92.g:763:37: ( COMMA variable_id )* while True: #loop124 alt124 = 2 LA124_0 = self.input.LA(1) if (LA124_0 == COMMA) : alt124 = 1 if alt124 == 1: # sdl92.g:763:38: COMMA variable_id pass COMMA358=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_export8397) if self._state.backtracking == 0: stream_COMMA.add(COMMA358) self._state.following.append(self.FOLLOW_variable_id_in_export8399) variable_id359 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id359.tree) else: break #loop124 R_PAREN360=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_export8403) if self._state.backtracking == 0: stream_R_PAREN.add(R_PAREN360) self._state.following.append(self.FOLLOW_end_in_export8421) end361 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end361.tree) # AST Rewrite # elements: EXPORT, 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() # 765:9: -> ^( EXPORT ( variable_id )+ ) # sdl92.g:765:17: ^( EXPORT ( variable_id )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_EXPORT.nextNode(), root_1) # sdl92.g:765: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:776: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 CALL364 = None cif362 = None hyperlink363 = None procedure_call_body365 = None end366 = None CALL364_tree = None stream_CALL = RewriteRuleTokenStream(self._adaptor, "token CALL") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_procedure_call_body = RewriteRuleSubtreeStream(self._adaptor, "rule procedure_call_body") try: try: # sdl92.g:777:9: ( ( cif )? ( hyperlink )? CALL procedure_call_body end -> ^( PROCEDURE_CALL ( cif )? ( hyperlink )? ( end )? procedure_call_body ) ) # sdl92.g:777:17: ( cif )? ( hyperlink )? CALL procedure_call_body end pass # sdl92.g:777:17: ( cif )? alt125 = 2 LA125_0 = self.input.LA(1) if (LA125_0 == 228) : LA125_1 = self.input.LA(2) if (LA125_1 == ANSWER or LA125_1 == COMMENT or LA125_1 == CONNECT or LA125_1 == DECISION or LA125_1 == INPUT or (JOIN <= LA125_1 <= LABEL) or LA125_1 == NEXTSTATE or LA125_1 == OUTPUT or (PROCEDURE <= LA125_1 <= PROCEDURE_CALL) or (PROCESS <= LA125_1 <= PROVIDED) or LA125_1 == RETURN or LA125_1 == STATE or LA125_1 == STOP or LA125_1 == TASK or LA125_1 == TEXT or LA125_1 == START) : alt125 = 1 if alt125 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_procedure_call8477) cif362 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif362.tree) # sdl92.g:778:17: ( hyperlink )? alt126 = 2 LA126_0 = self.input.LA(1) if (LA126_0 == 228) : alt126 = 1 if alt126 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_procedure_call8496) hyperlink363 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink363.tree) CALL364=self.match(self.input, CALL, self.FOLLOW_CALL_in_procedure_call8515) if self._state.backtracking == 0: stream_CALL.add(CALL364) self._state.following.append(self.FOLLOW_procedure_call_body_in_procedure_call8517) procedure_call_body365 = self.procedure_call_body() self._state.following.pop() if self._state.backtracking == 0: stream_procedure_call_body.add(procedure_call_body365.tree) self._state.following.append(self.FOLLOW_end_in_procedure_call8519) end366 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end366.tree) # AST Rewrite # elements: procedure_call_body, hyperlink, cif, 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() # 780:9: -> ^( PROCEDURE_CALL ( cif )? ( hyperlink )? ( end )? procedure_call_body ) # sdl92.g:780: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:780:34: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:780:39: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:780: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:784: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_id367 = None actual_parameters368 = None stream_procedure_id = RewriteRuleSubtreeStream(self._adaptor, "rule procedure_id") stream_actual_parameters = RewriteRuleSubtreeStream(self._adaptor, "rule actual_parameters") try: try: # sdl92.g:785:9: ( procedure_id ( actual_parameters )? -> ^( OUTPUT_BODY procedure_id ( actual_parameters )? ) ) # sdl92.g:785:17: procedure_id ( actual_parameters )? pass self._state.following.append(self.FOLLOW_procedure_id_in_procedure_call_body8581) procedure_id367 = self.procedure_id() self._state.following.pop() if self._state.backtracking == 0: stream_procedure_id.add(procedure_id367.tree) # sdl92.g:785:30: ( actual_parameters )? alt127 = 2 LA127_0 = self.input.LA(1) if (LA127_0 == L_PAREN) : alt127 = 1 if alt127 == 1: # sdl92.g:0:0: actual_parameters pass self._state.following.append(self.FOLLOW_actual_parameters_in_procedure_call_body8583) actual_parameters368 = self.actual_parameters() self._state.following.pop() if self._state.backtracking == 0: stream_actual_parameters.add(actual_parameters368.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() # 786:9: -> ^( OUTPUT_BODY procedure_id ( actual_parameters )? ) # sdl92.g:786: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:786: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:790: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 SET369 = None COMMA371 = None set_statement370 = None set_statement372 = None end373 = None SET369_tree = None COMMA371_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_SET = RewriteRuleTokenStream(self._adaptor, "token SET") stream_set_statement = RewriteRuleSubtreeStream(self._adaptor, "rule set_statement") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:791:9: ( SET set_statement ( COMMA set_statement )* end -> ( set_statement )+ ) # sdl92.g:791:17: SET set_statement ( COMMA set_statement )* end pass SET369=self.match(self.input, SET, self.FOLLOW_SET_in_set_timer8640) if self._state.backtracking == 0: stream_SET.add(SET369) self._state.following.append(self.FOLLOW_set_statement_in_set_timer8642) set_statement370 = self.set_statement() self._state.following.pop() if self._state.backtracking == 0: stream_set_statement.add(set_statement370.tree) # sdl92.g:791:35: ( COMMA set_statement )* while True: #loop128 alt128 = 2 LA128_0 = self.input.LA(1) if (LA128_0 == COMMA) : alt128 = 1 if alt128 == 1: # sdl92.g:791:36: COMMA set_statement pass COMMA371=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_set_timer8645) if self._state.backtracking == 0: stream_COMMA.add(COMMA371) self._state.following.append(self.FOLLOW_set_statement_in_set_timer8647) set_statement372 = self.set_statement() self._state.following.pop() if self._state.backtracking == 0: stream_set_statement.add(set_statement372.tree) else: break #loop128 self._state.following.append(self.FOLLOW_end_in_set_timer8667) end373 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end373.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() # 793:9: -> ( set_statement )+ # sdl92.g:793: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:797: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_PAREN374 = None COMMA376 = None R_PAREN378 = None expression375 = None timer_id377 = None L_PAREN374_tree = None COMMA376_tree = None R_PAREN378_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") stream_timer_id = RewriteRuleSubtreeStream(self._adaptor, "rule timer_id") try: try: # sdl92.g:798:9: ( L_PAREN ( expression COMMA )? timer_id R_PAREN -> ^( SET ( expression )? timer_id ) ) # sdl92.g:798:17: L_PAREN ( expression COMMA )? timer_id R_PAREN pass L_PAREN374=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_set_statement8717) if self._state.backtracking == 0: stream_L_PAREN.add(L_PAREN374) # sdl92.g:798:25: ( expression COMMA )? alt129 = 2 LA129_0 = self.input.LA(1) if (LA129_0 == ID) : LA129_1 = self.input.LA(2) if (LA129_1 == IN or LA129_1 == AND or LA129_1 == ASTERISK or LA129_1 == L_PAREN or LA129_1 == COMMA or (EQ <= LA129_1 <= GE) or (DOT <= LA129_1 <= REM) or LA129_1 == 223 or LA129_1 == 225) : alt129 = 1 elif (LA129_0 == FLOAT or LA129_0 == IF or LA129_0 == STATE or LA129_0 == STRING 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 if alt129 == 1: # sdl92.g:798:26: expression COMMA pass self._state.following.append(self.FOLLOW_expression_in_set_statement8720) expression375 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression375.tree) COMMA376=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_set_statement8722) if self._state.backtracking == 0: stream_COMMA.add(COMMA376) self._state.following.append(self.FOLLOW_timer_id_in_set_statement8726) timer_id377 = self.timer_id() self._state.following.pop() if self._state.backtracking == 0: stream_timer_id.add(timer_id377.tree) R_PAREN378=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_set_statement8728) if self._state.backtracking == 0: stream_R_PAREN.add(R_PAREN378) # AST Rewrite # elements: timer_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() # 799:9: -> ^( SET ( expression )? timer_id ) # sdl92.g:799:17: ^( SET ( expression )? timer_id ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(SET, "SET"), root_1) # sdl92.g:799: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:804: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 RESET379 = None char_literal381 = None reset_statement380 = None reset_statement382 = None end383 = None RESET379_tree = None char_literal381_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_RESET = RewriteRuleTokenStream(self._adaptor, "token RESET") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_reset_statement = RewriteRuleSubtreeStream(self._adaptor, "rule reset_statement") try: try: # sdl92.g:805:9: ( RESET reset_statement ( ',' reset_statement )* end -> ( reset_statement )+ ) # sdl92.g:805:17: RESET reset_statement ( ',' reset_statement )* end pass RESET379=self.match(self.input, RESET, self.FOLLOW_RESET_in_reset_timer8793) if self._state.backtracking == 0: stream_RESET.add(RESET379) self._state.following.append(self.FOLLOW_reset_statement_in_reset_timer8795) reset_statement380 = self.reset_statement() self._state.following.pop() if self._state.backtracking == 0: stream_reset_statement.add(reset_statement380.tree) # sdl92.g:805:39: ( ',' reset_statement )* while True: #loop130 alt130 = 2 LA130_0 = self.input.LA(1) if (LA130_0 == COMMA) : alt130 = 1 if alt130 == 1: # sdl92.g:805:40: ',' reset_statement pass char_literal381=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_reset_timer8798) if self._state.backtracking == 0: stream_COMMA.add(char_literal381) self._state.following.append(self.FOLLOW_reset_statement_in_reset_timer8800) reset_statement382 = self.reset_statement() self._state.following.pop() if self._state.backtracking == 0: stream_reset_statement.add(reset_statement382.tree) else: break #loop130 self._state.following.append(self.FOLLOW_end_in_reset_timer8820) end383 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end383.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() # 807:9: -> ( reset_statement )+ # sdl92.g:807: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:811: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_literal385 = None char_literal387 = None timer_id384 = None expression_list386 = None char_literal385_tree = None char_literal387_tree = None stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_expression_list = RewriteRuleSubtreeStream(self._adaptor, "rule expression_list") stream_timer_id = RewriteRuleSubtreeStream(self._adaptor, "rule timer_id") try: try: # sdl92.g:812:9: ( timer_id ( '(' expression_list ')' )? -> ^( RESET timer_id ( expression_list )? ) ) # sdl92.g:812:17: timer_id ( '(' expression_list ')' )? pass self._state.following.append(self.FOLLOW_timer_id_in_reset_statement8870) timer_id384 = self.timer_id() self._state.following.pop() if self._state.backtracking == 0: stream_timer_id.add(timer_id384.tree) # sdl92.g:812:26: ( '(' expression_list ')' )? alt131 = 2 LA131_0 = self.input.LA(1) if (LA131_0 == L_PAREN) : alt131 = 1 if alt131 == 1: # sdl92.g:812:27: '(' expression_list ')' pass char_literal385=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_reset_statement8873) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal385) self._state.following.append(self.FOLLOW_expression_list_in_reset_statement8875) expression_list386 = self.expression_list() self._state.following.pop() if self._state.backtracking == 0: stream_expression_list.add(expression_list386.tree) char_literal387=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_reset_statement8877) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal387) # 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() # 813:9: -> ^( RESET timer_id ( expression_list )? ) # sdl92.g:813: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:813: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:817: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 ALTERNATIVE388 = None ENDALTERNATIVE392 = None e = None f = None alternative_question389 = None answer_part390 = None alternative_part391 = None ALTERNATIVE388_tree = None ENDALTERNATIVE392_tree = None stream_ALTERNATIVE = RewriteRuleTokenStream(self._adaptor, "token ALTERNATIVE") stream_ENDALTERNATIVE = RewriteRuleTokenStream(self._adaptor, "token ENDALTERNATIVE") stream_alternative_part = RewriteRuleSubtreeStream(self._adaptor, "rule alternative_part") stream_alternative_question = RewriteRuleSubtreeStream(self._adaptor, "rule alternative_question") stream_answer_part = RewriteRuleSubtreeStream(self._adaptor, "rule answer_part") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:818:9: ( ALTERNATIVE alternative_question e= end answer_part alternative_part ENDALTERNATIVE f= end -> ^( ALTERNATIVE answer_part alternative_part ) ) # sdl92.g:818:17: ALTERNATIVE alternative_question e= end answer_part alternative_part ENDALTERNATIVE f= end pass ALTERNATIVE388=self.match(self.input, ALTERNATIVE, self.FOLLOW_ALTERNATIVE_in_transition_option8935) if self._state.backtracking == 0: stream_ALTERNATIVE.add(ALTERNATIVE388) self._state.following.append(self.FOLLOW_alternative_question_in_transition_option8937) alternative_question389 = self.alternative_question() self._state.following.pop() if self._state.backtracking == 0: stream_alternative_question.add(alternative_question389.tree) self._state.following.append(self.FOLLOW_end_in_transition_option8941) 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_option8959) answer_part390 = self.answer_part() self._state.following.pop() if self._state.backtracking == 0: stream_answer_part.add(answer_part390.tree) self._state.following.append(self.FOLLOW_alternative_part_in_transition_option8977) alternative_part391 = self.alternative_part() self._state.following.pop() if self._state.backtracking == 0: stream_alternative_part.add(alternative_part391.tree) ENDALTERNATIVE392=self.match(self.input, ENDALTERNATIVE, self.FOLLOW_ENDALTERNATIVE_in_transition_option8995) if self._state.backtracking == 0: stream_ENDALTERNATIVE.add(ENDALTERNATIVE392) self._state.following.append(self.FOLLOW_end_in_transition_option8999) 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() # 822:9: -> ^( ALTERNATIVE answer_part alternative_part ) # sdl92.g:822: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:826: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_part393 = None else_part394 = None else_part395 = None stream_answer_part = RewriteRuleSubtreeStream(self._adaptor, "rule answer_part") stream_else_part = RewriteRuleSubtreeStream(self._adaptor, "rule else_part") try: try: # sdl92.g:827:9: ( ( ( answer_part )+ ( else_part )? ) -> ( answer_part )+ ( else_part )? | else_part -> else_part ) alt134 = 2 alt134 = self.dfa134.predict(self.input) if alt134 == 1: # sdl92.g:827:17: ( ( answer_part )+ ( else_part )? ) pass # sdl92.g:827:17: ( ( answer_part )+ ( else_part )? ) # sdl92.g:827:18: ( answer_part )+ ( else_part )? pass # sdl92.g:827:18: ( answer_part )+ cnt132 = 0 while True: #loop132 alt132 = 2 alt132 = self.dfa132.predict(self.input) if alt132 == 1: # sdl92.g:0:0: answer_part pass self._state.following.append(self.FOLLOW_answer_part_in_alternative_part9055) answer_part393 = self.answer_part() self._state.following.pop() if self._state.backtracking == 0: stream_answer_part.add(answer_part393.tree) else: if cnt132 >= 1: break #loop132 if self._state.backtracking > 0: raise BacktrackingFailed eee = EarlyExitException(132, self.input) raise eee cnt132 += 1 # sdl92.g:827:31: ( else_part )? alt133 = 2 LA133_0 = self.input.LA(1) if (LA133_0 == ELSE or LA133_0 == 228) : alt133 = 1 if alt133 == 1: # sdl92.g:0:0: else_part pass self._state.following.append(self.FOLLOW_else_part_in_alternative_part9058) else_part394 = self.else_part() self._state.following.pop() if self._state.backtracking == 0: stream_else_part.add(else_part394.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() # 828:9: -> ( answer_part )+ ( else_part )? # sdl92.g:828: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:828: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 alt134 == 2: # sdl92.g:829:19: else_part pass self._state.following.append(self.FOLLOW_else_part_in_alternative_part9101) else_part395 = self.else_part() self._state.following.pop() if self._state.backtracking == 0: stream_else_part.add(else_part395.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() # 830: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:834:1: alternative_question : ( expression | informal_text ); def alternative_question(self, ): retval = self.alternative_question_return() retval.start = self.input.LT(1) root_0 = None expression396 = None informal_text397 = None try: try: # sdl92.g:835:9: ( expression | informal_text ) alt135 = 2 LA135_0 = self.input.LA(1) if (LA135_0 == FLOAT or LA135_0 == IF or LA135_0 == STATE or LA135_0 == ID or LA135_0 == INT or LA135_0 == L_PAREN or LA135_0 == DASH or (NOT <= LA135_0 <= MINUS_INFINITY) or LA135_0 == L_BRACKET) : alt135 = 1 elif (LA135_0 == STRING) : LA135_2 = self.input.LA(2) if (self.synpred174_sdl92()) : alt135 = 1 elif (True) : alt135 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 135, 2, self.input) raise nvae else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 135, 0, self.input) raise nvae if alt135 == 1: # sdl92.g:835:17: expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_expression_in_alternative_question9150) expression396 = self.expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, expression396.tree) elif alt135 == 2: # sdl92.g:836:19: informal_text pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_informal_text_in_alternative_question9170) informal_text397 = self.informal_text() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, informal_text397.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:840: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 DECISION400 = None ENDDECISION404 = None e = None f = None cif398 = None hyperlink399 = None question401 = None answer_part402 = None alternative_part403 = None DECISION400_tree = None ENDDECISION404_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_question = RewriteRuleSubtreeStream(self._adaptor, "rule question") stream_alternative_part = RewriteRuleSubtreeStream(self._adaptor, "rule alternative_part") stream_answer_part = RewriteRuleSubtreeStream(self._adaptor, "rule answer_part") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") try: try: # sdl92.g:841: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:841:17: ( cif )? ( hyperlink )? DECISION question e= end ( answer_part )? ( alternative_part )? ENDDECISION f= end pass # sdl92.g:841:17: ( cif )? alt136 = 2 LA136_0 = self.input.LA(1) if (LA136_0 == 228) : LA136_1 = self.input.LA(2) if (LA136_1 == ANSWER or LA136_1 == COMMENT or LA136_1 == CONNECT or LA136_1 == DECISION or LA136_1 == INPUT or (JOIN <= LA136_1 <= LABEL) or LA136_1 == NEXTSTATE or LA136_1 == OUTPUT or (PROCEDURE <= LA136_1 <= PROCEDURE_CALL) or (PROCESS <= LA136_1 <= PROVIDED) or LA136_1 == RETURN or LA136_1 == STATE or LA136_1 == STOP or LA136_1 == TASK or LA136_1 == TEXT or LA136_1 == START) : alt136 = 1 if alt136 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_decision9202) cif398 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif398.tree) # sdl92.g:842:17: ( hyperlink )? alt137 = 2 LA137_0 = self.input.LA(1) if (LA137_0 == 228) : alt137 = 1 if alt137 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_decision9221) hyperlink399 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink399.tree) DECISION400=self.match(self.input, DECISION, self.FOLLOW_DECISION_in_decision9240) if self._state.backtracking == 0: stream_DECISION.add(DECISION400) self._state.following.append(self.FOLLOW_question_in_decision9242) question401 = self.question() self._state.following.pop() if self._state.backtracking == 0: stream_question.add(question401.tree) self._state.following.append(self.FOLLOW_end_in_decision9246) e = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(e.tree) # sdl92.g:844:17: ( answer_part )? alt138 = 2 LA138_0 = self.input.LA(1) if (LA138_0 == 228) : LA138_1 = self.input.LA(2) if (self.synpred177_sdl92()) : alt138 = 1 elif (LA138_0 == L_PAREN) : LA138_2 = self.input.LA(2) if (self.synpred177_sdl92()) : alt138 = 1 if alt138 == 1: # sdl92.g:0:0: answer_part pass self._state.following.append(self.FOLLOW_answer_part_in_decision9264) answer_part402 = self.answer_part() self._state.following.pop() if self._state.backtracking == 0: stream_answer_part.add(answer_part402.tree) # sdl92.g:845:17: ( alternative_part )? alt139 = 2 LA139_0 = self.input.LA(1) if (LA139_0 == ELSE or LA139_0 == L_PAREN or LA139_0 == 228) : alt139 = 1 if alt139 == 1: # sdl92.g:0:0: alternative_part pass self._state.following.append(self.FOLLOW_alternative_part_in_decision9283) alternative_part403 = self.alternative_part() self._state.following.pop() if self._state.backtracking == 0: stream_alternative_part.add(alternative_part403.tree) ENDDECISION404=self.match(self.input, ENDDECISION, self.FOLLOW_ENDDECISION_in_decision9302) if self._state.backtracking == 0: stream_ENDDECISION.add(ENDDECISION404) self._state.following.append(self.FOLLOW_end_in_decision9306) f = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(f.tree) # AST Rewrite # elements: cif, hyperlink, e, DECISION, answer_part, alternative_part, question # token labels: # rule labels: e, retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 if e is not None: stream_e = RewriteRuleSubtreeStream(self._adaptor, "rule e", e.tree) else: stream_e = RewriteRuleSubtreeStream(self._adaptor, "token e", 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() # 847:9: -> ^( DECISION ( cif )? ( hyperlink )? ( $e)? question ( answer_part )? ( alternative_part )? ) # sdl92.g:847: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:847:28: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:847:33: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:847: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:848:17: ( answer_part )? if stream_answer_part.hasNext(): self._adaptor.addChild(root_1, stream_answer_part.nextTree()) stream_answer_part.reset(); # sdl92.g:848: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:852: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_PAREN407 = None R_PAREN409 = None char_literal410 = None cif405 = None hyperlink406 = None answer408 = None transition411 = None L_PAREN407_tree = None R_PAREN409_tree = None char_literal410_tree = None stream_223 = RewriteRuleTokenStream(self._adaptor, "token 223") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_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:853:9: ( ( cif )? ( hyperlink )? L_PAREN answer R_PAREN ':' ( transition )? -> ^( ANSWER ( cif )? ( hyperlink )? answer ( transition )? ) ) # sdl92.g:853:17: ( cif )? ( hyperlink )? L_PAREN answer R_PAREN ':' ( transition )? pass # sdl92.g:853:17: ( cif )? alt140 = 2 LA140_0 = self.input.LA(1) if (LA140_0 == 228) : LA140_1 = self.input.LA(2) if (LA140_1 == ANSWER or LA140_1 == COMMENT or LA140_1 == CONNECT or LA140_1 == DECISION or LA140_1 == INPUT or (JOIN <= LA140_1 <= LABEL) or LA140_1 == NEXTSTATE or LA140_1 == OUTPUT or (PROCEDURE <= LA140_1 <= PROCEDURE_CALL) or (PROCESS <= LA140_1 <= PROVIDED) or LA140_1 == RETURN or LA140_1 == STATE or LA140_1 == STOP or LA140_1 == TASK or LA140_1 == TEXT or LA140_1 == START) : alt140 = 1 if alt140 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_answer_part9391) cif405 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif405.tree) # sdl92.g:854:17: ( hyperlink )? alt141 = 2 LA141_0 = self.input.LA(1) if (LA141_0 == 228) : alt141 = 1 if alt141 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_answer_part9410) hyperlink406 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink406.tree) L_PAREN407=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_answer_part9429) if self._state.backtracking == 0: stream_L_PAREN.add(L_PAREN407) self._state.following.append(self.FOLLOW_answer_in_answer_part9431) answer408 = self.answer() self._state.following.pop() if self._state.backtracking == 0: stream_answer.add(answer408.tree) R_PAREN409=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_answer_part9433) if self._state.backtracking == 0: stream_R_PAREN.add(R_PAREN409) char_literal410=self.match(self.input, 223, self.FOLLOW_223_in_answer_part9435) if self._state.backtracking == 0: stream_223.add(char_literal410) # sdl92.g:855:44: ( transition )? alt142 = 2 alt142 = self.dfa142.predict(self.input) if alt142 == 1: # sdl92.g:0:0: transition pass self._state.following.append(self.FOLLOW_transition_in_answer_part9437) transition411 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition411.tree) # AST Rewrite # elements: cif, hyperlink, transition, answer # 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() # 856:9: -> ^( ANSWER ( cif )? ( hyperlink )? answer ( transition )? ) # sdl92.g:856: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:856:26: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:856: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:856: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:860:1: answer : ( range_condition | informal_text ); def answer(self, ): retval = self.answer_return() retval.start = self.input.LT(1) root_0 = None range_condition412 = None informal_text413 = None try: try: # sdl92.g:861:9: ( range_condition | informal_text ) alt143 = 2 LA143_0 = self.input.LA(1) if (LA143_0 == FLOAT or LA143_0 == IF or LA143_0 == STATE or LA143_0 == ID or LA143_0 == INT or LA143_0 == L_PAREN or (EQ <= LA143_0 <= GE) or LA143_0 == DASH or (NOT <= LA143_0 <= MINUS_INFINITY) or LA143_0 == L_BRACKET) : alt143 = 1 elif (LA143_0 == STRING) : LA143_2 = self.input.LA(2) if (self.synpred182_sdl92()) : alt143 = 1 elif (True) : alt143 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 143, 2, self.input) raise nvae else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 143, 0, self.input) raise nvae if alt143 == 1: # sdl92.g:861:17: range_condition pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_range_condition_in_answer9500) range_condition412 = self.range_condition() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, range_condition412.tree) elif alt143 == 2: # sdl92.g:862:19: informal_text pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_informal_text_in_answer9520) informal_text413 = self.informal_text() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, informal_text413.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:866: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 ELSE416 = None char_literal417 = None cif414 = None hyperlink415 = None transition418 = None ELSE416_tree = None char_literal417_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:867:9: ( ( cif )? ( hyperlink )? ELSE ':' ( transition )? -> ^( ELSE ( cif )? ( hyperlink )? ( transition )? ) ) # sdl92.g:867:17: ( cif )? ( hyperlink )? ELSE ':' ( transition )? pass # sdl92.g:867:17: ( cif )? alt144 = 2 LA144_0 = self.input.LA(1) if (LA144_0 == 228) : LA144_1 = self.input.LA(2) if (LA144_1 == ANSWER or LA144_1 == COMMENT or LA144_1 == CONNECT or LA144_1 == DECISION or LA144_1 == INPUT or (JOIN <= LA144_1 <= LABEL) or LA144_1 == NEXTSTATE or LA144_1 == OUTPUT or (PROCEDURE <= LA144_1 <= PROCEDURE_CALL) or (PROCESS <= LA144_1 <= PROVIDED) or LA144_1 == RETURN or LA144_1 == STATE or LA144_1 == STOP or LA144_1 == TASK or LA144_1 == TEXT or LA144_1 == START) : alt144 = 1 if alt144 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_else_part9552) cif414 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif414.tree) # sdl92.g:868:17: ( hyperlink )? alt145 = 2 LA145_0 = self.input.LA(1) if (LA145_0 == 228) : alt145 = 1 if alt145 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_else_part9571) hyperlink415 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink415.tree) ELSE416=self.match(self.input, ELSE, self.FOLLOW_ELSE_in_else_part9590) if self._state.backtracking == 0: stream_ELSE.add(ELSE416) char_literal417=self.match(self.input, 223, self.FOLLOW_223_in_else_part9592) if self._state.backtracking == 0: stream_223.add(char_literal417) # sdl92.g:869:26: ( transition )? alt146 = 2 LA146_0 = self.input.LA(1) if (LA146_0 == ALTERNATIVE or LA146_0 == DECISION or LA146_0 == EXPORT or LA146_0 == FOR or LA146_0 == JOIN or LA146_0 == NEXTSTATE or LA146_0 == OUTPUT or (RESET <= LA146_0 <= RETURN) or LA146_0 == SET or LA146_0 == STOP or LA146_0 == STRING or LA146_0 == TASK or LA146_0 == ID or LA146_0 == CALL or LA146_0 == CREATE or LA146_0 == 228) : alt146 = 1 if alt146 == 1: # sdl92.g:0:0: transition pass self._state.following.append(self.FOLLOW_transition_in_else_part9594) transition418 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition418.tree) # AST Rewrite # elements: hyperlink, transition, ELSE, 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() # 870:9: -> ^( ELSE ( cif )? ( hyperlink )? ( transition )? ) # sdl92.g:870:17: ^( ELSE ( cif )? ( hyperlink )? ( transition )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_ELSE.nextNode(), root_1) # sdl92.g:870:24: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:870:29: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:870: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:874: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 ANY421 = None informal_text419 = None expression420 = None ANY421_tree = None stream_ANY = RewriteRuleTokenStream(self._adaptor, "token ANY") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:875:9: ( informal_text | expression -> ^( QUESTION expression ) | ANY -> ^( ANY ) ) alt147 = 3 LA147 = self.input.LA(1) if LA147 == STRING: LA147_1 = self.input.LA(2) if (self.synpred186_sdl92()) : alt147 = 1 elif (self.synpred187_sdl92()) : alt147 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 147, 1, self.input) raise nvae elif LA147 == FLOAT or LA147 == IF or LA147 == STATE or LA147 == ID or LA147 == INT or LA147 == L_PAREN or LA147 == DASH or LA147 == NOT or LA147 == TRUE or LA147 == FALSE or LA147 == PLUS_INFINITY or LA147 == MINUS_INFINITY or LA147 == L_BRACKET: alt147 = 2 elif LA147 == ANY: alt147 = 3 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 147, 0, self.input) raise nvae if alt147 == 1: # sdl92.g:875:17: informal_text pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_informal_text_in_question9655) informal_text419 = self.informal_text() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, informal_text419.tree) elif alt147 == 2: # sdl92.g:876:19: expression pass self._state.following.append(self.FOLLOW_expression_in_question9675) expression420 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression420.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() # 877:9: -> ^( QUESTION expression ) # sdl92.g:877: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 alt147 == 3: # sdl92.g:878:19: ANY pass ANY421=self.match(self.input, ANY, self.FOLLOW_ANY_in_question9716) if self._state.backtracking == 0: stream_ANY.add(ANY421) # 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() # 879:9: -> ^( ANY ) # sdl92.g:879: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:883: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_range422 = None open_range423 = None try: try: # sdl92.g:884:9: ( ( closed_range | open_range ) ) # sdl92.g:884:17: ( closed_range | open_range ) pass root_0 = self._adaptor.nil() # sdl92.g:884:17: ( closed_range | open_range ) alt148 = 2 alt148 = self.dfa148.predict(self.input) if alt148 == 1: # sdl92.g:884:18: closed_range pass self._state.following.append(self.FOLLOW_closed_range_in_range_condition9768) closed_range422 = self.closed_range() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, closed_range422.tree) elif alt148 == 2: # sdl92.g:884:33: open_range pass self._state.following.append(self.FOLLOW_open_range_in_range_condition9772) open_range423 = self.open_range() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, open_range423.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:889: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_literal424 = None a = None b = None char_literal424_tree = None stream_223 = RewriteRuleTokenStream(self._adaptor, "token 223") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:890:9: (a= expression ':' b= expression -> ^( CLOSED_RANGE $a $b) ) # sdl92.g:890:17: a= expression ':' b= expression pass self._state.following.append(self.FOLLOW_expression_in_closed_range9824) a = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(a.tree) char_literal424=self.match(self.input, 223, self.FOLLOW_223_in_closed_range9826) if self._state.backtracking == 0: stream_223.add(char_literal424) self._state.following.append(self.FOLLOW_expression_in_closed_range9830) 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: a, b, retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 if a is not None: stream_a = RewriteRuleSubtreeStream(self._adaptor, "rule a", a.tree) else: stream_a = RewriteRuleSubtreeStream(self._adaptor, "token a", 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 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() # 891:9: -> ^( CLOSED_RANGE $a $b) # sdl92.g:891: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:895: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 EQ426 = None NEQ427 = None GT428 = None LT429 = None LE430 = None GE431 = None constant425 = None constant432 = None EQ426_tree = None NEQ427_tree = None GT428_tree = None LT429_tree = None LE430_tree = None GE431_tree = None stream_LT = RewriteRuleTokenStream(self._adaptor, "token LT") stream_LE = RewriteRuleTokenStream(self._adaptor, "token LE") stream_NEQ = RewriteRuleTokenStream(self._adaptor, "token NEQ") stream_EQ = RewriteRuleTokenStream(self._adaptor, "token EQ") stream_GT = RewriteRuleTokenStream(self._adaptor, "token GT") stream_GE = RewriteRuleTokenStream(self._adaptor, "token GE") stream_constant = RewriteRuleSubtreeStream(self._adaptor, "rule constant") try: try: # sdl92.g:896:9: ( constant -> constant | ( ( EQ | NEQ | GT | LT | LE | GE ) constant ) -> ^( OPEN_RANGE ( EQ )? ( NEQ )? ( GT )? ( LT )? ( LE )? ( GE )? constant ) ) alt150 = 2 LA150_0 = self.input.LA(1) if (LA150_0 == FLOAT or LA150_0 == IF or LA150_0 == STATE or LA150_0 == STRING or LA150_0 == ID or LA150_0 == INT or LA150_0 == L_PAREN or LA150_0 == DASH or (NOT <= LA150_0 <= MINUS_INFINITY) or LA150_0 == L_BRACKET) : alt150 = 1 elif ((EQ <= LA150_0 <= GE)) : alt150 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 150, 0, self.input) raise nvae if alt150 == 1: # sdl92.g:896:17: constant pass self._state.following.append(self.FOLLOW_constant_in_open_range9887) constant425 = self.constant() self._state.following.pop() if self._state.backtracking == 0: stream_constant.add(constant425.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() # 897:9: -> constant self._adaptor.addChild(root_0, stream_constant.nextTree()) retval.tree = root_0 elif alt150 == 2: # sdl92.g:898:19: ( ( EQ | NEQ | GT | LT | LE | GE ) constant ) pass # sdl92.g:898:19: ( ( EQ | NEQ | GT | LT | LE | GE ) constant ) # sdl92.g:898:21: ( EQ | NEQ | GT | LT | LE | GE ) constant pass # sdl92.g:898:21: ( EQ | NEQ | GT | LT | LE | GE ) alt149 = 6 LA149 = self.input.LA(1) if LA149 == EQ: alt149 = 1 elif LA149 == NEQ: alt149 = 2 elif LA149 == GT: alt149 = 3 elif LA149 == LT: alt149 = 4 elif LA149 == LE: alt149 = 5 elif LA149 == GE: alt149 = 6 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 149, 0, self.input) raise nvae if alt149 == 1: # sdl92.g:898:22: EQ pass EQ426=self.match(self.input, EQ, self.FOLLOW_EQ_in_open_range9927) if self._state.backtracking == 0: stream_EQ.add(EQ426) elif alt149 == 2: # sdl92.g:898:25: NEQ pass NEQ427=self.match(self.input, NEQ, self.FOLLOW_NEQ_in_open_range9929) if self._state.backtracking == 0: stream_NEQ.add(NEQ427) elif alt149 == 3: # sdl92.g:898:29: GT pass GT428=self.match(self.input, GT, self.FOLLOW_GT_in_open_range9931) if self._state.backtracking == 0: stream_GT.add(GT428) elif alt149 == 4: # sdl92.g:898:32: LT pass LT429=self.match(self.input, LT, self.FOLLOW_LT_in_open_range9933) if self._state.backtracking == 0: stream_LT.add(LT429) elif alt149 == 5: # sdl92.g:898:35: LE pass LE430=self.match(self.input, LE, self.FOLLOW_LE_in_open_range9935) if self._state.backtracking == 0: stream_LE.add(LE430) elif alt149 == 6: # sdl92.g:898:38: GE pass GE431=self.match(self.input, GE, self.FOLLOW_GE_in_open_range9937) if self._state.backtracking == 0: stream_GE.add(GE431) self._state.following.append(self.FOLLOW_constant_in_open_range9940) constant432 = self.constant() self._state.following.pop() if self._state.backtracking == 0: stream_constant.add(constant432.tree) # AST Rewrite # elements: constant, LE, NEQ, GT, 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() # 899:9: -> ^( OPEN_RANGE ( EQ )? ( NEQ )? ( GT )? ( LT )? ( LE )? ( GE )? constant ) # sdl92.g:899: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:899:30: ( EQ )? if stream_EQ.hasNext(): self._adaptor.addChild(root_1, stream_EQ.nextNode()) stream_EQ.reset(); # sdl92.g:899:34: ( NEQ )? if stream_NEQ.hasNext(): self._adaptor.addChild(root_1, stream_NEQ.nextNode()) stream_NEQ.reset(); # sdl92.g:899:39: ( GT )? if stream_GT.hasNext(): self._adaptor.addChild(root_1, stream_GT.nextNode()) stream_GT.reset(); # sdl92.g:899:43: ( LT )? if stream_LT.hasNext(): self._adaptor.addChild(root_1, stream_LT.nextNode()) stream_LT.reset(); # sdl92.g:899:47: ( LE )? if stream_LE.hasNext(): self._adaptor.addChild(root_1, stream_LE.nextNode()) stream_LE.reset(); # sdl92.g:899: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:903:1: constant : expression -> ^( CONSTANT expression ) ; def constant(self, ): retval = self.constant_return() retval.start = self.input.LT(1) root_0 = None expression433 = None stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:904:9: ( expression -> ^( CONSTANT expression ) ) # sdl92.g:904:17: expression pass self._state.following.append(self.FOLLOW_expression_in_constant10012) expression433 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression433.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() # 905:9: -> ^( CONSTANT expression ) # sdl92.g:905: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:909: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 CREATE434 = None createbody435 = None actual_parameters436 = None end437 = None CREATE434_tree = None stream_CREATE = RewriteRuleTokenStream(self._adaptor, "token CREATE") stream_actual_parameters = RewriteRuleSubtreeStream(self._adaptor, "rule actual_parameters") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_createbody = RewriteRuleSubtreeStream(self._adaptor, "rule createbody") try: try: # sdl92.g:910:9: ( CREATE createbody ( actual_parameters )? end -> ^( CREATE createbody ( actual_parameters )? ) ) # sdl92.g:910:17: CREATE createbody ( actual_parameters )? end pass CREATE434=self.match(self.input, CREATE, self.FOLLOW_CREATE_in_create_request10065) if self._state.backtracking == 0: stream_CREATE.add(CREATE434) self._state.following.append(self.FOLLOW_createbody_in_create_request10083) createbody435 = self.createbody() self._state.following.pop() if self._state.backtracking == 0: stream_createbody.add(createbody435.tree) # sdl92.g:912: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_create_request10101) actual_parameters436 = self.actual_parameters() self._state.following.pop() if self._state.backtracking == 0: stream_actual_parameters.add(actual_parameters436.tree) self._state.following.append(self.FOLLOW_end_in_create_request10120) end437 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end437.tree) # AST Rewrite # elements: CREATE, createbody, 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() # 914:9: -> ^( CREATE createbody ( actual_parameters )? ) # sdl92.g:914: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:914: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:918:1: createbody : ( process_id | THIS ); def createbody(self, ): retval = self.createbody_return() retval.start = self.input.LT(1) root_0 = None THIS439 = None process_id438 = None THIS439_tree = None try: try: # sdl92.g:919:9: ( process_id | THIS ) alt152 = 2 LA152_0 = self.input.LA(1) if (LA152_0 == ID) : alt152 = 1 elif (LA152_0 == THIS) : alt152 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 152, 0, self.input) raise nvae if alt152 == 1: # sdl92.g:919:17: process_id pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_process_id_in_createbody10176) process_id438 = self.process_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, process_id438.tree) elif alt152 == 2: # sdl92.g:920:19: THIS pass root_0 = self._adaptor.nil() THIS439=self.match(self.input, THIS, self.FOLLOW_THIS_in_createbody10196) if self._state.backtracking == 0: THIS439_tree = self._adaptor.createWithPayload(THIS439) self._adaptor.addChild(root_0, THIS439_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:924: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 OUTPUT442 = None cif440 = None hyperlink441 = None outputbody443 = None end444 = None OUTPUT442_tree = None stream_OUTPUT = RewriteRuleTokenStream(self._adaptor, "token OUTPUT") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_outputbody = RewriteRuleSubtreeStream(self._adaptor, "rule outputbody") try: try: # sdl92.g:925:9: ( ( cif )? ( hyperlink )? OUTPUT outputbody end -> ^( OUTPUT ( cif )? ( hyperlink )? ( end )? outputbody ) ) # sdl92.g:925:17: ( cif )? ( hyperlink )? OUTPUT outputbody end pass # sdl92.g:925:17: ( cif )? alt153 = 2 LA153_0 = self.input.LA(1) if (LA153_0 == 228) : LA153_1 = self.input.LA(2) if (LA153_1 == ANSWER or LA153_1 == COMMENT or LA153_1 == CONNECT or LA153_1 == DECISION or LA153_1 == INPUT or (JOIN <= LA153_1 <= LABEL) or LA153_1 == NEXTSTATE or LA153_1 == OUTPUT or (PROCEDURE <= LA153_1 <= PROCEDURE_CALL) or (PROCESS <= LA153_1 <= PROVIDED) or LA153_1 == RETURN or LA153_1 == STATE or LA153_1 == STOP or LA153_1 == TASK or LA153_1 == TEXT or LA153_1 == START) : alt153 = 1 if alt153 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_output10228) cif440 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif440.tree) # sdl92.g:926:17: ( hyperlink )? alt154 = 2 LA154_0 = self.input.LA(1) if (LA154_0 == 228) : alt154 = 1 if alt154 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_output10247) hyperlink441 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink441.tree) OUTPUT442=self.match(self.input, OUTPUT, self.FOLLOW_OUTPUT_in_output10266) if self._state.backtracking == 0: stream_OUTPUT.add(OUTPUT442) self._state.following.append(self.FOLLOW_outputbody_in_output10268) outputbody443 = self.outputbody() self._state.following.pop() if self._state.backtracking == 0: stream_outputbody.add(outputbody443.tree) self._state.following.append(self.FOLLOW_end_in_output10270) end444 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end444.tree) # AST Rewrite # elements: cif, hyperlink, end, OUTPUT, outputbody # 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() # 928:9: -> ^( OUTPUT ( cif )? ( hyperlink )? ( end )? outputbody ) # sdl92.g:928:17: ^( OUTPUT ( cif )? ( hyperlink )? ( end )? outputbody ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_OUTPUT.nextNode(), root_1) # sdl92.g:928:26: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:928:31: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:928: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:932: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_literal446 = None outputstmt445 = None outputstmt447 = None to_part448 = None char_literal446_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:933:9: ( outputstmt ( ',' outputstmt )* ( to_part )? -> ^( OUTPUT_BODY ( outputstmt )+ ( to_part )? ) ) # sdl92.g:933:17: outputstmt ( ',' outputstmt )* ( to_part )? pass self._state.following.append(self.FOLLOW_outputstmt_in_outputbody10332) outputstmt445 = self.outputstmt() self._state.following.pop() if self._state.backtracking == 0: stream_outputstmt.add(outputstmt445.tree) # sdl92.g:933:28: ( ',' outputstmt )* while True: #loop155 alt155 = 2 LA155_0 = self.input.LA(1) if (LA155_0 == COMMA) : alt155 = 1 if alt155 == 1: # sdl92.g:933:29: ',' outputstmt pass char_literal446=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_outputbody10335) if self._state.backtracking == 0: stream_COMMA.add(char_literal446) self._state.following.append(self.FOLLOW_outputstmt_in_outputbody10337) outputstmt447 = self.outputstmt() self._state.following.pop() if self._state.backtracking == 0: stream_outputstmt.add(outputstmt447.tree) else: break #loop155 # sdl92.g:933:46: ( to_part )? alt156 = 2 LA156_0 = self.input.LA(1) if (LA156_0 == TO) : alt156 = 1 if alt156 == 1: # sdl92.g:0:0: to_part pass self._state.following.append(self.FOLLOW_to_part_in_outputbody10341) to_part448 = self.to_part() self._state.following.pop() if self._state.backtracking == 0: stream_to_part.add(to_part448.tree) # AST Rewrite # elements: to_part, outputstmt # 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() # 934:9: -> ^( OUTPUT_BODY ( outputstmt )+ ( to_part )? ) # sdl92.g:934: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:934: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:934: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:940:1: outputstmt : signal_id ( actual_parameters )? ; def outputstmt(self, ): retval = self.outputstmt_return() retval.start = self.input.LT(1) root_0 = None signal_id449 = None actual_parameters450 = None try: try: # sdl92.g:941:9: ( signal_id ( actual_parameters )? ) # sdl92.g:941:17: signal_id ( actual_parameters )? pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_signal_id_in_outputstmt10403) signal_id449 = self.signal_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, signal_id449.tree) # sdl92.g:942:17: ( actual_parameters )? alt157 = 2 LA157_0 = self.input.LA(1) if (LA157_0 == L_PAREN) : alt157 = 1 if alt157 == 1: # sdl92.g:0:0: actual_parameters pass self._state.following.append(self.FOLLOW_actual_parameters_in_outputstmt10421) actual_parameters450 = self.actual_parameters() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, actual_parameters450.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:945: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 TO451 = None destination452 = None TO451_tree = None stream_TO = RewriteRuleTokenStream(self._adaptor, "token TO") stream_destination = RewriteRuleSubtreeStream(self._adaptor, "rule destination") try: try: # sdl92.g:946:9: ( ( TO destination ) -> ^( TO destination ) ) # sdl92.g:946:17: ( TO destination ) pass # sdl92.g:946:17: ( TO destination ) # sdl92.g:946:18: TO destination pass TO451=self.match(self.input, TO, self.FOLLOW_TO_in_to_part10454) if self._state.backtracking == 0: stream_TO.add(TO451) self._state.following.append(self.FOLLOW_destination_in_to_part10456) destination452 = self.destination() self._state.following.pop() if self._state.backtracking == 0: stream_destination.add(destination452.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() # 947:9: -> ^( TO destination ) # sdl92.g:947: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:950: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 VIA453 = None viabody454 = None VIA453_tree = None stream_VIA = RewriteRuleTokenStream(self._adaptor, "token VIA") stream_viabody = RewriteRuleSubtreeStream(self._adaptor, "rule viabody") try: try: # sdl92.g:951:9: ( VIA viabody -> ^( VIA viabody ) ) # sdl92.g:951:17: VIA viabody pass VIA453=self.match(self.input, VIA, self.FOLLOW_VIA_in_via_part10509) if self._state.backtracking == 0: stream_VIA.add(VIA453) self._state.following.append(self.FOLLOW_viabody_in_via_part10511) viabody454 = self.viabody() self._state.following.pop() if self._state.backtracking == 0: stream_viabody.add(viabody454.tree) # AST Rewrite # elements: viabody, 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() # 952:9: -> ^( VIA viabody ) # sdl92.g:952: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:957: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 ALL455 = None via_path456 = None ALL455_tree = None stream_ALL = RewriteRuleTokenStream(self._adaptor, "token ALL") stream_via_path = RewriteRuleSubtreeStream(self._adaptor, "rule via_path") try: try: # sdl92.g:958:9: ( ALL -> ^( ALL ) | via_path -> ^( VIAPATH via_path ) ) alt158 = 2 LA158_0 = self.input.LA(1) if (LA158_0 == ALL) : alt158 = 1 elif (LA158_0 == ID) : alt158 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 158, 0, self.input) raise nvae if alt158 == 1: # sdl92.g:958:17: ALL pass ALL455=self.match(self.input, ALL, self.FOLLOW_ALL_in_viabody10565) if self._state.backtracking == 0: stream_ALL.add(ALL455) # 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() # 959:9: -> ^( ALL ) # sdl92.g:959: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 alt158 == 2: # sdl92.g:960:19: via_path pass self._state.following.append(self.FOLLOW_via_path_in_viabody10604) via_path456 = self.via_path() self._state.following.pop() if self._state.backtracking == 0: stream_via_path.add(via_path456.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() # 961:9: -> ^( VIAPATH via_path ) # sdl92.g:961: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:965:1: destination : ( pid_expression | process_id | THIS ); def destination(self, ): retval = self.destination_return() retval.start = self.input.LT(1) root_0 = None THIS459 = None pid_expression457 = None process_id458 = None THIS459_tree = None try: try: # sdl92.g:966:9: ( pid_expression | process_id | THIS ) alt159 = 3 LA159 = self.input.LA(1) if LA159 == P or LA159 == S or LA159 == O: alt159 = 1 elif LA159 == ID: alt159 = 2 elif LA159 == THIS: alt159 = 3 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 159, 0, self.input) raise nvae if alt159 == 1: # sdl92.g:966:17: pid_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_pid_expression_in_destination10657) pid_expression457 = self.pid_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, pid_expression457.tree) elif alt159 == 2: # sdl92.g:967:19: process_id pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_process_id_in_destination10677) process_id458 = self.process_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, process_id458.tree) elif alt159 == 3: # sdl92.g:968:19: THIS pass root_0 = self._adaptor.nil() THIS459=self.match(self.input, THIS, self.FOLLOW_THIS_in_destination10697) if self._state.backtracking == 0: THIS459_tree = self._adaptor.createWithPayload(THIS459) self._adaptor.addChild(root_0, THIS459_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:972: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_literal461 = None via_path_element460 = None via_path_element462 = None char_literal461_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_via_path_element = RewriteRuleSubtreeStream(self._adaptor, "rule via_path_element") try: try: # sdl92.g:973:9: ( via_path_element ( ',' via_path_element )* -> ( via_path_element )+ ) # sdl92.g:973:17: via_path_element ( ',' via_path_element )* pass self._state.following.append(self.FOLLOW_via_path_element_in_via_path10729) via_path_element460 = self.via_path_element() self._state.following.pop() if self._state.backtracking == 0: stream_via_path_element.add(via_path_element460.tree) # sdl92.g:973:34: ( ',' via_path_element )* while True: #loop160 alt160 = 2 LA160_0 = self.input.LA(1) if (LA160_0 == COMMA) : alt160 = 1 if alt160 == 1: # sdl92.g:973:35: ',' via_path_element pass char_literal461=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_via_path10732) if self._state.backtracking == 0: stream_COMMA.add(char_literal461) self._state.following.append(self.FOLLOW_via_path_element_in_via_path10734) via_path_element462 = self.via_path_element() self._state.following.pop() if self._state.backtracking == 0: stream_via_path_element.add(via_path_element462.tree) else: break #loop160 # 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() # 974:9: -> ( via_path_element )+ # sdl92.g:974: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:978: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 ID463 = None ID463_tree = None try: try: # sdl92.g:979:9: ( ID ) # sdl92.g:979:17: ID pass root_0 = self._adaptor.nil() ID463=self.match(self.input, ID, self.FOLLOW_ID_in_via_path_element10786) if self._state.backtracking == 0: ID463_tree = self._adaptor.createWithPayload(ID463) self._adaptor.addChild(root_0, ID463_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:983: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_literal464 = None char_literal466 = None char_literal468 = None expression465 = None expression467 = None char_literal464_tree = None char_literal466_tree = None char_literal468_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:984:9: ( '(' expression ( ',' expression )* ')' -> ^( PARAMS ( expression )+ ) ) # sdl92.g:984:16: '(' expression ( ',' expression )* ')' pass char_literal464=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_actual_parameters10818) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal464) self._state.following.append(self.FOLLOW_expression_in_actual_parameters10820) expression465 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression465.tree) # sdl92.g:984:31: ( ',' expression )* while True: #loop161 alt161 = 2 LA161_0 = self.input.LA(1) if (LA161_0 == COMMA) : alt161 = 1 if alt161 == 1: # sdl92.g:984:32: ',' expression pass char_literal466=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_actual_parameters10823) if self._state.backtracking == 0: stream_COMMA.add(char_literal466) self._state.following.append(self.FOLLOW_expression_in_actual_parameters10825) expression467 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression467.tree) else: break #loop161 char_literal468=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_actual_parameters10829) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal468) # 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() # 985:9: -> ^( PARAMS ( expression )+ ) # sdl92.g:985:16: ^( PARAMS ( expression )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(PARAMS, "PARAMS"), root_1) # sdl92.g:985: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:989: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 TASK471 = None cif469 = None hyperlink470 = None task_body472 = None end473 = None TASK471_tree = None stream_TASK = RewriteRuleTokenStream(self._adaptor, "token TASK") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_task_body = RewriteRuleSubtreeStream(self._adaptor, "rule task_body") try: try: # sdl92.g:990:9: ( ( cif )? ( hyperlink )? TASK ( task_body )? end -> ^( TASK ( cif )? ( hyperlink )? ( end )? ( task_body )? ) ) # sdl92.g:990:17: ( cif )? ( hyperlink )? TASK ( task_body )? end pass # sdl92.g:990:17: ( cif )? alt162 = 2 LA162_0 = self.input.LA(1) if (LA162_0 == 228) : LA162_1 = self.input.LA(2) if (LA162_1 == ANSWER or LA162_1 == COMMENT or LA162_1 == CONNECT or LA162_1 == DECISION or LA162_1 == INPUT or (JOIN <= LA162_1 <= LABEL) or LA162_1 == NEXTSTATE or LA162_1 == OUTPUT or (PROCEDURE <= LA162_1 <= PROCEDURE_CALL) or (PROCESS <= LA162_1 <= PROVIDED) or LA162_1 == RETURN or LA162_1 == STATE or LA162_1 == STOP or LA162_1 == TASK or LA162_1 == TEXT or LA162_1 == START) : alt162 = 1 if alt162 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_task10882) cif469 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif469.tree) # sdl92.g:991:17: ( hyperlink )? alt163 = 2 LA163_0 = self.input.LA(1) if (LA163_0 == 228) : alt163 = 1 if alt163 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_task10901) hyperlink470 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink470.tree) TASK471=self.match(self.input, TASK, self.FOLLOW_TASK_in_task10920) if self._state.backtracking == 0: stream_TASK.add(TASK471) # sdl92.g:992:22: ( task_body )? alt164 = 2 LA164_0 = self.input.LA(1) if (LA164_0 == FOR or LA164_0 == STRING or LA164_0 == ID) : alt164 = 1 if alt164 == 1: # sdl92.g:0:0: task_body pass self._state.following.append(self.FOLLOW_task_body_in_task10922) task_body472 = self.task_body() self._state.following.pop() if self._state.backtracking == 0: stream_task_body.add(task_body472.tree) self._state.following.append(self.FOLLOW_end_in_task10925) end473 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end473.tree) # AST Rewrite # elements: task_body, hyperlink, TASK, end, 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() # 993:9: -> ^( TASK ( cif )? ( hyperlink )? ( end )? ( task_body )? ) # sdl92.g:993:17: ^( TASK ( cif )? ( hyperlink )? ( end )? ( task_body )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_TASK.nextNode(), root_1) # sdl92.g:993:24: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:993:29: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:993:40: ( end )? if stream_end.hasNext(): self._adaptor.addChild(root_1, stream_end.nextTree()) stream_end.reset(); # sdl92.g:993: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:997: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_literal475 = None char_literal478 = None char_literal481 = None assignement_statement474 = None assignement_statement476 = None informal_text477 = None informal_text479 = None forloop480 = None forloop482 = None char_literal475_tree = None char_literal478_tree = None char_literal481_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_forloop = RewriteRuleSubtreeStream(self._adaptor, "rule forloop") stream_informal_text = RewriteRuleSubtreeStream(self._adaptor, "rule informal_text") stream_assignement_statement = RewriteRuleSubtreeStream(self._adaptor, "rule assignement_statement") try: try: # sdl92.g:998:9: ( ( assignement_statement ( ',' assignement_statement )* ) -> ^( TASK_BODY ( assignement_statement )+ ) | ( informal_text ( ',' informal_text )* ) -> ^( TASK_BODY ( informal_text )+ ) | ( forloop ( ',' forloop )* ) -> ^( TASK_BODY ( forloop )+ ) ) alt168 = 3 LA168 = self.input.LA(1) if LA168 == ID: alt168 = 1 elif LA168 == STRING: alt168 = 2 elif LA168 == FOR: alt168 = 3 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 168, 0, self.input) raise nvae if alt168 == 1: # sdl92.g:998:17: ( assignement_statement ( ',' assignement_statement )* ) pass # sdl92.g:998:17: ( assignement_statement ( ',' assignement_statement )* ) # sdl92.g:998:18: assignement_statement ( ',' assignement_statement )* pass self._state.following.append(self.FOLLOW_assignement_statement_in_task_body10989) assignement_statement474 = self.assignement_statement() self._state.following.pop() if self._state.backtracking == 0: stream_assignement_statement.add(assignement_statement474.tree) # sdl92.g:998:40: ( ',' assignement_statement )* while True: #loop165 alt165 = 2 LA165_0 = self.input.LA(1) if (LA165_0 == COMMA) : alt165 = 1 if alt165 == 1: # sdl92.g:998:41: ',' assignement_statement pass char_literal475=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_task_body10992) if self._state.backtracking == 0: stream_COMMA.add(char_literal475) self._state.following.append(self.FOLLOW_assignement_statement_in_task_body10994) assignement_statement476 = self.assignement_statement() self._state.following.pop() if self._state.backtracking == 0: stream_assignement_statement.add(assignement_statement476.tree) else: break #loop165 # 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() # 999:9: -> ^( TASK_BODY ( assignement_statement )+ ) # sdl92.g:999: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:999: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 alt168 == 2: # sdl92.g:1000:19: ( informal_text ( ',' informal_text )* ) pass # sdl92.g:1000:19: ( informal_text ( ',' informal_text )* ) # sdl92.g:1000:20: informal_text ( ',' informal_text )* pass self._state.following.append(self.FOLLOW_informal_text_in_task_body11040) informal_text477 = self.informal_text() self._state.following.pop() if self._state.backtracking == 0: stream_informal_text.add(informal_text477.tree) # sdl92.g:1000:34: ( ',' informal_text )* while True: #loop166 alt166 = 2 LA166_0 = self.input.LA(1) if (LA166_0 == COMMA) : alt166 = 1 if alt166 == 1: # sdl92.g:1000:35: ',' informal_text pass char_literal478=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_task_body11043) if self._state.backtracking == 0: stream_COMMA.add(char_literal478) self._state.following.append(self.FOLLOW_informal_text_in_task_body11045) informal_text479 = self.informal_text() self._state.following.pop() if self._state.backtracking == 0: stream_informal_text.add(informal_text479.tree) else: break #loop166 # 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() # 1001:9: -> ^( TASK_BODY ( informal_text )+ ) # sdl92.g:1001: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:1001: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 alt168 == 3: # sdl92.g:1002:19: ( forloop ( ',' forloop )* ) pass # sdl92.g:1002:19: ( forloop ( ',' forloop )* ) # sdl92.g:1002:20: forloop ( ',' forloop )* pass self._state.following.append(self.FOLLOW_forloop_in_task_body11091) forloop480 = self.forloop() self._state.following.pop() if self._state.backtracking == 0: stream_forloop.add(forloop480.tree) # sdl92.g:1002:28: ( ',' forloop )* while True: #loop167 alt167 = 2 LA167_0 = self.input.LA(1) if (LA167_0 == COMMA) : alt167 = 1 if alt167 == 1: # sdl92.g:1002:29: ',' forloop pass char_literal481=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_task_body11094) if self._state.backtracking == 0: stream_COMMA.add(char_literal481) self._state.following.append(self.FOLLOW_forloop_in_task_body11096) forloop482 = self.forloop() self._state.following.pop() if self._state.backtracking == 0: stream_forloop.add(forloop482.tree) else: break #loop167 # 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() # 1003:9: -> ^( TASK_BODY ( forloop )+ ) # sdl92.g:1003: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:1003: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:1008: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 FOR483 = None IN485 = None char_literal488 = None ENDFOR490 = None variable_id484 = None range486 = None variable487 = None transition489 = None FOR483_tree = None IN485_tree = None char_literal488_tree = None ENDFOR490_tree = None stream_223 = RewriteRuleTokenStream(self._adaptor, "token 223") stream_IN = RewriteRuleTokenStream(self._adaptor, "token IN") stream_ENDFOR = RewriteRuleTokenStream(self._adaptor, "token ENDFOR") stream_FOR = RewriteRuleTokenStream(self._adaptor, "token FOR") stream_variable_id = RewriteRuleSubtreeStream(self._adaptor, "rule variable_id") stream_variable = RewriteRuleSubtreeStream(self._adaptor, "rule variable") stream_range = RewriteRuleSubtreeStream(self._adaptor, "rule range") stream_transition = RewriteRuleSubtreeStream(self._adaptor, "rule transition") try: try: # sdl92.g:1009:9: ( FOR variable_id IN ( range | variable ) ':' ( transition )? ENDFOR -> ^( FOR variable_id ( variable )? ( range )? ( transition )? ) ) # sdl92.g:1009:17: FOR variable_id IN ( range | variable ) ':' ( transition )? ENDFOR pass FOR483=self.match(self.input, FOR, self.FOLLOW_FOR_in_forloop11154) if self._state.backtracking == 0: stream_FOR.add(FOR483) self._state.following.append(self.FOLLOW_variable_id_in_forloop11156) variable_id484 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: stream_variable_id.add(variable_id484.tree) IN485=self.match(self.input, IN, self.FOLLOW_IN_in_forloop11158) if self._state.backtracking == 0: stream_IN.add(IN485) # sdl92.g:1009:36: ( range | variable ) alt169 = 2 LA169_0 = self.input.LA(1) if (LA169_0 == RANGE) : alt169 = 1 elif (LA169_0 == ID) : alt169 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 169, 0, self.input) raise nvae if alt169 == 1: # sdl92.g:1009:37: range pass self._state.following.append(self.FOLLOW_range_in_forloop11161) range486 = self.range() self._state.following.pop() if self._state.backtracking == 0: stream_range.add(range486.tree) elif alt169 == 2: # sdl92.g:1009:45: variable pass self._state.following.append(self.FOLLOW_variable_in_forloop11165) variable487 = self.variable() self._state.following.pop() if self._state.backtracking == 0: stream_variable.add(variable487.tree) char_literal488=self.match(self.input, 223, self.FOLLOW_223_in_forloop11168) if self._state.backtracking == 0: stream_223.add(char_literal488) # sdl92.g:1010:17: ( transition )? alt170 = 2 LA170_0 = self.input.LA(1) if (LA170_0 == ALTERNATIVE or LA170_0 == DECISION or LA170_0 == EXPORT or LA170_0 == FOR or LA170_0 == JOIN or LA170_0 == NEXTSTATE or LA170_0 == OUTPUT or (RESET <= LA170_0 <= RETURN) or LA170_0 == SET or LA170_0 == STOP or LA170_0 == STRING or LA170_0 == TASK or LA170_0 == ID or LA170_0 == CALL or LA170_0 == CREATE or LA170_0 == 228) : alt170 = 1 if alt170 == 1: # sdl92.g:0:0: transition pass self._state.following.append(self.FOLLOW_transition_in_forloop11186) transition489 = self.transition() self._state.following.pop() if self._state.backtracking == 0: stream_transition.add(transition489.tree) ENDFOR490=self.match(self.input, ENDFOR, self.FOLLOW_ENDFOR_in_forloop11205) if self._state.backtracking == 0: stream_ENDFOR.add(ENDFOR490) # AST Rewrite # elements: transition, variable, range, FOR, 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() # 1012:9: -> ^( FOR variable_id ( variable )? ( range )? ( transition )? ) # sdl92.g:1012: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:1012:35: ( variable )? if stream_variable.hasNext(): self._adaptor.addChild(root_1, stream_variable.nextTree()) stream_variable.reset(); # sdl92.g:1012:45: ( range )? if stream_range.hasNext(): self._adaptor.addChild(root_1, stream_range.nextTree()) stream_range.reset(); # sdl92.g:1012: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:1014: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 RANGE491 = None L_PAREN492 = None COMMA493 = None COMMA494 = None R_PAREN495 = None a = None b = None step_tree = None RANGE491_tree = None L_PAREN492_tree = None COMMA493_tree = None COMMA494_tree = None R_PAREN495_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_INT = RewriteRuleTokenStream(self._adaptor, "token INT") stream_RANGE = RewriteRuleTokenStream(self._adaptor, "token RANGE") stream_ground_expression = RewriteRuleSubtreeStream(self._adaptor, "rule ground_expression") try: try: # sdl92.g:1015:9: ( RANGE L_PAREN a= ground_expression ( COMMA b= ground_expression )? ( COMMA step= INT )? R_PAREN -> ^( RANGE $a ( $b)? ( $step)? ) ) # sdl92.g:1015:17: RANGE L_PAREN a= ground_expression ( COMMA b= ground_expression )? ( COMMA step= INT )? R_PAREN pass RANGE491=self.match(self.input, RANGE, self.FOLLOW_RANGE_in_range11257) if self._state.backtracking == 0: stream_RANGE.add(RANGE491) L_PAREN492=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_range11275) if self._state.backtracking == 0: stream_L_PAREN.add(L_PAREN492) self._state.following.append(self.FOLLOW_ground_expression_in_range11279) a = self.ground_expression() self._state.following.pop() if self._state.backtracking == 0: stream_ground_expression.add(a.tree) # sdl92.g:1017:17: ( COMMA b= ground_expression )? alt171 = 2 LA171_0 = self.input.LA(1) if (LA171_0 == COMMA) : LA171_1 = self.input.LA(2) if (LA171_1 == INT) : LA171_3 = self.input.LA(3) if (self.synpred217_sdl92()) : alt171 = 1 elif (LA171_1 == FLOAT or LA171_1 == IF or LA171_1 == STATE or LA171_1 == STRING or LA171_1 == ID or LA171_1 == L_PAREN or LA171_1 == DASH or (NOT <= LA171_1 <= MINUS_INFINITY) or LA171_1 == L_BRACKET) : alt171 = 1 if alt171 == 1: # sdl92.g:1017:18: COMMA b= ground_expression pass COMMA493=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_range11298) if self._state.backtracking == 0: stream_COMMA.add(COMMA493) self._state.following.append(self.FOLLOW_ground_expression_in_range11302) b = self.ground_expression() self._state.following.pop() if self._state.backtracking == 0: stream_ground_expression.add(b.tree) # sdl92.g:1017:46: ( COMMA step= INT )? alt172 = 2 LA172_0 = self.input.LA(1) if (LA172_0 == COMMA) : alt172 = 1 if alt172 == 1: # sdl92.g:1017:47: COMMA step= INT pass COMMA494=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_range11307) if self._state.backtracking == 0: stream_COMMA.add(COMMA494) step=self.match(self.input, INT, self.FOLLOW_INT_in_range11311) if self._state.backtracking == 0: stream_INT.add(step) R_PAREN495=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_range11331) if self._state.backtracking == 0: stream_R_PAREN.add(R_PAREN495) # AST Rewrite # elements: RANGE, step, a, b # token labels: step # rule labels: a, b, retval # 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 a is not None: stream_a = RewriteRuleSubtreeStream(self._adaptor, "rule a", a.tree) else: stream_a = RewriteRuleSubtreeStream(self._adaptor, "token a", 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 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() # 1019:9: -> ^( RANGE $a ( $b)? ( $step)? ) # sdl92.g:1019: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:1019:28: ( $b)? if stream_b.hasNext(): self._adaptor.addChild(root_1, stream_b.nextTree()) stream_b.reset(); # sdl92.g:1019: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:1021: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_literal497 = None variable496 = None expression498 = None string_literal497_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:1022:9: ( variable ':=' expression -> ^( ASSIGN variable expression ) ) # sdl92.g:1022:17: variable ':=' expression pass self._state.following.append(self.FOLLOW_variable_in_assignement_statement11383) variable496 = self.variable() self._state.following.pop() if self._state.backtracking == 0: stream_variable.add(variable496.tree) string_literal497=self.match(self.input, ASSIG_OP, self.FOLLOW_ASSIG_OP_in_assignement_statement11385) if self._state.backtracking == 0: stream_ASSIG_OP.add(string_literal497) self._state.following.append(self.FOLLOW_expression_in_assignement_statement11387) expression498 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression498.tree) # AST Rewrite # elements: variable, 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() # 1023:9: -> ^( ASSIGN variable expression ) # sdl92.g:1023: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:1027:1: variable : ( postfix_expression | ID -> ^( VARIABLE ID ) ); def variable(self, ): retval = self.variable_return() retval.start = self.input.LT(1) root_0 = None ID500 = None postfix_expression499 = None ID500_tree = None stream_ID = RewriteRuleTokenStream(self._adaptor, "token ID") try: try: # sdl92.g:1028:9: ( postfix_expression | ID -> ^( VARIABLE ID ) ) alt173 = 2 LA173_0 = self.input.LA(1) if (LA173_0 == ID) : LA173_1 = self.input.LA(2) if (LA173_1 == L_PAREN or LA173_1 == DOT or LA173_1 == 225) : alt173 = 1 elif (LA173_1 == ASSIG_OP or LA173_1 == 223) : alt173 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 173, 1, self.input) raise nvae else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 173, 0, self.input) raise nvae if alt173 == 1: # sdl92.g:1028:17: postfix_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_postfix_expression_in_variable11434) postfix_expression499 = self.postfix_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, postfix_expression499.tree) elif alt173 == 2: # sdl92.g:1029:17: ID pass ID500=self.match(self.input, ID, self.FOLLOW_ID_in_variable11452) if self._state.backtracking == 0: stream_ID.add(ID500) # 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() # 1029:40: -> ^( VARIABLE ID ) # sdl92.g:1029: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:1032:1: field_selection : ( ( '!' | DOT ) field_name ) ; def field_selection(self, ): retval = self.field_selection_return() retval.start = self.input.LT(1) root_0 = None set501 = None field_name502 = None set501_tree = None try: try: # sdl92.g:1033:9: ( ( ( '!' | DOT ) field_name ) ) # sdl92.g:1033:17: ( ( '!' | DOT ) field_name ) pass root_0 = self._adaptor.nil() # sdl92.g:1033:17: ( ( '!' | DOT ) field_name ) # sdl92.g:1033:18: ( '!' | DOT ) field_name pass set501 = 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(set501)) 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_selection11513) field_name502 = self.field_name() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, field_name502.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:1036:1: expression : binary_expression ; def expression(self, ): retval = self.expression_return() retval.start = self.input.LT(1) root_0 = None binary_expression503 = None try: try: # sdl92.g:1037:9: ( binary_expression ) # sdl92.g:1037:17: binary_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_binary_expression_in_expression11537) binary_expression503 = self.binary_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression503.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:1040: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 IMPLIES505 = None binary_expression_0504 = None binary_expression_0506 = None IMPLIES505_tree = None try: try: # sdl92.g:1041:9: ( binary_expression_0 ( IMPLIES binary_expression_0 )* ) # sdl92.g:1041: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_expression11560) binary_expression_0504 = self.binary_expression_0() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_0504.tree) # sdl92.g:1041:37: ( IMPLIES binary_expression_0 )* while True: #loop174 alt174 = 2 LA174_0 = self.input.LA(1) if (LA174_0 == IMPLIES) : LA174_2 = self.input.LA(2) if (self.synpred221_sdl92()) : alt174 = 1 if alt174 == 1: # sdl92.g:1041:39: IMPLIES binary_expression_0 pass IMPLIES505=self.match(self.input, IMPLIES, self.FOLLOW_IMPLIES_in_binary_expression11564) if self._state.backtracking == 0: IMPLIES505_tree = self._adaptor.createWithPayload(IMPLIES505) root_0 = self._adaptor.becomeRoot(IMPLIES505_tree, root_0) self._state.following.append(self.FOLLOW_binary_expression_0_in_binary_expression11567) binary_expression_0506 = self.binary_expression_0() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_0506.tree) else: break #loop174 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:1042: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 OR508 = None ELSE509 = None XOR510 = None binary_expression_1507 = None binary_expression_1511 = None OR508_tree = None ELSE509_tree = None XOR510_tree = None try: try: # sdl92.g:1043:9: ( binary_expression_1 ( ( ( OR ( ELSE )? ) | XOR ) binary_expression_1 )* ) # sdl92.g:1043: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_011590) binary_expression_1507 = self.binary_expression_1() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_1507.tree) # sdl92.g:1043:37: ( ( ( OR ( ELSE )? ) | XOR ) binary_expression_1 )* while True: #loop177 alt177 = 2 LA177_0 = self.input.LA(1) if (LA177_0 == OR) : LA177_2 = self.input.LA(2) if (self.synpred224_sdl92()) : alt177 = 1 elif (LA177_0 == XOR) : LA177_3 = self.input.LA(2) if (self.synpred224_sdl92()) : alt177 = 1 if alt177 == 1: # sdl92.g:1043:38: ( ( OR ( ELSE )? ) | XOR ) binary_expression_1 pass # sdl92.g:1043:38: ( ( OR ( ELSE )? ) | XOR ) alt176 = 2 LA176_0 = self.input.LA(1) if (LA176_0 == OR) : alt176 = 1 elif (LA176_0 == XOR) : alt176 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 176, 0, self.input) raise nvae if alt176 == 1: # sdl92.g:1043:40: ( OR ( ELSE )? ) pass # sdl92.g:1043:40: ( OR ( ELSE )? ) # sdl92.g:1043:41: OR ( ELSE )? pass OR508=self.match(self.input, OR, self.FOLLOW_OR_in_binary_expression_011596) if self._state.backtracking == 0: OR508_tree = self._adaptor.createWithPayload(OR508) root_0 = self._adaptor.becomeRoot(OR508_tree, root_0) # sdl92.g:1043:45: ( ELSE )? alt175 = 2 LA175_0 = self.input.LA(1) if (LA175_0 == ELSE) : alt175 = 1 if alt175 == 1: # sdl92.g:0:0: ELSE pass ELSE509=self.match(self.input, ELSE, self.FOLLOW_ELSE_in_binary_expression_011599) if self._state.backtracking == 0: ELSE509_tree = self._adaptor.createWithPayload(ELSE509) self._adaptor.addChild(root_0, ELSE509_tree) elif alt176 == 2: # sdl92.g:1043:54: XOR pass XOR510=self.match(self.input, XOR, self.FOLLOW_XOR_in_binary_expression_011605) if self._state.backtracking == 0: XOR510_tree = self._adaptor.createWithPayload(XOR510) root_0 = self._adaptor.becomeRoot(XOR510_tree, root_0) self._state.following.append(self.FOLLOW_binary_expression_1_in_binary_expression_011610) binary_expression_1511 = self.binary_expression_1() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_1511.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_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:1044: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 AND513 = None THEN514 = None binary_expression_2512 = None binary_expression_2515 = None AND513_tree = None THEN514_tree = None try: try: # sdl92.g:1045:9: ( binary_expression_2 ( AND ( THEN )? binary_expression_2 )* ) # sdl92.g:1045: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_111633) binary_expression_2512 = self.binary_expression_2() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_2512.tree) # sdl92.g:1045:37: ( AND ( THEN )? binary_expression_2 )* while True: #loop179 alt179 = 2 LA179_0 = self.input.LA(1) if (LA179_0 == AND) : LA179_2 = self.input.LA(2) if (self.synpred226_sdl92()) : alt179 = 1 if alt179 == 1: # sdl92.g:1045:39: AND ( THEN )? binary_expression_2 pass AND513=self.match(self.input, AND, self.FOLLOW_AND_in_binary_expression_111637) if self._state.backtracking == 0: AND513_tree = self._adaptor.createWithPayload(AND513) root_0 = self._adaptor.becomeRoot(AND513_tree, root_0) # sdl92.g:1045:44: ( THEN )? alt178 = 2 LA178_0 = self.input.LA(1) if (LA178_0 == THEN) : alt178 = 1 if alt178 == 1: # sdl92.g:0:0: THEN pass THEN514=self.match(self.input, THEN, self.FOLLOW_THEN_in_binary_expression_111640) if self._state.backtracking == 0: THEN514_tree = self._adaptor.createWithPayload(THEN514) self._adaptor.addChild(root_0, THEN514_tree) self._state.following.append(self.FOLLOW_binary_expression_2_in_binary_expression_111643) binary_expression_2515 = self.binary_expression_2() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_2515.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_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:1046: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 EQ517 = None NEQ518 = None GT519 = None GE520 = None LT521 = None LE522 = None IN523 = None binary_expression_3516 = None binary_expression_3524 = None EQ517_tree = None NEQ518_tree = None GT519_tree = None GE520_tree = None LT521_tree = None LE522_tree = None IN523_tree = None try: try: # sdl92.g:1047:9: ( binary_expression_3 ( ( EQ | NEQ | GT | GE | LT | LE | IN ) binary_expression_3 )* ) # sdl92.g:1047: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_211666) binary_expression_3516 = self.binary_expression_3() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_3516.tree) # sdl92.g:1047:37: ( ( EQ | NEQ | GT | GE | LT | LE | IN ) binary_expression_3 )* while True: #loop181 alt181 = 2 alt181 = self.dfa181.predict(self.input) if alt181 == 1: # sdl92.g:1047:38: ( EQ | NEQ | GT | GE | LT | LE | IN ) binary_expression_3 pass # sdl92.g:1047:38: ( EQ | NEQ | GT | GE | LT | LE | IN ) alt180 = 7 LA180 = self.input.LA(1) if LA180 == EQ: alt180 = 1 elif LA180 == NEQ: alt180 = 2 elif LA180 == GT: alt180 = 3 elif LA180 == GE: alt180 = 4 elif LA180 == LT: alt180 = 5 elif LA180 == LE: alt180 = 6 elif LA180 == IN: alt180 = 7 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 180, 0, self.input) raise nvae if alt180 == 1: # sdl92.g:1047:40: EQ pass EQ517=self.match(self.input, EQ, self.FOLLOW_EQ_in_binary_expression_211671) if self._state.backtracking == 0: EQ517_tree = self._adaptor.createWithPayload(EQ517) root_0 = self._adaptor.becomeRoot(EQ517_tree, root_0) elif alt180 == 2: # sdl92.g:1047:46: NEQ pass NEQ518=self.match(self.input, NEQ, self.FOLLOW_NEQ_in_binary_expression_211676) if self._state.backtracking == 0: NEQ518_tree = self._adaptor.createWithPayload(NEQ518) root_0 = self._adaptor.becomeRoot(NEQ518_tree, root_0) elif alt180 == 3: # sdl92.g:1047:53: GT pass GT519=self.match(self.input, GT, self.FOLLOW_GT_in_binary_expression_211681) if self._state.backtracking == 0: GT519_tree = self._adaptor.createWithPayload(GT519) root_0 = self._adaptor.becomeRoot(GT519_tree, root_0) elif alt180 == 4: # sdl92.g:1047:59: GE pass GE520=self.match(self.input, GE, self.FOLLOW_GE_in_binary_expression_211686) if self._state.backtracking == 0: GE520_tree = self._adaptor.createWithPayload(GE520) root_0 = self._adaptor.becomeRoot(GE520_tree, root_0) elif alt180 == 5: # sdl92.g:1047:65: LT pass LT521=self.match(self.input, LT, self.FOLLOW_LT_in_binary_expression_211691) if self._state.backtracking == 0: LT521_tree = self._adaptor.createWithPayload(LT521) root_0 = self._adaptor.becomeRoot(LT521_tree, root_0) elif alt180 == 6: # sdl92.g:1047:71: LE pass LE522=self.match(self.input, LE, self.FOLLOW_LE_in_binary_expression_211696) if self._state.backtracking == 0: LE522_tree = self._adaptor.createWithPayload(LE522) root_0 = self._adaptor.becomeRoot(LE522_tree, root_0) elif alt180 == 7: # sdl92.g:1047:77: IN pass IN523=self.match(self.input, IN, self.FOLLOW_IN_in_binary_expression_211701) if self._state.backtracking == 0: IN523_tree = self._adaptor.createWithPayload(IN523) root_0 = self._adaptor.becomeRoot(IN523_tree, root_0) self._state.following.append(self.FOLLOW_binary_expression_3_in_binary_expression_211706) binary_expression_3524 = self.binary_expression_3() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_3524.tree) else: break #loop181 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:1048: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 PLUS526 = None DASH527 = None APPEND528 = None binary_expression_4525 = None binary_expression_4529 = None PLUS526_tree = None DASH527_tree = None APPEND528_tree = None try: try: # sdl92.g:1049:9: ( binary_expression_4 ( ( PLUS | DASH | APPEND ) binary_expression_4 )* ) # sdl92.g:1049: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_311729) binary_expression_4525 = self.binary_expression_4() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_4525.tree) # sdl92.g:1049:37: ( ( PLUS | DASH | APPEND ) binary_expression_4 )* while True: #loop183 alt183 = 2 LA183 = self.input.LA(1) if LA183 == PLUS: LA183_2 = self.input.LA(2) if (self.synpred236_sdl92()) : alt183 = 1 elif LA183 == DASH: LA183_3 = self.input.LA(2) if (self.synpred236_sdl92()) : alt183 = 1 elif LA183 == APPEND: LA183_4 = self.input.LA(2) if (self.synpred236_sdl92()) : alt183 = 1 if alt183 == 1: # sdl92.g:1049:38: ( PLUS | DASH | APPEND ) binary_expression_4 pass # sdl92.g:1049:38: ( PLUS | DASH | APPEND ) alt182 = 3 LA182 = self.input.LA(1) if LA182 == PLUS: alt182 = 1 elif LA182 == DASH: alt182 = 2 elif LA182 == APPEND: alt182 = 3 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 182, 0, self.input) raise nvae if alt182 == 1: # sdl92.g:1049:40: PLUS pass PLUS526=self.match(self.input, PLUS, self.FOLLOW_PLUS_in_binary_expression_311734) if self._state.backtracking == 0: PLUS526_tree = self._adaptor.createWithPayload(PLUS526) root_0 = self._adaptor.becomeRoot(PLUS526_tree, root_0) elif alt182 == 2: # sdl92.g:1049:48: DASH pass DASH527=self.match(self.input, DASH, self.FOLLOW_DASH_in_binary_expression_311739) if self._state.backtracking == 0: DASH527_tree = self._adaptor.createWithPayload(DASH527) root_0 = self._adaptor.becomeRoot(DASH527_tree, root_0) elif alt182 == 3: # sdl92.g:1049:56: APPEND pass APPEND528=self.match(self.input, APPEND, self.FOLLOW_APPEND_in_binary_expression_311744) if self._state.backtracking == 0: APPEND528_tree = self._adaptor.createWithPayload(APPEND528) root_0 = self._adaptor.becomeRoot(APPEND528_tree, root_0) self._state.following.append(self.FOLLOW_binary_expression_4_in_binary_expression_311749) binary_expression_4529 = self.binary_expression_4() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, binary_expression_4529.tree) else: break #loop183 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:1050: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 ASTERISK531 = None DIV532 = None MOD533 = None REM534 = None unary_expression530 = None unary_expression535 = None ASTERISK531_tree = None DIV532_tree = None MOD533_tree = None REM534_tree = None try: try: # sdl92.g:1051:9: ( unary_expression ( ( ASTERISK | DIV | MOD | REM ) unary_expression )* ) # sdl92.g:1051: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_411772) unary_expression530 = self.unary_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, unary_expression530.tree) # sdl92.g:1051:34: ( ( ASTERISK | DIV | MOD | REM ) unary_expression )* while True: #loop185 alt185 = 2 LA185 = self.input.LA(1) if LA185 == ASTERISK: LA185_2 = self.input.LA(2) if (self.synpred240_sdl92()) : alt185 = 1 elif LA185 == DIV: LA185_3 = self.input.LA(2) if (self.synpred240_sdl92()) : alt185 = 1 elif LA185 == MOD: LA185_4 = self.input.LA(2) if (self.synpred240_sdl92()) : alt185 = 1 elif LA185 == REM: LA185_5 = self.input.LA(2) if (self.synpred240_sdl92()) : alt185 = 1 if alt185 == 1: # sdl92.g:1051:35: ( ASTERISK | DIV | MOD | REM ) unary_expression pass # sdl92.g:1051:35: ( ASTERISK | DIV | MOD | REM ) alt184 = 4 LA184 = self.input.LA(1) if LA184 == ASTERISK: alt184 = 1 elif LA184 == DIV: alt184 = 2 elif LA184 == MOD: alt184 = 3 elif LA184 == REM: alt184 = 4 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 184, 0, self.input) raise nvae if alt184 == 1: # sdl92.g:1051:37: ASTERISK pass ASTERISK531=self.match(self.input, ASTERISK, self.FOLLOW_ASTERISK_in_binary_expression_411777) if self._state.backtracking == 0: ASTERISK531_tree = self._adaptor.createWithPayload(ASTERISK531) root_0 = self._adaptor.becomeRoot(ASTERISK531_tree, root_0) elif alt184 == 2: # sdl92.g:1051:49: DIV pass DIV532=self.match(self.input, DIV, self.FOLLOW_DIV_in_binary_expression_411782) if self._state.backtracking == 0: DIV532_tree = self._adaptor.createWithPayload(DIV532) root_0 = self._adaptor.becomeRoot(DIV532_tree, root_0) elif alt184 == 3: # sdl92.g:1051:56: MOD pass MOD533=self.match(self.input, MOD, self.FOLLOW_MOD_in_binary_expression_411787) if self._state.backtracking == 0: MOD533_tree = self._adaptor.createWithPayload(MOD533) root_0 = self._adaptor.becomeRoot(MOD533_tree, root_0) elif alt184 == 4: # sdl92.g:1051:63: REM pass REM534=self.match(self.input, REM, self.FOLLOW_REM_in_binary_expression_411792) if self._state.backtracking == 0: REM534_tree = self._adaptor.createWithPayload(REM534) root_0 = self._adaptor.becomeRoot(REM534_tree, root_0) self._state.following.append(self.FOLLOW_unary_expression_in_binary_expression_411797) unary_expression535 = self.unary_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, unary_expression535.tree) else: break #loop185 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:1054: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 NOT538 = None DASH540 = None postfix_expression536 = None primary_expression537 = None unary_expression539 = None unary_expression541 = None NOT538_tree = None DASH540_tree = None stream_DASH = RewriteRuleTokenStream(self._adaptor, "token DASH") stream_unary_expression = RewriteRuleSubtreeStream(self._adaptor, "rule unary_expression") try: try: # sdl92.g:1055:9: ( postfix_expression | primary_expression | NOT unary_expression | DASH unary_expression -> ^( NEG unary_expression ) ) alt186 = 4 alt186 = self.dfa186.predict(self.input) if alt186 == 1: # sdl92.g:1055:17: postfix_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_postfix_expression_in_unary_expression11822) postfix_expression536 = self.postfix_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, postfix_expression536.tree) elif alt186 == 2: # sdl92.g:1056:17: primary_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_primary_expression_in_unary_expression11840) primary_expression537 = self.primary_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, primary_expression537.tree) elif alt186 == 3: # sdl92.g:1057:17: NOT unary_expression pass root_0 = self._adaptor.nil() NOT538=self.match(self.input, NOT, self.FOLLOW_NOT_in_unary_expression11858) if self._state.backtracking == 0: NOT538_tree = self._adaptor.createWithPayload(NOT538) root_0 = self._adaptor.becomeRoot(NOT538_tree, root_0) self._state.following.append(self.FOLLOW_unary_expression_in_unary_expression11861) unary_expression539 = self.unary_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, unary_expression539.tree) elif alt186 == 4: # sdl92.g:1058:17: DASH unary_expression pass DASH540=self.match(self.input, DASH, self.FOLLOW_DASH_in_unary_expression11879) if self._state.backtracking == 0: stream_DASH.add(DASH540) self._state.following.append(self.FOLLOW_unary_expression_in_unary_expression11881) unary_expression541 = self.unary_expression() self._state.following.pop() if self._state.backtracking == 0: stream_unary_expression.add(unary_expression541.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() # 1058:39: -> ^( NEG unary_expression ) # sdl92.g:1058: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:1062:1: postfix_expression : ( ID -> ^( PRIMARY ^( VARIABLE ID ) ) ) ( '(' params= expression_list ')' -> ^( CALL $postfix_expression ^( PARAMS $params) ) | ( '!' | DOT ) 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 ID542 = None char_literal543 = None char_literal544 = None char_literal545 = None DOT546 = None params = None field_name547 = None ID542_tree = None char_literal543_tree = None char_literal544_tree = None char_literal545_tree = None DOT546_tree = None stream_225 = RewriteRuleTokenStream(self._adaptor, "token 225") stream_DOT = RewriteRuleTokenStream(self._adaptor, "token DOT") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_ID = RewriteRuleTokenStream(self._adaptor, "token ID") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_expression_list = RewriteRuleSubtreeStream(self._adaptor, "rule expression_list") stream_field_name = RewriteRuleSubtreeStream(self._adaptor, "rule field_name") try: try: # sdl92.g:1063:9: ( ( ID -> ^( PRIMARY ^( VARIABLE ID ) ) ) ( '(' params= expression_list ')' -> ^( CALL $postfix_expression ^( PARAMS $params) ) | ( '!' | DOT ) field_name -> ^( SELECTOR $postfix_expression field_name ) )+ ) # sdl92.g:1063:17: ( ID -> ^( PRIMARY ^( VARIABLE ID ) ) ) ( '(' params= expression_list ')' -> ^( CALL $postfix_expression ^( PARAMS $params) ) | ( '!' | DOT ) field_name -> ^( SELECTOR $postfix_expression field_name ) )+ pass # sdl92.g:1063:17: ( ID -> ^( PRIMARY ^( VARIABLE ID ) ) ) # sdl92.g:1063:18: ID pass ID542=self.match(self.input, ID, self.FOLLOW_ID_in_postfix_expression11922) if self._state.backtracking == 0: stream_ID.add(ID542) # 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() # 1063:21: -> ^( PRIMARY ^( VARIABLE ID ) ) # sdl92.g:1063:24: ^( PRIMARY ^( VARIABLE ID ) ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(PRIMARY, "PRIMARY"), root_1) # sdl92.g:1063: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:1064:17: ( '(' params= expression_list ')' -> ^( CALL $postfix_expression ^( PARAMS $params) ) | ( '!' | DOT ) field_name -> ^( SELECTOR $postfix_expression field_name ) )+ cnt188 = 0 while True: #loop188 alt188 = 3 alt188 = self.dfa188.predict(self.input) if alt188 == 1: # sdl92.g:1064:21: '(' params= expression_list ')' pass char_literal543=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_postfix_expression11957) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal543) self._state.following.append(self.FOLLOW_expression_list_in_postfix_expression11961) params = self.expression_list() self._state.following.pop() if self._state.backtracking == 0: stream_expression_list.add(params.tree) char_literal544=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_postfix_expression11963) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal544) # AST Rewrite # elements: params, postfix_expression # token labels: # rule labels: params, retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 if params is not None: stream_params = RewriteRuleSubtreeStream(self._adaptor, "rule params", params.tree) else: stream_params = RewriteRuleSubtreeStream(self._adaptor, "token params", 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() # 1065:17: -> ^( CALL $postfix_expression ^( PARAMS $params) ) # sdl92.g:1065:20: ^( 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:1065:47: ^( 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 alt188 == 2: # sdl92.g:1066:21: ( '!' | DOT ) field_name pass # sdl92.g:1066:21: ( '!' | DOT ) alt187 = 2 LA187_0 = self.input.LA(1) if (LA187_0 == 225) : alt187 = 1 elif (LA187_0 == DOT) : alt187 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 187, 0, self.input) raise nvae if alt187 == 1: # sdl92.g:1066:22: '!' pass char_literal545=self.match(self.input, 225, self.FOLLOW_225_in_postfix_expression12018) if self._state.backtracking == 0: stream_225.add(char_literal545) elif alt187 == 2: # sdl92.g:1066:28: DOT pass DOT546=self.match(self.input, DOT, self.FOLLOW_DOT_in_postfix_expression12022) if self._state.backtracking == 0: stream_DOT.add(DOT546) self._state.following.append(self.FOLLOW_field_name_in_postfix_expression12025) field_name547 = self.field_name() self._state.following.pop() if self._state.backtracking == 0: stream_field_name.add(field_name547.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() # 1067:17: -> ^( SELECTOR $postfix_expression field_name ) # sdl92.g:1067:20: ^( 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 cnt188 >= 1: break #loop188 if self._state.backtracking > 0: raise BacktrackingFailed eee = EarlyExitException(188, self.input) raise eee cnt188 += 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:1072: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_literal549 = None char_literal551 = None primary548 = None expression550 = None conditional_expression552 = None char_literal549_tree = None char_literal551_tree = None stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") stream_primary = RewriteRuleSubtreeStream(self._adaptor, "rule primary") try: try: # sdl92.g:1073:9: ( primary -> ^( PRIMARY primary ) | '(' expression ')' -> ^( PAREN expression ) | conditional_expression ) alt189 = 3 LA189 = self.input.LA(1) if LA189 == FLOAT or LA189 == STATE or LA189 == STRING or LA189 == ID or LA189 == INT or LA189 == TRUE or LA189 == FALSE or LA189 == PLUS_INFINITY or LA189 == MINUS_INFINITY or LA189 == L_BRACKET: alt189 = 1 elif LA189 == L_PAREN: alt189 = 2 elif LA189 == IF: alt189 = 3 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 189, 0, self.input) raise nvae if alt189 == 1: # sdl92.g:1073:17: primary pass self._state.following.append(self.FOLLOW_primary_in_primary_expression12103) primary548 = self.primary() self._state.following.pop() if self._state.backtracking == 0: stream_primary.add(primary548.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() # 1073:47: -> ^( PRIMARY primary ) # sdl92.g:1073: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 alt189 == 2: # sdl92.g:1074:17: '(' expression ')' pass char_literal549=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_primary_expression12151) if self._state.backtracking == 0: stream_L_PAREN.add(char_literal549) self._state.following.append(self.FOLLOW_expression_in_primary_expression12153) expression550 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression550.tree) char_literal551=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_primary_expression12155) if self._state.backtracking == 0: stream_R_PAREN.add(char_literal551) # 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() # 1074:47: -> ^( PAREN expression ) # sdl92.g:1074: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 alt189 == 3: # sdl92.g:1075:17: conditional_expression pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_conditional_expression_in_primary_expression12192) conditional_expression552 = self.conditional_expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, conditional_expression552.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:1079:1: primary : ( TRUE | FALSE | STRING | 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 )+ ) | '{' expression ( COMMA expression )* '}' -> ^( SEQOF ( expression )+ ) | STATE ); def primary(self, ): retval = self.primary_return() retval.start = self.input.LT(1) root_0 = None mant = None bas = None exp = None TRUE553 = None FALSE554 = None STRING555 = None PLUS_INFINITY556 = None MINUS_INFINITY557 = None INT558 = None FLOAT559 = None ID560 = None char_literal561 = None ID563 = None char_literal564 = None char_literal565 = None char_literal566 = None MANTISSA567 = None COMMA568 = None BASE569 = None COMMA570 = None EXPONENT571 = None char_literal572 = None char_literal573 = None COMMA575 = None char_literal577 = None char_literal578 = None COMMA580 = None char_literal582 = None STATE583 = None expression562 = None named_value574 = None named_value576 = None expression579 = None expression581 = None mant_tree = None bas_tree = None exp_tree = None TRUE553_tree = None FALSE554_tree = None STRING555_tree = None PLUS_INFINITY556_tree = None MINUS_INFINITY557_tree = None INT558_tree = None FLOAT559_tree = None ID560_tree = None char_literal561_tree = None ID563_tree = None char_literal564_tree = None char_literal565_tree = None char_literal566_tree = None MANTISSA567_tree = None COMMA568_tree = None BASE569_tree = None COMMA570_tree = None EXPONENT571_tree = None char_literal572_tree = None char_literal573_tree = None COMMA575_tree = None char_literal577_tree = None char_literal578_tree = None COMMA580_tree = None char_literal582_tree = None STATE583_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_223 = RewriteRuleTokenStream(self._adaptor, "token 223") stream_L_BRACKET = RewriteRuleTokenStream(self._adaptor, "token L_BRACKET") stream_MANTISSA = RewriteRuleTokenStream(self._adaptor, "token MANTISSA") stream_EXPONENT = RewriteRuleTokenStream(self._adaptor, "token EXPONENT") stream_ID = RewriteRuleTokenStream(self._adaptor, "token ID") stream_R_BRACKET = RewriteRuleTokenStream(self._adaptor, "token R_BRACKET") stream_INT = RewriteRuleTokenStream(self._adaptor, "token INT") stream_BASE = RewriteRuleTokenStream(self._adaptor, "token BASE") stream_named_value = RewriteRuleSubtreeStream(self._adaptor, "rule named_value") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:1080:9: ( TRUE | FALSE | STRING | 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 )+ ) | '{' expression ( COMMA expression )* '}' -> ^( SEQOF ( expression )+ ) | STATE ) alt192 = 14 alt192 = self.dfa192.predict(self.input) if alt192 == 1: # sdl92.g:1080:17: TRUE pass root_0 = self._adaptor.nil() TRUE553=self.match(self.input, TRUE, self.FOLLOW_TRUE_in_primary12224) if self._state.backtracking == 0: TRUE553_tree = self._adaptor.createWithPayload(TRUE553) root_0 = self._adaptor.becomeRoot(TRUE553_tree, root_0) elif alt192 == 2: # sdl92.g:1081:17: FALSE pass root_0 = self._adaptor.nil() FALSE554=self.match(self.input, FALSE, self.FOLLOW_FALSE_in_primary12243) if self._state.backtracking == 0: FALSE554_tree = self._adaptor.createWithPayload(FALSE554) root_0 = self._adaptor.becomeRoot(FALSE554_tree, root_0) elif alt192 == 3: # sdl92.g:1082:17: STRING pass root_0 = self._adaptor.nil() STRING555=self.match(self.input, STRING, self.FOLLOW_STRING_in_primary12262) if self._state.backtracking == 0: STRING555_tree = self._adaptor.createWithPayload(STRING555) self._adaptor.addChild(root_0, STRING555_tree) elif alt192 == 4: # sdl92.g:1083:17: PLUS_INFINITY pass root_0 = self._adaptor.nil() PLUS_INFINITY556=self.match(self.input, PLUS_INFINITY, self.FOLLOW_PLUS_INFINITY_in_primary12280) if self._state.backtracking == 0: PLUS_INFINITY556_tree = self._adaptor.createWithPayload(PLUS_INFINITY556) root_0 = self._adaptor.becomeRoot(PLUS_INFINITY556_tree, root_0) elif alt192 == 5: # sdl92.g:1084:17: MINUS_INFINITY pass root_0 = self._adaptor.nil() MINUS_INFINITY557=self.match(self.input, MINUS_INFINITY, self.FOLLOW_MINUS_INFINITY_in_primary12299) if self._state.backtracking == 0: MINUS_INFINITY557_tree = self._adaptor.createWithPayload(MINUS_INFINITY557) root_0 = self._adaptor.becomeRoot(MINUS_INFINITY557_tree, root_0) elif alt192 == 6: # sdl92.g:1085:17: INT pass root_0 = self._adaptor.nil() INT558=self.match(self.input, INT, self.FOLLOW_INT_in_primary12318) if self._state.backtracking == 0: INT558_tree = self._adaptor.createWithPayload(INT558) root_0 = self._adaptor.becomeRoot(INT558_tree, root_0) elif alt192 == 7: # sdl92.g:1086:17: FLOAT pass root_0 = self._adaptor.nil() FLOAT559=self.match(self.input, FLOAT, self.FOLLOW_FLOAT_in_primary12337) if self._state.backtracking == 0: FLOAT559_tree = self._adaptor.createWithPayload(FLOAT559) root_0 = self._adaptor.becomeRoot(FLOAT559_tree, root_0) elif alt192 == 8: # sdl92.g:1087:17: ID ':' expression pass ID560=self.match(self.input, ID, self.FOLLOW_ID_in_primary12356) if self._state.backtracking == 0: stream_ID.add(ID560) char_literal561=self.match(self.input, 223, self.FOLLOW_223_in_primary12358) if self._state.backtracking == 0: stream_223.add(char_literal561) self._state.following.append(self.FOLLOW_expression_in_primary12360) expression562 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression562.tree) # AST Rewrite # elements: expression, 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() # 1087:45: -> ^( CHOICE ID expression ) # sdl92.g:1087: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 alt192 == 9: # sdl92.g:1088:17: ID pass ID563=self.match(self.input, ID, self.FOLLOW_ID_in_primary12398) if self._state.backtracking == 0: stream_ID.add(ID563) # 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() # 1088:45: -> ^( VARIABLE ID ) # sdl92.g:1088: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 alt192 == 10: # sdl92.g:1089:17: '{' '}' pass char_literal564=self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_primary12449) if self._state.backtracking == 0: stream_L_BRACKET.add(char_literal564) char_literal565=self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_primary12451) if self._state.backtracking == 0: stream_R_BRACKET.add(char_literal565) # 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() # 1089:45: -> ^( EMPTYSTR ) # sdl92.g:1089: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 alt192 == 11: # sdl92.g:1090:17: '{' MANTISSA mant= INT COMMA BASE bas= INT COMMA EXPONENT exp= INT '}' pass char_literal566=self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_primary12495) if self._state.backtracking == 0: stream_L_BRACKET.add(char_literal566) MANTISSA567=self.match(self.input, MANTISSA, self.FOLLOW_MANTISSA_in_primary12513) if self._state.backtracking == 0: stream_MANTISSA.add(MANTISSA567) mant=self.match(self.input, INT, self.FOLLOW_INT_in_primary12517) if self._state.backtracking == 0: stream_INT.add(mant) COMMA568=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_primary12519) if self._state.backtracking == 0: stream_COMMA.add(COMMA568) BASE569=self.match(self.input, BASE, self.FOLLOW_BASE_in_primary12537) if self._state.backtracking == 0: stream_BASE.add(BASE569) bas=self.match(self.input, INT, self.FOLLOW_INT_in_primary12541) if self._state.backtracking == 0: stream_INT.add(bas) COMMA570=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_primary12543) if self._state.backtracking == 0: stream_COMMA.add(COMMA570) EXPONENT571=self.match(self.input, EXPONENT, self.FOLLOW_EXPONENT_in_primary12561) if self._state.backtracking == 0: stream_EXPONENT.add(EXPONENT571) exp=self.match(self.input, INT, self.FOLLOW_INT_in_primary12565) if self._state.backtracking == 0: stream_INT.add(exp) char_literal572=self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_primary12583) if self._state.backtracking == 0: stream_R_BRACKET.add(char_literal572) # AST Rewrite # elements: bas, mant, exp # token labels: bas, mant, exp # rule labels: retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 stream_bas = RewriteRuleTokenStream(self._adaptor, "token bas", bas) stream_mant = RewriteRuleTokenStream(self._adaptor, "token mant", mant) stream_exp = RewriteRuleTokenStream(self._adaptor, "token exp", exp) 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() # 1094:45: -> ^( FLOAT2 $mant $bas $exp) # sdl92.g:1094: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 alt192 == 12: # sdl92.g:1095:17: '{' named_value ( COMMA named_value )* '}' pass char_literal573=self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_primary12640) if self._state.backtracking == 0: stream_L_BRACKET.add(char_literal573) self._state.following.append(self.FOLLOW_named_value_in_primary12658) named_value574 = self.named_value() self._state.following.pop() if self._state.backtracking == 0: stream_named_value.add(named_value574.tree) # sdl92.g:1096:29: ( COMMA named_value )* while True: #loop190 alt190 = 2 LA190_0 = self.input.LA(1) if (LA190_0 == COMMA) : alt190 = 1 if alt190 == 1: # sdl92.g:1096:30: COMMA named_value pass COMMA575=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_primary12661) if self._state.backtracking == 0: stream_COMMA.add(COMMA575) self._state.following.append(self.FOLLOW_named_value_in_primary12663) named_value576 = self.named_value() self._state.following.pop() if self._state.backtracking == 0: stream_named_value.add(named_value576.tree) else: break #loop190 char_literal577=self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_primary12683) if self._state.backtracking == 0: stream_R_BRACKET.add(char_literal577) # 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() # 1097:45: -> ^( SEQUENCE ( named_value )+ ) # sdl92.g:1097:48: ^( SEQUENCE ( named_value )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(SEQUENCE, "SEQUENCE"), root_1) # sdl92.g:1097: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 alt192 == 13: # sdl92.g:1098:17: '{' expression ( COMMA expression )* '}' pass char_literal578=self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_primary12734) if self._state.backtracking == 0: stream_L_BRACKET.add(char_literal578) self._state.following.append(self.FOLLOW_expression_in_primary12752) expression579 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression579.tree) # sdl92.g:1099:28: ( COMMA expression )* while True: #loop191 alt191 = 2 LA191_0 = self.input.LA(1) if (LA191_0 == COMMA) : alt191 = 1 if alt191 == 1: # sdl92.g:1099:29: COMMA expression pass COMMA580=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_primary12755) if self._state.backtracking == 0: stream_COMMA.add(COMMA580) self._state.following.append(self.FOLLOW_expression_in_primary12757) expression581 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression581.tree) else: break #loop191 char_literal582=self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_primary12777) if self._state.backtracking == 0: stream_R_BRACKET.add(char_literal582) # 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() # 1100:45: -> ^( SEQOF ( expression )+ ) # sdl92.g:1100:48: ^( SEQOF ( expression )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(SEQOF, "SEQOF"), root_1) # sdl92.g:1100:56: ( 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 elif alt192 == 14: # sdl92.g:1101:17: STATE pass root_0 = self._adaptor.nil() STATE583=self.match(self.input, STATE, self.FOLLOW_STATE_in_primary12828) if self._state.backtracking == 0: STATE583_tree = self._adaptor.createWithPayload(STATE583) root_0 = self._adaptor.becomeRoot(STATE583_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:1105: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 STRING584 = None STRING584_tree = None stream_STRING = RewriteRuleTokenStream(self._adaptor, "token STRING") try: try: # sdl92.g:1106:9: ( STRING -> ^( INFORMAL_TEXT STRING ) ) # sdl92.g:1106:18: STRING pass STRING584=self.match(self.input, STRING, self.FOLLOW_STRING_in_informal_text12862) if self._state.backtracking == 0: stream_STRING.add(STRING584) # 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() # 1107:9: -> ^( INFORMAL_TEXT STRING ) # sdl92.g:1107: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:1112:1: named_value : ID expression ; def named_value(self, ): retval = self.named_value_return() retval.start = self.input.LT(1) root_0 = None ID585 = None expression586 = None ID585_tree = None try: try: # sdl92.g:1113:9: ( ID expression ) # sdl92.g:1113:17: ID expression pass root_0 = self._adaptor.nil() ID585=self.match(self.input, ID, self.FOLLOW_ID_in_named_value12917) if self._state.backtracking == 0: ID585_tree = self._adaptor.createWithPayload(ID585) self._adaptor.addChild(root_0, ID585_tree) self._state.following.append(self.FOLLOW_expression_in_named_value12919) expression586 = self.expression() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, expression586.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 indexed_primary_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.indexed_primary_return, self).__init__() self.tree = None # $ANTLR start "indexed_primary" # sdl92.g:1136: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_literal588 = None char_literal590 = None primary587 = None expression_list589 = None char_literal588_tree = None char_literal590_tree = None try: try: # sdl92.g:1137:9: ( primary '(' expression_list ')' ) # sdl92.g:1137:17: primary '(' expression_list ')' pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_primary_in_indexed_primary12957) primary587 = self.primary() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, primary587.tree) char_literal588=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_indexed_primary12959) if self._state.backtracking == 0: char_literal588_tree = self._adaptor.createWithPayload(char_literal588) self._adaptor.addChild(root_0, char_literal588_tree) self._state.following.append(self.FOLLOW_expression_list_in_indexed_primary12961) expression_list589 = self.expression_list() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, expression_list589.tree) char_literal590=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_indexed_primary12963) if self._state.backtracking == 0: char_literal590_tree = self._adaptor.createWithPayload(char_literal590) self._adaptor.addChild(root_0, char_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 "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:1141:1: field_primary : primary field_selection ; def field_primary(self, ): retval = self.field_primary_return() retval.start = self.input.LT(1) root_0 = None primary591 = None field_selection592 = None try: try: # sdl92.g:1142:9: ( primary field_selection ) # sdl92.g:1142:17: primary field_selection pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_primary_in_field_primary12995) primary591 = self.primary() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, primary591.tree) self._state.following.append(self.FOLLOW_field_selection_in_field_primary12997) field_selection592 = self.field_selection() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, field_selection592.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:1146:1: structure_primary : '(.' expression_list '.)' ; def structure_primary(self, ): retval = self.structure_primary_return() retval.start = self.input.LT(1) root_0 = None string_literal593 = None string_literal595 = None expression_list594 = None string_literal593_tree = None string_literal595_tree = None try: try: # sdl92.g:1147:9: ( '(.' expression_list '.)' ) # sdl92.g:1147:17: '(.' expression_list '.)' pass root_0 = self._adaptor.nil() string_literal593=self.match(self.input, 226, self.FOLLOW_226_in_structure_primary13029) if self._state.backtracking == 0: string_literal593_tree = self._adaptor.createWithPayload(string_literal593) self._adaptor.addChild(root_0, string_literal593_tree) self._state.following.append(self.FOLLOW_expression_list_in_structure_primary13031) expression_list594 = self.expression_list() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, expression_list594.tree) string_literal595=self.match(self.input, 227, self.FOLLOW_227_in_structure_primary13033) if self._state.backtracking == 0: string_literal595_tree = self._adaptor.createWithPayload(string_literal595) self._adaptor.addChild(root_0, string_literal595_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 sort_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.sort_return, self).__init__() self.tree = None # $ANTLR start "sort" # sdl92.g:1189:1: sort : sort_id -> ^( SORT sort_id ) ; def sort(self, ): retval = self.sort_return() retval.start = self.input.LT(1) root_0 = None sort_id596 = None stream_sort_id = RewriteRuleSubtreeStream(self._adaptor, "rule sort_id") try: try: # sdl92.g:1189:9: ( sort_id -> ^( SORT sort_id ) ) # sdl92.g:1189:17: sort_id pass self._state.following.append(self.FOLLOW_sort_id_in_sort13064) sort_id596 = self.sort_id() self._state.following.pop() if self._state.backtracking == 0: stream_sort_id.add(sort_id596.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() # 1190:9: -> ^( SORT sort_id ) # sdl92.g:1190: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:1194: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_id597 = None stream_type_id = RewriteRuleSubtreeStream(self._adaptor, "rule type_id") try: try: # sdl92.g:1195:9: ( type_id -> ^( TYPE_INSTANCE type_id ) ) # sdl92.g:1195:17: type_id pass self._state.following.append(self.FOLLOW_type_id_in_type_inst13117) type_id597 = self.type_id() self._state.following.pop() if self._state.backtracking == 0: stream_type_id.add(type_id597.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() # 1196:9: -> ^( TYPE_INSTANCE type_id ) # sdl92.g:1196: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:1200:1: syntype : syntype_id ; def syntype(self, ): retval = self.syntype_return() retval.start = self.input.LT(1) root_0 = None syntype_id598 = None try: try: # sdl92.g:1200:9: ( syntype_id ) # sdl92.g:1200:17: syntype_id pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_syntype_id_in_syntype13162) syntype_id598 = self.syntype_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, syntype_id598.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 variable_access_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.variable_access_return, self).__init__() self.tree = None # $ANTLR start "variable_access" # sdl92.g:1214:1: variable_access : variable_id ; def variable_access(self, ): retval = self.variable_access_return() retval.start = self.input.LT(1) root_0 = None variable_id599 = None try: try: # sdl92.g:1215:9: ( variable_id ) # sdl92.g:1215:17: variable_id pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_variable_id_in_variable_access13196) variable_id599 = self.variable_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, variable_id599.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 external_synonym_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.external_synonym_return, self).__init__() self.tree = None # $ANTLR start "external_synonym" # sdl92.g:1233: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_id600 = None try: try: # sdl92.g:1234:9: ( external_synonym_id ) # sdl92.g:1234:17: external_synonym_id pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_external_synonym_id_in_external_synonym13232) external_synonym_id600 = self.external_synonym_id() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, external_synonym_id600.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:1238: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 IF601 = None THEN602 = None ELSE603 = None FI604 = None ifexpr = None thenexpr = None elseexpr = None IF601_tree = None THEN602_tree = None ELSE603_tree = None FI604_tree = None stream_FI = RewriteRuleTokenStream(self._adaptor, "token FI") stream_ELSE = RewriteRuleTokenStream(self._adaptor, "token ELSE") stream_THEN = RewriteRuleTokenStream(self._adaptor, "token THEN") stream_IF = RewriteRuleTokenStream(self._adaptor, "token IF") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:1239:9: ( IF ifexpr= expression THEN thenexpr= expression ELSE elseexpr= expression FI -> ^( CONDITIONAL $ifexpr $thenexpr $elseexpr) ) # sdl92.g:1239:17: IF ifexpr= expression THEN thenexpr= expression ELSE elseexpr= expression FI pass IF601=self.match(self.input, IF, self.FOLLOW_IF_in_conditional_expression13264) if self._state.backtracking == 0: stream_IF.add(IF601) self._state.following.append(self.FOLLOW_expression_in_conditional_expression13268) ifexpr = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(ifexpr.tree) THEN602=self.match(self.input, THEN, self.FOLLOW_THEN_in_conditional_expression13286) if self._state.backtracking == 0: stream_THEN.add(THEN602) self._state.following.append(self.FOLLOW_expression_in_conditional_expression13290) thenexpr = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(thenexpr.tree) ELSE603=self.match(self.input, ELSE, self.FOLLOW_ELSE_in_conditional_expression13308) if self._state.backtracking == 0: stream_ELSE.add(ELSE603) self._state.following.append(self.FOLLOW_expression_in_conditional_expression13312) elseexpr = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(elseexpr.tree) FI604=self.match(self.input, FI, self.FOLLOW_FI_in_conditional_expression13314) if self._state.backtracking == 0: stream_FI.add(FI604) # AST Rewrite # elements: ifexpr, elseexpr, thenexpr # token labels: # rule labels: thenexpr, elseexpr, ifexpr, retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 if thenexpr is not None: stream_thenexpr = RewriteRuleSubtreeStream(self._adaptor, "rule thenexpr", thenexpr.tree) else: stream_thenexpr = RewriteRuleSubtreeStream(self._adaptor, "token thenexpr", None) if elseexpr is not None: stream_elseexpr = RewriteRuleSubtreeStream(self._adaptor, "rule elseexpr", elseexpr.tree) else: stream_elseexpr = RewriteRuleSubtreeStream(self._adaptor, "token elseexpr", 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 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() # 1242:9: -> ^( CONDITIONAL $ifexpr $thenexpr $elseexpr) # sdl92.g:1242: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:1246: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_literal606 = None expression605 = None expression607 = None char_literal606_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:1247:9: ( expression ( ',' expression )* -> ( expression )+ ) # sdl92.g:1247:17: expression ( ',' expression )* pass self._state.following.append(self.FOLLOW_expression_in_expression_list13374) expression605 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression605.tree) # sdl92.g:1247:28: ( ',' expression )* while True: #loop193 alt193 = 2 LA193_0 = self.input.LA(1) if (LA193_0 == COMMA) : alt193 = 1 if alt193 == 1: # sdl92.g:1247:29: ',' expression pass char_literal606=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_expression_list13377) if self._state.backtracking == 0: stream_COMMA.add(char_literal606) self._state.following.append(self.FOLLOW_expression_in_expression_list13379) expression607 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression607.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() # 1248:9: -> ( expression )+ # sdl92.g:1248: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:1252: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 label608 = None cif609 = None hyperlink610 = None terminator611 = None end612 = None stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") stream_terminator = RewriteRuleSubtreeStream(self._adaptor, "rule terminator") stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end") stream_label = RewriteRuleSubtreeStream(self._adaptor, "rule label") try: try: # sdl92.g:1253:9: ( ( label )? ( cif )? ( hyperlink )? terminator end -> ^( TERMINATOR ( label )? ( cif )? ( hyperlink )? ( end )? terminator ) ) # sdl92.g:1253:17: ( label )? ( cif )? ( hyperlink )? terminator end pass # sdl92.g:1253: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_statement13431) label608 = self.label() self._state.following.pop() if self._state.backtracking == 0: stream_label.add(label608.tree) # sdl92.g:1254:17: ( cif )? alt195 = 2 LA195_0 = self.input.LA(1) if (LA195_0 == 228) : 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_statement13450) cif609 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif609.tree) # sdl92.g:1255:17: ( hyperlink )? alt196 = 2 LA196_0 = self.input.LA(1) if (LA196_0 == 228) : alt196 = 1 if alt196 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_terminator_statement13469) hyperlink610 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink610.tree) self._state.following.append(self.FOLLOW_terminator_in_terminator_statement13488) terminator611 = self.terminator() self._state.following.pop() if self._state.backtracking == 0: stream_terminator.add(terminator611.tree) self._state.following.append(self.FOLLOW_end_in_terminator_statement13506) end612 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end612.tree) # AST Rewrite # elements: hyperlink, end, label, terminator, 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() # 1258:9: -> ^( TERMINATOR ( label )? ( cif )? ( hyperlink )? ( end )? terminator ) # sdl92.g:1258: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:1258:30: ( label )? if stream_label.hasNext(): self._adaptor.addChild(root_1, stream_label.nextTree()) stream_label.reset(); # sdl92.g:1258:37: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:1258:42: ( hyperlink )? if stream_hyperlink.hasNext(): self._adaptor.addChild(root_1, stream_hyperlink.nextTree()) stream_hyperlink.reset(); # sdl92.g:1258: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:1261: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_literal615 = None cif613 = None connector_name614 = None char_literal615_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:1262:9: ( ( cif )? connector_name ':' -> ^( LABEL ( cif )? connector_name ) ) # sdl92.g:1262:17: ( cif )? connector_name ':' pass # sdl92.g:1262:17: ( cif )? alt197 = 2 LA197_0 = self.input.LA(1) if (LA197_0 == 228) : alt197 = 1 if alt197 == 1: # sdl92.g:0:0: cif pass self._state.following.append(self.FOLLOW_cif_in_label13570) cif613 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif613.tree) self._state.following.append(self.FOLLOW_connector_name_in_label13573) connector_name614 = self.connector_name() self._state.following.pop() if self._state.backtracking == 0: stream_connector_name.add(connector_name614.tree) char_literal615=self.match(self.input, 223, self.FOLLOW_223_in_label13575) if self._state.backtracking == 0: stream_223.add(char_literal615) # 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() # 1263:9: -> ^( LABEL ( cif )? connector_name ) # sdl92.g:1263:17: ^( LABEL ( cif )? connector_name ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(LABEL, "LABEL"), root_1) # sdl92.g:1263: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:1267:1: terminator : ( nextstate | join | stop | return_stmt ); def terminator(self, ): retval = self.terminator_return() retval.start = self.input.LT(1) root_0 = None nextstate616 = None join617 = None stop618 = None return_stmt619 = None try: try: # sdl92.g:1268: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:1268:17: nextstate pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_nextstate_in_terminator13631) nextstate616 = self.nextstate() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, nextstate616.tree) elif alt198 == 2: # sdl92.g:1268:29: join pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_join_in_terminator13635) join617 = self.join() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, join617.tree) elif alt198 == 3: # sdl92.g:1268:36: stop pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_stop_in_terminator13639) stop618 = self.stop() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, stop618.tree) elif alt198 == 4: # sdl92.g:1268:43: return_stmt pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_return_stmt_in_terminator13643) return_stmt619 = self.return_stmt() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, return_stmt619.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:1272:1: join : JOIN connector_name -> ^( JOIN connector_name ) ; def join(self, ): retval = self.join_return() retval.start = self.input.LT(1) root_0 = None JOIN620 = None connector_name621 = None JOIN620_tree = None stream_JOIN = RewriteRuleTokenStream(self._adaptor, "token JOIN") stream_connector_name = RewriteRuleSubtreeStream(self._adaptor, "rule connector_name") try: try: # sdl92.g:1273:9: ( JOIN connector_name -> ^( JOIN connector_name ) ) # sdl92.g:1273:18: JOIN connector_name pass JOIN620=self.match(self.input, JOIN, self.FOLLOW_JOIN_in_join13676) if self._state.backtracking == 0: stream_JOIN.add(JOIN620) self._state.following.append(self.FOLLOW_connector_name_in_join13678) connector_name621 = self.connector_name() self._state.following.pop() if self._state.backtracking == 0: stream_connector_name.add(connector_name621.tree) # AST Rewrite # elements: connector_name, JOIN # 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: -> ^( JOIN connector_name ) # sdl92.g:1274: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:1278:1: stop : STOP ; def stop(self, ): retval = self.stop_return() retval.start = self.input.LT(1) root_0 = None STOP622 = None STOP622_tree = None try: try: # sdl92.g:1278:9: ( STOP ) # sdl92.g:1278:17: STOP pass root_0 = self._adaptor.nil() STOP622=self.match(self.input, STOP, self.FOLLOW_STOP_in_stop13727) if self._state.backtracking == 0: STOP622_tree = self._adaptor.createWithPayload(STOP622) self._adaptor.addChild(root_0, STOP622_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:1282: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 RETURN623 = None expression624 = None RETURN623_tree = None stream_RETURN = RewriteRuleTokenStream(self._adaptor, "token RETURN") stream_expression = RewriteRuleSubtreeStream(self._adaptor, "rule expression") try: try: # sdl92.g:1283:9: ( RETURN ( expression )? -> ^( RETURN ( expression )? ) ) # sdl92.g:1283:17: RETURN ( expression )? pass RETURN623=self.match(self.input, RETURN, self.FOLLOW_RETURN_in_return_stmt13759) if self._state.backtracking == 0: stream_RETURN.add(RETURN623) # sdl92.g:1283: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_stmt13761) expression624 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression624.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() # 1284:9: -> ^( RETURN ( expression )? ) # sdl92.g:1284:17: ^( RETURN ( expression )? ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_RETURN.nextNode(), root_1) # sdl92.g:1284: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:1288:1: nextstate : NEXTSTATE nextstatebody -> ^( NEXTSTATE nextstatebody ) ; def nextstate(self, ): retval = self.nextstate_return() retval.start = self.input.LT(1) root_0 = None NEXTSTATE625 = None nextstatebody626 = None NEXTSTATE625_tree = None stream_NEXTSTATE = RewriteRuleTokenStream(self._adaptor, "token NEXTSTATE") stream_nextstatebody = RewriteRuleSubtreeStream(self._adaptor, "rule nextstatebody") try: try: # sdl92.g:1289:9: ( NEXTSTATE nextstatebody -> ^( NEXTSTATE nextstatebody ) ) # sdl92.g:1289:17: NEXTSTATE nextstatebody pass NEXTSTATE625=self.match(self.input, NEXTSTATE, self.FOLLOW_NEXTSTATE_in_nextstate13816) if self._state.backtracking == 0: stream_NEXTSTATE.add(NEXTSTATE625) self._state.following.append(self.FOLLOW_nextstatebody_in_nextstate13818) nextstatebody626 = self.nextstatebody() self._state.following.pop() if self._state.backtracking == 0: stream_nextstatebody.add(nextstatebody626.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() # 1290:9: -> ^( NEXTSTATE nextstatebody ) # sdl92.g:1290: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:1294:1: nextstatebody : ( statename ( via )? | dash_nextstate ); def nextstatebody(self, ): retval = self.nextstatebody_return() retval.start = self.input.LT(1) root_0 = None statename627 = None via628 = None dash_nextstate629 = None try: try: # sdl92.g:1295: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:1295:17: statename ( via )? pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_statename_in_nextstatebody13871) statename627 = self.statename() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, statename627.tree) # sdl92.g:1295: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_nextstatebody13873) via628 = self.via() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, via628.tree) elif alt201 == 2: # sdl92.g:1296:19: dash_nextstate pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_dash_nextstate_in_nextstatebody13894) dash_nextstate629 = self.dash_nextstate() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, dash_nextstate629.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:1300: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 VIA630 = None state_entry_point_name631 = None VIA630_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:1300:9: ( VIA state_entry_point_name -> ^( VIA state_entry_point_name ) ) # sdl92.g:1300:17: VIA state_entry_point_name pass VIA630=self.match(self.input, VIA, self.FOLLOW_VIA_in_via13922) if self._state.backtracking == 0: stream_VIA.add(VIA630) self._state.following.append(self.FOLLOW_state_entry_point_name_in_via13924) state_entry_point_name631 = self.state_entry_point_name() self._state.following.pop() if self._state.backtracking == 0: stream_state_entry_point_name.add(state_entry_point_name631.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() # 1301:9: -> ^( VIA state_entry_point_name ) # sdl92.g:1301: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:1305: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 COMMENT634 = None STRING635 = None SEMI636 = None cif632 = None hyperlink633 = None COMMENT634_tree = None STRING635_tree = None SEMI636_tree = None stream_SEMI = RewriteRuleTokenStream(self._adaptor, "token SEMI") stream_STRING = RewriteRuleTokenStream(self._adaptor, "token STRING") stream_COMMENT = RewriteRuleTokenStream(self._adaptor, "token COMMENT") stream_cif = RewriteRuleSubtreeStream(self._adaptor, "rule cif") stream_hyperlink = RewriteRuleSubtreeStream(self._adaptor, "rule hyperlink") try: try: # sdl92.g:1306:9: ( ( ( cif )? ( hyperlink )? COMMENT STRING )? ( SEMI )+ -> ( ^( COMMENT ( cif )? ( hyperlink )? STRING ) )? ) # sdl92.g:1306:13: ( ( cif )? ( hyperlink )? COMMENT STRING )? ( SEMI )+ pass # sdl92.g:1306:13: ( ( cif )? ( hyperlink )? COMMENT STRING )? alt204 = 2 LA204_0 = self.input.LA(1) if (LA204_0 == COMMENT or LA204_0 == 228) : alt204 = 1 if alt204 == 1: # sdl92.g:1306:14: ( cif )? ( hyperlink )? COMMENT STRING pass # sdl92.g:1306:14: ( cif )? alt202 = 2 LA202_0 = self.input.LA(1) if (LA202_0 == 228) : 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_end13974) cif632 = self.cif() self._state.following.pop() if self._state.backtracking == 0: stream_cif.add(cif632.tree) # sdl92.g:1306:19: ( hyperlink )? alt203 = 2 LA203_0 = self.input.LA(1) if (LA203_0 == 228) : alt203 = 1 if alt203 == 1: # sdl92.g:0:0: hyperlink pass self._state.following.append(self.FOLLOW_hyperlink_in_end13977) hyperlink633 = self.hyperlink() self._state.following.pop() if self._state.backtracking == 0: stream_hyperlink.add(hyperlink633.tree) COMMENT634=self.match(self.input, COMMENT, self.FOLLOW_COMMENT_in_end13980) if self._state.backtracking == 0: stream_COMMENT.add(COMMENT634) STRING635=self.match(self.input, STRING, self.FOLLOW_STRING_in_end13982) if self._state.backtracking == 0: stream_STRING.add(STRING635) # sdl92.g:1306: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.synpred278_sdl92()) : alt205 = 1 if alt205 == 1: # sdl92.g:0:0: SEMI pass SEMI636=self.match(self.input, SEMI, self.FOLLOW_SEMI_in_end13986) if self._state.backtracking == 0: stream_SEMI.add(SEMI636) 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, hyperlink, COMMENT, 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() # 1307:9: -> ( ^( COMMENT ( cif )? ( hyperlink )? STRING ) )? # sdl92.g:1307:12: ( ^( COMMENT ( cif )? ( hyperlink )? STRING ) )? if stream_cif.hasNext() or stream_hyperlink.hasNext() or stream_COMMENT.hasNext() or stream_STRING.hasNext(): # sdl92.g:1307:12: ^( COMMENT ( cif )? ( hyperlink )? STRING ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_COMMENT.nextNode(), root_1) # sdl92.g:1307:22: ( cif )? if stream_cif.hasNext(): self._adaptor.addChild(root_1, stream_cif.nextTree()) stream_cif.reset(); # sdl92.g:1307: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_hyperlink.reset(); stream_COMMENT.reset(); stream_STRING.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:1311:1: cif : cif_decl symbolname L_PAREN x= signed COMMA y= signed 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 width = None height = None L_PAREN639 = None COMMA640 = None R_PAREN641 = None COMMA642 = None L_PAREN643 = None COMMA644 = None R_PAREN645 = None x = None y = None cif_decl637 = None symbolname638 = None cif_end646 = None width_tree = None height_tree = None L_PAREN639_tree = None COMMA640_tree = None R_PAREN641_tree = None COMMA642_tree = None L_PAREN643_tree = None COMMA644_tree = None R_PAREN645_tree = None stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA") stream_L_PAREN = RewriteRuleTokenStream(self._adaptor, "token L_PAREN") stream_R_PAREN = RewriteRuleTokenStream(self._adaptor, "token R_PAREN") stream_INT = RewriteRuleTokenStream(self._adaptor, "token INT") stream_cif_decl = RewriteRuleSubtreeStream(self._adaptor, "rule cif_decl") stream_cif_end = RewriteRuleSubtreeStream(self._adaptor, "rule cif_end") stream_signed = RewriteRuleSubtreeStream(self._adaptor, "rule signed") stream_symbolname = RewriteRuleSubtreeStream(self._adaptor, "rule symbolname") try: try: # sdl92.g:1312:9: ( cif_decl symbolname L_PAREN x= signed COMMA y= signed R_PAREN COMMA L_PAREN width= INT COMMA height= INT R_PAREN cif_end -> ^( CIF $x $y $width $height) ) # sdl92.g:1312:17: cif_decl symbolname L_PAREN x= signed COMMA y= signed R_PAREN COMMA L_PAREN width= INT COMMA height= INT R_PAREN cif_end pass self._state.following.append(self.FOLLOW_cif_decl_in_cif14042) cif_decl637 = self.cif_decl() self._state.following.pop() if self._state.backtracking == 0: stream_cif_decl.add(cif_decl637.tree) self._state.following.append(self.FOLLOW_symbolname_in_cif14044) symbolname638 = self.symbolname() self._state.following.pop() if self._state.backtracking == 0: stream_symbolname.add(symbolname638.tree) L_PAREN639=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_cif14062) if self._state.backtracking == 0: stream_L_PAREN.add(L_PAREN639) self._state.following.append(self.FOLLOW_signed_in_cif14066) x = self.signed() self._state.following.pop() if self._state.backtracking == 0: stream_signed.add(x.tree) COMMA640=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_cif14068) if self._state.backtracking == 0: stream_COMMA.add(COMMA640) self._state.following.append(self.FOLLOW_signed_in_cif14072) y = self.signed() self._state.following.pop() if self._state.backtracking == 0: stream_signed.add(y.tree) R_PAREN641=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_cif14074) if self._state.backtracking == 0: stream_R_PAREN.add(R_PAREN641) COMMA642=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_cif14092) if self._state.backtracking == 0: stream_COMMA.add(COMMA642) L_PAREN643=self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_cif14110) if self._state.backtracking == 0: stream_L_PAREN.add(L_PAREN643) width=self.match(self.input, INT, self.FOLLOW_INT_in_cif14114) if self._state.backtracking == 0: stream_INT.add(width) COMMA644=self.match(self.input, COMMA, self.FOLLOW_COMMA_in_cif14116) if self._state.backtracking == 0: stream_COMMA.add(COMMA644) height=self.match(self.input, INT, self.FOLLOW_INT_in_cif14120) if self._state.backtracking == 0: stream_INT.add(height) R_PAREN645=self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_cif14122) if self._state.backtracking == 0: stream_R_PAREN.add(R_PAREN645) self._state.following.append(self.FOLLOW_cif_end_in_cif14140) cif_end646 = self.cif_end() self._state.following.pop() if self._state.backtracking == 0: stream_cif_end.add(cif_end646.tree) # AST Rewrite # elements: y, x, height, width # token labels: width, height # rule labels: x, y, retval # token list labels: # rule list labels: # wildcard labels: if self._state.backtracking == 0: retval.tree = root_0 stream_width = RewriteRuleTokenStream(self._adaptor, "token width", width) stream_height = RewriteRuleTokenStream(self._adaptor, "token height", height) if x is not None: stream_x = RewriteRuleSubtreeStream(self._adaptor, "rule x", x.tree) else: stream_x = RewriteRuleSubtreeStream(self._adaptor, "token x", None) if y is not None: stream_y = RewriteRuleSubtreeStream(self._adaptor, "rule y", y.tree) else: stream_y = RewriteRuleSubtreeStream(self._adaptor, "token y", 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() # 1317:9: -> ^( CIF $x $y $width $height) # sdl92.g:1317: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.nextTree()) self._adaptor.addChild(root_1, stream_y.nextTree()) 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:1321: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 KEEP648 = None SPECIFIC649 = None GEODE650 = None HYPERLINK651 = None STRING652 = None cif_decl647 = None cif_end653 = None KEEP648_tree = None SPECIFIC649_tree = None GEODE650_tree = None HYPERLINK651_tree = None STRING652_tree = None stream_KEEP = RewriteRuleTokenStream(self._adaptor, "token KEEP") stream_SPECIFIC = RewriteRuleTokenStream(self._adaptor, "token SPECIFIC") stream_HYPERLINK = RewriteRuleTokenStream(self._adaptor, "token HYPERLINK") stream_STRING = RewriteRuleTokenStream(self._adaptor, "token STRING") stream_GEODE = RewriteRuleTokenStream(self._adaptor, "token GEODE") stream_cif_decl = RewriteRuleSubtreeStream(self._adaptor, "rule cif_decl") stream_cif_end = RewriteRuleSubtreeStream(self._adaptor, "rule cif_end") try: try: # sdl92.g:1322:9: ( cif_decl KEEP SPECIFIC GEODE HYPERLINK STRING cif_end -> ^( HYPERLINK STRING ) ) # sdl92.g:1322:17: cif_decl KEEP SPECIFIC GEODE HYPERLINK STRING cif_end pass self._state.following.append(self.FOLLOW_cif_decl_in_hyperlink14203) cif_decl647 = self.cif_decl() self._state.following.pop() if self._state.backtracking == 0: stream_cif_decl.add(cif_decl647.tree) KEEP648=self.match(self.input, KEEP, self.FOLLOW_KEEP_in_hyperlink14205) if self._state.backtracking == 0: stream_KEEP.add(KEEP648) SPECIFIC649=self.match(self.input, SPECIFIC, self.FOLLOW_SPECIFIC_in_hyperlink14207) if self._state.backtracking == 0: stream_SPECIFIC.add(SPECIFIC649) GEODE650=self.match(self.input, GEODE, self.FOLLOW_GEODE_in_hyperlink14209) if self._state.backtracking == 0: stream_GEODE.add(GEODE650) HYPERLINK651=self.match(self.input, HYPERLINK, self.FOLLOW_HYPERLINK_in_hyperlink14211) if self._state.backtracking == 0: stream_HYPERLINK.add(HYPERLINK651) STRING652=self.match(self.input, STRING, self.FOLLOW_STRING_in_hyperlink14213) if self._state.backtracking == 0: stream_STRING.add(STRING652) self._state.following.append(self.FOLLOW_cif_end_in_hyperlink14231) cif_end653 = self.cif_end() self._state.following.pop() if self._state.backtracking == 0: stream_cif_end.add(cif_end653.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() # 1324:9: -> ^( HYPERLINK STRING ) # sdl92.g:1324: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:1334: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 KEEP655 = None SPECIFIC656 = None GEODE657 = None PARAMNAMES658 = None cif_decl654 = None field_name659 = None cif_end660 = None KEEP655_tree = None SPECIFIC656_tree = None GEODE657_tree = None PARAMNAMES658_tree = None stream_KEEP = RewriteRuleTokenStream(self._adaptor, "token KEEP") stream_SPECIFIC = RewriteRuleTokenStream(self._adaptor, "token SPECIFIC") stream_GEODE = RewriteRuleTokenStream(self._adaptor, "token GEODE") stream_PARAMNAMES = RewriteRuleTokenStream(self._adaptor, "token PARAMNAMES") stream_cif_decl = RewriteRuleSubtreeStream(self._adaptor, "rule cif_decl") stream_cif_end = RewriteRuleSubtreeStream(self._adaptor, "rule cif_end") stream_field_name = RewriteRuleSubtreeStream(self._adaptor, "rule field_name") try: try: # sdl92.g:1335:9: ( cif_decl KEEP SPECIFIC GEODE PARAMNAMES ( field_name )+ cif_end -> ^( PARAMNAMES ( field_name )+ ) ) # sdl92.g:1335:17: cif_decl KEEP SPECIFIC GEODE PARAMNAMES ( field_name )+ cif_end pass self._state.following.append(self.FOLLOW_cif_decl_in_paramnames14285) cif_decl654 = self.cif_decl() self._state.following.pop() if self._state.backtracking == 0: stream_cif_decl.add(cif_decl654.tree) KEEP655=self.match(self.input, KEEP, self.FOLLOW_KEEP_in_paramnames14287) if self._state.backtracking == 0: stream_KEEP.add(KEEP655) SPECIFIC656=self.match(self.input, SPECIFIC, self.FOLLOW_SPECIFIC_in_paramnames14289) if self._state.backtracking == 0: stream_SPECIFIC.add(SPECIFIC656) GEODE657=self.match(self.input, GEODE, self.FOLLOW_GEODE_in_paramnames14291) if self._state.backtracking == 0: stream_GEODE.add(GEODE657) PARAMNAMES658=self.match(self.input, PARAMNAMES, self.FOLLOW_PARAMNAMES_in_paramnames14293) if self._state.backtracking == 0: stream_PARAMNAMES.add(PARAMNAMES658) # sdl92.g:1335: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_paramnames14295) field_name659 = self.field_name() self._state.following.pop() if self._state.backtracking == 0: stream_field_name.add(field_name659.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_paramnames14298) cif_end660 = self.cif_end() self._state.following.pop() if self._state.backtracking == 0: stream_cif_end.add(cif_end660.tree) # AST Rewrite # elements: PARAMNAMES, 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() # 1336:9: -> ^( PARAMNAMES ( field_name )+ ) # sdl92.g:1336:17: ^( PARAMNAMES ( field_name )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(stream_PARAMNAMES.nextNode(), root_1) # sdl92.g:1336: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:1344: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 KEEP662 = None SPECIFIC663 = None GEODE664 = None ASNFILENAME665 = None STRING666 = None cif_decl661 = None cif_end667 = None KEEP662_tree = None SPECIFIC663_tree = None GEODE664_tree = None ASNFILENAME665_tree = None STRING666_tree = None stream_KEEP = RewriteRuleTokenStream(self._adaptor, "token KEEP") stream_SPECIFIC = RewriteRuleTokenStream(self._adaptor, "token SPECIFIC") stream_ASNFILENAME = RewriteRuleTokenStream(self._adaptor, "token ASNFILENAME") stream_STRING = RewriteRuleTokenStream(self._adaptor, "token STRING") stream_GEODE = RewriteRuleTokenStream(self._adaptor, "token GEODE") stream_cif_decl = RewriteRuleSubtreeStream(self._adaptor, "rule cif_decl") stream_cif_end = RewriteRuleSubtreeStream(self._adaptor, "rule cif_end") try: try: # sdl92.g:1345:9: ( cif_decl KEEP SPECIFIC GEODE ASNFILENAME STRING cif_end -> ^( ASN1 STRING ) ) # sdl92.g:1345:17: cif_decl KEEP SPECIFIC GEODE ASNFILENAME STRING cif_end pass self._state.following.append(self.FOLLOW_cif_decl_in_use_asn114354) cif_decl661 = self.cif_decl() self._state.following.pop() if self._state.backtracking == 0: stream_cif_decl.add(cif_decl661.tree) KEEP662=self.match(self.input, KEEP, self.FOLLOW_KEEP_in_use_asn114356) if self._state.backtracking == 0: stream_KEEP.add(KEEP662) SPECIFIC663=self.match(self.input, SPECIFIC, self.FOLLOW_SPECIFIC_in_use_asn114358) if self._state.backtracking == 0: stream_SPECIFIC.add(SPECIFIC663) GEODE664=self.match(self.input, GEODE, self.FOLLOW_GEODE_in_use_asn114360) if self._state.backtracking == 0: stream_GEODE.add(GEODE664) ASNFILENAME665=self.match(self.input, ASNFILENAME, self.FOLLOW_ASNFILENAME_in_use_asn114362) if self._state.backtracking == 0: stream_ASNFILENAME.add(ASNFILENAME665) STRING666=self.match(self.input, STRING, self.FOLLOW_STRING_in_use_asn114364) if self._state.backtracking == 0: stream_STRING.add(STRING666) self._state.following.append(self.FOLLOW_cif_end_in_use_asn114366) cif_end667 = self.cif_end() self._state.following.pop() if self._state.backtracking == 0: stream_cif_end.add(cif_end667.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() # 1346:9: -> ^( ASN1 STRING ) # sdl92.g:1346: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:1352: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 STOP668 = None IF669 = None expression670 = None end671 = None STOP668_tree = None IF669_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:1353:9: ( ( STOP IF expression end )+ -> ^( STOPIF ( expression )+ ) ) # sdl92.g:1353:17: ( STOP IF expression end )+ pass # sdl92.g:1353: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:1353:18: STOP IF expression end pass STOP668=self.match(self.input, STOP, self.FOLLOW_STOP_in_stop_if14422) if self._state.backtracking == 0: stream_STOP.add(STOP668) IF669=self.match(self.input, IF, self.FOLLOW_IF_in_stop_if14424) if self._state.backtracking == 0: stream_IF.add(IF669) self._state.following.append(self.FOLLOW_expression_in_stop_if14426) expression670 = self.expression() self._state.following.pop() if self._state.backtracking == 0: stream_expression.add(expression670.tree) self._state.following.append(self.FOLLOW_end_in_stop_if14428) end671 = self.end() self._state.following.pop() if self._state.backtracking == 0: stream_end.add(end671.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() # 1354:9: -> ^( STOPIF ( expression )+ ) # sdl92.g:1354:17: ^( STOPIF ( expression )+ ) root_1 = self._adaptor.nil() root_1 = self._adaptor.becomeRoot(self._adaptor.createFromType(STOPIF, "STOPIF"), root_1) # sdl92.g:1354: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:1358: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 set672 = None set672_tree = None try: try: # sdl92.g:1359: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() set672 = 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(set672)) 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:1381:1: cif_decl : '/* CIF' ; def cif_decl(self, ): retval = self.cif_decl_return() retval.start = self.input.LT(1) root_0 = None string_literal673 = None string_literal673_tree = None try: try: # sdl92.g:1382:9: ( '/* CIF' ) # sdl92.g:1382:17: '/* CIF' pass root_0 = self._adaptor.nil() string_literal673=self.match(self.input, 228, self.FOLLOW_228_in_cif_decl14876) if self._state.backtracking == 0: string_literal673_tree = self._adaptor.createWithPayload(string_literal673) self._adaptor.addChild(root_0, string_literal673_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:1386:1: cif_end : '*/' ; def cif_end(self, ): retval = self.cif_end_return() retval.start = self.input.LT(1) root_0 = None string_literal674 = None string_literal674_tree = None try: try: # sdl92.g:1387:9: ( '*/' ) # sdl92.g:1387:17: '*/' pass root_0 = self._adaptor.nil() string_literal674=self.match(self.input, 229, self.FOLLOW_229_in_cif_end14908) if self._state.backtracking == 0: string_literal674_tree = self._adaptor.createWithPayload(string_literal674) self._adaptor.addChild(root_0, string_literal674_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:1391: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 ENDTEXT676 = None cif_decl675 = None cif_end677 = None ENDTEXT676_tree = None stream_ENDTEXT = RewriteRuleTokenStream(self._adaptor, "token ENDTEXT") stream_cif_decl = RewriteRuleSubtreeStream(self._adaptor, "rule cif_decl") stream_cif_end = RewriteRuleSubtreeStream(self._adaptor, "rule cif_end") try: try: # sdl92.g:1392:9: ( cif_decl ENDTEXT cif_end -> ^( ENDTEXT ) ) # sdl92.g:1392:17: cif_decl ENDTEXT cif_end pass self._state.following.append(self.FOLLOW_cif_decl_in_cif_end_text14940) cif_decl675 = self.cif_decl() self._state.following.pop() if self._state.backtracking == 0: stream_cif_decl.add(cif_decl675.tree) ENDTEXT676=self.match(self.input, ENDTEXT, self.FOLLOW_ENDTEXT_in_cif_end_text14942) if self._state.backtracking == 0: stream_ENDTEXT.add(ENDTEXT676) self._state.following.append(self.FOLLOW_cif_end_in_cif_end_text14944) cif_end677 = self.cif_end() self._state.following.pop() if self._state.backtracking == 0: stream_cif_end.add(cif_end677.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() # 1393:9: -> ^( ENDTEXT ) # sdl92.g:1393: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:1397: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 END679 = None LABEL680 = None cif_decl678 = None cif_end681 = None END679_tree = None LABEL680_tree = None try: try: # sdl92.g:1398:9: ( cif_decl END LABEL cif_end ) # sdl92.g:1398:17: cif_decl END LABEL cif_end pass root_0 = self._adaptor.nil() self._state.following.append(self.FOLLOW_cif_decl_in_cif_end_label14995) cif_decl678 = self.cif_decl() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, cif_decl678.tree) END679=self.match(self.input, END, self.FOLLOW_END_in_cif_end_label14997) if self._state.backtracking == 0: END679_tree = self._adaptor.createWithPayload(END679) self._adaptor.addChild(root_0, END679_tree) LABEL680=self.match(self.input, LABEL, self.FOLLOW_LABEL_in_cif_end_label14999) if self._state.backtracking == 0: LABEL680_tree = self._adaptor.createWithPayload(LABEL680) self._adaptor.addChild(root_0, LABEL680_tree) self._state.following.append(self.FOLLOW_cif_end_in_cif_end_label15001) cif_end681 = self.cif_end() self._state.following.pop() if self._state.backtracking == 0: self._adaptor.addChild(root_0, cif_end681.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:1402:1: dash_nextstate : DASH ; def dash_nextstate(self, ): retval = self.dash_nextstate_return() retval.start = self.input.LT(1) root_0 = None DASH682 = None DASH682_tree = None try: try: # sdl92.g:1402:17: ( DASH ) # sdl92.g:1402:25: DASH pass root_0 = self._adaptor.nil() DASH682=self.match(self.input, DASH, self.FOLLOW_DASH_in_dash_nextstate15026) if self._state.backtracking == 0: DASH682_tree = self._adaptor.createWithPayload(DASH682) self._adaptor.addChild(root_0, DASH682_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:1403:1: connector_name : ID ; def connector_name(self, ): retval = self.connector_name_return() retval.start = self.input.LT(1) root_0 = None ID683 = None ID683_tree = None try: try: # sdl92.g:1403:17: ( ID ) # sdl92.g:1403:25: ID pass root_0 = self._adaptor.nil() ID683=self.match(self.input, ID, self.FOLLOW_ID_in_connector_name15040) if self._state.backtracking == 0: ID683_tree = self._adaptor.createWithPayload(ID683) self._adaptor.addChild(root_0, ID683_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:1404:1: signal_id : ID ; def signal_id(self, ): retval = self.signal_id_return() retval.start = self.input.LT(1) root_0 = None ID684 = None ID684_tree = None try: try: # sdl92.g:1404:17: ( ID ) # sdl92.g:1404:25: ID pass root_0 = self._adaptor.nil() ID684=self.match(self.input, ID, self.FOLLOW_ID_in_signal_id15059) if self._state.backtracking == 0: ID684_tree = self._adaptor.createWithPayload(ID684) self._adaptor.addChild(root_0, ID684_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:1405:1: statename : ID ; def statename(self, ): retval = self.statename_return() retval.start = self.input.LT(1) root_0 = None ID685 = None ID685_tree = None try: try: # sdl92.g:1405:17: ( ID ) # sdl92.g:1405:25: ID pass root_0 = self._adaptor.nil() ID685=self.match(self.input, ID, self.FOLLOW_ID_in_statename15078) if self._state.backtracking == 0: ID685_tree = self._adaptor.createWithPayload(ID685) self._adaptor.addChild(root_0, ID685_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:1406: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 ID686 = None ID686_tree = None try: try: # sdl92.g:1407:17: ( ID ) # sdl92.g:1407:25: ID pass root_0 = self._adaptor.nil() ID686=self.match(self.input, ID, self.FOLLOW_ID_in_state_exit_point_name15107) if self._state.backtracking == 0: ID686_tree = self._adaptor.createWithPayload(ID686) self._adaptor.addChild(root_0, ID686_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:1408: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 ID687 = None ID687_tree = None try: try: # sdl92.g:1409:17: ( ID ) # sdl92.g:1409:25: ID pass root_0 = self._adaptor.nil() ID687=self.match(self.input, ID, self.FOLLOW_ID_in_state_entry_point_name15136) if self._state.backtracking == 0: ID687_tree = self._adaptor.createWithPayload(ID687) self._adaptor.addChild(root_0, ID687_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:1410:1: variable_id : ID ; def variable_id(self, ): retval = self.variable_id_return() retval.start = self.input.LT(1) root_0 = None ID688 = None ID688_tree = None try: try: # sdl92.g:1410:17: ( ID ) # sdl92.g:1410:25: ID pass root_0 = self._adaptor.nil() ID688=self.match(self.input, ID, self.FOLLOW_ID_in_variable_id15153) if self._state.backtracking == 0: ID688_tree = self._adaptor.createWithPayload(ID688) self._adaptor.addChild(root_0, ID688_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:1411:1: literal_id : ( ID | INT ); def literal_id(self, ): retval = self.literal_id_return() retval.start = self.input.LT(1) root_0 = None set689 = None set689_tree = None try: try: # sdl92.g:1411:17: ( ID | INT ) # sdl92.g: pass root_0 = self._adaptor.nil() set689 = 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(set689)) 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:1412:1: process_id : ID ; def process_id(self, ): retval = self.process_id_return() retval.start = self.input.LT(1) root_0 = None ID690 = None ID690_tree = None try: try: # sdl92.g:1412:17: ( ID ) # sdl92.g:1412:25: ID pass root_0 = self._adaptor.nil() ID690=self.match(self.input, ID, self.FOLLOW_ID_in_process_id15193) if self._state.backtracking == 0: ID690_tree = self._adaptor.createWithPayload(ID690) self._adaptor.addChild(root_0, ID690_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:1413:1: system_name : ID ; def system_name(self, ): retval = self.system_name_return() retval.start = self.input.LT(1) root_0 = None ID691 = None ID691_tree = None try: try: # sdl92.g:1413:17: ( ID ) # sdl92.g:1413:25: ID pass root_0 = self._adaptor.nil() ID691=self.match(self.input, ID, self.FOLLOW_ID_in_system_name15210) if self._state.backtracking == 0: ID691_tree = self._adaptor.createWithPayload(ID691) self._adaptor.addChild(root_0, ID691_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:1414:1: package_name : ID ; def package_name(self, ): retval = self.package_name_return() retval.start = self.input.LT(1) root_0 = None ID692 = None ID692_tree = None try: try: # sdl92.g:1414:17: ( ID ) # sdl92.g:1414:25: ID pass root_0 = self._adaptor.nil() ID692=self.match(self.input, ID, self.FOLLOW_ID_in_package_name15226) if self._state.backtracking == 0: ID692_tree = self._adaptor.createWithPayload(ID692) self._adaptor.addChild(root_0, ID692_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:1415: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 ID693 = None ID693_tree = None try: try: # sdl92.g:1416:17: ( ID ) # sdl92.g:1416:25: ID pass root_0 = self._adaptor.nil() ID693=self.match(self.input, ID, self.FOLLOW_ID_in_priority_signal_id15255) if self._state.backtracking == 0: ID693_tree = self._adaptor.createWithPayload(ID693) self._adaptor.addChild(root_0, ID693_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:1417: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 ID694 = None ID694_tree = None try: try: # sdl92.g:1417:17: ( ID ) # sdl92.g:1417:25: ID pass root_0 = self._adaptor.nil() ID694=self.match(self.input, ID, self.FOLLOW_ID_in_signal_list_id15269) if self._state.backtracking == 0: ID694_tree = self._adaptor.createWithPayload(ID694) self._adaptor.addChild(root_0, ID694_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:1418:1: timer_id : ID ; def timer_id(self, ): retval = self.timer_id_return() retval.start = self.input.LT(1) root_0 = None ID695 = None ID695_tree = None try: try: # sdl92.g:1418:17: ( ID ) # sdl92.g:1418:25: ID pass root_0 = self._adaptor.nil() ID695=self.match(self.input, ID, self.FOLLOW_ID_in_timer_id15289) if self._state.backtracking == 0: ID695_tree = self._adaptor.createWithPayload(ID695) self._adaptor.addChild(root_0, ID695_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:1419:1: field_name : ID ; def field_name(self, ): retval = self.field_name_return() retval.start = self.input.LT(1) root_0 = None ID696 = None ID696_tree = None try: try: # sdl92.g:1419:17: ( ID ) # sdl92.g:1419:25: ID pass root_0 = self._adaptor.nil() ID696=self.match(self.input, ID, self.FOLLOW_ID_in_field_name15307) if self._state.backtracking == 0: ID696_tree = self._adaptor.createWithPayload(ID696) self._adaptor.addChild(root_0, ID696_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:1420: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 ID697 = None ID697_tree = None try: try: # sdl92.g:1420:17: ( ID ) # sdl92.g:1420:25: ID pass root_0 = self._adaptor.nil() ID697=self.match(self.input, ID, self.FOLLOW_ID_in_signal_route_id15320) if self._state.backtracking == 0: ID697_tree = self._adaptor.createWithPayload(ID697) self._adaptor.addChild(root_0, ID697_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:1421:1: channel_id : ID ; def channel_id(self, ): retval = self.channel_id_return() retval.start = self.input.LT(1) root_0 = None ID698 = None ID698_tree = None try: try: # sdl92.g:1421:17: ( ID ) # sdl92.g:1421:25: ID pass root_0 = self._adaptor.nil() ID698=self.match(self.input, ID, self.FOLLOW_ID_in_channel_id15338) if self._state.backtracking == 0: ID698_tree = self._adaptor.createWithPayload(ID698) self._adaptor.addChild(root_0, ID698_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:1422:1: route_id : ID ; def route_id(self, ): retval = self.route_id_return() retval.start = self.input.LT(1) root_0 = None ID699 = None ID699_tree = None try: try: # sdl92.g:1422:17: ( ID ) # sdl92.g:1422:25: ID pass root_0 = self._adaptor.nil() ID699=self.match(self.input, ID, self.FOLLOW_ID_in_route_id15358) if self._state.backtracking == 0: ID699_tree = self._adaptor.createWithPayload(ID699) self._adaptor.addChild(root_0, ID699_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:1423:1: block_id : ID ; def block_id(self, ): retval = self.block_id_return() retval.start = self.input.LT(1) root_0 = None ID700 = None ID700_tree = None try: try: # sdl92.g:1423:17: ( ID ) # sdl92.g:1423:25: ID pass root_0 = self._adaptor.nil() ID700=self.match(self.input, ID, self.FOLLOW_ID_in_block_id15378) if self._state.backtracking == 0: ID700_tree = self._adaptor.createWithPayload(ID700) self._adaptor.addChild(root_0, ID700_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:1424:1: source_id : ID ; def source_id(self, ): retval = self.source_id_return() retval.start = self.input.LT(1) root_0 = None ID701 = None ID701_tree = None try: try: # sdl92.g:1424:17: ( ID ) # sdl92.g:1424:25: ID pass root_0 = self._adaptor.nil() ID701=self.match(self.input, ID, self.FOLLOW_ID_in_source_id15397) if self._state.backtracking == 0: ID701_tree = self._adaptor.createWithPayload(ID701) self._adaptor.addChild(root_0, ID701_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:1425:1: dest_id : ID ; def dest_id(self, ): retval = self.dest_id_return() retval.start = self.input.LT(1) root_0 = None ID702 = None ID702_tree = None try: try: # sdl92.g:1425:17: ( ID ) # sdl92.g:1425:25: ID pass root_0 = self._adaptor.nil() ID702=self.match(self.input, ID, self.FOLLOW_ID_in_dest_id15418) if self._state.backtracking == 0: ID702_tree = self._adaptor.createWithPayload(ID702) self._adaptor.addChild(root_0, ID702_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:1426:1: gate_id : ID ; def gate_id(self, ): retval = self.gate_id_return() retval.start = self.input.LT(1) root_0 = None ID703 = None ID703_tree = None try: try: # sdl92.g:1426:17: ( ID ) # sdl92.g:1426:25: ID pass root_0 = self._adaptor.nil() ID703=self.match(self.input, ID, self.FOLLOW_ID_in_gate_id15439) if self._state.backtracking == 0: ID703_tree = self._adaptor.createWithPayload(ID703) self._adaptor.addChild(root_0, ID703_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:1427:1: procedure_id : ID ; def procedure_id(self, ): retval = self.procedure_id_return() retval.start = self.input.LT(1) root_0 = None ID704 = None ID704_tree = None try: try: # sdl92.g:1427:17: ( ID ) # sdl92.g:1427:25: ID pass root_0 = self._adaptor.nil() ID704=self.match(self.input, ID, self.FOLLOW_ID_in_procedure_id15455) if self._state.backtracking == 0: ID704_tree = self._adaptor.createWithPayload(ID704) self._adaptor.addChild(root_0, ID704_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:1428: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 ID705 = None ID705_tree = None try: try: # sdl92.g:1429:17: ( ID ) # sdl92.g:1429:25: ID pass root_0 = self._adaptor.nil() ID705=self.match(self.input, ID, self.FOLLOW_ID_in_remote_procedure_id15484) if self._state.backtracking == 0: ID705_tree = self._adaptor.createWithPayload(ID705) self._adaptor.addChild(root_0, ID705_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:1430:1: operator_id : ID ; def operator_id(self, ): retval = self.operator_id_return() retval.start = self.input.LT(1) root_0 = None ID706 = None ID706_tree = None try: try: # sdl92.g:1430:17: ( ID ) # sdl92.g:1430:25: ID pass root_0 = self._adaptor.nil() ID706=self.match(self.input, ID, self.FOLLOW_ID_in_operator_id15501) if self._state.backtracking == 0: ID706_tree = self._adaptor.createWithPayload(ID706) self._adaptor.addChild(root_0, ID706_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:1431:1: synonym_id : ID ; def synonym_id(self, ): retval = self.synonym_id_return() retval.start = self.input.LT(1) root_0 = None ID707 = None ID707_tree = None try: try: # sdl92.g:1431:17: ( ID ) # sdl92.g:1431:25: ID pass root_0 = self._adaptor.nil() ID707=self.match(self.input, ID, self.FOLLOW_ID_in_synonym_id15519) if self._state.backtracking == 0: ID707_tree = self._adaptor.createWithPayload(ID707) self._adaptor.addChild(root_0, ID707_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:1432: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 ID708 = None ID708_tree = None try: try: # sdl92.g:1433:17: ( ID ) # sdl92.g:1433:25: ID pass root_0 = self._adaptor.nil() ID708=self.match(self.input, ID, self.FOLLOW_ID_in_external_synonym_id15548) if self._state.backtracking == 0: ID708_tree = self._adaptor.createWithPayload(ID708) self._adaptor.addChild(root_0, ID708_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:1434: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 ID709 = None ID709_tree = None try: try: # sdl92.g:1435:17: ( ID ) # sdl92.g:1435:25: ID pass root_0 = self._adaptor.nil() ID709=self.match(self.input, ID, self.FOLLOW_ID_in_remote_variable_id15577) if self._state.backtracking == 0: ID709_tree = self._adaptor.createWithPayload(ID709) self._adaptor.addChild(root_0, ID709_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:1436:1: view_id : ID ; def view_id(self, ): retval = self.view_id_return() retval.start = self.input.LT(1) root_0 = None ID710 = None ID710_tree = None try: try: # sdl92.g:1436:17: ( ID ) # sdl92.g:1436:25: ID pass root_0 = self._adaptor.nil() ID710=self.match(self.input, ID, self.FOLLOW_ID_in_view_id15598) if self._state.backtracking == 0: ID710_tree = self._adaptor.createWithPayload(ID710) self._adaptor.addChild(root_0, ID710_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:1437:1: sort_id : ID ; def sort_id(self, ): retval = self.sort_id_return() retval.start = self.input.LT(1) root_0 = None ID711 = None ID711_tree = None try: try: # sdl92.g:1437:17: ( ID ) # sdl92.g:1437:25: ID pass root_0 = self._adaptor.nil() ID711=self.match(self.input, ID, self.FOLLOW_ID_in_sort_id15619) if self._state.backtracking == 0: ID711_tree = self._adaptor.createWithPayload(ID711) self._adaptor.addChild(root_0, ID711_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:1438:1: type_id : ID ; def type_id(self, ): retval = self.type_id_return() retval.start = self.input.LT(1) root_0 = None ID712 = None ID712_tree = None try: try: # sdl92.g:1438:17: ( ID ) # sdl92.g:1438:25: ID pass root_0 = self._adaptor.nil() ID712=self.match(self.input, ID, self.FOLLOW_ID_in_type_id15640) if self._state.backtracking == 0: ID712_tree = self._adaptor.createWithPayload(ID712) self._adaptor.addChild(root_0, ID712_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:1439:1: syntype_id : ID ; def syntype_id(self, ): retval = self.syntype_id_return() retval.start = self.input.LT(1) root_0 = None ID713 = None ID713_tree = None try: try: # sdl92.g:1439:17: ( ID ) # sdl92.g:1439:25: ID pass root_0 = self._adaptor.nil() ID713=self.match(self.input, ID, self.FOLLOW_ID_in_syntype_id15658) if self._state.backtracking == 0: ID713_tree = self._adaptor.createWithPayload(ID713) self._adaptor.addChild(root_0, ID713_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:1440:1: stimulus_id : ID ; def stimulus_id(self, ): retval = self.stimulus_id_return() retval.start = self.input.LT(1) root_0 = None ID714 = None ID714_tree = None try: try: # sdl92.g:1440:17: ( ID ) # sdl92.g:1440:25: ID pass root_0 = self._adaptor.nil() ID714=self.match(self.input, ID, self.FOLLOW_ID_in_stimulus_id15675) if self._state.backtracking == 0: ID714_tree = self._adaptor.createWithPayload(ID714) self._adaptor.addChild(root_0, ID714_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:1477: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 S715 = None E716 = None L717 = None F718 = None P719 = None A720 = None R721 = None E722 = None N723 = None T724 = None O725 = None F726 = None F727 = None S728 = None P729 = None R730 = None I731 = None N732 = None G733 = None S734 = None E735 = None N736 = None D737 = None E738 = None R739 = None S715_tree = None E716_tree = None L717_tree = None F718_tree = None P719_tree = None A720_tree = None R721_tree = None E722_tree = None N723_tree = None T724_tree = None O725_tree = None F726_tree = None F727_tree = None S728_tree = None P729_tree = None R730_tree = None I731_tree = None N732_tree = None G733_tree = None S734_tree = None E735_tree = None N736_tree = None D737_tree = None E738_tree = None R739_tree = None try: try: # sdl92.g:1478: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:1478:25: S E L F pass root_0 = self._adaptor.nil() S715=self.match(self.input, S, self.FOLLOW_S_in_pid_expression16772) if self._state.backtracking == 0: S715_tree = self._adaptor.createWithPayload(S715) self._adaptor.addChild(root_0, S715_tree) E716=self.match(self.input, E, self.FOLLOW_E_in_pid_expression16774) if self._state.backtracking == 0: E716_tree = self._adaptor.createWithPayload(E716) self._adaptor.addChild(root_0, E716_tree) L717=self.match(self.input, L, self.FOLLOW_L_in_pid_expression16776) if self._state.backtracking == 0: L717_tree = self._adaptor.createWithPayload(L717) self._adaptor.addChild(root_0, L717_tree) F718=self.match(self.input, F, self.FOLLOW_F_in_pid_expression16778) if self._state.backtracking == 0: F718_tree = self._adaptor.createWithPayload(F718) self._adaptor.addChild(root_0, F718_tree) elif alt208 == 2: # sdl92.g:1479:25: P A R E N T pass root_0 = self._adaptor.nil() P719=self.match(self.input, P, self.FOLLOW_P_in_pid_expression16804) if self._state.backtracking == 0: P719_tree = self._adaptor.createWithPayload(P719) self._adaptor.addChild(root_0, P719_tree) A720=self.match(self.input, A, self.FOLLOW_A_in_pid_expression16806) if self._state.backtracking == 0: A720_tree = self._adaptor.createWithPayload(A720) self._adaptor.addChild(root_0, A720_tree) R721=self.match(self.input, R, self.FOLLOW_R_in_pid_expression16808) if self._state.backtracking == 0: R721_tree = self._adaptor.createWithPayload(R721) self._adaptor.addChild(root_0, R721_tree) E722=self.match(self.input, E, self.FOLLOW_E_in_pid_expression16810) if self._state.backtracking == 0: E722_tree = self._adaptor.createWithPayload(E722) self._adaptor.addChild(root_0, E722_tree) N723=self.match(self.input, N, self.FOLLOW_N_in_pid_expression16812) if self._state.backtracking == 0: N723_tree = self._adaptor.createWithPayload(N723) self._adaptor.addChild(root_0, N723_tree) T724=self.match(self.input, T, self.FOLLOW_T_in_pid_expression16814) if self._state.backtracking == 0: T724_tree = self._adaptor.createWithPayload(T724) self._adaptor.addChild(root_0, T724_tree) elif alt208 == 3: # sdl92.g:1480:25: O F F S P R I N G pass root_0 = self._adaptor.nil() O725=self.match(self.input, O, self.FOLLOW_O_in_pid_expression16840) if self._state.backtracking == 0: O725_tree = self._adaptor.createWithPayload(O725) self._adaptor.addChild(root_0, O725_tree) F726=self.match(self.input, F, self.FOLLOW_F_in_pid_expression16842) if self._state.backtracking == 0: F726_tree = self._adaptor.createWithPayload(F726) self._adaptor.addChild(root_0, F726_tree) F727=self.match(self.input, F, self.FOLLOW_F_in_pid_expression16844) if self._state.backtracking == 0: F727_tree = self._adaptor.createWithPayload(F727) self._adaptor.addChild(root_0, F727_tree) S728=self.match(self.input, S, self.FOLLOW_S_in_pid_expression16846) if self._state.backtracking == 0: S728_tree = self._adaptor.createWithPayload(S728) self._adaptor.addChild(root_0, S728_tree) P729=self.match(self.input, P, self.FOLLOW_P_in_pid_expression16848) if self._state.backtracking == 0: P729_tree = self._adaptor.createWithPayload(P729) self._adaptor.addChild(root_0, P729_tree) R730=self.match(self.input, R, self.FOLLOW_R_in_pid_expression16850) if self._state.backtracking == 0: R730_tree = self._adaptor.createWithPayload(R730) self._adaptor.addChild(root_0, R730_tree) I731=self.match(self.input, I, self.FOLLOW_I_in_pid_expression16852) if self._state.backtracking == 0: I731_tree = self._adaptor.createWithPayload(I731) self._adaptor.addChild(root_0, I731_tree) N732=self.match(self.input, N, self.FOLLOW_N_in_pid_expression16854) if self._state.backtracking == 0: N732_tree = self._adaptor.createWithPayload(N732) self._adaptor.addChild(root_0, N732_tree) G733=self.match(self.input, G, self.FOLLOW_G_in_pid_expression16856) if self._state.backtracking == 0: G733_tree = self._adaptor.createWithPayload(G733) self._adaptor.addChild(root_0, G733_tree) elif alt208 == 4: # sdl92.g:1481:25: S E N D E R pass root_0 = self._adaptor.nil() S734=self.match(self.input, S, self.FOLLOW_S_in_pid_expression16882) if self._state.backtracking == 0: S734_tree = self._adaptor.createWithPayload(S734) self._adaptor.addChild(root_0, S734_tree) E735=self.match(self.input, E, self.FOLLOW_E_in_pid_expression16884) if self._state.backtracking == 0: E735_tree = self._adaptor.createWithPayload(E735) self._adaptor.addChild(root_0, E735_tree) N736=self.match(self.input, N, self.FOLLOW_N_in_pid_expression16886) if self._state.backtracking == 0: N736_tree = self._adaptor.createWithPayload(N736) self._adaptor.addChild(root_0, N736_tree) D737=self.match(self.input, D, self.FOLLOW_D_in_pid_expression16888) if self._state.backtracking == 0: D737_tree = self._adaptor.createWithPayload(D737) self._adaptor.addChild(root_0, D737_tree) E738=self.match(self.input, E, self.FOLLOW_E_in_pid_expression16890) if self._state.backtracking == 0: E738_tree = self._adaptor.createWithPayload(E738) self._adaptor.addChild(root_0, E738_tree) R739=self.match(self.input, R, self.FOLLOW_R_in_pid_expression16892) if self._state.backtracking == 0: R739_tree = self._adaptor.createWithPayload(R739) self._adaptor.addChild(root_0, R739_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:1482:1: now_expression : N O W ; def now_expression(self, ): retval = self.now_expression_return() retval.start = self.input.LT(1) root_0 = None N740 = None O741 = None W742 = None N740_tree = None O741_tree = None W742_tree = None try: try: # sdl92.g:1482:17: ( N O W ) # sdl92.g:1482:25: N O W pass root_0 = self._adaptor.nil() N740=self.match(self.input, N, self.FOLLOW_N_in_now_expression16906) if self._state.backtracking == 0: N740_tree = self._adaptor.createWithPayload(N740) self._adaptor.addChild(root_0, N740_tree) O741=self.match(self.input, O, self.FOLLOW_O_in_now_expression16908) if self._state.backtracking == 0: O741_tree = self._adaptor.createWithPayload(O741) self._adaptor.addChild(root_0, O741_tree) W742=self.match(self.input, W, self.FOLLOW_W_in_now_expression16910) if self._state.backtracking == 0: W742_tree = self._adaptor.createWithPayload(W742) self._adaptor.addChild(root_0, W742_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" class signed_return(ParserRuleReturnScope): def __init__(self): super(sdl92Parser.signed_return, self).__init__() self.tree = None # $ANTLR start "signed" # sdl92.g:1601:1: signed : ( DASH )? INT ; def signed(self, ): retval = self.signed_return() retval.start = self.input.LT(1) root_0 = None DASH743 = None INT744 = None DASH743_tree = None INT744_tree = None try: try: # sdl92.g:1602:9: ( ( DASH )? INT ) # sdl92.g:1602:17: ( DASH )? INT pass root_0 = self._adaptor.nil() # sdl92.g:1602:17: ( DASH )? alt209 = 2 LA209_0 = self.input.LA(1) if (LA209_0 == DASH) : alt209 = 1 if alt209 == 1: # sdl92.g:0:0: DASH pass DASH743=self.match(self.input, DASH, self.FOLLOW_DASH_in_signed19947) if self._state.backtracking == 0: DASH743_tree = self._adaptor.createWithPayload(DASH743) self._adaptor.addChild(root_0, DASH743_tree) INT744=self.match(self.input, INT, self.FOLLOW_INT_in_signed19950) if self._state.backtracking == 0: INT744_tree = self._adaptor.createWithPayload(INT744) self._adaptor.addChild(root_0, INT744_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 "signed" # $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 "synpred29_sdl92" def synpred29_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_synpred29_sdl922544) self.text_area() self._state.following.pop() # $ANTLR end "synpred29_sdl92" # $ANTLR start "synpred30_sdl92" def synpred30_sdl92_fragment(self, ): # sdl92.g:260:30: ( procedure ) # sdl92.g:260:30: procedure pass self._state.following.append(self.FOLLOW_procedure_in_synpred30_sdl922548) self.procedure() self._state.following.pop() # $ANTLR end "synpred30_sdl92" # $ANTLR start "synpred31_sdl92" def synpred31_sdl92_fragment(self, ): # sdl92.g:260:42: ( composite_state_preamble ) # sdl92.g:260:43: composite_state_preamble pass self._state.following.append(self.FOLLOW_composite_state_preamble_in_synpred31_sdl922553) self.composite_state_preamble() self._state.following.pop() # $ANTLR end "synpred31_sdl92" # $ANTLR start "synpred32_sdl92" def synpred32_sdl92_fragment(self, ): # sdl92.g:261:17: ( processBody ) # sdl92.g:261:17: processBody pass self._state.following.append(self.FOLLOW_processBody_in_synpred32_sdl922577) self.processBody() self._state.following.pop() # $ANTLR end "synpred32_sdl92" # $ANTLR start "synpred38_sdl92" def synpred38_sdl92_fragment(self, ): # sdl92.g:273:17: ( end ) # sdl92.g:273:17: end pass self._state.following.append(self.FOLLOW_end_in_synpred38_sdl922770) self.end() self._state.following.pop() # $ANTLR end "synpred38_sdl92" # $ANTLR start "synpred41_sdl92" def synpred41_sdl92_fragment(self, ): # sdl92.g:287:41: (e1= end ) # sdl92.g:287:41: e1= end pass self._state.following.append(self.FOLLOW_end_in_synpred41_sdl922917) e1 = self.end() self._state.following.pop() # $ANTLR end "synpred41_sdl92" # $ANTLR start "synpred44_sdl92" def synpred44_sdl92_fragment(self, ): # sdl92.g:290:18: ( text_area ) # sdl92.g:290:18: text_area pass self._state.following.append(self.FOLLOW_text_area_in_synpred44_sdl922981) self.text_area() self._state.following.pop() # $ANTLR end "synpred44_sdl92" # $ANTLR start "synpred45_sdl92" def synpred45_sdl92_fragment(self, ): # sdl92.g:290:30: ( procedure ) # sdl92.g:290:30: procedure pass self._state.following.append(self.FOLLOW_procedure_in_synpred45_sdl922985) self.procedure() self._state.following.pop() # $ANTLR end "synpred45_sdl92" # $ANTLR start "synpred46_sdl92" def synpred46_sdl92_fragment(self, ): # sdl92.g:291:19: ( processBody ) # sdl92.g:291:19: processBody pass self._state.following.append(self.FOLLOW_processBody_in_synpred46_sdl923007) self.processBody() self._state.following.pop() # $ANTLR end "synpred46_sdl92" # $ANTLR start "synpred57_sdl92" def synpred57_sdl92_fragment(self, ): # sdl92.g:324:17: ( content ) # sdl92.g:324:17: content pass self._state.following.append(self.FOLLOW_content_in_synpred57_sdl923459) self.content() self._state.following.pop() # $ANTLR end "synpred57_sdl92" # $ANTLR start "synpred94_sdl92" def synpred94_sdl92_fragment(self, ): # sdl92.g:483:34: (e= end ) # sdl92.g:483:34: e= end pass self._state.following.append(self.FOLLOW_end_in_synpred94_sdl925356) e = self.end() self._state.following.pop() # $ANTLR end "synpred94_sdl92" # $ANTLR start "synpred108_sdl92" def synpred108_sdl92_fragment(self, ): # sdl92.g:541:18: ( text_area ) # sdl92.g:541:18: text_area pass self._state.following.append(self.FOLLOW_text_area_in_synpred108_sdl926120) self.text_area() self._state.following.pop() # $ANTLR end "synpred108_sdl92" # $ANTLR start "synpred115_sdl92" def synpred115_sdl92_fragment(self, ): # sdl92.g:599:13: ( text_area ) # sdl92.g:599:13: text_area pass self._state.following.append(self.FOLLOW_text_area_in_synpred115_sdl926622) self.text_area() self._state.following.pop() # $ANTLR end "synpred115_sdl92" # $ANTLR start "synpred116_sdl92" def synpred116_sdl92_fragment(self, ): # sdl92.g:600:15: ( procedure ) # sdl92.g:600:15: procedure pass self._state.following.append(self.FOLLOW_procedure_in_synpred116_sdl926638) self.procedure() self._state.following.pop() # $ANTLR end "synpred116_sdl92" # $ANTLR start "synpred117_sdl92" def synpred117_sdl92_fragment(self, ): # sdl92.g:601:15: ( composite_state_preamble ) # sdl92.g:601:16: composite_state_preamble pass self._state.following.append(self.FOLLOW_composite_state_preamble_in_synpred117_sdl926655) self.composite_state_preamble() self._state.following.pop() # $ANTLR end "synpred117_sdl92" # $ANTLR start "synpred143_sdl92" def synpred143_sdl92_fragment(self, ): # sdl92.g:711:17: ( enabling_condition ) # sdl92.g:711:17: enabling_condition pass self._state.following.append(self.FOLLOW_enabling_condition_in_synpred143_sdl927739) self.enabling_condition() self._state.following.pop() # $ANTLR end "synpred143_sdl92" # $ANTLR start "synpred150_sdl92" def synpred150_sdl92_fragment(self, ): # sdl92.g:739:25: ( label ) # sdl92.g:739:25: label pass self._state.following.append(self.FOLLOW_label_in_synpred150_sdl928031) self.label() self._state.following.pop() # $ANTLR end "synpred150_sdl92" # $ANTLR start "synpred174_sdl92" def synpred174_sdl92_fragment(self, ): # sdl92.g:835:17: ( expression ) # sdl92.g:835:17: expression pass self._state.following.append(self.FOLLOW_expression_in_synpred174_sdl929150) self.expression() self._state.following.pop() # $ANTLR end "synpred174_sdl92" # $ANTLR start "synpred177_sdl92" def synpred177_sdl92_fragment(self, ): # sdl92.g:844:17: ( answer_part ) # sdl92.g:844:17: answer_part pass self._state.following.append(self.FOLLOW_answer_part_in_synpred177_sdl929264) self.answer_part() self._state.following.pop() # $ANTLR end "synpred177_sdl92" # $ANTLR start "synpred182_sdl92" def synpred182_sdl92_fragment(self, ): # sdl92.g:861:17: ( range_condition ) # sdl92.g:861:17: range_condition pass self._state.following.append(self.FOLLOW_range_condition_in_synpred182_sdl929500) self.range_condition() self._state.following.pop() # $ANTLR end "synpred182_sdl92" # $ANTLR start "synpred186_sdl92" def synpred186_sdl92_fragment(self, ): # sdl92.g:875:17: ( informal_text ) # sdl92.g:875:17: informal_text pass self._state.following.append(self.FOLLOW_informal_text_in_synpred186_sdl929655) self.informal_text() self._state.following.pop() # $ANTLR end "synpred186_sdl92" # $ANTLR start "synpred187_sdl92" def synpred187_sdl92_fragment(self, ): # sdl92.g:876:19: ( expression ) # sdl92.g:876:19: expression pass self._state.following.append(self.FOLLOW_expression_in_synpred187_sdl929675) self.expression() self._state.following.pop() # $ANTLR end "synpred187_sdl92" # $ANTLR start "synpred188_sdl92" def synpred188_sdl92_fragment(self, ): # sdl92.g:884:18: ( closed_range ) # sdl92.g:884:18: closed_range pass self._state.following.append(self.FOLLOW_closed_range_in_synpred188_sdl929768) self.closed_range() self._state.following.pop() # $ANTLR end "synpred188_sdl92" # $ANTLR start "synpred217_sdl92" def synpred217_sdl92_fragment(self, ): # sdl92.g:1017:18: ( COMMA b= ground_expression ) # sdl92.g:1017:18: COMMA b= ground_expression pass self.match(self.input, COMMA, self.FOLLOW_COMMA_in_synpred217_sdl9211298) self._state.following.append(self.FOLLOW_ground_expression_in_synpred217_sdl9211302) b = self.ground_expression() self._state.following.pop() # $ANTLR end "synpred217_sdl92" # $ANTLR start "synpred221_sdl92" def synpred221_sdl92_fragment(self, ): # sdl92.g:1041:39: ( IMPLIES binary_expression_0 ) # sdl92.g:1041:39: IMPLIES binary_expression_0 pass self.match(self.input, IMPLIES, self.FOLLOW_IMPLIES_in_synpred221_sdl9211564) self._state.following.append(self.FOLLOW_binary_expression_0_in_synpred221_sdl9211567) self.binary_expression_0() self._state.following.pop() # $ANTLR end "synpred221_sdl92" # $ANTLR start "synpred224_sdl92" def synpred224_sdl92_fragment(self, ): # sdl92.g:1043:38: ( ( ( OR ( ELSE )? ) | XOR ) binary_expression_1 ) # sdl92.g:1043:38: ( ( OR ( ELSE )? ) | XOR ) binary_expression_1 pass # sdl92.g:1043:38: ( ( OR ( ELSE )? ) | XOR ) alt224 = 2 LA224_0 = self.input.LA(1) if (LA224_0 == OR) : alt224 = 1 elif (LA224_0 == XOR) : alt224 = 2 else: if self._state.backtracking > 0: raise BacktrackingFailed nvae = NoViableAltException("", 224, 0, self.input) raise nvae if alt224 == 1: # sdl92.g:1043:40: ( OR ( ELSE )? ) pass # sdl92.g:1043:40: ( OR ( ELSE )? ) # sdl92.g:1043:41: OR ( ELSE )? pass self.match(self.input, OR, self.FOLLOW_OR_in_synpred224_sdl9211596) # sdl92.g:1043:45: ( ELSE )? alt223 = 2 LA223_0 = self.input.LA(1) if (LA223_0 == ELSE) : alt223 = 1 if alt223 == 1: # sdl92.g:0:0: ELSE pass self.match(self.input, ELSE, self.FOLLOW_ELSE_in_synpred224_sdl9211599) elif alt224 == 2: # sdl92.g:1043:54: XOR pass self.match(self.input, XOR, self.FOLLOW_XOR_in_synpred224_sdl9211605) self._state.following.append(self.FOLLOW_binary_expression_1_in_synpred224_sdl9211610) self.binary_expression_1() self._state.following.pop() # $ANTLR end "synpred224_sdl92" # $ANTLR start "synpred226_sdl92" def synpred226_sdl92_fragment(self, ): # sdl92.g:1045:39: ( AND ( THEN )? binary_expression_2 ) # sdl92.g:1045:39: AND ( THEN )? binary_expression_2 pass self.match(self.input, AND, self.FOLLOW_AND_in_synpred226_sdl9211637) # sdl92.g:1045:44: ( THEN )? alt225 = 2 LA225_0 = self.input.LA(1) if (LA225_0 == THEN) : alt225 = 1 if alt225 == 1: # sdl92.g:0:0: THEN pass self.match(self.input, THEN, self.FOLLOW_THEN_in_synpred226_sdl9211640) self._state.following.append(self.FOLLOW_binary_expression_2_in_synpred226_sdl9211643) self.binary_expression_2() self._state.following.pop() # $ANTLR end "synpred226_sdl92" # $ANTLR start "synpred233_sdl92" def synpred233_sdl92_fragment(self, ): # sdl92.g:1047:38: ( ( EQ | NEQ | GT | GE | LT | LE | IN ) binary_expression_3 ) # sdl92.g:1047: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_synpred233_sdl9211706) self.binary_expression_3() self._state.following.pop() # $ANTLR end "synpred233_sdl92" # $ANTLR start "synpred236_sdl92" def synpred236_sdl92_fragment(self, ): # sdl92.g:1049:38: ( ( PLUS | DASH | APPEND ) binary_expression_4 ) # sdl92.g:1049: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_synpred236_sdl9211749) self.binary_expression_4() self._state.following.pop() # $ANTLR end "synpred236_sdl92" # $ANTLR start "synpred240_sdl92" def synpred240_sdl92_fragment(self, ): # sdl92.g:1051:35: ( ( ASTERISK | DIV | MOD | REM ) unary_expression ) # sdl92.g:1051: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_synpred240_sdl9211797) self.unary_expression() self._state.following.pop() # $ANTLR end "synpred240_sdl92" # $ANTLR start "synpred241_sdl92" def synpred241_sdl92_fragment(self, ): # sdl92.g:1055:17: ( postfix_expression ) # sdl92.g:1055:17: postfix_expression pass self._state.following.append(self.FOLLOW_postfix_expression_in_synpred241_sdl9211822) self.postfix_expression() self._state.following.pop() # $ANTLR end "synpred241_sdl92" # $ANTLR start "synpred242_sdl92" def synpred242_sdl92_fragment(self, ): # sdl92.g:1056:17: ( primary_expression ) # sdl92.g:1056:17: primary_expression pass self._state.following.append(self.FOLLOW_primary_expression_in_synpred242_sdl9211840) self.primary_expression() self._state.following.pop() # $ANTLR end "synpred242_sdl92" # $ANTLR start "synpred244_sdl92" def synpred244_sdl92_fragment(self, ): # sdl92.g:1064:21: ( '(' params= expression_list ')' ) # sdl92.g:1064:21: '(' params= expression_list ')' pass self.match(self.input, L_PAREN, self.FOLLOW_L_PAREN_in_synpred244_sdl9211957) self._state.following.append(self.FOLLOW_expression_list_in_synpred244_sdl9211961) params = self.expression_list() self._state.following.pop() self.match(self.input, R_PAREN, self.FOLLOW_R_PAREN_in_synpred244_sdl9211963) # $ANTLR end "synpred244_sdl92" # $ANTLR start "synpred246_sdl92" def synpred246_sdl92_fragment(self, ): # sdl92.g:1066:21: ( ( '!' | DOT ) field_name ) # sdl92.g:1066:21: ( '!' | DOT ) field_name pass if self.input.LA(1) == DOT or self.input.LA(1) == 225: 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_field_name_in_synpred246_sdl9212025) self.field_name() self._state.following.pop() # $ANTLR end "synpred246_sdl92" # $ANTLR start "synpred256_sdl92" def synpred256_sdl92_fragment(self, ): # sdl92.g:1087:17: ( ID ':' expression ) # sdl92.g:1087:17: ID ':' expression pass self.match(self.input, ID, self.FOLLOW_ID_in_synpred256_sdl9212356) self.match(self.input, 223, self.FOLLOW_223_in_synpred256_sdl9212358) self._state.following.append(self.FOLLOW_expression_in_synpred256_sdl9212360) self.expression() self._state.following.pop() # $ANTLR end "synpred256_sdl92" # $ANTLR start "synpred257_sdl92" def synpred257_sdl92_fragment(self, ): # sdl92.g:1088:17: ( ID ) # sdl92.g:1088:17: ID pass self.match(self.input, ID, self.FOLLOW_ID_in_synpred257_sdl9212398) # $ANTLR end "synpred257_sdl92" # $ANTLR start "synpred258_sdl92" def synpred258_sdl92_fragment(self, ): # sdl92.g:1089:17: ( '{' '}' ) # sdl92.g:1089:17: '{' '}' pass self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_synpred258_sdl9212449) self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_synpred258_sdl9212451) # $ANTLR end "synpred258_sdl92" # $ANTLR start "synpred259_sdl92" def synpred259_sdl92_fragment(self, ): # sdl92.g:1090:17: ( '{' MANTISSA mant= INT COMMA BASE bas= INT COMMA EXPONENT exp= INT '}' ) # sdl92.g:1090:17: '{' MANTISSA mant= INT COMMA BASE bas= INT COMMA EXPONENT exp= INT '}' pass self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_synpred259_sdl9212495) self.match(self.input, MANTISSA, self.FOLLOW_MANTISSA_in_synpred259_sdl9212513) mant=self.match(self.input, INT, self.FOLLOW_INT_in_synpred259_sdl9212517) self.match(self.input, COMMA, self.FOLLOW_COMMA_in_synpred259_sdl9212519) self.match(self.input, BASE, self.FOLLOW_BASE_in_synpred259_sdl9212537) bas=self.match(self.input, INT, self.FOLLOW_INT_in_synpred259_sdl9212541) self.match(self.input, COMMA, self.FOLLOW_COMMA_in_synpred259_sdl9212543) self.match(self.input, EXPONENT, self.FOLLOW_EXPONENT_in_synpred259_sdl9212561) exp=self.match(self.input, INT, self.FOLLOW_INT_in_synpred259_sdl9212565) self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_synpred259_sdl9212583) # $ANTLR end "synpred259_sdl92" # $ANTLR start "synpred261_sdl92" def synpred261_sdl92_fragment(self, ): # sdl92.g:1095:17: ( '{' named_value ( COMMA named_value )* '}' ) # sdl92.g:1095:17: '{' named_value ( COMMA named_value )* '}' pass self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_synpred261_sdl9212640) self._state.following.append(self.FOLLOW_named_value_in_synpred261_sdl9212658) self.named_value() self._state.following.pop() # sdl92.g:1096:29: ( COMMA named_value )* while True: #loop226 alt226 = 2 LA226_0 = self.input.LA(1) if (LA226_0 == COMMA) : alt226 = 1 if alt226 == 1: # sdl92.g:1096:30: COMMA named_value pass self.match(self.input, COMMA, self.FOLLOW_COMMA_in_synpred261_sdl9212661) self._state.following.append(self.FOLLOW_named_value_in_synpred261_sdl9212663) self.named_value() self._state.following.pop() else: break #loop226 self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_synpred261_sdl9212683) # $ANTLR end "synpred261_sdl92" # $ANTLR start "synpred263_sdl92" def synpred263_sdl92_fragment(self, ): # sdl92.g:1098:17: ( '{' expression ( COMMA expression )* '}' ) # sdl92.g:1098:17: '{' expression ( COMMA expression )* '}' pass self.match(self.input, L_BRACKET, self.FOLLOW_L_BRACKET_in_synpred263_sdl9212734) self._state.following.append(self.FOLLOW_expression_in_synpred263_sdl9212752) self.expression() self._state.following.pop() # sdl92.g:1099:28: ( COMMA expression )* while True: #loop227 alt227 = 2 LA227_0 = self.input.LA(1) if (LA227_0 == COMMA) : alt227 = 1 if alt227 == 1: # sdl92.g:1099:29: COMMA expression pass self.match(self.input, COMMA, self.FOLLOW_COMMA_in_synpred263_sdl9212755) self._state.following.append(self.FOLLOW_expression_in_synpred263_sdl9212757) self.expression() self._state.following.pop() else: break #loop227 self.match(self.input, R_BRACKET, self.FOLLOW_R_BRACKET_in_synpred263_sdl9212777) # $ANTLR end "synpred263_sdl92" # $ANTLR start "synpred278_sdl92" def synpred278_sdl92_fragment(self, ): # sdl92.g:1306:47: ( SEMI ) # sdl92.g:1306:47: SEMI pass self.match(self.input, SEMI, self.FOLLOW_SEMI_in_synpred278_sdl9213986) # $ANTLR end "synpred278_sdl92" # Delegated rules def synpred45_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred45_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred278_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred278_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred188_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred188_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 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 synpred233_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred233_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred263_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred263_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred117_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred117_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred143_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred143_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred261_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred261_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred57_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred57_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred217_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred217_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 synpred256_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred256_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 synpred186_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred186_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred221_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred221_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred241_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred241_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 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 synpred224_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred224_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred244_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred244_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 synpred259_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred259_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 synpred46_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred46_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred94_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred94_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred174_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred174_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred116_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred116_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred226_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred226_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred242_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred242_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred44_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred44_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 synpred38_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred38_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred246_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred246_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred177_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred177_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred187_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred187_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred108_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred108_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred32_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred32_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success 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 synpred258_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred258_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred150_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred150_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred240_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred240_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success def synpred115_sdl92(self): self._state.backtracking += 1 start = self.input.mark() try: self.synpred115_sdl92_fragment() except BacktrackingFailed: success = False else: success = True self.input.rewind(start) self._state.backtracking -= 1 return success # lookup tables for DFA #21 DFA21_eot = DFA.unpack( u"\26\uffff" ) DFA21_eof = DFA.unpack( u"\1\2\25\uffff" ) DFA21_min = DFA.unpack( u"\1\14\1\0\1\uffff\1\0\22\uffff" ) DFA21_max = DFA.unpack( u"\1\u00e4\1\0\1\uffff\1\0\22\uffff" ) DFA21_accept = DFA.unpack( u"\2\uffff\1\4\20\uffff\1\2\1\1\1\3" ) DFA21_special = DFA.unpack( u"\1\uffff\1\0\1\uffff\1\1\22\uffff" ) DFA21_transition = [ DFA.unpack(u"\1\2\4\uffff\1\2\2\uffff\2\2\63\uffff\1\23\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\1\uffff\1\2\1\uffff\2\2\3\uffff\1\2\132\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""), 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_1 = input.LA(1) index21_1 = input.index() input.rewind() s = -1 if (self.synpred29_sdl92()): s = 20 elif (self.synpred30_sdl92()): s = 19 elif (True): s = 2 input.seek(index21_1) if s >= 0: return s elif s == 1: LA21_3 = input.LA(1) index21_3 = input.index() input.rewind() s = -1 if (self.synpred31_sdl92()): s = 21 elif (True): s = 2 input.seek(index21_3) 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 #22 DFA22_eot = DFA.unpack( u"\22\uffff" ) DFA22_eof = DFA.unpack( u"\1\10\21\uffff" ) DFA22_min = DFA.unpack( u"\1\14\1\0\1\uffff\16\0\1\uffff" ) DFA22_max = DFA.unpack( u"\1\u00e4\1\0\1\uffff\16\0\1\uffff" ) DFA22_accept = DFA.unpack( u"\2\uffff\1\1\16\uffff\1\2" ) DFA22_special = DFA.unpack( u"\1\uffff\1\12\1\uffff\1\2\1\3\1\10\1\16\1\6\1\4\1\0\1\5\1\13\1" u"\14\1\15\1\1\1\7\1\11\1\uffff" ) DFA22_transition = [ DFA.unpack(u"\1\20\4\uffff\1\6\2\uffff\1\17\1\2\66\uffff\1\13\14" u"\uffff\1\15\2\uffff\1\2\13\uffff\1\12\13\uffff\1\11\6\uffff\1\5" u"\3\uffff\1\14\1\16\1\uffff\1\4\1\uffff\1\3\1\7\3\uffff\1\2\132" u"\uffff\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"\1\uffff"), DFA.unpack(u"") ] # class definition for DFA #22 class DFA22(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: LA22_9 = input.LA(1) index22_9 = input.index() input.rewind() s = -1 if (self.synpred32_sdl92()): s = 2 elif (True): s = 17 input.seek(index22_9) if s >= 0: return s elif s == 1: LA22_14 = input.LA(1) index22_14 = input.index() input.rewind() s = -1 if (self.synpred32_sdl92()): s = 2 elif (True): s = 17 input.seek(index22_14) if s >= 0: return s elif s == 2: LA22_3 = input.LA(1) index22_3 = input.index() input.rewind() s = -1 if (self.synpred32_sdl92()): s = 2 elif (True): s = 17 input.seek(index22_3) if s >= 0: return s elif s == 3: LA22_4 = input.LA(1) index22_4 = input.index() input.rewind() s = -1 if (self.synpred32_sdl92()): s = 2 elif (True): s = 17 input.seek(index22_4) if s >= 0: return s elif s == 4: LA22_8 = input.LA(1) index22_8 = input.index() input.rewind() s = -1 if (self.synpred32_sdl92()): s = 2 elif (True): s = 17 input.seek(index22_8) if s >= 0: return s elif s == 5: LA22_10 = input.LA(1) index22_10 = input.index() input.rewind() s = -1 if (self.synpred32_sdl92()): s = 2 elif (True): s = 17 input.seek(index22_10) if s >= 0: return s elif s == 6: LA22_7 = input.LA(1) index22_7 = input.index() input.rewind() s = -1 if (self.synpred32_sdl92()): s = 2 elif (True): s = 17 input.seek(index22_7) if s >= 0: return s elif s == 7: LA22_15 = input.LA(1) index22_15 = input.index() input.rewind() s = -1 if (self.synpred32_sdl92()): s = 2 elif (True): s = 17 input.seek(index22_15) if s >= 0: return s elif s == 8: LA22_5 = input.LA(1) index22_5 = input.index() input.rewind() s = -1 if (self.synpred32_sdl92()): s = 2 elif (True): s = 17 input.seek(index22_5) if s >= 0: return s elif s == 9: LA22_16 = input.LA(1) index22_16 = input.index() input.rewind() s = -1 if (self.synpred32_sdl92()): s = 2 elif (True): s = 17 input.seek(index22_16) if s >= 0: return s elif s == 10: LA22_1 = input.LA(1) index22_1 = input.index() input.rewind() s = -1 if (self.synpred32_sdl92()): s = 2 elif (True): s = 17 input.seek(index22_1) if s >= 0: return s elif s == 11: LA22_11 = input.LA(1) index22_11 = input.index() input.rewind() s = -1 if (self.synpred32_sdl92()): s = 2 elif (True): s = 17 input.seek(index22_11) if s >= 0: return s elif s == 12: LA22_12 = input.LA(1) index22_12 = input.index() input.rewind() s = -1 if (self.synpred32_sdl92()): s = 2 elif (True): s = 17 input.seek(index22_12) if s >= 0: return s elif s == 13: LA22_13 = input.LA(1) index22_13 = input.index() input.rewind() s = -1 if (self.synpred32_sdl92()): s = 2 elif (True): s = 17 input.seek(index22_13) if s >= 0: return s elif s == 14: LA22_6 = input.LA(1) index22_6 = input.index() input.rewind() s = -1 if (self.synpred32_sdl92()): s = 2 elif (True): s = 17 input.seek(index22_6) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 22, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #26 DFA26_eot = DFA.unpack( u"\26\uffff" ) DFA26_eof = DFA.unpack( u"\1\3\25\uffff" ) DFA26_min = DFA.unpack( u"\1\14\1\7\2\uffff\1\u0093\1\u00b6\1\u0088\1\u00b7\1\u0088\1\u0095" u"\1\56\2\u0088\1\u0094\1\u0095\1\u0093\1\u0088\1\u0095\1\u0088\1" u"\u0094\1\u00e5\1\21" ) DFA26_max = DFA.unpack( u"\1\u00e4\1\u00b5\2\uffff\1\u0093\1\u00b6\1\u00a8\1\u00b7\1\u0088" u"\1\u0095\1\u00b8\1\u00a8\1\u0088\1\u0094\1\u0095\1\u0093\1\u0088" u"\1\u0095\1\u0088\1\u0094\1\u00e5\1\u00e4" ) DFA26_accept = DFA.unpack( u"\2\uffff\1\1\1\2\22\uffff" ) DFA26_special = DFA.unpack( u"\26\uffff" ) DFA26_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\4\uffff\1\2\136\uffff" u"\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"\34\uffff\1\4\53\uffff\1\5"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\11\37\uffff\1\10"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\2\24\uffff\1\3\164\uffff\1\3"), DFA.unpack(u"\1\15\37\uffff\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\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\2\72\uffff\1\3\u0097\uffff\1\2") ] # class definition for DFA #26 class DFA26(DFA): pass # lookup tables for DFA #28 DFA28_eot = DFA.unpack( u"\40\uffff" ) DFA28_eof = DFA.unpack( u"\1\4\37\uffff" ) DFA28_min = DFA.unpack( u"\1\14\1\7\1\143\1\0\1\uffff\1\u0093\1\u00b6\1\u0085\1\uffff\1\u0088" u"\1\u00b7\1\u0088\1\u0095\1\56\1\u0088\1\143\1\u0088\1\u0094\1\u00e5" u"\1\u0095\1\21\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1" u"\21\1\7\1\u00b6\1\u00b7\1\56" ) DFA28_max = DFA.unpack( u"\1\u00e4\1\u00b5\1\143\1\0\1\uffff\1\u0093\1\u00b6\1\u0085\1\uffff" u"\1\u00a8\1\u00b7\1\u0088\1\u0095\1\u00b8\1\u00a8\1\143\1\u0088" u"\1\u0094\1\u00e5\1\u0095\1\u0089\1\u0093\1\u0088\1\u0095\1\u0088" u"\1\u0094\1\u00e5\1\u00e4\1\u00b5\1\u00b6\1\u00b7\1\u00b8" ) DFA28_accept = DFA.unpack( u"\4\uffff\1\2\3\uffff\1\1\27\uffff" ) DFA28_special = DFA.unpack( u"\3\uffff\1\0\34\uffff" ) DFA28_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\1\uffff\1\4\1\uffff\1\4\1\3\3\uffff\1\4\132\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"\34\uffff\1\5\53\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\14\37\uffff\1\13"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17\24\uffff\1\4\164\uffff\1\4"), DFA.unpack(u"\1\21\37\uffff\1\20"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\2\3\uffff\1\4\106\uffff\1\4\54\uffff\1\4"), 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\33"), 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\24\uffff\1" u"\4\126\uffff\1\4\3\uffff\1\34"), 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\34\uffff\1\4\53\uffff\1\35"), DFA.unpack(u"\1\36"), DFA.unpack(u"\1\37"), DFA.unpack(u"\1\17\24\uffff\1\4\164\uffff\1\4") ] # class definition for DFA #28 class DFA28(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: LA28_3 = input.LA(1) index28_3 = input.index() input.rewind() s = -1 if (self.synpred38_sdl92()): s = 8 elif (True): s = 4 input.seek(index28_3) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 28, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #40 DFA40_eot = DFA.unpack( u"\35\uffff" ) DFA40_eof = DFA.unpack( u"\1\3\34\uffff" ) DFA40_min = DFA.unpack( u"\1\21\1\7\2\uffff\1\u0093\1\u00b6\1\u0088\1\u00b7\1\u0088\1\u0095" u"\1\56\1\u0088\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\21\1\u0093" u"\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\21\1\7\1\u00b6\1\u00b7" u"\1\56" ) DFA40_max = DFA.unpack( u"\1\u00e4\1\u00b5\2\uffff\1\u0093\1\u00b6\1\u00a8\1\u00b7\1\u0088" u"\1\u0095\1\u00b8\1\u00a8\1\143\1\u0088\1\u0094\1\u00e5\1\u0095" u"\1\u0089\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\u00e4" u"\1\u00b5\1\u00b6\1\u00b7\1\u00b8" ) DFA40_accept = DFA.unpack( u"\2\uffff\1\1\1\2\31\uffff" ) DFA40_special = DFA.unpack( u"\35\uffff" ) DFA40_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\20\uffff\1" u"\2\1\3\2\uffff\1\3\126\uffff\1\3\3\uffff\1\1"), DFA.unpack(u"\1\4\11\uffff\1\4\2\uffff\1\4\4\uffff\1\4\5\uffff\1" u"\3\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\34\uffff\1\4\53\uffff\1\5"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\11\37\uffff\1\10"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14\24\uffff\1\3\164\uffff\1\3"), DFA.unpack(u"\1\16\37\uffff\1\15"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\2\3\uffff\1\3\106\uffff\1\3\54\uffff\1\3"), 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\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\24\uffff\1\3\126\uffff" u"\1\3\3\uffff\1\31"), 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\34\uffff\1\3\53\uffff\1\32"), DFA.unpack(u"\1\33"), DFA.unpack(u"\1\34"), DFA.unpack(u"\1\14\24\uffff\1\3\164\uffff\1\3") ] # class definition for DFA #40 class DFA40(DFA): pass # lookup tables for DFA #45 DFA45_eot = DFA.unpack( u"\20\uffff" ) DFA45_eof = DFA.unpack( u"\1\2\17\uffff" ) DFA45_min = DFA.unpack( u"\1\30\1\7\13\uffff\1\u00b6\1\u00b7\1\103" ) DFA45_max = DFA.unpack( u"\1\u00e4\1\u00b5\13\uffff\1\u00b6\1\u00b7\1\u00b8" ) DFA45_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" ) DFA45_special = DFA.unpack( u"\20\uffff" ) DFA45_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\3\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\34\uffff\1\3\53\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\164\uffff\1\4") ] # class definition for DFA #45 class DFA45(DFA): pass # lookup tables for DFA #52 DFA52_eot = DFA.unpack( u"\35\uffff" ) DFA52_eof = DFA.unpack( u"\3\uffff\1\10\31\uffff" ) DFA52_min = DFA.unpack( u"\1\21\1\7\1\143\1\35\1\u00b6\1\u0093\1\u0085\2\uffff\1\u00b7\1" u"\u0088\1\56\1\u0088\1\u0095\1\143\1\u0088\1\u00e5\1\u0088\1\u0094" u"\1\21\1\u0095\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1" u"\21\1\u00b5" ) DFA52_max = DFA.unpack( u"\1\u00e4\1\u00b5\1\143\1\u0085\1\u00b6\1\u0093\1\u0085\2\uffff" u"\1\u00b7\1\u00a8\1\56\1\u0088\1\u0095\1\143\1\u00a8\1\u00e5\1\u0088" u"\1\u0094\1\21\1\u0095\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1" u"\u00e5\1\u00e4\1\u00b5" ) DFA52_accept = DFA.unpack( u"\7\uffff\1\1\1\2\24\uffff" ) DFA52_special = DFA.unpack( u"\35\uffff" ) DFA52_transition = [ DFA.unpack(u"\1\2\163\uffff\1\3\136\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"\34\uffff\1\5\53\uffff\1\4"), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\10\135\uffff\1\7\11\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\15\37\uffff\1\14"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\22\37\uffff\1\21"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\2"), 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\33"), DFA.unpack(u"\1\2\u00d2\uffff\1\34"), DFA.unpack(u"\1\4") ] # class definition for DFA #52 class DFA52(DFA): pass # lookup tables for DFA #58 DFA58_eot = DFA.unpack( u"\35\uffff" ) DFA58_eof = DFA.unpack( u"\1\3\34\uffff" ) DFA58_min = DFA.unpack( u"\1\14\1\7\2\uffff\1\u00b6\1\u0093\1\u00b7\1\u0088\1\56\1\u0088" u"\1\u0095\1\143\1\u0088\1\u00e5\1\u0088\1\u0094\1\21\1\u0095\1\u0093" u"\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\21\1\u00b5\1\u00b6\1" u"\u00b7\1\56" ) DFA58_max = DFA.unpack( u"\1\u00e4\1\u00b5\2\uffff\1\u00b6\1\u0093\1\u00b7\1\u00a8\1\u00b8" u"\1\u0088\1\u0095\1\143\1\u00a8\1\u00e5\1\u0088\1\u0094\1\u0089" u"\1\u0095\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\u00e4" u"\1\u00b5\1\u00b6\1\u00b7\1\56" ) DFA58_accept = DFA.unpack( u"\2\uffff\1\1\1\2\31\uffff" ) DFA58_special = DFA.unpack( u"\35\uffff" ) DFA58_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\1\uffff\1\3\1\uffff\3\3\2\uffff\1\2\132\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"\34\uffff\1\5\53\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\12\37\uffff\1\11"), DFA.unpack(u"\1\13\24\uffff\1\3\164\uffff\1\3"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\17\37\uffff\1\16"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\3\3\uffff\1\3\106\uffff\1\3\54\uffff\1\2"), 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\3\3\uffff\1\3\66\uffff\1\3\17\uffff\1\3\54\uffff" u"\1\2\132\uffff\1\31"), DFA.unpack(u"\1\32"), DFA.unpack(u"\1\33"), DFA.unpack(u"\1\34"), DFA.unpack(u"\1\13") ] # class definition for DFA #58 class DFA58(DFA): pass # lookup tables for DFA #59 DFA59_eot = DFA.unpack( u"\36\uffff" ) DFA59_eof = DFA.unpack( u"\1\1\35\uffff" ) DFA59_min = DFA.unpack( u"\1\14\1\uffff\1\7\2\uffff\1\u0093\1\u00b6\1\u0088\1\u00b7\1\u0088" u"\1\u0095\1\56\1\u0088\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\21" u"\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\21\1\u00b5\1" u"\u00b6\1\u00b7\1\56" ) DFA59_max = DFA.unpack( u"\1\u00e4\1\uffff\1\u00b5\2\uffff\1\u0093\1\u00b6\1\u00a8\1\u00b7" u"\1\u0088\1\u0095\1\u00b8\1\u00a8\1\143\1\u0088\1\u0094\1\u00e5" u"\1\u0095\1\134\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5" u"\1\u00e4\1\u00b5\1\u00b6\1\u00b7\1\56" ) DFA59_accept = DFA.unpack( u"\1\uffff\1\3\1\uffff\1\1\1\2\31\uffff" ) DFA59_special = DFA.unpack( u"\36\uffff" ) DFA59_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\1\uffff\1\1\1\uffff\3\1\135\uffff\1\2"), DFA.unpack(u""), 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"\34\uffff\1\5\53\uffff\1\6"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\12\37\uffff\1\11"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15\24\uffff\1\1\164\uffff\1\1"), DFA.unpack(u"\1\17\37\uffff\1\16"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\1\3\uffff\1\4\106\uffff\1\3"), 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\1\3\uffff\1\4\66\uffff\1\1\17\uffff\1\3\u0087\uffff" u"\1\32"), DFA.unpack(u"\1\33"), DFA.unpack(u"\1\34"), DFA.unpack(u"\1\35"), DFA.unpack(u"\1\15") ] # class definition for DFA #59 class DFA59(DFA): pass # lookup tables for DFA #63 DFA63_eot = DFA.unpack( u"\36\uffff" ) DFA63_eof = DFA.unpack( u"\1\4\1\uffff\1\4\33\uffff" ) DFA63_min = DFA.unpack( u"\1\6\1\7\1\14\2\uffff\1\u0093\1\u00b6\1\u0088\1\u00b7\1\u0088\1" u"\u0095\1\56\1\u0088\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\21" u"\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\21\1\u00b5\1" u"\u00b6\1\u00b7\1\56" ) DFA63_max = DFA.unpack( u"\1\u00e4\1\u00b5\1\u00e4\2\uffff\1\u0093\1\u00b6\1\u00a8\1\u00b7" u"\1\u0088\1\u0095\1\u00b8\1\u00a8\1\143\1\u0088\1\u0094\1\u00e5" u"\1\u0095\1\u0096\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5" u"\1\u00e4\1\u00b5\1\u00b6\1\u00b7\1\56" ) DFA63_accept = DFA.unpack( u"\3\uffff\1\1\1\2\31\uffff" ) DFA63_special = DFA.unpack( u"\36\uffff" ) DFA63_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\1\uffff\1\4\1\uffff\3\4\2\uffff\1\4\5\uffff\1\4\6\uffff\1" u"\3\11\uffff\1\3\103\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"\34\uffff\1\5\53\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\4\uffff\1\4\15\uffff" u"\1\3\17\uffff\1\3\26\uffff\1\3\44\uffff\1\3\1\uffff\1\3\2\uffff" u"\1\4"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\12\37\uffff\1\11"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15\24\uffff\1\4\164\uffff\1\4"), DFA.unpack(u"\1\17\37\uffff\1\16"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), 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\37\uffff\1\4\14\uffff\1\3"), 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\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\15\uffff\1\4\14\uffff\1\3\115\uffff" u"\1\32"), DFA.unpack(u"\1\33"), DFA.unpack(u"\1\34"), DFA.unpack(u"\1\35"), DFA.unpack(u"\1\15") ] # class definition for DFA #63 class DFA63(DFA): pass # lookup tables for DFA #82 DFA82_eot = DFA.unpack( u"\27\uffff" ) DFA82_eof = DFA.unpack( u"\27\uffff" ) DFA82_min = DFA.unpack( u"\1\24\1\uffff\1\7\1\uffff\1\u0093\2\u0088\1\u0095\2\u0088\1\u0094" u"\1\u0095\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\30\1" u"\7\1\u00b6\1\u00b7\1\56" ) DFA82_max = DFA.unpack( u"\1\u00e4\1\uffff\1\u00b5\1\uffff\1\u0093\1\u00a8\1\u0088\1\u0095" u"\1\u00a8\1\u0088\1\u0094\1\u0095\1\u0093\1\u0088\1\u0095\1\u0088" u"\1\u0094\1\u00e5\1\u00e4\1\u00b5\1\u00b6\1\u00b7\1\u00b8" ) DFA82_accept = DFA.unpack( u"\1\uffff\1\2\1\uffff\1\1\23\uffff" ) DFA82_special = DFA.unpack( u"\27\uffff" ) DFA82_transition = [ DFA.unpack(u"\1\1\64\uffff\1\3\22\uffff\1\1\62\uffff\1\1\124\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"\34\uffff\1\4\53\uffff\1\1"), DFA.unpack(u""), DFA.unpack(u"\1\5"), DFA.unpack(u"\1\7\37\uffff\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\12\37\uffff\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\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\3\uffff\1\23"), 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\34\uffff\1\3\53\uffff\1\24"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\1\24\uffff\1\3\164\uffff\1\3") ] # class definition for DFA #82 class DFA82(DFA): pass # lookup tables for DFA #85 DFA85_eot = DFA.unpack( u"\41\uffff" ) DFA85_eof = DFA.unpack( u"\41\uffff" ) DFA85_min = DFA.unpack( u"\1\24\1\uffff\1\173\2\uffff\1\21\1\7\1\143\1\24\1\u00b6\1\u0093" u"\1\u0085\1\24\1\u00b7\1\u0088\1\56\1\u0088\1\u0095\1\143\1\u0088" u"\1\u00e5\1\u0088\1\u0094\1\21\1\u0095\1\u0093\1\u0088\1\u0095\1" u"\u0088\1\u0094\1\u00e5\1\21\1\u00b5" ) DFA85_max = DFA.unpack( u"\1\u00e4\1\uffff\1\u008d\2\uffff\1\u00e4\1\u00b5\1\143\1\u00e4" u"\1\u00b6\1\u0093\1\u0085\1\u00e4\1\u00b7\1\u00a8\1\56\1\u0088\1" u"\u0095\1\143\1\u00a8\1\u00e5\1\u0088\1\u0094\1\21\1\u0095\1\u0093" u"\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\u00e4\1\u00b5" ) DFA85_accept = DFA.unpack( u"\1\uffff\1\3\1\uffff\1\2\1\1\34\uffff" ) DFA85_special = DFA.unpack( u"\41\uffff" ) DFA85_transition = [ DFA.unpack(u"\1\3\107\uffff\1\2\62\uffff\1\1\124\uffff\1\1"), DFA.unpack(u""), DFA.unpack(u"\1\5\20\uffff\1\1\1\4"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\7\163\uffff\1\10\17\uffff\1\1\116\uffff\1\6"), DFA.unpack(u"\1\12\11\uffff\1\12\2\uffff\1\12\4\uffff\1\12\32\uffff" u"\1\12\2\uffff\2\12\3\uffff\1\12\3\uffff\1\12\10\uffff\2\12\1\uffff" u"\2\12\3\uffff\1\12\12\uffff\1\12\4\uffff\1\12\7\uffff\1\12\2\uffff" u"\1\12\34\uffff\1\12\53\uffff\1\11"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\1\37\uffff\1\1\30\uffff\1\1\6\uffff\1\1\60\uffff" u"\1\14\5\uffff\1\1\2\uffff\1\4\125\uffff\1\1"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\1\37\uffff\1\1\30\uffff\1\1\6\uffff\1\1\60\uffff" u"\1\14\5\uffff\1\1\2\uffff\1\4\125\uffff\1\1"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\21\37\uffff\1\20"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\26\37\uffff\1\25"), DFA.unpack(u"\1\27"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\30"), DFA.unpack(u"\1\7"), 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\7\u00d2\uffff\1\40"), DFA.unpack(u"\1\11") ] # class definition for DFA #85 class DFA85(DFA): pass # lookup tables for DFA #90 DFA90_eot = DFA.unpack( u"\12\uffff" ) DFA90_eof = DFA.unpack( u"\1\2\11\uffff" ) DFA90_min = DFA.unpack( u"\1\25\1\0\1\uffff\1\0\6\uffff" ) DFA90_max = DFA.unpack( u"\1\u00e4\1\0\1\uffff\1\0\6\uffff" ) DFA90_accept = DFA.unpack( u"\2\uffff\1\4\4\uffff\1\2\1\1\1\3" ) DFA90_special = DFA.unpack( u"\1\uffff\1\0\1\uffff\1\1\6\uffff" ) DFA90_transition = [ DFA.unpack(u"\1\2\63\uffff\1\7\22\uffff\1\3\54\uffff\1\2\5\uffff" u"\1\2\124\uffff\1\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"") ] # class definition for DFA #90 class DFA90(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: LA90_1 = input.LA(1) index90_1 = input.index() input.rewind() s = -1 if (self.synpred115_sdl92()): s = 8 elif (self.synpred116_sdl92()): s = 7 elif (True): s = 2 input.seek(index90_1) if s >= 0: return s elif s == 1: LA90_3 = input.LA(1) index90_3 = input.index() input.rewind() s = -1 if (self.synpred117_sdl92()): s = 9 elif (True): s = 2 input.seek(index90_3) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 90, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #91 DFA91_eot = DFA.unpack( u"\32\uffff" ) DFA91_eof = DFA.unpack( u"\1\2\31\uffff" ) DFA91_min = DFA.unpack( u"\1\25\1\7\2\uffff\1\u0093\1\u00b6\1\u0088\1\u00b7\1\u0088\1\u0095" u"\1\56\1\u0088\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\25\1\u0093" u"\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\25\1\u00b5" ) DFA91_max = DFA.unpack( u"\1\u00e4\1\u00b5\2\uffff\1\u0093\1\u00b6\1\u00a8\1\u00b7\1\u0088" u"\1\u0095\1\56\1\u00a8\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\u0089" u"\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\u00e4\1\u00b5" ) DFA91_accept = DFA.unpack( u"\2\uffff\1\2\1\1\26\uffff" ) DFA91_special = DFA.unpack( u"\32\uffff" ) DFA91_transition = [ DFA.unpack(u"\1\2\106\uffff\1\2\54\uffff\1\3\5\uffff\1\2\124\uffff" u"\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"\34\uffff\1\4\53\uffff\1\5"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\11\37\uffff\1\10"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\16\37\uffff\1\15"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\2\106\uffff\1\2\54\uffff\1\3"), 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\2\106\uffff\1\2\54\uffff\1\3\132\uffff\1\31"), DFA.unpack(u"\1\5") ] # class definition for DFA #91 class DFA91(DFA): pass # lookup tables for DFA #92 DFA92_eot = DFA.unpack( u"\33\uffff" ) DFA92_eof = DFA.unpack( u"\1\1\32\uffff" ) DFA92_min = DFA.unpack( u"\1\25\1\uffff\1\7\2\uffff\1\u0093\1\u00b6\1\u0088\1\u00b7\1\u0088" u"\1\u0095\1\56\1\u0088\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\25" u"\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\25\1\u00b5" ) DFA92_max = DFA.unpack( u"\1\u00e4\1\uffff\1\u00b5\2\uffff\1\u0093\1\u00b6\1\u00a8\1\u00b7" u"\1\u0088\1\u0095\1\56\1\u00a8\1\143\1\u0088\1\u0094\1\u00e5\1\u0095" u"\1\134\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\u00e4" u"\1\u00b5" ) DFA92_accept = DFA.unpack( u"\1\uffff\1\3\1\uffff\1\1\1\2\26\uffff" ) DFA92_special = DFA.unpack( u"\33\uffff" ) DFA92_transition = [ DFA.unpack(u"\1\4\106\uffff\1\3\62\uffff\1\1\124\uffff\1\2"), DFA.unpack(u""), 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"\34\uffff\1\5\53\uffff\1\6"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\12\37\uffff\1\11"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\17\37\uffff\1\16"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\4\106\uffff\1\3"), 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\4\106\uffff\1\3\u0087\uffff\1\32"), DFA.unpack(u"\1\6") ] # class definition for DFA #92 class DFA92(DFA): pass # lookup tables for DFA #94 DFA94_eot = DFA.unpack( u"\36\uffff" ) DFA94_eof = DFA.unpack( u"\36\uffff" ) DFA94_min = DFA.unpack( u"\1\24\1\7\1\173\3\uffff\1\u00b6\1\u0093\2\uffff\1\u00b7\1\u0088" u"\1\56\1\u0088\1\u0095\1\143\1\u0088\1\u00e5\1\u0088\1\u0094\1\24" u"\1\u0095\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\24\1" u"\u00b5" ) DFA94_max = DFA.unpack( u"\1\u00e4\1\u00b5\1\u0091\3\uffff\1\u00b6\1\u0093\2\uffff\1\u00b7" u"\1\u00a8\1\56\1\u0088\1\u0095\1\143\1\u00a8\1\u00e5\1\u0088\1\u0094" u"\1\115\1\u0095\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5" u"\1\u00e4\1\u00b5" ) DFA94_accept = DFA.unpack( u"\3\uffff\1\2\1\4\1\5\2\uffff\1\3\1\1\24\uffff" ) DFA94_special = DFA.unpack( u"\36\uffff" ) DFA94_transition = [ DFA.unpack(u"\1\5\37\uffff\1\2\30\uffff\1\4\6\uffff\1\3\u008f\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"\34\uffff\1\7\53\uffff\1\6"), DFA.unpack(u"\1\11\20\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\16\37\uffff\1\15"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\23\37\uffff\1\22"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\5\37\uffff\1\2\30\uffff\1\4"), 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\33"), DFA.unpack(u"\1\34"), DFA.unpack(u"\1\5\37\uffff\1\2\30\uffff\1\4\u0096\uffff\1\35"), DFA.unpack(u"\1\6") ] # class definition for DFA #94 class DFA94(DFA): pass # lookup tables for DFA #98 DFA98_eot = DFA.unpack( u"\32\uffff" ) DFA98_eof = DFA.unpack( u"\1\3\31\uffff" ) DFA98_min = DFA.unpack( u"\1\6\1\7\2\uffff\1\u0093\1\u00b6\1\u0088\1\u00b7\1\u0088\1\u0095" u"\1\56\1\u0088\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\24\1\u0093" u"\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\24\1\u00b5" ) DFA98_max = DFA.unpack( u"\1\u00e4\1\u00b5\2\uffff\1\u0093\1\u00b6\1\u00a8\1\u00b7\1\u0088" u"\1\u0095\1\56\1\u00a8\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\u0096" u"\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\u00e4\1\u00b5" ) DFA98_accept = DFA.unpack( u"\2\uffff\1\1\1\2\26\uffff" ) DFA98_special = DFA.unpack( u"\32\uffff" ) DFA98_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\17\uffff\1\3\12\uffff\1\2\11\uffff\1" u"\2\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"\34\uffff\1\4\53\uffff\1\5"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\11\37\uffff\1\10"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\16\37\uffff\1\15"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), 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\54\uffff\1\2"), 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\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\32\uffff\1\2\115\uffff\1\31"), DFA.unpack(u"\1\5") ] # class definition for DFA #98 class DFA98(DFA): pass # lookup tables for DFA #107 DFA107_eot = DFA.unpack( u"\32\uffff" ) DFA107_eof = DFA.unpack( u"\1\3\31\uffff" ) DFA107_min = DFA.unpack( u"\1\6\1\7\2\uffff\1\u0093\1\u00b6\1\u0088\1\u00b7\1\u0088\1\u0095" u"\1\56\1\u0088\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\24\1\u0093" u"\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\24\1\u00b5" ) DFA107_max = DFA.unpack( u"\1\u00e4\1\u00b5\2\uffff\1\u0093\1\u00b6\1\u00a8\1\u00b7\1\u0088" u"\1\u0095\1\56\1\u00a8\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\u0096" u"\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\u00e4\1\u00b5" ) DFA107_accept = DFA.unpack( u"\2\uffff\1\1\1\2\26\uffff" ) DFA107_special = DFA.unpack( u"\32\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\17\uffff\1\3\12\uffff\1\2\11\uffff\1" u"\2\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"\34\uffff\1\4\53\uffff\1\5"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\11\37\uffff\1\10"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\16\37\uffff\1\15"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), 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\54\uffff\1\2"), 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\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\32\uffff\1\2\115\uffff\1\31"), DFA.unpack(u"\1\5") ] # class definition for DFA #107 class DFA107(DFA): pass # lookup tables for DFA #112 DFA112_eot = DFA.unpack( u"\31\uffff" ) DFA112_eof = DFA.unpack( u"\1\2\30\uffff" ) DFA112_min = DFA.unpack( u"\1\6\1\0\27\uffff" ) DFA112_max = DFA.unpack( u"\1\u00e4\1\0\27\uffff" ) DFA112_accept = DFA.unpack( u"\2\uffff\1\2\25\uffff\1\1" ) DFA112_special = DFA.unpack( u"\1\uffff\1\0\27\uffff" ) DFA112_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\17\uffff\1\2\12\uffff\1\2\11\uffff\1" u"\2\103\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 #112 class DFA112(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: LA112_1 = input.LA(1) index112_1 = input.index() input.rewind() s = -1 if (self.synpred143_sdl92()): s = 24 elif (True): s = 2 input.seek(index112_1) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 112, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #113 DFA113_eot = DFA.unpack( u"\32\uffff" ) DFA113_eof = DFA.unpack( u"\1\3\31\uffff" ) DFA113_min = DFA.unpack( u"\1\6\1\7\2\uffff\1\u0093\1\u00b6\1\u0088\1\u00b7\1\u0088\1\u0095" u"\1\56\1\u0088\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\24\1\u0093" u"\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\24\1\u00b5" ) DFA113_max = DFA.unpack( u"\1\u00e4\1\u00b5\2\uffff\1\u0093\1\u00b6\1\u00a8\1\u00b7\1\u0088" u"\1\u0095\1\56\1\u00a8\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\u0096" u"\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\u00e4\1\u00b5" ) DFA113_accept = DFA.unpack( u"\2\uffff\1\1\1\2\26\uffff" ) DFA113_special = DFA.unpack( u"\32\uffff" ) DFA113_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\17\uffff\1\3\12\uffff\1\2\11\uffff\1" u"\2\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"\34\uffff\1\4\53\uffff\1\5"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\11\37\uffff\1\10"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\16\37\uffff\1\15"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), 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\54\uffff\1\2"), 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\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\32\uffff\1\2\115\uffff\1\31"), DFA.unpack(u"\1\5") ] # class definition for DFA #113 class DFA113(DFA): pass # lookup tables for DFA #121 DFA121_eot = DFA.unpack( u"\55\uffff" ) DFA121_eof = DFA.unpack( u"\55\uffff" ) DFA121_min = DFA.unpack( u"\1\6\1\7\1\u0093\2\uffff\1\u00b6\1\u0093\1\6\1\u00b7\1\u0088\1" u"\7\1\56\1\u0088\1\u0095\1\u0093\1\143\2\u0088\1\u00e5\1\u0088\1" u"\u0094\1\u0088\1\u0095\1\31\1\u0095\1\u0088\1\u0093\1\u0088\1\u0094" u"\1\u0088\2\u0095\1\u0093\2\u0088\1\u0094\1\u0095\1\u00e5\1\u0088" u"\1\31\1\u0094\1\u00b5\1\u00df\1\u00e5\1\31" ) DFA121_max = DFA.unpack( u"\1\u00e4\1\u00b5\1\u00e1\2\uffff\1\u00b6\1\u0093\1\u00e4\1\u00b7" u"\1\u00a8\1\u00b5\1\56\1\u0088\1\u0095\1\u0093\1\143\2\u00a8\1\u00e5" u"\1\u0088\1\u0094\1\u0088\1\u0095\1\u0096\1\u0095\1\u00a8\1\u0093" u"\1\u0088\1\u0094\1\u0088\2\u0095\1\u0093\2\u0088\1\u0094\1\u0095" u"\1\u00e5\1\u0088\1\u00e4\1\u0094\1\u00b5\1\u00df\1\u00e5\1\u00e4" ) DFA121_accept = DFA.unpack( u"\3\uffff\1\1\1\2\50\uffff" ) DFA121_special = DFA.unpack( u"\55\uffff" ) DFA121_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\32\uffff\1\3\11\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"\34\uffff\1\6\53\uffff\1\5"), DFA.unpack(u"\1\3\17\uffff\1\3\26\uffff\1\3\44\uffff\1\7\1\uffff" u"\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\32\uffff\1\3\11\uffff" u"\1\3\103\uffff\1\12"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\15\37\uffff\1\14"), 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\34\uffff\1\16\53\uffff\1\5"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\24\37\uffff\1\23"), DFA.unpack(u"\1\26\37\uffff\1\25"), DFA.unpack(u"\1\27"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\30"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\31"), 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\54\uffff\1\3"), DFA.unpack(u"\1\32"), DFA.unpack(u"\1\34\37\uffff\1\33"), DFA.unpack(u"\1\35"), DFA.unpack(u"\1\34"), 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\46"), DFA.unpack(u"\1\47"), 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\21\uffff\1\52\32\uffff\1\3\115\uffff" u"\1\51"), DFA.unpack(u"\1\53"), DFA.unpack(u"\1\5"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\54"), 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\54\uffff\1\3\115\uffff\1\51") ] # class definition for DFA #121 class DFA121(DFA): pass # lookup tables for DFA #118 DFA118_eot = DFA.unpack( u"\61\uffff" ) DFA118_eof = DFA.unpack( u"\1\3\1\uffff\1\3\4\uffff\1\3\3\uffff\1\3\45\uffff" ) DFA118_min = DFA.unpack( u"\1\6\1\7\1\14\2\uffff\1\u0093\1\u00b6\1\6\1\u0088\1\u00b7\1\7\1" u"\14\1\u0088\1\u0095\1\56\1\u0093\1\u0088\1\143\2\u0088\1\u0094" u"\1\u00e5\1\u0088\2\u0095\1\21\1\u0088\1\u0093\1\u0088\1\u0094\1" u"\u0088\2\u0095\1\u0093\2\u0088\1\u0094\1\u0095\1\u00e5\1\u0088" u"\1\21\1\u0094\1\u00b5\1\u00df\1\u00e5\1\u00b6\1\21\1\u00b7\1\56" ) DFA118_max = DFA.unpack( u"\1\u00e4\1\u00b9\1\u00e4\2\uffff\1\u0093\1\u00b6\1\u00e4\1\u00a8" u"\1\u00b7\1\u00b9\1\u00e4\1\u0088\1\u0095\1\u00b8\1\u0093\1\u00a8" u"\1\143\1\u00a8\1\u0088\1\u0094\1\u00e5\1\u0088\2\u0095\1\u0096" u"\1\u00a8\1\u0093\1\u0088\1\u0094\1\u0088\2\u0095\1\u0093\2\u0088" u"\1\u0094\1\u0095\1\u00e5\1\u0088\1\u00e4\1\u0094\1\u00b5\1\u00df" u"\1\u00e5\1\u00b6\1\u00e4\1\u00b7\1\56" ) DFA118_accept = DFA.unpack( u"\3\uffff\1\2\1\1\54\uffff" ) DFA118_special = DFA.unpack( u"\61\uffff" ) DFA118_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\1\uffff\1\3\1\uffff" u"\3\3\2\uffff\3\3\3\uffff\1\3\3\uffff\1\3\2\uffff\1\4\2\3\7\uffff" u"\1\4\1\uffff\1\3\101\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"\34\uffff\1\5\53\uffff\1\6\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\4\uffff\1\3\15\uffff" u"\1\4\17\uffff\1\4\26\uffff\1\4\44\uffff\1\7\1\uffff\1\4\2\uffff" u"\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\1\uffff\1\3\1\uffff" u"\3\3\2\uffff\3\3\3\uffff\1\3\3\uffff\1\3\2\uffff\1\4\2\3\7\uffff" u"\1\4\1\uffff\1\3\101\uffff\1\12"), DFA.unpack(u"\1\15\37\uffff\1\14"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\17\11\uffff\1\17\2\uffff\1\17\4\uffff\1\17\32\uffff" u"\1\17\2\uffff\2\17\3\uffff\1\17\3\uffff\1\17\10\uffff\2\17\1\uffff" u"\2\17\3\uffff\1\17\12\uffff\1\17\4\uffff\1\17\7\uffff\1\17\2\uffff" u"\1\17\34\uffff\1\17\53\uffff\1\6\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\4\uffff\1\3\15\uffff" u"\1\4\17\uffff\1\4\26\uffff\1\4\44\uffff\1\3\1\uffff\1\4\2\uffff" u"\1\3"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21\24\uffff\1\3\164\uffff\1\3"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\24\37\uffff\1\23"), DFA.unpack(u"\1\25"), DFA.unpack(u"\1\27\37\uffff\1\26"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\30"), DFA.unpack(u"\1\31"), DFA.unpack(u"\1\27"), DFA.unpack(u"\1\32"), DFA.unpack(u"\1\33"), 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\37\uffff\1\3\11\uffff\1\3" u"\2\uffff\1\4"), DFA.unpack(u"\1\35\37\uffff\1\34"), DFA.unpack(u"\1\36"), DFA.unpack(u"\1\35"), 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\46"), DFA.unpack(u"\1\47"), DFA.unpack(u"\1\50"), DFA.unpack(u"\1\51"), 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\53\15\uffff\1" u"\3\11\uffff\1\3\2\uffff\1\4\115\uffff\1\52"), DFA.unpack(u"\1\54"), DFA.unpack(u"\1\55"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\56"), DFA.unpack(u"\1\57"), 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\15\uffff\1\3" u"\11\uffff\1\3\2\uffff\1\4\115\uffff\1\52"), DFA.unpack(u"\1\60"), DFA.unpack(u"\1\21") ] # class definition for DFA #118 class DFA118(DFA): pass # lookup tables for DFA #119 DFA119_eot = DFA.unpack( u"\26\uffff" ) DFA119_eof = DFA.unpack( u"\1\3\1\uffff\1\3\23\uffff" ) DFA119_min = DFA.unpack( u"\1\14\1\7\1\14\1\uffff\1\u0093\1\0\1\u0088\1\uffff\1\u0088\1\u0095" u"\2\u0088\1\u0094\1\u0095\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094" u"\1\u00e5\1\21\1\u00df" ) DFA119_max = DFA.unpack( u"\1\u00e4\1\u00b9\1\u00e4\1\uffff\1\u0093\1\0\1\u00a8\1\uffff\1" u"\u0088\1\u0095\1\u00a8\1\u0088\1\u0094\1\u0095\1\u0093\1\u0088" u"\1\u0095\1\u0088\1\u0094\1\u00e5\1\u00e4\1\u00df" ) DFA119_accept = DFA.unpack( u"\3\uffff\1\2\3\uffff\1\1\16\uffff" ) DFA119_special = DFA.unpack( u"\5\uffff\1\0\20\uffff" ) DFA119_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\1\uffff\1\3\1\uffff\3\3\2\uffff\3\3\3\uffff" u"\1\3\3\uffff\1\3\3\uffff\2\3\11\uffff\1\3\101\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"\34\uffff\1\4\53\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\4\uffff\1\3\131\uffff" u"\1\5\4\uffff\1\3"), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\uffff"), DFA.unpack(u"\1\11\37\uffff\1\10"), DFA.unpack(u""), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\14\37\uffff\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\24"), 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\25\15\uffff\1\3\11\uffff\1\3\120\uffff\1\3"), DFA.unpack(u"\1\5") ] # class definition for DFA #119 class DFA119(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: LA119_5 = input.LA(1) index119_5 = input.index() input.rewind() s = -1 if (self.synpred150_sdl92()): s = 7 elif (True): s = 3 input.seek(index119_5) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 119, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #120 DFA120_eot = DFA.unpack( u"\36\uffff" ) DFA120_eof = DFA.unpack( u"\1\4\1\uffff\1\4\33\uffff" ) DFA120_min = DFA.unpack( u"\1\14\1\7\1\14\2\uffff\1\u0093\1\u00b6\1\u0088\1\u00b7\1\u0088" u"\1\u0095\1\56\1\u0088\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\21" u"\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\21\1\u00b5\1" u"\u00b6\1\u00b7\1\56" ) DFA120_max = DFA.unpack( u"\1\u00e4\1\u00b9\1\u00e4\2\uffff\1\u0093\1\u00b6\1\u00a8\1\u00b7" u"\1\u0088\1\u0095\1\u00b8\1\u00a8\1\143\1\u0088\1\u0094\1\u00e5" u"\1\u0095\2\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\u00e4" u"\1\u00b5\1\u00b6\1\u00b7\1\56" ) DFA120_accept = DFA.unpack( u"\3\uffff\1\1\1\2\31\uffff" ) DFA120_special = DFA.unpack( u"\36\uffff" ) DFA120_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\1\uffff\1\4\1\uffff\3\4\2\uffff\3\4\3\uffff" u"\1\4\3\uffff\1\4\3\uffff\2\4\11\uffff\1\4\101\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"\34\uffff\1\5\53\uffff\1\6\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\4\uffff\1\4\131\uffff" u"\1\3\4\uffff\1\4"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\12\37\uffff\1\11"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15\24\uffff\1\4\164\uffff\1\4"), DFA.unpack(u"\1\17\37\uffff\1\16"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\23"), 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\47\uffff\1\4\11\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\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\15\uffff\1\4\11\uffff\1\4\120\uffff\1\32"), DFA.unpack(u"\1\33"), DFA.unpack(u"\1\34"), DFA.unpack(u"\1\35"), DFA.unpack(u"\1\15") ] # class definition for DFA #120 class DFA120(DFA): pass # lookup tables for DFA #122 DFA122_eot = DFA.unpack( u"\24\uffff" ) DFA122_eof = DFA.unpack( u"\24\uffff" ) DFA122_min = DFA.unpack( u"\1\6\1\7\1\u0093\1\uffff\1\u0093\1\uffff\2\u0088\1\u0095\2\u0088" u"\1\u0094\1\u0095\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5" u"\1\31" ) DFA122_max = DFA.unpack( u"\1\u00e4\1\u00b5\1\u00e1\1\uffff\1\u0093\1\uffff\1\u00a8\1\u0088" u"\1\u0095\1\u00a8\1\u0088\1\u0094\1\u0095\1\u0093\1\u0088\1\u0095" u"\1\u0088\1\u0094\1\u00e5\1\u00e4" ) DFA122_accept = DFA.unpack( u"\3\uffff\1\2\1\uffff\1\1\16\uffff" ) DFA122_special = DFA.unpack( u"\24\uffff" ) DFA122_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\32\uffff\1\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"\34\uffff\1\4\53\uffff\1\3"), DFA.unpack(u"\1\3\17\uffff\1\3\26\uffff\1\3\44\uffff\1\5\1\uffff" u"\1\3"), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u""), DFA.unpack(u"\1\10\37\uffff\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\13\37\uffff\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\3\46\uffff\1\3\50\uffff\1\3\21\uffff\1\5\32\uffff" u"\1\3\115\uffff\1\3") ] # class definition for DFA #122 class DFA122(DFA): pass # lookup tables for DFA #123 DFA123_eot = DFA.unpack( u"\42\uffff" ) DFA123_eof = DFA.unpack( u"\42\uffff" ) DFA123_min = DFA.unpack( u"\1\6\1\7\12\uffff\1\u0093\1\u00b6\1\u0088\1\u00b7\1\u0088\1\u0095" u"\1\56\1\u0088\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\31\1\u0093" u"\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\31\1\u00b5" ) DFA123_max = DFA.unpack( u"\1\u00e4\1\u00b5\12\uffff\1\u0093\1\u00b6\1\u00a8\1\u00b7\1\u0088" u"\1\u0095\1\56\1\u00a8\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\u0096" u"\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\u00e4\1\u00b5" ) DFA123_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\26\uffff" ) DFA123_special = DFA.unpack( u"\42\uffff" ) DFA123_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\32\uffff\1\13\11\uffff\1\5\103\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\34\uffff\1\14\53\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\21\37\uffff\1\20"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\23"), DFA.unpack(u"\1\24"), DFA.unpack(u"\1\26\37\uffff\1\25"), DFA.unpack(u"\1\27"), DFA.unpack(u"\1\26"), DFA.unpack(u"\1\30"), DFA.unpack(u"\1\31"), DFA.unpack(u"\1\32"), DFA.unpack(u"\1\6\46\uffff\1\4\50\uffff\1\2\54\uffff\1\13"), 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\6\46\uffff\1\4\50\uffff\1\2\54\uffff\1\13\115\uffff" u"\1\41"), DFA.unpack(u"\1\15") ] # class definition for DFA #123 class DFA123(DFA): pass # lookup tables for DFA #134 DFA134_eot = DFA.unpack( u"\32\uffff" ) DFA134_eof = DFA.unpack( u"\32\uffff" ) DFA134_min = DFA.unpack( u"\1\33\1\7\2\uffff\1\u0093\1\u00b6\1\u0088\1\u00b7\1\u0088\1\u0095" u"\1\56\1\u0088\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\1\33\1\u0093" u"\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\33\1\u00b5" ) DFA134_max = DFA.unpack( u"\1\u00e4\1\u00b5\2\uffff\1\u0093\1\u00b6\1\u00a8\1\u00b7\1\u0088" u"\1\u0095\1\56\1\u00a8\1\143\1\u0088\1\u0094\1\u00e5\1\u0095\2\u0093" u"\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\u00e4\1\u00b5" ) DFA134_accept = DFA.unpack( u"\2\uffff\1\1\1\2\26\uffff" ) DFA134_special = DFA.unpack( u"\32\uffff" ) DFA134_transition = [ DFA.unpack(u"\1\3\167\uffff\1\2\120\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"\34\uffff\1\4\53\uffff\1\5"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\11\37\uffff\1\10"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\11"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\16\37\uffff\1\15"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\16"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\22"), DFA.unpack(u"\1\3\167\uffff\1\2"), 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\3\167\uffff\1\2\120\uffff\1\31"), DFA.unpack(u"\1\5") ] # class definition for DFA #134 class DFA134(DFA): pass # lookup tables for DFA #132 DFA132_eot = DFA.unpack( u"\32\uffff" ) DFA132_eof = DFA.unpack( u"\1\2\31\uffff" ) DFA132_min = DFA.unpack( u"\1\33\1\7\2\uffff\1\u00b6\1\u0093\1\u00b7\1\u0088\1\56\1\u0088" u"\1\u0095\1\143\1\u0088\1\u00e5\1\u0088\1\u0094\1\33\1\u0095\1\u0093" u"\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\33\1\u00b5" ) DFA132_max = DFA.unpack( u"\1\u00e4\1\u00b5\2\uffff\1\u00b6\1\u0093\1\u00b7\1\u00a8\1\56\1" u"\u0088\1\u0095\1\143\1\u00a8\1\u00e5\1\u0088\1\u0094\1\u0093\1" u"\u0095\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\u00e4" u"\1\u00b5" ) DFA132_accept = DFA.unpack( u"\2\uffff\1\2\1\1\26\uffff" ) DFA132_special = DFA.unpack( u"\32\uffff" ) DFA132_transition = [ DFA.unpack(u"\1\2\167\uffff\1\3\3\uffff\2\2\113\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"\34\uffff\1\5\53\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\12\37\uffff\1\11"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\17\37\uffff\1\16"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\21"), DFA.unpack(u"\1\2\167\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\30"), DFA.unpack(u"\1\2\167\uffff\1\3\120\uffff\1\31"), DFA.unpack(u"\1\4") ] # class definition for DFA #132 class DFA132(DFA): pass # lookup tables for DFA #142 DFA142_eot = DFA.unpack( u"\32\uffff" ) DFA142_eof = DFA.unpack( u"\1\3\31\uffff" ) DFA142_min = DFA.unpack( u"\1\6\1\7\2\uffff\1\u00b6\1\u0093\1\u00b7\1\u0088\1\56\1\u0088\1" u"\u0095\1\143\1\u0088\1\u00e5\1\u0088\1\u0094\1\31\1\u0095\1\u0093" u"\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\31\1\u00b5" ) DFA142_max = DFA.unpack( u"\1\u00e4\1\u00b5\2\uffff\1\u00b6\1\u0093\1\u00b7\1\u00a8\1\56\1" u"\u0088\1\u0095\1\143\1\u00a8\1\u00e5\1\u0088\1\u0094\1\u0096\1" u"\u0095\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\u00e4" u"\1\u00b5" ) DFA142_accept = DFA.unpack( u"\2\uffff\1\1\1\2\26\uffff" ) DFA142_special = DFA.unpack( u"\32\uffff" ) DFA142_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\27\uffff\1" u"\3\2\uffff\1\2\2\3\7\uffff\1\2\103\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"\34\uffff\1\5\53\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\12\37\uffff\1\11"), DFA.unpack(u"\1\13"), DFA.unpack(u"\1\12"), DFA.unpack(u"\1\14"), DFA.unpack(u"\1\15"), DFA.unpack(u"\1\17\37\uffff\1\16"), DFA.unpack(u"\1\20"), DFA.unpack(u"\1\17"), DFA.unpack(u"\1\21"), 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\51\uffff\1\3\2\uffff\1" u"\2"), 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\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\27\uffff" u"\1\3\2\uffff\1\2\115\uffff\1\31"), DFA.unpack(u"\1\4") ] # class definition for DFA #142 class DFA142(DFA): pass # lookup tables for DFA #148 DFA148_eot = DFA.unpack( u"\26\uffff" ) DFA148_eof = DFA.unpack( u"\26\uffff" ) DFA148_min = DFA.unpack( u"\1\51\16\0\7\uffff" ) DFA148_max = DFA.unpack( u"\1\u00bb\16\0\7\uffff" ) DFA148_accept = DFA.unpack( u"\17\uffff\1\2\5\uffff\1\1" ) DFA148_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\7\uffff" ) DFA148_transition = [ DFA.unpack(u"\1\10\5\uffff\1\14\54\uffff\1\12\6\uffff\1\4\27\uffff" u"\1\1\14\uffff\1\7\12\uffff\1\13\6\uffff\6\17\10\uffff\1\16\4\uffff" u"\1\15\1\2\1\3\1\5\1\6\11\uffff\1\11"), 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 #148 class DFA148(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: LA148_1 = input.LA(1) index148_1 = input.index() input.rewind() s = -1 if (self.synpred188_sdl92()): s = 21 elif (True): s = 15 input.seek(index148_1) if s >= 0: return s elif s == 1: LA148_2 = input.LA(1) index148_2 = input.index() input.rewind() s = -1 if (self.synpred188_sdl92()): s = 21 elif (True): s = 15 input.seek(index148_2) if s >= 0: return s elif s == 2: LA148_3 = input.LA(1) index148_3 = input.index() input.rewind() s = -1 if (self.synpred188_sdl92()): s = 21 elif (True): s = 15 input.seek(index148_3) if s >= 0: return s elif s == 3: LA148_4 = input.LA(1) index148_4 = input.index() input.rewind() s = -1 if (self.synpred188_sdl92()): s = 21 elif (True): s = 15 input.seek(index148_4) if s >= 0: return s elif s == 4: LA148_5 = input.LA(1) index148_5 = input.index() input.rewind() s = -1 if (self.synpred188_sdl92()): s = 21 elif (True): s = 15 input.seek(index148_5) if s >= 0: return s elif s == 5: LA148_6 = input.LA(1) index148_6 = input.index() input.rewind() s = -1 if (self.synpred188_sdl92()): s = 21 elif (True): s = 15 input.seek(index148_6) if s >= 0: return s elif s == 6: LA148_7 = input.LA(1) index148_7 = input.index() input.rewind() s = -1 if (self.synpred188_sdl92()): s = 21 elif (True): s = 15 input.seek(index148_7) if s >= 0: return s elif s == 7: LA148_8 = input.LA(1) index148_8 = input.index() input.rewind() s = -1 if (self.synpred188_sdl92()): s = 21 elif (True): s = 15 input.seek(index148_8) if s >= 0: return s elif s == 8: LA148_9 = input.LA(1) index148_9 = input.index() input.rewind() s = -1 if (self.synpred188_sdl92()): s = 21 elif (True): s = 15 input.seek(index148_9) if s >= 0: return s elif s == 9: LA148_10 = input.LA(1) index148_10 = input.index() input.rewind() s = -1 if (self.synpred188_sdl92()): s = 21 elif (True): s = 15 input.seek(index148_10) if s >= 0: return s elif s == 10: LA148_11 = input.LA(1) index148_11 = input.index() input.rewind() s = -1 if (self.synpred188_sdl92()): s = 21 elif (True): s = 15 input.seek(index148_11) if s >= 0: return s elif s == 11: LA148_12 = input.LA(1) index148_12 = input.index() input.rewind() s = -1 if (self.synpred188_sdl92()): s = 21 elif (True): s = 15 input.seek(index148_12) if s >= 0: return s elif s == 12: LA148_13 = input.LA(1) index148_13 = input.index() input.rewind() s = -1 if (self.synpred188_sdl92()): s = 21 elif (True): s = 15 input.seek(index148_13) if s >= 0: return s elif s == 13: LA148_14 = input.LA(1) index148_14 = input.index() input.rewind() s = -1 if (self.synpred188_sdl92()): s = 21 elif (True): s = 15 input.seek(index148_14) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 148, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #181 DFA181_eot = DFA.unpack( u"\12\uffff" ) DFA181_eof = DFA.unpack( u"\1\1\11\uffff" ) DFA181_min = DFA.unpack( u"\1\6\1\uffff\7\0\1\uffff" ) DFA181_max = DFA.unpack( u"\1\u00e4\1\uffff\7\0\1\uffff" ) DFA181_accept = DFA.unpack( u"\1\uffff\1\2\7\uffff\1\1" ) DFA181_special = DFA.unpack( u"\2\uffff\1\0\1\4\1\1\1\5\1\2\1\6\1\3\1\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\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\4\1\1\uffff\3\1\2\uffff\4\1\2\uffff\1\1\3\uffff\6\1" u"\1\uffff\1\2\1\3\1\4\1\6\1\7\1\5\1\1\1\uffff\13\1\17\uffff\1\1" u"\42\uffff\1\1\1\uffff\1\1\1\uffff\2\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 #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_2 = input.LA(1) index181_2 = input.index() input.rewind() s = -1 if (self.synpred233_sdl92()): s = 9 elif (True): s = 1 input.seek(index181_2) if s >= 0: return s elif s == 1: LA181_4 = input.LA(1) index181_4 = input.index() input.rewind() s = -1 if (self.synpred233_sdl92()): s = 9 elif (True): s = 1 input.seek(index181_4) if s >= 0: return s elif s == 2: LA181_6 = input.LA(1) index181_6 = input.index() input.rewind() s = -1 if (self.synpred233_sdl92()): s = 9 elif (True): s = 1 input.seek(index181_6) if s >= 0: return s elif s == 3: LA181_8 = input.LA(1) index181_8 = input.index() input.rewind() s = -1 if (self.synpred233_sdl92()): s = 9 elif (True): s = 1 input.seek(index181_8) if s >= 0: return s elif s == 4: LA181_3 = input.LA(1) index181_3 = input.index() input.rewind() s = -1 if (self.synpred233_sdl92()): s = 9 elif (True): s = 1 input.seek(index181_3) if s >= 0: return s elif s == 5: LA181_5 = input.LA(1) index181_5 = input.index() input.rewind() s = -1 if (self.synpred233_sdl92()): s = 9 elif (True): s = 1 input.seek(index181_5) if s >= 0: return s elif s == 6: LA181_7 = input.LA(1) index181_7 = input.index() input.rewind() s = -1 if (self.synpred233_sdl92()): s = 9 elif (True): s = 1 input.seek(index181_7) 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 #186 DFA186_eot = DFA.unpack( u"\20\uffff" ) DFA186_eof = DFA.unpack( u"\20\uffff" ) DFA186_min = DFA.unpack( u"\1\51\1\0\16\uffff" ) DFA186_max = DFA.unpack( u"\1\u00bb\1\0\16\uffff" ) DFA186_accept = DFA.unpack( u"\2\uffff\1\2\12\uffff\1\3\1\4\1\1" ) DFA186_special = DFA.unpack( u"\1\uffff\1\0\16\uffff" ) DFA186_transition = [ DFA.unpack(u"\1\2\5\uffff\1\2\54\uffff\1\2\6\uffff\1\2\27\uffff\1" u"\1\14\uffff\1\2\12\uffff\1\2\24\uffff\1\16\4\uffff\1\15\4\2\11" 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"") ] # class definition for DFA #186 class DFA186(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: LA186_1 = input.LA(1) index186_1 = input.index() input.rewind() s = -1 if (self.synpred241_sdl92()): s = 15 elif (self.synpred242_sdl92()): s = 2 input.seek(index186_1) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 186, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #188 DFA188_eot = DFA.unpack( u"\115\uffff" ) DFA188_eof = DFA.unpack( u"\1\1\114\uffff" ) DFA188_min = DFA.unpack( u"\1\6\64\uffff\1\0\17\uffff\1\0\4\uffff\1\0\2\uffff" ) DFA188_max = DFA.unpack( u"\1\u00e4\64\uffff\1\0\17\uffff\1\0\4\uffff\1\0\2\uffff" ) DFA188_accept = DFA.unpack( u"\1\uffff\1\3\111\uffff\1\1\1\2" ) DFA188_special = DFA.unpack( u"\65\uffff\1\0\17\uffff\1\1\4\uffff\1\2\2\uffff" ) DFA188_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\4\1\1\uffff\3\1\2\uffff\4\1\2\uffff\1\1\3\uffff\1\65\5" u"\1\1\uffff\7\1\1\uffff\1\1\1\112\11\1\15\uffff\1\1\1\uffff\1\1" u"\42\uffff\1\1\1\uffff\1\105\1\uffff\2\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""), 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"\1\uffff"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\uffff"), DFA.unpack(u""), DFA.unpack(u"") ] # class definition for DFA #188 class DFA188(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: LA188_53 = input.LA(1) index188_53 = input.index() input.rewind() s = -1 if (self.synpred244_sdl92()): s = 75 elif (True): s = 1 input.seek(index188_53) if s >= 0: return s elif s == 1: LA188_69 = input.LA(1) index188_69 = input.index() input.rewind() s = -1 if (self.synpred246_sdl92()): s = 76 elif (True): s = 1 input.seek(index188_69) if s >= 0: return s elif s == 2: LA188_74 = input.LA(1) index188_74 = input.index() input.rewind() s = -1 if (self.synpred246_sdl92()): s = 76 elif (True): s = 1 input.seek(index188_74) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 188, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #192 DFA192_eot = DFA.unpack( u"\21\uffff" ) DFA192_eof = DFA.unpack( u"\21\uffff" ) DFA192_min = DFA.unpack( u"\1\51\7\uffff\2\0\7\uffff" ) DFA192_max = DFA.unpack( u"\1\u00bb\7\uffff\2\0\7\uffff" ) DFA192_accept = DFA.unpack( u"\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\2\uffff\1\16\1\10\1\11\1\12" u"\1\13\1\14\1\15" ) DFA192_special = DFA.unpack( u"\10\uffff\1\0\1\1\7\uffff" ) DFA192_transition = [ DFA.unpack(u"\1\7\62\uffff\1\12\6\uffff\1\3\27\uffff\1\10\14\uffff" u"\1\6\45\uffff\1\1\1\2\1\4\1\5\11\uffff\1\11"), 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 #192 class DFA192(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: LA192_8 = input.LA(1) index192_8 = input.index() input.rewind() s = -1 if (self.synpred256_sdl92()): s = 11 elif (self.synpred257_sdl92()): s = 12 input.seek(index192_8) if s >= 0: return s elif s == 1: LA192_9 = input.LA(1) index192_9 = input.index() input.rewind() s = -1 if (self.synpred258_sdl92()): s = 13 elif (self.synpred259_sdl92()): s = 14 elif (self.synpred261_sdl92()): s = 15 elif (self.synpred263_sdl92()): s = 16 input.seek(index192_9) if s >= 0: return s if self._state.backtracking >0: raise BacktrackingFailed nvae = NoViableAltException(self_.getDescription(), 192, _s, input) self_.error(nvae) raise nvae # lookup tables for DFA #194 DFA194_eot = DFA.unpack( u"\23\uffff" ) DFA194_eof = DFA.unpack( u"\23\uffff" ) DFA194_min = DFA.unpack( u"\1\67\1\7\2\uffff\1\u0093\2\u0088\1\u0095\2\u0088\1\u0094\1\u0095" u"\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094\1\u00e5\1\67" ) DFA194_max = DFA.unpack( u"\1\u00e4\1\u00b5\2\uffff\1\u0093\1\u00a8\1\u0088\1\u0095\1\u00a8" u"\1\u0088\1\u0094\1\u0095\1\u0093\1\u0088\1\u0095\1\u0088\1\u0094" u"\1\u00e5\1\u00e4" ) DFA194_accept = DFA.unpack( u"\2\uffff\1\1\1\2\17\uffff" ) DFA194_special = DFA.unpack( u"\23\uffff" ) DFA194_transition = [ DFA.unpack(u"\1\3\4\uffff\1\3\24\uffff\1\3\17\uffff\1\3\31\uffff" u"\1\2\150\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"\34\uffff\1\4\53\uffff\1\3"), DFA.unpack(u""), DFA.unpack(u""), DFA.unpack(u"\1\5"), DFA.unpack(u"\1\7\37\uffff\1\6"), DFA.unpack(u"\1\7"), DFA.unpack(u"\1\10"), DFA.unpack(u"\1\12\37\uffff\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\4\uffff\1\3\24\uffff\1\3\17\uffff\1\3\31\uffff" u"\1\2\150\uffff\1\3") ] # class definition for DFA #194 class DFA194(DFA): pass FOLLOW_use_clause_in_pr_file1375 = frozenset([1, 76, 104, 116, 228]) FOLLOW_system_definition_in_pr_file1395 = frozenset([1, 76, 104, 116, 228]) FOLLOW_process_definition_in_pr_file1415 = frozenset([1, 76, 104, 116, 228]) FOLLOW_SYSTEM_in_system_definition1449 = frozenset([123]) FOLLOW_system_name_in_system_definition1451 = frozenset([17, 133, 228]) FOLLOW_end_in_system_definition1453 = frozenset([12, 13, 73, 89, 122, 228]) FOLLOW_entity_in_system_in_system_definition1471 = frozenset([12, 13, 73, 89, 122, 228]) FOLLOW_ENDSYSTEM_in_system_definition1490 = frozenset([17, 123, 133, 228]) FOLLOW_system_name_in_system_definition1492 = frozenset([17, 133, 228]) FOLLOW_end_in_system_definition1495 = frozenset([1]) FOLLOW_use_asn1_in_use_clause1551 = frozenset([116]) FOLLOW_USE_in_use_clause1570 = frozenset([123]) FOLLOW_package_name_in_use_clause1572 = frozenset([17, 133, 170, 228]) FOLLOW_DIV_in_use_clause1591 = frozenset([123]) FOLLOW_def_selection_list_in_use_clause1593 = frozenset([17, 133, 228]) FOLLOW_end_in_use_clause1614 = frozenset([1]) FOLLOW_ID_in_def_selection_list1678 = frozenset([1, 149]) FOLLOW_COMMA_in_def_selection_list1681 = frozenset([123]) FOLLOW_ID_in_def_selection_list1684 = frozenset([1, 149]) FOLLOW_signal_declaration_in_entity_in_system1720 = frozenset([1]) FOLLOW_text_area_in_entity_in_system1740 = frozenset([1]) FOLLOW_procedure_in_entity_in_system1760 = frozenset([1]) FOLLOW_channel_in_entity_in_system1780 = frozenset([1]) FOLLOW_block_definition_in_entity_in_system1800 = frozenset([1]) FOLLOW_paramnames_in_signal_declaration1833 = frozenset([89]) FOLLOW_SIGNAL_in_signal_declaration1852 = frozenset([123]) FOLLOW_signal_id_in_signal_declaration1854 = frozenset([17, 133, 147, 228]) FOLLOW_input_params_in_signal_declaration1856 = frozenset([17, 133, 228]) FOLLOW_end_in_signal_declaration1859 = frozenset([1]) FOLLOW_CHANNEL_in_channel1918 = frozenset([123]) FOLLOW_channel_id_in_channel1920 = frozenset([125]) FOLLOW_route_in_channel1938 = frozenset([124, 125]) FOLLOW_ENDCHANNEL_in_channel1957 = frozenset([17, 133, 228]) FOLLOW_end_in_channel1959 = frozenset([1]) FOLLOW_FROM_in_route2015 = frozenset([123]) FOLLOW_source_id_in_route2017 = frozenset([113]) FOLLOW_TO_in_route2019 = frozenset([123]) FOLLOW_dest_id_in_route2021 = frozenset([126]) FOLLOW_WITH_in_route2023 = frozenset([123]) FOLLOW_signal_id_in_route2025 = frozenset([17, 133, 149, 228]) FOLLOW_COMMA_in_route2028 = frozenset([123]) FOLLOW_signal_id_in_route2030 = frozenset([17, 133, 149, 228]) FOLLOW_end_in_route2034 = frozenset([1]) FOLLOW_BLOCK_in_block_definition2092 = frozenset([123]) FOLLOW_block_id_in_block_definition2094 = frozenset([17, 133, 228]) FOLLOW_end_in_block_definition2096 = frozenset([12, 13, 20, 73, 76, 89, 104, 116, 127, 128, 228]) FOLLOW_entity_in_block_in_block_definition2114 = frozenset([12, 13, 20, 73, 76, 89, 104, 116, 127, 128, 228]) FOLLOW_ENDBLOCK_in_block_definition2133 = frozenset([17, 133, 228]) FOLLOW_end_in_block_definition2135 = frozenset([1]) FOLLOW_signal_declaration_in_entity_in_block2193 = frozenset([1]) FOLLOW_signalroute_in_entity_in_block2213 = frozenset([1]) FOLLOW_connection_in_entity_in_block2233 = frozenset([1]) FOLLOW_block_definition_in_entity_in_block2253 = frozenset([1]) FOLLOW_process_definition_in_entity_in_block2273 = frozenset([1]) FOLLOW_SIGNALROUTE_in_signalroute2305 = frozenset([123]) FOLLOW_route_id_in_signalroute2307 = frozenset([125]) FOLLOW_route_in_signalroute2325 = frozenset([1, 125]) FOLLOW_CONNECT_in_connection2382 = frozenset([123]) FOLLOW_channel_id_in_connection2384 = frozenset([129]) FOLLOW_AND_in_connection2386 = frozenset([123]) FOLLOW_route_id_in_connection2388 = frozenset([17, 133, 228]) FOLLOW_end_in_connection2390 = frozenset([1]) FOLLOW_cif_in_process_definition2447 = frozenset([76]) FOLLOW_PROCESS_in_process_definition2466 = frozenset([123, 130]) FOLLOW_TYPE_in_process_definition2470 = frozenset([123, 130]) FOLLOW_process_id_in_process_definition2473 = frozenset([17, 131, 133, 147, 223, 228]) FOLLOW_number_of_instances_in_process_definition2491 = frozenset([17, 131, 133, 223, 228]) FOLLOW_223_in_process_definition2495 = frozenset([123]) FOLLOW_type_inst_in_process_definition2497 = frozenset([17, 131, 133, 228]) FOLLOW_REFERENCED_in_process_definition2501 = frozenset([17, 133, 228]) FOLLOW_end_in_process_definition2506 = frozenset([17, 21, 44, 73, 92, 123, 130, 132, 133, 137, 228]) FOLLOW_pfpar_in_process_definition2524 = frozenset([17, 21, 73, 92, 123, 130, 132, 133, 137, 228]) FOLLOW_text_area_in_process_definition2544 = frozenset([17, 21, 73, 92, 123, 130, 132, 133, 137, 228]) FOLLOW_procedure_in_process_definition2548 = frozenset([17, 21, 73, 92, 123, 130, 132, 133, 137, 228]) FOLLOW_composite_state_in_process_definition2557 = frozenset([17, 21, 73, 92, 123, 130, 132, 133, 137, 228]) FOLLOW_processBody_in_process_definition2577 = frozenset([1, 17, 123, 130, 132, 133, 228]) FOLLOW_ENDPROCESS_in_process_definition2580 = frozenset([1, 17, 123, 130, 133, 228]) FOLLOW_TYPE_in_process_definition2583 = frozenset([1, 17, 123, 130, 133, 228]) FOLLOW_process_id_in_process_definition2586 = frozenset([1, 17, 133, 228]) FOLLOW_end_in_process_definition2605 = frozenset([1]) FOLLOW_FPAR_in_pfpar2727 = frozenset([123]) FOLLOW_parameters_of_sort_in_pfpar2729 = frozenset([1, 17, 133, 149, 228]) FOLLOW_COMMA_in_pfpar2748 = frozenset([123]) FOLLOW_parameters_of_sort_in_pfpar2750 = frozenset([1, 17, 133, 149, 228]) FOLLOW_end_in_pfpar2770 = frozenset([1]) FOLLOW_variable_id_in_parameters_of_sort2825 = frozenset([123, 149]) FOLLOW_COMMA_in_parameters_of_sort2828 = frozenset([123]) FOLLOW_variable_id_in_parameters_of_sort2830 = frozenset([123, 149]) FOLLOW_sort_in_parameters_of_sort2834 = frozenset([1]) FOLLOW_cif_in_procedure2891 = frozenset([73]) FOLLOW_PROCEDURE_in_procedure2910 = frozenset([123]) FOLLOW_procedure_id_in_procedure2912 = frozenset([17, 133, 228]) FOLLOW_end_in_procedure2917 = frozenset([21, 35, 44, 73, 82, 92, 134, 137, 224, 228]) FOLLOW_SEMI_in_procedure2921 = frozenset([21, 35, 44, 73, 82, 92, 134, 137, 224, 228]) FOLLOW_fpar_in_procedure2940 = frozenset([21, 35, 73, 82, 92, 134, 137, 224, 228]) FOLLOW_procedure_result_in_procedure2961 = frozenset([21, 35, 73, 92, 134, 137, 228]) FOLLOW_text_area_in_procedure2981 = frozenset([21, 35, 73, 92, 134, 137, 228]) FOLLOW_procedure_in_procedure2985 = frozenset([21, 35, 73, 92, 134, 137, 228]) FOLLOW_processBody_in_procedure3007 = frozenset([134]) FOLLOW_ENDPROCEDURE_in_procedure3010 = frozenset([17, 123, 133, 228]) FOLLOW_procedure_id_in_procedure3012 = frozenset([17, 133, 228]) FOLLOW_EXTERNAL_in_procedure3018 = frozenset([17, 133, 228]) FOLLOW_end_in_procedure3039 = frozenset([1]) FOLLOW_224_in_procedure_result3139 = frozenset([123, 149]) FOLLOW_RETURNS_in_procedure_result3143 = frozenset([123, 149]) FOLLOW_variable_id_in_procedure_result3162 = frozenset([123, 149]) FOLLOW_sort_in_procedure_result3181 = frozenset([1, 17, 133, 228]) FOLLOW_end_in_procedure_result3183 = frozenset([1]) FOLLOW_FPAR_in_fpar3240 = frozenset([49, 51, 123, 135]) FOLLOW_formal_variable_param_in_fpar3242 = frozenset([17, 133, 149, 228]) FOLLOW_COMMA_in_fpar3261 = frozenset([49, 51, 123, 135]) FOLLOW_formal_variable_param_in_fpar3263 = frozenset([17, 133, 149, 228]) FOLLOW_end_in_fpar3283 = frozenset([1]) FOLLOW_INOUT_in_formal_variable_param3338 = frozenset([123]) FOLLOW_IN_in_formal_variable_param3342 = frozenset([123]) FOLLOW_OUT_in_formal_variable_param3346 = frozenset([123]) FOLLOW_variable_id_in_formal_variable_param3366 = frozenset([123, 149]) FOLLOW_COMMA_in_formal_variable_param3369 = frozenset([123]) FOLLOW_variable_id_in_formal_variable_param3371 = frozenset([123, 149]) FOLLOW_sort_in_formal_variable_param3375 = frozenset([1]) FOLLOW_cif_in_text_area3441 = frozenset([24, 44, 59, 73, 82, 89, 101, 103, 112, 116, 224, 228]) FOLLOW_content_in_text_area3459 = frozenset([24, 44, 59, 73, 82, 89, 101, 103, 112, 116, 224, 228]) FOLLOW_cif_end_text_in_text_area3478 = frozenset([1]) FOLLOW_procedure_in_content3540 = frozenset([1, 24, 44, 59, 73, 82, 89, 101, 103, 112, 116, 224, 228]) FOLLOW_use_clause_in_content3561 = frozenset([1, 24, 44, 59, 73, 82, 89, 101, 103, 112, 116, 224, 228]) FOLLOW_signal_declaration_in_content3582 = frozenset([1, 24, 44, 59, 73, 82, 89, 101, 103, 112, 116, 224, 228]) FOLLOW_fpar_in_content3603 = frozenset([1, 24, 44, 59, 73, 82, 89, 101, 103, 112, 116, 224, 228]) FOLLOW_procedure_result_in_content3626 = frozenset([1, 24, 44, 59, 73, 82, 89, 101, 103, 112, 116, 224, 228]) FOLLOW_timer_declaration_in_content3647 = frozenset([1, 24, 44, 59, 73, 82, 89, 101, 103, 112, 116, 224, 228]) FOLLOW_syntype_definition_in_content3668 = frozenset([1, 24, 44, 59, 73, 82, 89, 101, 103, 112, 116, 224, 228]) FOLLOW_newtype_definition_in_content3689 = frozenset([1, 24, 44, 59, 73, 82, 89, 101, 103, 112, 116, 224, 228]) FOLLOW_variable_definition_in_content3710 = frozenset([1, 24, 44, 59, 73, 82, 89, 101, 103, 112, 116, 224, 228]) FOLLOW_synonym_definition_in_content3731 = frozenset([1, 24, 44, 59, 73, 82, 89, 101, 103, 112, 116, 224, 228]) FOLLOW_TIMER_in_timer_declaration3854 = frozenset([123]) FOLLOW_timer_id_in_timer_declaration3856 = frozenset([17, 133, 149, 228]) FOLLOW_COMMA_in_timer_declaration3875 = frozenset([123]) FOLLOW_timer_id_in_timer_declaration3877 = frozenset([17, 133, 149, 228]) FOLLOW_end_in_timer_declaration3897 = frozenset([1]) FOLLOW_SYNTYPE_in_syntype_definition3951 = frozenset([123, 149]) FOLLOW_syntype_name_in_syntype_definition3953 = frozenset([154]) FOLLOW_EQ_in_syntype_definition3955 = frozenset([123, 149]) FOLLOW_parent_sort_in_syntype_definition3957 = frozenset([23, 30]) FOLLOW_CONSTANTS_in_syntype_definition3976 = frozenset([41, 47, 92, 99, 123, 136, 147, 154, 155, 156, 157, 158, 159, 168, 173, 174, 175, 176, 177, 187]) FOLLOW_range_condition_in_syntype_definition3979 = frozenset([30, 149]) FOLLOW_COMMA_in_syntype_definition3982 = frozenset([41, 47, 92, 99, 123, 136, 147, 154, 155, 156, 157, 158, 159, 168, 173, 174, 175, 176, 177, 187]) FOLLOW_range_condition_in_syntype_definition3984 = frozenset([30, 149]) FOLLOW_ENDSYNTYPE_in_syntype_definition4008 = frozenset([17, 123, 133, 149, 228]) FOLLOW_syntype_name_in_syntype_definition4010 = frozenset([17, 133, 228]) FOLLOW_end_in_syntype_definition4013 = frozenset([1]) FOLLOW_sort_in_syntype_name4071 = frozenset([1]) FOLLOW_sort_in_parent_sort4103 = frozenset([1]) FOLLOW_NEWTYPE_in_newtype_definition4135 = frozenset([123, 149]) FOLLOW_type_name_in_newtype_definition4137 = frozenset([8, 29, 100]) FOLLOW_array_definition_in_newtype_definition4140 = frozenset([29]) FOLLOW_structure_definition_in_newtype_definition4142 = frozenset([29]) FOLLOW_ENDNEWTYPE_in_newtype_definition4162 = frozenset([17, 123, 133, 149, 228]) FOLLOW_type_name_in_newtype_definition4164 = frozenset([17, 133, 228]) FOLLOW_end_in_newtype_definition4167 = frozenset([1]) FOLLOW_sort_in_type_name4226 = frozenset([1]) FOLLOW_ARRAY_in_array_definition4258 = frozenset([147]) FOLLOW_L_PAREN_in_array_definition4260 = frozenset([123, 149]) FOLLOW_sort_in_array_definition4262 = frozenset([149]) FOLLOW_COMMA_in_array_definition4264 = frozenset([123, 149]) FOLLOW_sort_in_array_definition4266 = frozenset([148]) FOLLOW_R_PAREN_in_array_definition4268 = frozenset([1]) FOLLOW_STRUCT_in_structure_definition4323 = frozenset([123]) FOLLOW_field_list_in_structure_definition4325 = frozenset([17, 133, 228]) FOLLOW_end_in_structure_definition4327 = frozenset([1]) FOLLOW_field_definition_in_field_list4380 = frozenset([1, 17, 133, 228]) FOLLOW_end_in_field_list4383 = frozenset([123]) FOLLOW_field_definition_in_field_list4385 = frozenset([1, 17, 133, 228]) FOLLOW_field_name_in_field_definition4441 = frozenset([123, 149]) FOLLOW_COMMA_in_field_definition4444 = frozenset([123]) FOLLOW_field_name_in_field_definition4446 = frozenset([123, 149]) FOLLOW_sort_in_field_definition4450 = frozenset([1]) FOLLOW_DCL_in_variable_definition4506 = frozenset([123]) FOLLOW_variables_of_sort_in_variable_definition4508 = frozenset([17, 133, 149, 228]) FOLLOW_COMMA_in_variable_definition4527 = frozenset([123]) FOLLOW_variables_of_sort_in_variable_definition4529 = frozenset([17, 133, 149, 228]) FOLLOW_end_in_variable_definition4549 = frozenset([1]) FOLLOW_internal_synonym_definition_in_synonym_definition4603 = frozenset([1]) FOLLOW_SYNONYM_in_internal_synonym_definition4635 = frozenset([123, 149]) FOLLOW_synonym_definition_item_in_internal_synonym_definition4637 = frozenset([17, 133, 149, 228]) FOLLOW_COMMA_in_internal_synonym_definition4640 = frozenset([123, 149]) FOLLOW_synonym_definition_item_in_internal_synonym_definition4642 = frozenset([17, 133, 149, 228]) FOLLOW_end_in_internal_synonym_definition4662 = frozenset([1]) FOLLOW_sort_in_synonym_definition_item4716 = frozenset([123, 149]) FOLLOW_sort_in_synonym_definition_item4718 = frozenset([154]) FOLLOW_EQ_in_synonym_definition_item4720 = frozenset([41, 47, 92, 99, 123, 136, 147, 168, 173, 174, 175, 176, 177, 187]) FOLLOW_ground_expression_in_synonym_definition_item4722 = frozenset([1]) FOLLOW_variable_id_in_variables_of_sort4779 = frozenset([123, 149]) FOLLOW_COMMA_in_variables_of_sort4782 = frozenset([123]) FOLLOW_variable_id_in_variables_of_sort4784 = frozenset([123, 149]) FOLLOW_sort_in_variables_of_sort4788 = frozenset([1, 186]) FOLLOW_ASSIG_OP_in_variables_of_sort4791 = frozenset([41, 47, 92, 99, 123, 136, 147, 168, 173, 174, 175, 176, 177, 187]) FOLLOW_ground_expression_in_variables_of_sort4793 = frozenset([1]) FOLLOW_expression_in_ground_expression4854 = frozenset([1]) FOLLOW_L_PAREN_in_number_of_instances4907 = frozenset([136]) FOLLOW_INT_in_number_of_instances4911 = frozenset([149]) FOLLOW_COMMA_in_number_of_instances4913 = frozenset([136]) FOLLOW_INT_in_number_of_instances4917 = frozenset([148]) FOLLOW_R_PAREN_in_number_of_instances4919 = frozenset([1]) FOLLOW_start_in_processBody4976 = frozenset([1, 21, 92, 228]) FOLLOW_state_in_processBody4980 = frozenset([1, 21, 92, 228]) FOLLOW_floating_label_in_processBody4984 = frozenset([1, 21, 92, 228]) FOLLOW_cif_in_start5018 = frozenset([137, 228]) FOLLOW_hyperlink_in_start5037 = frozenset([137]) FOLLOW_START_in_start5056 = frozenset([17, 123, 133, 228]) FOLLOW_state_entry_point_name_in_start5060 = frozenset([17, 133, 228]) FOLLOW_end_in_start5063 = frozenset([1, 6, 25, 33, 43, 55, 60, 64, 80, 81, 88, 97, 99, 105, 123, 150, 160, 228]) FOLLOW_transition_in_start5081 = frozenset([1]) FOLLOW_cif_in_floating_label5149 = frozenset([21, 228]) FOLLOW_hyperlink_in_floating_label5168 = frozenset([21]) FOLLOW_CONNECTION_in_floating_label5187 = frozenset([123, 228]) FOLLOW_connector_name_in_floating_label5189 = frozenset([223]) FOLLOW_223_in_floating_label5191 = frozenset([6, 25, 33, 43, 55, 60, 64, 80, 81, 88, 97, 99, 105, 123, 138, 150, 160, 228]) FOLLOW_transition_in_floating_label5209 = frozenset([138, 228]) FOLLOW_cif_end_label_in_floating_label5228 = frozenset([138]) FOLLOW_ENDCONNECTION_in_floating_label5247 = frozenset([133]) FOLLOW_SEMI_in_floating_label5249 = frozenset([1]) FOLLOW_cif_in_state5311 = frozenset([92, 228]) FOLLOW_hyperlink_in_state5330 = frozenset([92]) FOLLOW_STATE_in_state5349 = frozenset([123, 140]) FOLLOW_statelist_in_state5351 = frozenset([17, 133, 228]) FOLLOW_end_in_state5356 = frozenset([20, 52, 77, 84, 139, 228]) FOLLOW_SEMI_in_state5360 = frozenset([20, 52, 77, 84, 139, 228]) FOLLOW_state_part_in_state5380 = frozenset([20, 52, 77, 84, 139, 228]) FOLLOW_ENDSTATE_in_state5400 = frozenset([17, 123, 133, 228]) FOLLOW_statename_in_state5402 = frozenset([17, 133, 228]) FOLLOW_end_in_state5407 = frozenset([1]) FOLLOW_statename_in_statelist5475 = frozenset([1, 149]) FOLLOW_COMMA_in_statelist5478 = frozenset([123]) FOLLOW_statename_in_statelist5480 = frozenset([1, 149]) FOLLOW_ASTERISK_in_statelist5525 = frozenset([1, 147]) FOLLOW_exception_state_in_statelist5527 = frozenset([1]) FOLLOW_L_PAREN_in_exception_state5582 = frozenset([123]) FOLLOW_statename_in_exception_state5584 = frozenset([148, 149]) FOLLOW_COMMA_in_exception_state5587 = frozenset([123]) FOLLOW_statename_in_exception_state5589 = frozenset([148, 149]) FOLLOW_R_PAREN_in_exception_state5593 = frozenset([1]) FOLLOW_composite_state_graph_in_composite_state5644 = frozenset([1]) FOLLOW_state_aggregation_in_composite_state5664 = frozenset([1]) FOLLOW_STATE_in_composite_state_preamble5696 = frozenset([123, 141]) FOLLOW_AGGREGATION_in_composite_state_preamble5698 = frozenset([123]) FOLLOW_statename_in_composite_state_preamble5701 = frozenset([17, 133, 228]) FOLLOW_end_in_composite_state_preamble5703 = frozenset([142]) FOLLOW_SUBSTRUCTURE_in_composite_state_preamble5721 = frozenset([1]) FOLLOW_STATE_in_composite_state_graph5752 = frozenset([123]) FOLLOW_statename_in_composite_state_graph5754 = frozenset([17, 133, 228]) FOLLOW_end_in_composite_state_graph5758 = frozenset([142]) FOLLOW_SUBSTRUCTURE_in_composite_state_graph5776 = frozenset([21, 49, 73, 92, 135, 137, 143, 228]) FOLLOW_connection_points_in_composite_state_graph5794 = frozenset([21, 49, 73, 92, 135, 137, 143, 228]) FOLLOW_composite_state_body_in_composite_state_graph5815 = frozenset([143]) FOLLOW_ENDSUBSTRUCTURE_in_composite_state_graph5833 = frozenset([17, 123, 133, 228]) FOLLOW_statename_in_composite_state_graph5835 = frozenset([17, 133, 228]) FOLLOW_end_in_composite_state_graph5840 = frozenset([1]) FOLLOW_STATE_in_state_aggregation5904 = frozenset([141]) FOLLOW_AGGREGATION_in_state_aggregation5906 = frozenset([123]) FOLLOW_statename_in_state_aggregation5908 = frozenset([17, 133, 228]) FOLLOW_end_in_state_aggregation5912 = frozenset([142]) FOLLOW_SUBSTRUCTURE_in_state_aggregation5930 = frozenset([20, 49, 73, 92, 135, 143, 228]) FOLLOW_connection_points_in_state_aggregation5948 = frozenset([20, 49, 73, 92, 135, 143, 228]) FOLLOW_entity_in_composite_state_in_state_aggregation5969 = frozenset([20, 73, 92, 143, 228]) FOLLOW_state_aggregation_body_in_state_aggregation5990 = frozenset([143]) FOLLO