sdl92Parser.py

# $ANTLR 3.5.2 sdl92.g 2020-01-17 13:43:14

import sys
from antlr3 import *

from antlr3.tree import *




# for convenience in actions
HIDDEN = BaseRecognizer.HIDDEN

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

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

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



class sdl92Parser(Parser):
    grammarFileName = "sdl92.g"
    api_version = 1
    tokenNames = tokenNames

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

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

        self.dfa52 = self.DFA52(
            self, 52,
            eot = self.DFA52_eot,
            eof = self.DFA52_eof,
            min = self.DFA52_min,
            max = self.DFA52_max,
            accept = self.DFA52_accept,
            special = self.DFA52_special,
            transition = self.DFA52_transition
            )

        self.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.dfa189 = self.DFA189(
            self, 189,
            eot = self.DFA189_eot,
            eof = self.DFA189_eof,
            min = self.DFA189_min,
            max = self.DFA189_max,
            accept = self.DFA189_accept,
            special = self.DFA189_special,
            transition = self.DFA189_transition
            )




        self.delegates = []

        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().__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 in {228}:
                        LA1_2 = self.input.LA(2)

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


                    elif LA1 in {USE}:
                        alt1 = 1
                    elif LA1 in {SYSTEM}:
                        alt1 = 2
                    elif LA1 in {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 as re:
                self.reportError(re)
                self.recover(self.input, re)
                retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)

        finally:
            pass
        return retval

    # $ANTLR end "pr_file"


    class system_definition_return(ParserRuleReturnScope):
        def __init__(self):
            super().__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 (LA2_0 in {BLOCK, CHANNEL, PROCEDURE, SIGNAL, 228}) :
                        alt2 = 1


                    if alt2 == 1:
                        # sdl92.g:155:17: 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:156:27: system_name
                    pass 
                    self._state.following.append(self.FOLLOW_system_name_in_system_definition1492)
                    system_name9 = self.system_name()

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





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

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


                # AST Rewrite
                # elements: SYSTEM, system_name, entity_in_system
                # token labels: 
                # rule labels: retval
                # token list labels: 
                # rule list labels: 
                # wildcard labels: 
                if self._state.backtracking == 0:
                    retval.tree = root_0
                    if retval is not None:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "rule retval", retval.tree)
                    else:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                    root_0 = self._adaptor.nil()
                    # 157:9: -> ^( SYSTEM system_name ( entity_in_system )* )
                    # sdl92.g:157:17: ^( SYSTEM system_name ( entity_in_system )* )
                    root_1 = self._adaptor.nil()
                    root_1 = self._adaptor.becomeRoot(
                    stream_SYSTEM.nextNode()
                    , root_1)

                    self._adaptor.addChild(root_1, stream_system_name.nextTree())

                    # sdl92.g:157:38: ( entity_in_system )*
                    while stream_entity_in_system.hasNext():
                        self._adaptor.addChild(root_1, stream_entity_in_system.nextTree())


                    stream_entity_in_system.reset();

                    self._adaptor.addChild(root_0, root_1)




                    retval.tree = root_0





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


                if self._state.backtracking == 0:
                    retval.tree = self._adaptor.rulePostProcessing(root_0)
                    self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)



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

        finally:
            pass
        return retval

    # $ANTLR end "system_definition"


    class use_clause_return(ParserRuleReturnScope):
        def __init__(self):
            super().__init__()

            self.tree = None





    # $ANTLR start "use_clause"
    # sdl92.g:161:1: use_clause : ( use_asn1 )? USE package_name ( '/' def_selection_list )? end -> ^( USE ( use_asn1 )? ( end )? package_name ( def_selection_list )? ) ;
    def use_clause(self, ):
        retval = self.use_clause_return()
        retval.start = self.input.LT(1)


        root_0 = None

        USE12 = None
        char_literal14 = None
        use_asn111 = None
        package_name13 = None
        def_selection_list15 = None
        end16 = None

        USE12_tree = None
        char_literal14_tree = None
        stream_DIV = RewriteRuleTokenStream(self._adaptor, "token DIV")
        stream_USE = RewriteRuleTokenStream(self._adaptor, "token USE")
        stream_use_asn1 = RewriteRuleSubtreeStream(self._adaptor, "rule use_asn1")
        stream_package_name = RewriteRuleSubtreeStream(self._adaptor, "rule package_name")
        stream_end = RewriteRuleSubtreeStream(self._adaptor, "rule end")
        stream_def_selection_list = RewriteRuleSubtreeStream(self._adaptor, "rule def_selection_list")
        try:
            try:
                # sdl92.g:162:9: ( ( use_asn1 )? USE package_name ( '/' def_selection_list )? end -> ^( USE ( use_asn1 )? ( end )? package_name ( def_selection_list )? ) )
                # sdl92.g:162:17: ( use_asn1 )? USE package_name ( '/' def_selection_list )? end
                pass 
                # sdl92.g:162:17: ( use_asn1 )?
                alt4 = 2
                LA4_0 = self.input.LA(1)

                if (LA4_0 == 228) :
                    alt4 = 1
                if alt4 == 1:
                    # sdl92.g:162:17: use_asn1
                    pass 
                    self._state.following.append(self.FOLLOW_use_asn1_in_use_clause1551)
                    use_asn111 = self.use_asn1()

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





                USE12 = self.match(self.input, USE, self.FOLLOW_USE_in_use_clause1570) 
                if self._state.backtracking == 0:
                    stream_USE.add(USE12)


                self._state.following.append(self.FOLLOW_package_name_in_use_clause1572)
                package_name13 = self.package_name()

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


                # sdl92.g:164:17: ( '/' def_selection_list )?
                alt5 = 2
                LA5_0 = self.input.LA(1)

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


                    self._state.following.append(self.FOLLOW_def_selection_list_in_use_clause1593)
                    def_selection_list15 = self.def_selection_list()

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





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

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


                # AST Rewrite
                # elements: USE, use_asn1, end, package_name, def_selection_list
                # token labels: 
                # rule labels: retval
                # token list labels: 
                # rule list labels: 
                # wildcard labels: 
                if self._state.backtracking == 0:
                    retval.tree = root_0
                    if retval is not None:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "rule retval", retval.tree)
                    else:
                        stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)


                    root_0 = self._adaptor.nil()
                    # 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 as re:
                self.reportError(re)
                self.recover(self.input, re)
                retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)

        finally:
            pass
        return retval

    # $ANTLR end "use_clause"


    class def_selection_list_return(ParserRuleReturnScope):
        def __init__(self):
            super().__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 as re:
                self.reportError(re)
                self.recover(self.input, re)
                retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)

        finally:
            pass
        return retval

    # $ANTLR end "def_selection_list"


    class entity_in_system_return(ParserRuleReturnScope):
        def __init__(self):
            super().__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 in {228}:
                    LA7_1 = self.input.LA(2)

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


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

                        raise nvae


                elif LA7 in {SIGNAL}:
                    alt7 = 1
                elif LA7 in {PROCEDURE}:
                    alt7 = 3
                elif LA7 in {CHANNEL}:
                    alt7 = 4
                elif LA7 in {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 as re:
                self.reportError(re)
                self.recover(self.input, re)
                retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)

        finally:
            pass
        return retval

    # $ANTLR end "entity_in_system"


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

            self.tree = None





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


        root_0 = None

        SIGNAL26 = None
        paramnames25 = None
        signal_id27 = None
        input_params28 = None
        end29 = None

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

                if (LA8_0 == 228) :
                    alt8 = 1
                if alt8 == 1:
                    # sdl92.g:193:17: 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:194:34: input_params
                    pass 
                    self._state.following.append(self.FOLLOW_input_params_in_signal_declaration1856)
                    input_params28 = self.input_params()

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





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

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


                # AST Rewrite
                # elements: SIGNAL, paramnames, signal_id, input_params
                # 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 as re:
                self.reportError(re)
                self.recover(self.input, re)
                retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)

        finally:
            pass
        return retval

    # $ANTLR end "signal_declaration"


    class channel_return(ParserRuleReturnScope):
        def __init__(self):
            super().__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()