sdl92Parser.py

# $ANTLR 3.1.3 Mar 17, 2009 19:23:44 sdl92.g 2015-03-28 16:25:40

import sys
from antlr3 import *
from antlr3.compat import set, frozenset

from antlr3.tree import *



# for convenience in actions
HIDDEN = BaseRecognizer.HIDDEN

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

# 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", "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", "PRIMARY", 
    "PROCEDURE", "PROCEDURE_CALL", "PROCEDURE_NAME", "PROCESS", "PROVIDED", 
    "QUESTION", "RANGE", "RESET", "RETURN", "ROUTE", "SAVE", "SELECTOR", 
    "SEQOF", "SEQUENCE", "SET", "SIGNAL", "SIGNAL_LIST", "SORT", "STATE", 
    "STATELIST", "STIMULUS", "STOP", "STOPIF", "STRING", "STRUCT", "SYNONYM", 
    "SYNONYM_LIST", "SYNTYPE", "SYSTEM", "TASK", "TASK_BODY", "TERMINATOR", 
    "TEXT", "TEXTAREA", "TEXTAREA_CONTENT", "THEN", "TIMER", "TO", "TRANSITION", 
    "USE", "VALUE", "VARIABLE", "VARIABLES", "VIA", "VIAPATH", "ENDSYSTEM", 
    "ENDCHANNEL", "FROM", "WITH", "ENDBLOCK", "SIGNALROUTE", "AND", "REFERENCED", 
    "ENDPROCESS", "ENDPROCEDURE", "INT", "START", "ENDCONNECTION", "SEMI", 
    "ENDSTATE", "ASTERISK", "SUBSTRUCTURE", "ENDSUBSTRUCTURE", "OUT", "NONE", 
    "PRIORITY", "L_PAREN", "R_PAREN", "COMMA", "CALL", "ENDALTERNATIVE", 
    "ENDDECISION", "ANY", "EQ", "NEQ", "GT", "LT", "LE", "GE", "CREATE", 
    "THIS", "ID", "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.dfa19 = self.DFA19(
            self, 19,
            eot = self.DFA19_eot,
            eof = self.DFA19_eof,
            min = self.DFA19_min,
            max = self.DFA19_max,
            accept = self.DFA19_accept,
            special = self.DFA19_special,
            transition = self.DFA19_transition
            )

        self.dfa30 = self.DFA30(
            self, 30,
            eot = self.DFA30_eot,
            eof = self.DFA30_eof,
            min = self.DFA30_min,
            max = self.DFA30_max,
            accept = self.DFA30_accept,
            special = self.DFA30_special,
            transition = self.DFA30_transition
            )

        self.dfa37 = self.DFA37(
            self, 37,
            eot = self.DFA37_eot,
            eof = self.DFA37_eof,
            min = self.DFA37_min,
            max = self.DFA37_max,
            accept = self.DFA37_accept,
            special = self.DFA37_special,
            transition = self.DFA37_transition
            )

        self.dfa43 = self.DFA43(
            self, 43,
            eot = self.DFA43_eot,
            eof = self.DFA43_eof,
            min = self.DFA43_min,
            max = self.DFA43_max,
            accept = self.DFA43_accept,
            special = self.DFA43_special,
            transition = self.DFA43_transition
            )

        self.dfa44 = self.DFA44(
            self, 44,
            eot = self.DFA44_eot,
            eof = self.DFA44_eof,
            min = self.DFA44_min,
            max = self.DFA44_max,
            accept = self.DFA44_accept,
            special = self.DFA44_special,
            transition = self.DFA44_transition
            )

        self.dfa48 = self.DFA48(
            self, 48,
            eot = self.DFA48_eot,
            eof = self.DFA48_eof,
            min = self.DFA48_min,
            max = self.DFA48_max,
            accept = self.DFA48_accept,
            special = self.DFA48_special,
            transition = self.DFA48_transition
            )

        self.dfa66 = self.DFA66(
            self, 66,
            eot = self.DFA66_eot,
            eof = self.DFA66_eof,
            min = self.DFA66_min,
            max = self.DFA66_max,
            accept = self.DFA66_accept,
            special = self.DFA66_special,
            transition = self.DFA66_transition
            )

        self.dfa67 = self.DFA67(
            self, 67,
            eot = self.DFA67_eot,
            eof = self.DFA67_eof,
            min = self.DFA67_min,
            max = self.DFA67_max,
            accept = self.DFA67_accept,
            special = self.DFA67_special,
            transition = self.DFA67_transition
            )

        self.dfa68 = self.DFA68(
            self, 68,
            eot = self.DFA68_eot,
            eof = self.DFA68_eof,
            min = self.DFA68_min,
            max = self.DFA68_max,
            accept = self.DFA68_accept,
            special = self.DFA68_special,
            transition = self.DFA68_transition
            )

        self.dfa72 = self.DFA72(
            self, 72,
            eot = self.DFA72_eot,
            eof = self.DFA72_eof,
            min = self.DFA72_min,
            max = self.DFA72_max,
            accept = self.DFA72_accept,
            special = self.DFA72_special,
            transition = self.DFA72_transition
            )

        self.dfa83 = self.DFA83(
            self, 83,
            eot = self.DFA83_eot,
            eof = self.DFA83_eof,
            min = self.DFA83_min,
            max = self.DFA83_max,
            accept = self.DFA83_accept,
            special = self.DFA83_special,
            transition = self.DFA83_transition
            )

        self.dfa84 = self.DFA84(
            self, 84,
            eot = self.DFA84_eot,
            eof = self.DFA84_eof,
            min = self.DFA84_min,
            max = self.DFA84_max,
            accept = self.DFA84_accept,
            special = self.DFA84_special,
            transition = self.DFA84_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.dfa89 = self.DFA89(
            self, 89,
            eot = self.DFA89_eot,
            eof = self.DFA89_eof,
            min = self.DFA89_min,
            max = self.DFA89_max,
            accept = self.DFA89_accept,
            special = self.DFA89_special,
            transition = self.DFA89_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.dfa93 = self.DFA93(
            self, 93,
            eot = self.DFA93_eot,
            eof = self.DFA93_eof,
            min = self.DFA93_min,
            max = self.DFA93_max,
            accept = self.DFA93_accept,
            special = self.DFA93_special,
            transition = self.DFA93_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.dfa105 = self.DFA105(
            self, 105,
            eot = self.DFA105_eot,
            eof = self.DFA105_eof,
            min = self.DFA105_min,
            max = self.DFA105_max,
            accept = self.DFA105_accept,
            special = self.DFA105_special,
            transition = self.DFA105_transition
            )

        self.dfa103 = self.DFA103(
            self, 103,
            eot = self.DFA103_eot,
            eof = self.DFA103_eof,
            min = self.DFA103_min,
            max = self.DFA103_max,
            accept = self.DFA103_accept,
            special = self.DFA103_special,
            transition = self.DFA103_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.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.dfa152 = self.DFA152(
            self, 152,
            eot = self.DFA152_eot,
            eof = self.DFA152_eof,
            min = self.DFA152_min,
            max = self.DFA152_max,
            accept = self.DFA152_accept,
            special = self.DFA152_special,
            transition = self.DFA152_transition
            )

        self.dfa157 = self.DFA157(
            self, 157,
            eot = self.DFA157_eot,
            eof = self.DFA157_eof,
            min = self.DFA157_min,
            max = self.DFA157_max,
            accept = self.DFA157_accept,
            special = self.DFA157_special,
            transition = self.DFA157_transition
            )

        self.dfa158 = self.DFA158(
            self, 158,
            eot = self.DFA158_eot,
            eof = self.DFA158_eof,
            min = self.DFA158_min,
            max = self.DFA158_max,
            accept = self.DFA158_accept,
            special = self.DFA158_special,
            transition = self.DFA158_transition
            )

        self.dfa162 = self.DFA162(
            self, 162,
            eot = self.DFA162_eot,
            eof = self.DFA162_eof,
            min = self.DFA162_min,
            max = self.DFA162_max,
            accept = self.DFA162_accept,
            special = self.DFA162_special,
            transition = self.DFA162_transition
            )

        self.dfa171 = self.DFA171(
            self, 171,
            eot = self.DFA171_eot,
            eof = self.DFA171_eof,
            min = self.DFA171_min,
            max = self.DFA171_max,
            accept = self.DFA171_accept,
            special = self.DFA171_special,
            transition = self.DFA171_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:139: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:140:9: ( ( use_clause | system_definition | process_definition )+ )
                # sdl92.g:140:17: ( use_clause | system_definition | process_definition )+
                pass 
                root_0 = self._adaptor.nil()

                # sdl92.g:140:17: ( use_clause | system_definition | process_definition )+
                cnt1 = 0
                while True: #loop1
                    alt1 = 4
                    LA1 = self.input.LA(1)
                    if LA1 == 219:
                        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:140:18: use_clause
                        pass 
                        self._state.following.append(self.FOLLOW_use_clause_in_pr_file1299)
                        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:141:19: system_definition
                        pass 
                        self._state.following.append(self.FOLLOW_system_definition_in_pr_file1319)
                        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:142:19: process_definition
                        pass 
                        self._state.following.append(self.FOLLOW_process_definition_in_pr_file1339)
                        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:145:1: system_definition : SYSTEM system_name end ( entity_in_system )* ENDSYSTEM ( system_name )? end -> ^( SYSTEM system_name ( entity_in_system )* ) ;
    def system_definition(self, ):

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

        root_0 = None

        SYSTEM4 = None
        ENDSYSTEM8 = None
        system_name5 = None

        end6 = None

        entity_in_system7 = None

        system_name9 = None

        end10 = None


        SYSTEM4_tree = None
        ENDSYSTEM8_tree = None
        stream_ENDSYSTEM = RewriteRuleTokenStream(self._adaptor, "token ENDSYSTEM")
        stream_SYSTEM = RewriteRuleTokenStream(self._adaptor, "token SYSTEM")
        stream_entity_in_system = RewriteRuleSubtreeStream(self._adaptor, "rule entity_in_system")
        stream_system_name = RewriteRuleSubtreeStream(self._adaptor, "rule system_name")
        stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end")
        try:
            try:
                # sdl92.g:146:9: ( SYSTEM system_name end ( entity_in_system )* ENDSYSTEM ( system_name )? end -> ^( SYSTEM system_name ( entity_in_system )* ) )
                # sdl92.g:146:17: SYSTEM system_name end ( entity_in_system )* ENDSYSTEM ( system_name )? end
                pass 
                SYSTEM4=self.match(self.input, SYSTEM, self.FOLLOW_SYSTEM_in_system_definition1364) 
                if self._state.backtracking == 0:
                    stream_SYSTEM.add(SYSTEM4)
                self._state.following.append(self.FOLLOW_system_name_in_system_definition1366)
                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_definition1368)
                end6 = self.end()

                self._state.following.pop()
                if self._state.backtracking == 0:
                    stream_end.add(end6.tree)
                # sdl92.g:147: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 == 219) :
                        alt2 = 1


                    if alt2 == 1:
                        # sdl92.g:0:0: entity_in_system
                        pass 
                        self._state.following.append(self.FOLLOW_entity_in_system_in_system_definition1386)
                        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_definition1405) 
                if self._state.backtracking == 0:
                    stream_ENDSYSTEM.add(ENDSYSTEM8)
                # sdl92.g:148: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_definition1407)
                    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_definition1410)
                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()
                    # 149:9: -> ^( SYSTEM system_name ( entity_in_system )* )
                    # sdl92.g:149: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:149: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:152:1: use_clause : ( use_asn1 )? USE package_name end -> ^( USE ( use_asn1 )? ( end )? package_name ) ;
    def use_clause(self, ):

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

        root_0 = None

        USE12 = None
        use_asn111 = None

        package_name13 = None

        end14 = None


        USE12_tree = None
        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")
        try:
            try:
                # sdl92.g:153:9: ( ( use_asn1 )? USE package_name end -> ^( USE ( use_asn1 )? ( end )? package_name ) )
                # sdl92.g:153:17: ( use_asn1 )? USE package_name end
                pass 
                # sdl92.g:153:17: ( use_asn1 )?
                alt4 = 2
                LA4_0 = self.input.LA(1)

                if (LA4_0 == 219) :
                    alt4 = 1
                if alt4 == 1:
                    # sdl92.g:0:0: use_asn1
                    pass 
                    self._state.following.append(self.FOLLOW_use_asn1_in_use_clause1457)
                    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_clause1476) 
                if self._state.backtracking == 0:
                    stream_USE.add(USE12)
                self._state.following.append(self.FOLLOW_package_name_in_use_clause1478)
                package_name13 = self.package_name()

                self._state.following.pop()
                if self._state.backtracking == 0:
                    stream_package_name.add(package_name13.tree)
                self._state.following.append(self.FOLLOW_end_in_use_clause1480)
                end14 = self.end()

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

                # AST Rewrite
                # elements: package_name, use_asn1, end, USE
                # 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()
                    # 155:9: -> ^( USE ( use_asn1 )? ( end )? package_name )
                    # sdl92.g:155:17: ^( USE ( use_asn1 )? ( end )? package_name )
                    root_1 = self._adaptor.nil()
                    root_1 = self._adaptor.becomeRoot(stream_USE.nextNode(), root_1)

                    # sdl92.g:155:23: ( use_asn1 )?
                    if stream_use_asn1.hasNext():
                        self._adaptor.addChild(root_1, stream_use_asn1.nextTree())


                    stream_use_asn1.reset();
                    # sdl92.g:155: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())

                    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 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:161: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_declaration15 = None

        text_area16 = None

        procedure17 = None

        channel18 = None

        block_definition19 = None



        try:
            try:
                # sdl92.g:162:9: ( signal_declaration | text_area | procedure | channel | block_definition )
                alt5 = 5
                LA5 = self.input.LA(1)
                if LA5 == 219:
                    LA5_1 = self.input.LA(2)

                    if (self.synpred7_sdl92()) :
                        alt5 = 1
                    elif (self.synpred8_sdl92()) :
                        alt5 = 2
                    elif (self.synpred9_sdl92()) :
                        alt5 = 3
                    else:
                        if self._state.backtracking > 0:
                            raise BacktrackingFailed

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

                        raise nvae

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

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

                    raise nvae

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

                    self._state.following.append(self.FOLLOW_signal_declaration_in_entity_in_system1532)
                    signal_declaration15 = self.signal_declaration()

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


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

                    self._state.following.append(self.FOLLOW_text_area_in_entity_in_system1552)
                    text_area16 = self.text_area()

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


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

                    self._state.following.append(self.FOLLOW_procedure_in_entity_in_system1572)
                    procedure17 = self.procedure()

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


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

                    self._state.following.append(self.FOLLOW_channel_in_entity_in_system1592)
                    channel18 = self.channel()

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


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

                    self._state.following.append(self.FOLLOW_block_definition_in_entity_in_system1612)
                    block_definition19 = self.block_definition()

                    self._state.following.pop()
                    if self._state.backtracking == 0:
                        self._adaptor.addChild(root_0, block_definition19.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:171: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

        SIGNAL21 = None
        paramnames20 = None

        signal_id22 = None

        input_params23 = None

        end24 = None


        SIGNAL21_tree = None
        stream_SIGNAL = RewriteRuleTokenStream(self._adaptor, "token SIGNAL")
        stream_input_params = RewriteRuleSubtreeStream(self._adaptor, "rule input_params")
        stream_paramnames = RewriteRuleSubtreeStream(self._adaptor, "rule paramnames")
        stream_signal_id = RewriteRuleSubtreeStream(self._adaptor, "rule signal_id")
        stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end")
        try:
            try:
                # sdl92.g:172:9: ( ( paramnames )? SIGNAL signal_id ( input_params )? end -> ^( SIGNAL ( paramnames )? signal_id ( input_params )? ) )
                # sdl92.g:172:17: ( paramnames )? SIGNAL signal_id ( input_params )? end
                pass 
                # sdl92.g:172:17: ( paramnames )?
                alt6 = 2
                LA6_0 = self.input.LA(1)

                if (LA6_0 == 219) :
                    alt6 = 1
                if alt6 == 1:
                    # sdl92.g:0:0: paramnames
                    pass 
                    self._state.following.append(self.FOLLOW_paramnames_in_signal_declaration1636)
                    paramnames20 = self.paramnames()

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



                SIGNAL21=self.match(self.input, SIGNAL, self.FOLLOW_SIGNAL_in_signal_declaration1655) 
                if self._state.backtracking == 0:
                    stream_SIGNAL.add(SIGNAL21)
                self._state.following.append(self.FOLLOW_signal_id_in_signal_declaration1657)
                signal_id22 = self.signal_id()

                self._state.following.pop()
                if self._state.backtracking == 0:
                    stream_signal_id.add(signal_id22.tree)
                # sdl92.g:173:34: ( input_params )?
                alt7 = 2
                LA7_0 = self.input.LA(1)

                if (LA7_0 == L_PAREN) :
                    alt7 = 1
                if alt7 == 1:
                    # sdl92.g:0:0: input_params
                    pass 
                    self._state.following.append(self.FOLLOW_input_params_in_signal_declaration1659)
                    input_params23 = self.input_params()

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



                self._state.following.append(self.FOLLOW_end_in_signal_declaration1662)
                end24 = self.end()

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

                # AST Rewrite
                # elements: paramnames, input_params, signal_id, SIGNAL
                # 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()
                    # 174:9: -> ^( SIGNAL ( paramnames )? signal_id ( input_params )? )
                    # sdl92.g:174:17: ^( SIGNAL ( paramnames )? signal_id ( input_params )? )
                    root_1 = self._adaptor.nil()
                    root_1 = self._adaptor.becomeRoot(stream_SIGNAL.nextNode(), root_1)

                    # sdl92.g:174: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:174: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:177: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

        CHANNEL25 = None
        ENDCHANNEL28 = None
        channel_id26 = None

        route27 = None

        end29 = None


        CHANNEL25_tree = None
        ENDCHANNEL28_tree = None
        stream_CHANNEL = RewriteRuleTokenStream(self._adaptor, "token CHANNEL")
        stream_ENDCHANNEL = RewriteRuleTokenStream(self._adaptor, "token ENDCHANNEL")
        stream_route = RewriteRuleSubtreeStream(self._adaptor, "rule route")
        stream_channel_id = RewriteRuleSubtreeStream(self._adaptor, "rule channel_id")
        stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end")
        try:
            try:
                # sdl92.g:178:9: ( CHANNEL channel_id ( route )+ ENDCHANNEL end -> ^( CHANNEL channel_id ( route )+ ) )
                # sdl92.g:178:17: CHANNEL channel_id ( route )+ ENDCHANNEL end
                pass 
                CHANNEL25=self.match(self.input, CHANNEL, self.FOLLOW_CHANNEL_in_channel1712) 
                if self._state.backtracking == 0:
                    stream_CHANNEL.add(CHANNEL25)
                self._state.following.append(self.FOLLOW_channel_id_in_channel1714)
                channel_id26 = self.channel_id()

                self._state.following.pop()
                if self._state.backtracking == 0:
                    stream_channel_id.add(channel_id26.tree)
                # sdl92.g:179:17: ( route )+
                cnt8 = 0
                while True: #loop8
                    alt8 = 2
                    LA8_0 = self.input.LA(1)

                    if (LA8_0 == FROM) :
                        alt8 = 1


                    if alt8 == 1:
                        # sdl92.g:0:0: route
                        pass 
                        self._state.following.append(self.FOLLOW_route_in_channel1732)
                        route27 = self.route()

                        self._state.following.pop()
                        if self._state.backtracking == 0:
                            stream_route.add(route27.tree)


                    else:
                        if cnt8 >= 1:
                            break #loop8

                        if self._state.backtracking > 0:
                            raise BacktrackingFailed

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

                    cnt8 += 1
                ENDCHANNEL28=self.match(self.input, ENDCHANNEL, self.FOLLOW_ENDCHANNEL_in_channel1751) 
                if self._state.backtracking == 0:
                    stream_ENDCHANNEL.add(ENDCHANNEL28)
                self._state.following.append(self.FOLLOW_end_in_channel1753)
                end29 = self.end()

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

                # AST Rewrite
                # elements: route, channel_id, CHANNEL
                # token labels: 
                # rule labels: retval
                # token list labels: 
                # rule list labels: 
                # wildcard labels: 
                if self._state.backtracking == 0:

                    retval.tree = root_0

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


                    root_0 = self._adaptor.nil()
                    # 181:9: -> ^( CHANNEL channel_id ( route )+ )
                    # sdl92.g:181: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:181: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:184: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

        FROM30 = None
        TO32 = None
        WITH34 = None
        char_literal36 = None
        source_id31 = None

        dest_id33 = None

        signal_id35 = None

        signal_id37 = None

        end38 = None


        FROM30_tree = None
        TO32_tree = None
        WITH34_tree = None
        char_literal36_tree = None
        stream_FROM = RewriteRuleTokenStream(self._adaptor, "token FROM")
        stream_TO = RewriteRuleTokenStream(self._adaptor, "token TO")
        stream_COMMA = RewriteRuleTokenStream(self._adaptor, "token COMMA")
        stream_WITH = RewriteRuleTokenStream(self._adaptor, "token WITH")
        stream_source_id = RewriteRuleSubtreeStream(self._adaptor, "rule source_id")
        stream_dest_id = RewriteRuleSubtreeStream(self._adaptor, "rule dest_id")
        stream_signal_id = RewriteRuleSubtreeStream(self._adaptor, "rule signal_id")
        stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end")
        try:
            try:
                # sdl92.g:185:9: ( FROM source_id TO dest_id WITH signal_id ( ',' signal_id )* end -> ^( ROUTE source_id dest_id ( signal_id )+ ) )
                # sdl92.g:185:17: FROM source_id TO dest_id WITH signal_id ( ',' signal_id )* end
                pass 
                FROM30=self.match(self.input, FROM, self.FOLLOW_FROM_in_route1800) 
                if self._state.backtracking == 0:
                    stream_FROM.add(FROM30)
                self._state.following.append(self.FOLLOW_source_id_in_route1802)
                source_id31 = self.source_id()

                self._state.following.pop()
                if self._state.backtracking == 0:
                    stream_source_id.add(source_id31.tree)
                TO32=self.match(self.input, TO, self.FOLLOW_TO_in_route1804) 
                if self._state.backtr