sdl92Parser.py

# $ANTLR 3.1.3 Mar 17, 2009 19:23:44 sdl92.g 2014-10-23 14:32:24

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

# 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", "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:138: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:139:9: ( ( use_clause | system_definition | process_definition )+ )
                # sdl92.g:139:17: ( use_clause | system_definition | process_definition )+
                pass 
                root_0 = self._adaptor.nil()

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

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


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

                    if alt1 == 1:
                        # sdl92.g:139:18: use_clause
                        pass 
                        self._state.following.append(self.FOLLOW_use_clause_in_pr_file1288)
                        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:140:19: system_definition
                        pass 
                        self._state.following.append(self.FOLLOW_system_definition_in_pr_file1308)
                        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:141:19: process_definition
                        pass 
                        self._state.following.append(self.FOLLOW_process_definition_in_pr_file1328)
                        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:144: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:145:9: ( SYSTEM system_name end ( entity_in_system )* ENDSYSTEM ( system_name )? end -> ^( SYSTEM system_name ( entity_in_system )* ) )
                # sdl92.g:145:17: SYSTEM system_name end ( entity_in_system )* ENDSYSTEM ( system_name )? end
                pass 
                SYSTEM4=self.match(self.input, SYSTEM, self.FOLLOW_SYSTEM_in_system_definition1353) 
                if self._state.backtracking == 0:
                    stream_SYSTEM.add(SYSTEM4)
                self._state.following.append(self.FOLLOW_system_name_in_system_definition1355)
                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_definition1357)
                end6 = self.end()

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


                    if alt2 == 1:
                        # sdl92.g:0:0: entity_in_system
                        pass 
                        self._state.following.append(self.FOLLOW_entity_in_system_in_system_definition1375)
                        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_definition1394) 
                if self._state.backtracking == 0:
                    stream_ENDSYSTEM.add(ENDSYSTEM8)
                # sdl92.g:147: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_definition1396)
                    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_definition1399)
                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()
                    # 148:9: -> ^( SYSTEM system_name ( entity_in_system )* )
                    # sdl92.g:148: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:148: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:151:1: use_clause : ( use_asn1 )? USE package_name end -> ^( USE ( use_asn1 )? 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:152:9: ( ( use_asn1 )? USE package_name end -> ^( USE ( use_asn1 )? package_name ) )
                # sdl92.g:152:17: ( use_asn1 )? USE package_name end
                pass 
                # sdl92.g:152:17: ( use_asn1 )?
                alt4 = 2
                LA4_0 = self.input.LA(1)

                if (LA4_0 == 218) :
                    alt4 = 1
                if alt4 == 1:
                    # sdl92.g:0:0: use_asn1
                    pass 
                    self._state.following.append(self.FOLLOW_use_asn1_in_use_clause1446)
                    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_clause1465) 
                if self._state.backtracking == 0:
                    stream_USE.add(USE12)
                self._state.following.append(self.FOLLOW_package_name_in_use_clause1467)
                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_clause1469)
                end14 = self.end()

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

                # AST Rewrite
                # elements: USE, use_asn1, package_name
                # token labels: 
                # rule labels: retval
                # token list labels: 
                # rule list labels: 
                # wildcard labels: 
                if self._state.backtracking == 0:

                    retval.tree = root_0

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


                    root_0 = self._adaptor.nil()
                    # 154:9: -> ^( USE ( use_asn1 )? package_name )
                    # sdl92.g:154:17: ^( USE ( use_asn1 )? package_name )
                    root_1 = self._adaptor.nil()
                    root_1 = self._adaptor.becomeRoot(stream_USE.nextNode(), root_1)

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


                    stream_use_asn1.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)