sdl92Parser.py

# $ANTLR 3.1.3 Mar 17, 2009 19:23:44 sdl92.g 2016-03-26 10:12:57

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=159
ENTRY_POINT=32
ENDSTATE=138
STR=216
PROCESS=76
STOP=97
ENDFOR=161
PROVIDED=77
CONDITIONAL=19
CHANNEL=13
THEN=111
XOR=164
CALL=149
A=191
B=213
PFPAR=70
SET=88
C=195
D=194
E=197
F=204
G=205
H=207
L_BRACKET=189
I=203
OPEN_RANGE=63
J=214
K=198
L=196
M=201
ENDSYSTEM=122
N=192
O=206
P=199
Q=221
R=200
S=202
T=208
U=210
VARIABLE=118
V=211
GROUND=45
W=212
X=209
Y=193
FPAR=44
Z=222
PROCEDURE=73
PARAMNAMES=67
PAREN=69
APPEND=167
NEWTYPE=59
CONNECTION=21
DIV=168
SELECTOR=85
MINUS_INFINITY=176
STRING=99
VARIABLES=119
TO=113
REM=170
ASSIG_OP=188
SYSTEM=104
ROUTE=83
T__223=223
ENDCHANNEL=124
IFTHENELSE=48
TASK_BODY=106
ALPHA=217
PRIORITY=145
VIEW=182
HYPERLINK=46
LABEL=56
CIF=15
OUTPUT=64
FOR=43
INPUTLIST=54
EQ=153
FLOATING_LABEL=42
VIAPATH=121
FLOAT2=40
NOT=171
SPECIFIC=184
STIMULUS=96
THIS=160
ENDPROCEDURE=132
END=187
AGGREGATION=142
FI=36
DIGITS=26
STATE=92
OUTPUT_BODY=65
QUESTION=78
BITSTR=11
BASE=178
RETURN=81
STATE_AGGREGATION=93
ENDNEWTYPE=29
SEQUENCE=87
R_PAREN=147
WS=219
EOF=-1
GE=158
NEXTSTATE=60
ANSWER=7
MOD=169
SEQOF=86
T__230=230
PLUS_INFINITY=175
PARAM=66
R_BRACKET=190
GT=155
WITH=126
ACTION=4
T__229=229
STOPIF=98
T__228=228
START=135
FALSE=173
T__225=225
T__224=224
T__227=227
DEFAULT=143
T__226=226
IMPLIES=162
ENDCONNECTION=136
ENDDECISION=151
EXPORT=33
JOIN=55
TEXT=108
REFERENCED=130
ALTERNATIVE=6
SYNTYPE=103
ELSE=27
PROCEDURE_NAME=75
ID=123
NONE=144
IF=47
SUBSTRUCTURE=140
FIELDS=39
LITERAL=57
IN=49
FIELD=37
DOT=215
SYNONYM=101
OUT=133
ENDBLOCK=127
STATELIST=95
SEMI=137
CONNECT=20
ASN1=9
ASSIGN=10
COMMENT=17
IMPORT=181
MANTISSA=177
SAVE=84
CLOSED_RANGE=16
SIGNAL=89
COMMA=148
ENDTEXT=31
NUMBER_OF_INSTANCES=61
USE=116
RETURNS=82
CONSTANT=22
ASTERISK=139
COMMENT2=220
TRANSITION=114
NEG=58
LE=157
EXPONENT=179
NEQ=154
GEODE=185
EXPRESSION=34
ALL=5
SYNONYM_LIST=102
TERMINATOR=107
DECISION=25
TEXTAREA_CONTENT=110
ARRAY=8
INPUT=52
LT=156
STATE_PARTITION_CONNECTION=94
ENDALTERNATIVE=150
RESET=80
VALUE=117
FROM=125
DASH=166
TASK=105
NULL=174
KEEP=183
BLOCK=12
TRUE=172
ENDSYNTYPE=30
DCL=24
OCTSTR=62
AND=129
SORT=91
PARAMS=68
STRUCT=100
RANGE=79
PLUS=165
INOUT=51
FLOAT=41
CONSTANTS=23
ACTIVE=180
Exponent=218
L_PAREN=146
ANY=152
INT=134
CHOICE=14
EXTERNAL=35
FIELD_NAME=38
TYPE_INSTANCE=115
ENDSUBSTRUCTURE=141
PROCEDURE_CALL=74
TEXTAREA=109
OR=163
SIGNAL_LIST=90
INFORMAL_TEXT=50
TIMER=112
PRIMARY=72
COMPOSITE_STATE=18
VIA=120
ASNFILENAME=186
ENDPROCESS=131
EMPTYSTR=28
SIGNALROUTE=128
INPUT_NONE=53
POINT=71

# token names
tokenNames = [
    "<invalid>", "<EOR>", "<DOWN>", "<UP>", 
    "ACTION", "ALL", "ALTERNATIVE", "ANSWER", "ARRAY", "ASN1", "ASSIGN", 
    "BITSTR", "BLOCK", "CHANNEL", "CHOICE", "CIF", "CLOSED_RANGE", "COMMENT", 
    "COMPOSITE_STATE", "CONDITIONAL", "CONNECT", "CONNECTION", "CONSTANT", 
    "CONSTANTS", "DCL", "DECISION", "DIGITS", "ELSE", "EMPTYSTR", "ENDNEWTYPE", 
    "ENDSYNTYPE", "ENDTEXT", "ENTRY_POINT", "EXPORT", "EXPRESSION", "EXTERNAL", 
    "FI", "FIELD", "FIELD_NAME", "FIELDS", "FLOAT2", "FLOAT", "FLOATING_LABEL", 
    "FOR", "FPAR", "GROUND", "HYPERLINK", "IF", "IFTHENELSE", "IN", "INFORMAL_TEXT", 
    "INOUT", "INPUT", "INPUT_NONE", "INPUTLIST", "JOIN", "LABEL", "LITERAL", 
    "NEG", "NEWTYPE", "NEXTSTATE", "NUMBER_OF_INSTANCES", "OCTSTR", "OPEN_RANGE", 
    "OUTPUT", "OUTPUT_BODY", "PARAM", "PARAMNAMES", "PARAMS", "PAREN", "PFPAR", 
    "POINT", "PRIMARY", "PROCEDURE", "PROCEDURE_CALL", "PROCEDURE_NAME", 
    "PROCESS", "PROVIDED", "QUESTION", "RANGE", "RESET", "RETURN", "RETURNS", 
    "ROUTE", "SAVE", "SELECTOR", "SEQOF", "SEQUENCE", "SET", "SIGNAL", "SIGNAL_LIST", 
    "SORT", "STATE", "STATE_AGGREGATION", "STATE_PARTITION_CONNECTION", 
    "STATELIST", "STIMULUS", "STOP", "STOPIF", "STRING", "STRUCT", "SYNONYM", 
    "SYNONYM_LIST", "SYNTYPE", "SYSTEM", "TASK", "TASK_BODY", "TERMINATOR", 
    "TEXT", "TEXTAREA", "TEXTAREA_CONTENT", "THEN", "TIMER", "TO", "TRANSITION", 
    "TYPE_INSTANCE", "USE", "VALUE", "VARIABLE", "VARIABLES", "VIA", "VIAPATH", 
    "ENDSYSTEM", "ID", "ENDCHANNEL", "FROM", "WITH", "ENDBLOCK", "SIGNALROUTE", 
    "AND", "REFERENCED", "ENDPROCESS", "ENDPROCEDURE", "OUT", "INT", "START", 
    "ENDCONNECTION", "SEMI", "ENDSTATE", "ASTERISK", "SUBSTRUCTURE", "ENDSUBSTRUCTURE", 
    "AGGREGATION", "DEFAULT", "NONE", "PRIORITY", "L_PAREN", "R_PAREN", 
    "COMMA", "CALL", "ENDALTERNATIVE", "ENDDECISION", "ANY", "EQ", "NEQ", 
    "GT", "LT", "LE", "GE", "CREATE", "THIS", "ENDFOR", "IMPLIES", "OR", 
    "XOR", "PLUS", "DASH", "APPEND", "DIV", "MOD", "REM", "NOT", "TRUE", 
    "FALSE", "NULL", "PLUS_INFINITY", "MINUS_INFINITY", "MANTISSA", "BASE", 
    "EXPONENT", "ACTIVE", "IMPORT", "VIEW", "KEEP", "SPECIFIC", "GEODE", 
    "ASNFILENAME", "END", "ASSIG_OP", "L_BRACKET", "R_BRACKET", "A", "N", 
    "Y", "D", "C", "L", "E", "K", "P", "R", "M", "S", "I", "F", "G", "O", 
    "H", "T", "X", "U", "V", "W", "B", "J", "DOT", "STR", "ALPHA", "Exponent", 
    "WS", "COMMENT2", "Q", "Z", "':'", "'->'", "'!'", "'(.'", "'.)'", "'ERROR'", 
    "'/* CIF'", "'*/'"
]




class sdl92Parser(Parser):
    grammarFileName = "sdl92.g"
    antlr_version = version_str_to_tuple("3.1.3 Mar 17, 2009 19:23:44")
    antlr_version_str = "3.1.3 Mar 17, 2009 19:23:44"
    tokenNames = tokenNames

    def __init__(self, input, state=None, *args, **kwargs):
        if state is None:
            state = RecognizerSharedState()

        super(sdl92Parser, self).__init__(input, state, *args, **kwargs)

        self.dfa20 = self.DFA20(
            self, 20,
            eot = self.DFA20_eot,
            eof = self.DFA20_eof,
            min = self.DFA20_min,
            max = self.DFA20_max,
            accept = self.DFA20_accept,
            special = self.DFA20_special,
            transition = self.DFA20_transition
            )

        self.dfa21 = self.DFA21(
            self, 21,
            eot = self.DFA21_eot,
            eof = self.DFA21_eof,
            min = self.DFA21_min,
            max = self.DFA21_max,
            accept = self.DFA21_accept,
            special = self.DFA21_special,
            transition = self.DFA21_transition
            )

        self.dfa24 = self.DFA24(
            self, 24,
            eot = self.DFA24_eot,
            eof = self.DFA24_eof,
            min = self.DFA24_min,
            max = self.DFA24_max,
            accept = self.DFA24_accept,
            special = self.DFA24_special,
            transition = self.DFA24_transition
            )

        self.dfa26 = self.DFA26(
            self, 26,
            eot = self.DFA26_eot,
            eof = self.DFA26_eof,
            min = self.DFA26_min,
            max = self.DFA26_max,
            accept = self.DFA26_accept,
            special = self.DFA26_special,
            transition = self.DFA26_transition
            )

        self.dfa38 = self.DFA38(
            self, 38,
            eot = self.DFA38_eot,
            eof = self.DFA38_eof,
            min = self.DFA38_min,
            max = self.DFA38_max,
            accept = self.DFA38_accept,
            special = self.DFA38_special,
            transition = self.DFA38_transition
            )

        self.dfa42 = self.DFA42(
            self, 42,
            eot = self.DFA42_eot,
            eof = self.DFA42_eof,
            min = self.DFA42_min,
            max = self.DFA42_max,
            accept = self.DFA42_accept,
            special = self.DFA42_special,
            transition = self.DFA42_transition
            )

        self.dfa49 = self.DFA49(
            self, 49,
            eot = self.DFA49_eot,
            eof = self.DFA49_eof,
            min = self.DFA49_min,
            max = self.DFA49_max,
            accept = self.DFA49_accept,
            special = self.DFA49_special,
            transition = self.DFA49_transition
            )

        self.dfa55 = self.DFA55(
            self, 55,
            eot = self.DFA55_eot,
            eof = self.DFA55_eof,
            min = self.DFA55_min,
            max = self.DFA55_max,
            accept = self.DFA55_accept,
            special = self.DFA55_special,
            transition = self.DFA55_transition
            )

        self.dfa56 = self.DFA56(
            self, 56,
            eot = self.DFA56_eot,
            eof = self.DFA56_eof,
            min = self.DFA56_min,
            max = self.DFA56_max,
            accept = self.DFA56_accept,
            special = self.DFA56_special,
            transition = self.DFA56_transition
            )

        self.dfa60 = self.DFA60(
            self, 60,
            eot = self.DFA60_eot,
            eof = self.DFA60_eof,
            min = self.DFA60_min,
            max = self.DFA60_max,
            accept = self.DFA60_accept,
            special = self.DFA60_special,
            transition = self.DFA60_transition
            )

        self.dfa77 = self.DFA77(
            self, 77,
            eot = self.DFA77_eot,
            eof = self.DFA77_eof,
            min = self.DFA77_min,
            max = self.DFA77_max,
            accept = self.DFA77_accept,
            special = self.DFA77_special,
            transition = self.DFA77_transition
            )

        self.dfa80 = self.DFA80(
            self, 80,
            eot = self.DFA80_eot,
            eof = self.DFA80_eof,
            min = self.DFA80_min,
            max = self.DFA80_max,
            accept = self.DFA80_accept,
            special = self.DFA80_special,
            transition = self.DFA80_transition
            )

        self.dfa86 = self.DFA86(
            self, 86,
            eot = self.DFA86_eot,
            eof = self.DFA86_eof,
            min = self.DFA86_min,
            max = self.DFA86_max,
            accept = self.DFA86_accept,
            special = self.DFA86_special,
            transition = self.DFA86_transition
            )

        self.dfa87 = self.DFA87(
            self, 87,
            eot = self.DFA87_eot,
            eof = self.DFA87_eof,
            min = self.DFA87_min,
            max = self.DFA87_max,
            accept = self.DFA87_accept,
            special = self.DFA87_special,
            transition = self.DFA87_transition
            )

        self.dfa88 = self.DFA88(
            self, 88,
            eot = self.DFA88_eot,
            eof = self.DFA88_eof,
            min = self.DFA88_min,
            max = self.DFA88_max,
            accept = self.DFA88_accept,
            special = self.DFA88_special,
            transition = self.DFA88_transition
            )

        self.dfa92 = self.DFA92(
            self, 92,
            eot = self.DFA92_eot,
            eof = self.DFA92_eof,
            min = self.DFA92_min,
            max = self.DFA92_max,
            accept = self.DFA92_accept,
            special = self.DFA92_special,
            transition = self.DFA92_transition
            )

        self.dfa101 = self.DFA101(
            self, 101,
            eot = self.DFA101_eot,
            eof = self.DFA101_eof,
            min = self.DFA101_min,
            max = self.DFA101_max,
            accept = self.DFA101_accept,
            special = self.DFA101_special,
            transition = self.DFA101_transition
            )

        self.dfa106 = self.DFA106(
            self, 106,
            eot = self.DFA106_eot,
            eof = self.DFA106_eof,
            min = self.DFA106_min,
            max = self.DFA106_max,
            accept = self.DFA106_accept,
            special = self.DFA106_special,
            transition = self.DFA106_transition
            )

        self.dfa107 = self.DFA107(
            self, 107,
            eot = self.DFA107_eot,
            eof = self.DFA107_eof,
            min = self.DFA107_min,
            max = self.DFA107_max,
            accept = self.DFA107_accept,
            special = self.DFA107_special,
            transition = self.DFA107_transition
            )

        self.dfa115 = self.DFA115(
            self, 115,
            eot = self.DFA115_eot,
            eof = self.DFA115_eof,
            min = self.DFA115_min,
            max = self.DFA115_max,
            accept = self.DFA115_accept,
            special = self.DFA115_special,
            transition = self.DFA115_transition
            )

        self.dfa112 = self.DFA112(
            self, 112,
            eot = self.DFA112_eot,
            eof = self.DFA112_eof,
            min = self.DFA112_min,
            max = self.DFA112_max,
            accept = self.DFA112_accept,
            special = self.DFA112_special,
            transition = self.DFA112_transition
            )

        self.dfa113 = self.DFA113(
            self, 113,
            eot = self.DFA113_eot,
            eof = self.DFA113_eof,
            min = self.DFA113_min,
            max = self.DFA113_max,
            accept = self.DFA113_accept,
            special = self.DFA113_special,
            transition = self.DFA113_transition
            )

        self.dfa114 = self.DFA114(
            self, 114,
            eot = self.DFA114_eot,
            eof = self.DFA114_eof,
            min = self.DFA114_min,
            max = self.DFA114_max,
            accept = self.DFA114_accept,
            special = self.DFA114_special,
            transition = self.DFA114_transition
            )

        self.dfa116 = self.DFA116(
            self, 116,
            eot = self.DFA116_eot,
            eof = self.DFA116_eof,
            min = self.DFA116_min,
            max = self.DFA116_max,
            accept = self.DFA116_accept,
            special = self.DFA116_special,
            transition = self.DFA116_transition
            )

        self.dfa117 = self.DFA117(
            self, 117,
            eot = self.DFA117_eot,
            eof = self.DFA117_eof,
            min = self.DFA117_min,
            max = self.DFA117_max,
            accept = self.DFA117_accept,
            special = self.DFA117_special,
            transition = self.DFA117_transition
            )

        self.dfa128 = self.DFA128(
            self, 128,
            eot = self.DFA128_eot,
            eof = self.DFA128_eof,
            min = self.DFA128_min,
            max = self.DFA128_max,
            accept = self.DFA128_accept,
            special = self.DFA128_special,
            transition = self.DFA128_transition
            )

        self.dfa126 = self.DFA126(
            self, 126,
            eot = self.DFA126_eot,
            eof = self.DFA126_eof,
            min = self.DFA126_min,
            max = self.DFA126_max,
            accept = self.DFA126_accept,
            special = self.DFA126_special,
            transition = self.DFA126_transition
            )

        self.dfa136 = self.DFA136(
            self, 136,
            eot = self.DFA136_eot,
            eof = self.DFA136_eof,
            min = self.DFA136_min,
            max = self.DFA136_max,
            accept = self.DFA136_accept,
            special = self.DFA136_special,
            transition = self.DFA136_transition
            )

        self.dfa142 = self.DFA142(
            self, 142,
            eot = self.DFA142_eot,
            eof = self.DFA142_eof,
            min = self.DFA142_min,
            max = self.DFA142_max,
            accept = self.DFA142_accept,
            special = self.DFA142_special,
            transition = self.DFA142_transition
            )

        self.dfa175 = self.DFA175(
            self, 175,
            eot = self.DFA175_eot,
            eof = self.DFA175_eof,
            min = self.DFA175_min,
            max = self.DFA175_max,
            accept = self.DFA175_accept,
            special = self.DFA175_special,
            transition = self.DFA175_transition
            )

        self.dfa180 = self.DFA180(
            self, 180,
            eot = self.DFA180_eot,
            eof = self.DFA180_eof,
            min = self.DFA180_min,
            max = self.DFA180_max,
            accept = self.DFA180_accept,
            special = self.DFA180_special,
            transition = self.DFA180_transition
            )

        self.dfa181 = self.DFA181(
            self, 181,
            eot = self.DFA181_eot,
            eof = self.DFA181_eof,
            min = self.DFA181_min,
            max = self.DFA181_max,
            accept = self.DFA181_accept,
            special = self.DFA181_special,
            transition = self.DFA181_transition
            )

        self.dfa185 = self.DFA185(
            self, 185,
            eot = self.DFA185_eot,
            eof = self.DFA185_eof,
            min = self.DFA185_min,
            max = self.DFA185_max,
            accept = self.DFA185_accept,
            special = self.DFA185_special,
            transition = self.DFA185_transition
            )

        self.dfa194 = self.DFA194(
            self, 194,
            eot = self.DFA194_eot,
            eof = self.DFA194_eof,
            min = self.DFA194_min,
            max = self.DFA194_max,
            accept = self.DFA194_accept,
            special = self.DFA194_special,
            transition = self.DFA194_transition
            )






        self._adaptor = None
        self.adaptor = CommonTreeAdaptor()
                


        
    def getTreeAdaptor(self):
        return self._adaptor

    def setTreeAdaptor(self, adaptor):
        self._adaptor = adaptor

    adaptor = property(getTreeAdaptor, setTreeAdaptor)


    class pr_file_return(ParserRuleReturnScope):
        def __init__(self):
            super(sdl92Parser.pr_file_return, self).__init__()

            self.tree = None




    # $ANTLR start "pr_file"
    # sdl92.g:146:1: pr_file : ( use_clause | system_definition | process_definition )+ ;
    def pr_file(self, ):

        retval = self.pr_file_return()
        retval.start = self.input.LT(1)

        root_0 = None

        use_clause1 = None

        system_definition2 = None

        process_definition3 = None



        try:
            try:
                # sdl92.g:147:9: ( ( use_clause | system_definition | process_definition )+ )
                # sdl92.g:147:17: ( use_clause | system_definition | process_definition )+
                pass 
                root_0 = self._adaptor.nil()

                # sdl92.g:147:17: ( use_clause | system_definition | process_definition )+
                cnt1 = 0
                while True: #loop1
                    alt1 = 4
                    LA1 = self.input.LA(1)
                    if LA1 == 229:
                        LA1_2 = self.input.LA(2)

                        if (LA1_2 == KEEP) :
                            alt1 = 1
                        elif (LA1_2 == ANSWER or LA1_2 == COMMENT or LA1_2 == CONNECT or LA1_2 == DECISION or LA1_2 == INPUT or (JOIN <= LA1_2 <= LABEL) or LA1_2 == NEXTSTATE or LA1_2 == OUTPUT or (PROCEDURE <= LA1_2 <= PROCEDURE_CALL) or (PROCESS <= LA1_2 <= PROVIDED) or LA1_2 == RETURN or LA1_2 == STATE or LA1_2 == STOP or LA1_2 == TASK or LA1_2 == TEXT or LA1_2 == START) :
                            alt1 = 3


                    elif LA1 == USE:
                        alt1 = 1
                    elif LA1 == SYSTEM:
                        alt1 = 2
                    elif LA1 == PROCESS:
                        alt1 = 3

                    if alt1 == 1:
                        # sdl92.g:147:18: use_clause
                        pass 
                        self._state.following.append(self.FOLLOW_use_clause_in_pr_file1375)
                        use_clause1 = self.use_clause()

                        self._state.following.pop()
                        if self._state.backtracking == 0:
                            self._adaptor.addChild(root_0, use_clause1.tree)


                    elif alt1 == 2:
                        # sdl92.g:148:19: system_definition
                        pass 
                        self._state.following.append(self.FOLLOW_system_definition_in_pr_file1395)
                        system_definition2 = self.system_definition()

                        self._state.following.pop()
                        if self._state.backtracking == 0:
                            self._adaptor.addChild(root_0, system_definition2.tree)


                    elif alt1 == 3:
                        # sdl92.g:149:19: process_definition
                        pass 
                        self._state.following.append(self.FOLLOW_process_definition_in_pr_file1415)
                        process_definition3 = self.process_definition()

                        self._state.following.pop()
                        if self._state.backtracking == 0:
                            self._adaptor.addChild(root_0, process_definition3.tree)


                    else:
                        if cnt1 >= 1:
                            break #loop1

                        if self._state.backtracking > 0:
                            raise BacktrackingFailed

                        eee = EarlyExitException(1, self.input)
                        raise eee

                    cnt1 += 1



                retval.stop = self.input.LT(-1)

                if self._state.backtracking == 0:

                    retval.tree = self._adaptor.rulePostProcessing(root_0)
                    self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, re:
                self.reportError(re)
                self.recover(self.input, re)
                retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
        finally:

            pass
        return retval

    # $ANTLR end "pr_file"

    class system_definition_return(ParserRuleReturnScope):
        def __init__(self):
            super(sdl92Parser.system_definition_return, self).__init__()

            self.tree = None




    # $ANTLR start "system_definition"
    # sdl92.g:153:1: system_definition : SYSTEM system_name end ( entity_in_system )* ENDSYSTEM ( system_name )? end -> ^( SYSTEM system_name ( entity_in_system )* ) ;
    def system_definition(self, ):

        retval = self.system_definition_return()
        retval.start = self.input.LT(1)

        root_0 = None

        SYSTEM4 = None
        ENDSYSTEM8 = None
        system_name5 = None

        end6 = None

        entity_in_system7 = None

        system_name9 = None

        end10 = None


        SYSTEM4_tree = None
        ENDSYSTEM8_tree = None
        stream_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 == 229) :
                        alt2 = 1


                    if alt2 == 1:
                        # sdl92.g:0:0: entity_in_system
                        pass 
                        self._state.following.append(self.FOLLOW_entity_in_system_in_system_definition1471)
                        entity_in_system7 = self.entity_in_system()

                        self._state.following.pop()
                        if self._state.backtracking == 0:
                            stream_entity_in_system.add(entity_in_system7.tree)


                    else:
                        break #loop2
                ENDSYSTEM8=self.match(self.input, ENDSYSTEM, self.FOLLOW_ENDSYSTEM_in_system_definition1490) 
                if self._state.backtracking == 0:
                    stream_ENDSYSTEM.add(ENDSYSTEM8)
                # sdl92.g:156:27: ( system_name )?
                alt3 = 2
                LA3_0 = self.input.LA(1)

                if (LA3_0 == ID) :
                    alt3 = 1
                if alt3 == 1:
                    # sdl92.g:0:0: system_name
                    pass 
                    self._state.following.append(self.FOLLOW_system_name_in_system_definition1492)
                    system_name9 = self.system_name()

                    self._state.following.pop()
                    if self._state.backtracking == 0:
                        stream_system_name.add(system_name9.tree)



                self._state.following.append(self.FOLLOW_end_in_system_definition1495)
                end10 = self.end()

                self._state.following.pop()
                if self._state.backtracking == 0:
                    stream_end.add(end10.tree)

                # AST Rewrite
                # elements: entity_in_system, SYSTEM, system_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()
                    # 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 == 229) :
                    alt4 = 1
                if alt4 == 1:
                    # sdl92.g:0:0: use_asn1
                    pass 
                    self._state.following.append(self.FOLLOW_use_asn1_in_use_clause1551)
                    use_asn111 = self.use_asn1()

                    self._state.following.pop()
                    if self._state.backtracking == 0:
                        stream_use_asn1.add(use_asn111.tree)



                USE12=self.match(self.input, USE, self.FOLLOW_USE_in_use_clause1570) 
                if self._state.backtracking == 0:
                    stream_USE.add(USE12)
                self._state.following.append(self.FOLLOW_package_name_in_use_clause1572)
                package_name13 = self.package_name()

                self._state.following.pop()
                if self._state.backtracking == 0:
                    stream_package_name.add(package_name13.tree)
                # sdl92.g:164:17: ( '/' def_selection_list )?
                alt5 = 2
                LA5_0 = self.input.LA(1)

                if (LA5_0 == DIV) :
                    alt5 = 1
                if alt5 == 1:
                    # sdl92.g:164:18: '/' def_selection_list
                    pass 
                    char_literal14=self.match(self.input, DIV, self.FOLLOW_DIV_in_use_clause1591) 
                    if self._state.backtracking == 0:
                        stream_DIV.add(char_literal14)
                    self._state.following.append(self.FOLLOW_def_selection_list_in_use_clause1593)
                    def_selection_list15 = self.def_selection_list()

                    self._state.following.pop()
                    if self._state.backtracking == 0:
                        stream_def_selection_list.add(def_selection_list15.tree)



                self._state.following.append(self.FOLLOW_end_in_use_clause1614)
                end16 = self.end()

                self._state.following.pop()
                if self._state.backtracking == 0:
                    stream_end.add(end16.tree)

                # AST Rewrite
                # elements: end, package_name, USE, 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 == 229:
                    LA7_1 = self.input.LA(2)

                    if (self.synpred9_sdl92()) :
                        alt7 = 1
                    elif (self.synpred10_sdl92()) :
                        alt7 = 2
                    elif (self.synpred11_sdl92()) :
                        alt7 = 3
                    else:
                        if self._state.backtracking > 0:
                            raise BacktrackingFailed

                        nvae = NoViableAltException("", 7, 1, self.input)

                        raise nvae

                elif LA7 == SIGNAL:
                    alt7 = 1
                elif LA7 == PROCEDURE:
                    alt7 = 3
                elif LA7 == CHANNEL:
                    alt7 = 4
                elif LA7 == BLOCK:
                    alt7 = 5
                else:
                    if self._state.backtracking > 0:
                        raise BacktrackingFailed

                    nvae = NoViableAltException("", 7, 0, self.input)

                    raise nvae

                if alt7 == 1:
                    # sdl92.g:182:17: signal_declaration
                    pass 
                    root_0 = self._adaptor.nil()

                    self._state.following.append(self.FOLLOW_signal_declaration_in_entity_in_system1720)
                    signal_declaration20 = self.signal_declaration()

                    self._state.following.pop()
                    if self._state.backtracking == 0:
                        self._adaptor.addChild(root_0, signal_declaration20.tree)


                elif alt7 == 2:
                    # sdl92.g:183:19: text_area
                    pass 
                    root_0 = self._adaptor.nil()

                    self._state.following.append(self.FOLLOW_text_area_in_entity_in_system1740)
                    text_area21 = self.text_area()

                    self._state.following.pop()
                    if self._state.backtracking == 0:
                        self._adaptor.addChild(root_0, text_area21.tree)


                elif alt7 == 3:
                    # sdl92.g:184:19: procedure
                    pass 
                    root_0 = self._adaptor.nil()

                    self._state.following.append(self.FOLLOW_procedure_in_entity_in_system1760)
                    procedure22 = self.procedure()

                    self._state.following.pop()
                    if self._state.backtracking == 0:
                        self._adaptor.addChild(root_0, procedure22.tree)


                elif alt7 == 4:
                    # sdl92.g:185:19: channel
                    pass 
                    root_0 = self._adaptor.nil()

                    self._state.following.append(self.FOLLOW_channel_in_entity_in_system1780)
                    channel23 = self.channel()

                    self._state.following.pop()
                    if self._state.backtracking == 0:
                        self._adaptor.addChild(root_0, channel23.tree)


                elif alt7 == 5:
                    # sdl92.g:186:19: block_definition
                    pass 
                    root_0 = self._adaptor.nil()

                    self._state.following.append(self.FOLLOW_block_definition_in_entity_in_system1800)
                    block_definition24 = self.block_definition()

                    self._state.following.pop()
                    if self._state.backtracking == 0:
                        self._adaptor.addChild(root_0, block_definition24.tree)


                retval.stop = self.input.LT(-1)

                if self._state.backtracking == 0:

                    retval.tree = self._adaptor.rulePostProcessing(root_0)
                    self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, re:
                self.reportError(re)
                self.recover(self.input, re)
                retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
        finally:

            pass
        return retval

    # $ANTLR end "entity_in_system"

    class signal_declaration_return(ParserRuleReturnScope):
        def __init__(self):
            super(sdl92Parser.signal_declaration_return, self).__init__()

            self.tree = None




    # $ANTLR start "signal_declaration"
    # sdl92.g:192:1: signal_declaration : ( paramnames )? SIGNAL signal_id ( input_params )? end -> ^( SIGNAL ( paramnames )? signal_id ( input_params )? ) ;
    def signal_declaration(self, ):

        retval = self.signal_declaration_return()
        retval.start = self.input.LT(1)

        root_0 = None

        SIGNAL26 = None
        paramnames25 = None

        signal_id27 = None

        input_params28 = None

        end29 = None


        SIGNAL26_tree = None
        stream_SIGNAL = RewriteRuleTokenStream(self._adaptor, "token SIGNAL")
        stream_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 == 229) :
                    alt8 = 1
                if alt8 == 1:
                    # sdl92.g:0:0: paramnames
                    pass 
                    self._state.following.append(self.FOLLOW_paramnames_in_signal_declaration1833)
                    paramnames25 = self.paramnames()

                    self._state.following.pop()
                    if self._state.backtracking == 0:
                        stream_paramnames.add(paramnames25.tree)



                SIGNAL26=self.match(self.input, SIGNAL, self.FOLLOW_SIGNAL_in_signal_declaration1852) 
                if self._state.backtracking == 0:
                    stream_SIGNAL.add(SIGNAL26)
                self._state.following.append(self.FOLLOW_signal_id_in_signal_declaration1854)
                signal_id27 = self.signal_id()

                self._state.following.pop()
                if self._state.backtracking == 0:
                    stream_signal_id.add(signal_id27.tree)
                # sdl92.g:194:34: ( input_params )?
                alt9 = 2
                LA9_0 = self.input.LA(1)

                if (LA9_0 == L_PAREN) :
                    alt9 = 1
                if alt9 == 1:
                    # sdl92.g:0:0: input_params
                    pass 
                    self._state.following.append(self.FOLLOW_input_params_in_signal_declaration1856)
                    input_params28 = self.input_params()

                    self._state.following.pop()
                    if self._state.backtracking == 0:
                        stream_input_params.add(input_params28.tree)



                self._state.following.append(self.FOLLOW_end_in_signal_declaration1859)
                end29 = self.end()

                self._state.following.pop()
                if self._state.backtracking == 0:
                    stream_end.add(end29.tree)

                # AST Rewrite
                # elements: signal_id, input_params, SIGNAL, paramnames
                # token labels: 
                # rule labels: retval
                # token list labels: 
                # rule list labels: 
                # wildcard labels: 
                if self._state.backtracking == 0:

                    retval.tree = root_0

                    if retval is not None:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "rule retval", retval.tree)
                    else:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                    root_0 = self._adaptor.nil()
                    # 195:9: -> ^( SIGNAL ( paramnames )? signal_id ( input_params )? )
                    # sdl92.g:195:17: ^( SIGNAL ( paramnames )? signal_id ( input_params )? )
                    root_1 = self._adaptor.nil()
                    root_1 = self._adaptor.becomeRoot(stream_SIGNAL.nextNode(), root_1)

                    # sdl92.g:195:26: ( paramnames )?
                    if stream_paramnames.hasNext():
                        self._adaptor.addChild(root_1, stream_paramnames.nextTree())


                    stream_paramnames.reset();
                    self._adaptor.addChild(root_1, stream_signal_id.nextTree())
                    # sdl92.g:195:48: ( input_params )?
                    if stream_input_params.hasNext():
                        self._adaptor.addChild(root_1, stream_input_params.nextTree())


                    stream_input_params.reset();

                    self._adaptor.addChild(root_0, root_1)



                    retval.tree = root_0



                retval.stop = self.input.LT(-1)

                if self._state.backtracking == 0:

                    retval.tree = self._adaptor.rulePostProcessing(root_0)
                    self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)


            except RecognitionException, re:
                self.reportError(re)
                self.recover(self.input, re)
                retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)
        finally:

            pass
        return retval

    # $ANTLR end "signal_declaration"

    class channel_return(ParserRuleReturnScope):
        def __init__(self):
            super(sdl92Parser.channel_return, self).__init__()

            self.tree = None




    # $ANTLR start "channel"
    # sdl92.g:199:1: channel : CHANNEL channel_id ( route )+ ENDCHANNEL end -> ^( CHANNEL channel_id ( route )+ ) ;
    def channel(self, ):

        retval = self.channel_return()
        retval.start = self.input.LT(1)

        root_0 = None

        CHANNEL30 = None
        ENDCHANNEL33 = None
        channel_id31 = None

        route32 = None

        end34 = None


        CHANNEL30_tree = None
        ENDCHANNEL33_tree = None
        stream_CHANNEL = RewriteRuleTokenStream(self._adaptor, "token CHANNEL")
        stream_ENDCHANNEL = RewriteRuleTokenStream(self._adaptor, "token ENDCHANNEL")
        stream_route = RewriteRuleSubtreeStream(self._adaptor, "rule route")
        stream_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, CHANNEL, 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()
                    # 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 )+