sdl92Lexer.py

# $ANTLR 3.1.3 Mar 17, 2009 19:23:44 sdl92.g 2015-07-11 15:47:46

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


# for convenience in actions
HIDDEN = BaseRecognizer.HIDDEN

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


class sdl92Lexer(Lexer):

    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"

    def __init__(self, input=None, state=None):
        if state is None:
            state = RecognizerSharedState()
        super(sdl92Lexer, self).__init__(input, state)


        self.dfa13 = self.DFA13(
            self, 13,
            eot = self.DFA13_eot,
            eof = self.DFA13_eof,
            min = self.DFA13_min,
            max = self.DFA13_max,
            accept = self.DFA13_accept,
            special = self.DFA13_special,
            transition = self.DFA13_transition
            )

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






    # $ANTLR start "T__216"
    def mT__216(self, ):

        try:
            _type = T__216
            _channel = DEFAULT_CHANNEL

            # sdl92.g:7:8: ( ':' )
            # sdl92.g:7:10: ':'
            pass 
            self.match(58)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__216"



    # $ANTLR start "T__217"
    def mT__217(self, ):

        try:
            _type = T__217
            _channel = DEFAULT_CHANNEL

            # sdl92.g:8:8: ( '!' )
            # sdl92.g:8:10: '!'
            pass 
            self.match(33)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__217"



    # $ANTLR start "T__218"
    def mT__218(self, ):

        try:
            _type = T__218
            _channel = DEFAULT_CHANNEL

            # sdl92.g:9:8: ( '(.' )
            # sdl92.g:9:10: '(.'
            pass 
            self.match("(.")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__218"



    # $ANTLR start "T__219"
    def mT__219(self, ):

        try:
            _type = T__219
            _channel = DEFAULT_CHANNEL

            # sdl92.g:10:8: ( '.)' )
            # sdl92.g:10:10: '.)'
            pass 
            self.match(".)")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__219"



    # $ANTLR start "T__220"
    def mT__220(self, ):

        try:
            _type = T__220
            _channel = DEFAULT_CHANNEL

            # sdl92.g:11:8: ( 'ERROR' )
            # sdl92.g:11:10: 'ERROR'
            pass 
            self.match("ERROR")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__220"



    # $ANTLR start "T__221"
    def mT__221(self, ):

        try:
            _type = T__221
            _channel = DEFAULT_CHANNEL

            # sdl92.g:12:8: ( '/* CIF' )
            # sdl92.g:12:10: '/* CIF'
            pass 
            self.match("/* CIF")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__221"



    # $ANTLR start "T__222"
    def mT__222(self, ):

        try:
            _type = T__222
            _channel = DEFAULT_CHANNEL

            # sdl92.g:13:8: ( '*/' )
            # sdl92.g:13:10: '*/'
            pass 
            self.match("*/")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "T__222"



    # $ANTLR start "ASSIG_OP"
    def mASSIG_OP(self, ):

        try:
            _type = ASSIG_OP
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1189:17: ( ':=' )
            # sdl92.g:1189:25: ':='
            pass 
            self.match(":=")



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ASSIG_OP"



    # $ANTLR start "L_BRACKET"
    def mL_BRACKET(self, ):

        try:
            _type = L_BRACKET
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1190:17: ( '{' )
            # sdl92.g:1190:25: '{'
            pass 
            self.match(123)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "L_BRACKET"



    # $ANTLR start "R_BRACKET"
    def mR_BRACKET(self, ):

        try:
            _type = R_BRACKET
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1191:17: ( '}' )
            # sdl92.g:1191:25: '}'
            pass 
            self.match(125)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "R_BRACKET"



    # $ANTLR start "L_PAREN"
    def mL_PAREN(self, ):

        try:
            _type = L_PAREN
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1192:17: ( '(' )
            # sdl92.g:1192:25: '('
            pass 
            self.match(40)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "L_PAREN"



    # $ANTLR start "R_PAREN"
    def mR_PAREN(self, ):

        try:
            _type = R_PAREN
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1193:17: ( ')' )
            # sdl92.g:1193:25: ')'
            pass 
            self.match(41)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "R_PAREN"



    # $ANTLR start "COMMA"
    def mCOMMA(self, ):

        try:
            _type = COMMA
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1194:17: ( ',' )
            # sdl92.g:1194:25: ','
            pass 
            self.match(44)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "COMMA"



    # $ANTLR start "SEMI"
    def mSEMI(self, ):

        try:
            _type = SEMI
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1195:17: ( ';' )
            # sdl92.g:1195:25: ';'
            pass 
            self.match(59)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "SEMI"



    # $ANTLR start "DASH"
    def mDASH(self, ):

        try:
            _type = DASH
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1196:17: ( '-' )
            # sdl92.g:1196:25: '-'
            pass 
            self.match(45)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "DASH"



    # $ANTLR start "ANY"
    def mANY(self, ):

        try:
            _type = ANY
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1197:17: ( A N Y )
            # sdl92.g:1197:25: A N Y
            pass 
            self.mA()
            self.mN()
            self.mY()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ANY"



    # $ANTLR start "ASTERISK"
    def mASTERISK(self, ):

        try:
            _type = ASTERISK
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1198:17: ( '*' )
            # sdl92.g:1198:25: '*'
            pass 
            self.match(42)



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ASTERISK"



    # $ANTLR start "DCL"
    def mDCL(self, ):

        try:
            _type = DCL
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1199:17: ( D C L )
            # sdl92.g:1199:25: D C L
            pass 
            self.mD()
            self.mC()
            self.mL()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "DCL"



    # $ANTLR start "END"
    def mEND(self, ):

        try:
            _type = END
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1200:17: ( E N D )
            # sdl92.g:1200:25: E N D
            pass 
            self.mE()
            self.mN()
            self.mD()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "END"



    # $ANTLR start "KEEP"
    def mKEEP(self, ):

        try:
            _type = KEEP
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1201:17: ( K E E P )
            # sdl92.g:1201:25: K E E P
            pass 
            self.mK()
            self.mE()
            self.mE()
            self.mP()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "KEEP"



    # $ANTLR start "PARAMNAMES"
    def mPARAMNAMES(self, ):

        try:
            _type = PARAMNAMES
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1202:17: ( P A R A M N A M E S )
            # sdl92.g:1202:25: P A R A M N A M E S
            pass 
            self.mP()
            self.mA()
            self.mR()
            self.mA()
            self.mM()
            self.mN()
            self.mA()
            self.mM()
            self.mE()
            self.mS()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "PARAMNAMES"



    # $ANTLR start "SPECIFIC"
    def mSPECIFIC(self, ):

        try:
            _type = SPECIFIC
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1203:17: ( S P E C I F I C )
            # sdl92.g:1203:25: S P E C I F I C
            pass 
            self.mS()
            self.mP()
            self.mE()
            self.mC()
            self.mI()
            self.mF()
            self.mI()
            self.mC()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "SPECIFIC"



    # $ANTLR start "GEODE"
    def mGEODE(self, ):

        try:
            _type = GEODE
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1204:17: ( G E O D E )
            # sdl92.g:1204:25: G E O D E
            pass 
            self.mG()
            self.mE()
            self.mO()
            self.mD()
            self.mE()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "GEODE"



    # $ANTLR start "HYPERLINK"
    def mHYPERLINK(self, ):

        try:
            _type = HYPERLINK
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1205:17: ( H Y P E R L I N K )
            # sdl92.g:1205:25: H Y P E R L I N K
            pass 
            self.mH()
            self.mY()
            self.mP()
            self.mE()
            self.mR()
            self.mL()
            self.mI()
            self.mN()
            self.mK()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "HYPERLINK"



    # $ANTLR start "ENDTEXT"
    def mENDTEXT(self, ):

        try:
            _type = ENDTEXT
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1206:17: ( E N D T E X T )
            # sdl92.g:1206:25: E N D T E X T
            pass 
            self.mE()
            self.mN()
            self.mD()
            self.mT()
            self.mE()
            self.mX()
            self.mT()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ENDTEXT"



    # $ANTLR start "RETURN"
    def mRETURN(self, ):

        try:
            _type = RETURN
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1207:17: ( R E T U R N )
            # sdl92.g:1207:25: R E T U R N
            pass 
            self.mR()
            self.mE()
            self.mT()
            self.mU()
            self.mR()
            self.mN()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "RETURN"



    # $ANTLR start "TIMER"
    def mTIMER(self, ):

        try:
            _type = TIMER
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1208:17: ( T I M E R )
            # sdl92.g:1208:25: T I M E R
            pass 
            self.mT()
            self.mI()
            self.mM()
            self.mE()
            self.mR()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "TIMER"



    # $ANTLR start "PROCESS"
    def mPROCESS(self, ):

        try:
            _type = PROCESS
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1209:17: ( P R O C E S S )
            # sdl92.g:1209:25: P R O C E S S
            pass 
            self.mP()
            self.mR()
            self.mO()
            self.mC()
            self.mE()
            self.mS()
            self.mS()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "PROCESS"



    # $ANTLR start "ENDPROCESS"
    def mENDPROCESS(self, ):

        try:
            _type = ENDPROCESS
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1210:17: ( E N D P R O C E S S )
            # sdl92.g:1210:25: E N D P R O C E S S
            pass 
            self.mE()
            self.mN()
            self.mD()
            self.mP()
            self.mR()
            self.mO()
            self.mC()
            self.mE()
            self.mS()
            self.mS()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ENDPROCESS"



    # $ANTLR start "START"
    def mSTART(self, ):

        try:
            _type = START
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1211:17: ( S T A R T )
            # sdl92.g:1211:25: S T A R T
            pass 
            self.mS()
            self.mT()
            self.mA()
            self.mR()
            self.mT()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "START"



    # $ANTLR start "STATE"
    def mSTATE(self, ):

        try:
            _type = STATE
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1212:17: ( S T A T E )
            # sdl92.g:1212:25: S T A T E
            pass 
            self.mS()
            self.mT()
            self.mA()
            self.mT()
            self.mE()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "STATE"



    # $ANTLR start "TEXT"
    def mTEXT(self, ):

        try:
            _type = TEXT
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1213:17: ( T E X T )
            # sdl92.g:1213:25: T E X T
            pass 
            self.mT()
            self.mE()
            self.mX()
            self.mT()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "TEXT"



    # $ANTLR start "PROCEDURE"
    def mPROCEDURE(self, ):

        try:
            _type = PROCEDURE
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1214:17: ( P R O C E D U R E )
            # sdl92.g:1214:25: P R O C E D U R E
            pass 
            self.mP()
            self.mR()
            self.mO()
            self.mC()
            self.mE()
            self.mD()
            self.mU()
            self.mR()
            self.mE()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "PROCEDURE"



    # $ANTLR start "ENDPROCEDURE"
    def mENDPROCEDURE(self, ):

        try:
            _type = ENDPROCEDURE
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1215:17: ( E N D P R O C E D U R E )
            # sdl92.g:1215:25: E N D P R O C E D U R E
            pass 
            self.mE()
            self.mN()
            self.mD()
            self.mP()
            self.mR()
            self.mO()
            self.mC()
            self.mE()
            self.mD()
            self.mU()
            self.mR()
            self.mE()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ENDPROCEDURE"



    # $ANTLR start "PROCEDURE_CALL"
    def mPROCEDURE_CALL(self, ):

        try:
            _type = PROCEDURE_CALL
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1216:17: ( P R O C E D U R E C A L L )
            # sdl92.g:1216:25: P R O C E D U R E C A L L
            pass 
            self.mP()
            self.mR()
            self.mO()
            self.mC()
            self.mE()
            self.mD()
            self.mU()
            self.mR()
            self.mE()
            self.mC()
            self.mA()
            self.mL()
            self.mL()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "PROCEDURE_CALL"



    # $ANTLR start "ENDSTATE"
    def mENDSTATE(self, ):

        try:
            _type = ENDSTATE
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1217:17: ( E N D S T A T E )
            # sdl92.g:1217:25: E N D S T A T E
            pass 
            self.mE()
            self.mN()
            self.mD()
            self.mS()
            self.mT()
            self.mA()
            self.mT()
            self.mE()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ENDSTATE"



    # $ANTLR start "INPUT"
    def mINPUT(self, ):

        try:
            _type = INPUT
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1218:17: ( I N P U T )
            # sdl92.g:1218:25: I N P U T
            pass 
            self.mI()
            self.mN()
            self.mP()
            self.mU()
            self.mT()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "INPUT"



    # $ANTLR start "PROVIDED"
    def mPROVIDED(self, ):

        try:
            _type = PROVIDED
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1219:17: ( P R O V I D E D )
            # sdl92.g:1219:25: P R O V I D E D
            pass 
            self.mP()
            self.mR()
            self.mO()
            self.mV()
            self.mI()
            self.mD()
            self.mE()
            self.mD()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "PROVIDED"



    # $ANTLR start "PRIORITY"
    def mPRIORITY(self, ):

        try:
            _type = PRIORITY
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1220:17: ( P R I O R I T Y )
            # sdl92.g:1220:25: P R I O R I T Y
            pass 
            self.mP()
            self.mR()
            self.mI()
            self.mO()
            self.mR()
            self.mI()
            self.mT()
            self.mY()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "PRIORITY"



    # $ANTLR start "SAVE"
    def mSAVE(self, ):

        try:
            _type = SAVE
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1221:17: ( S A V E )
            # sdl92.g:1221:25: S A V E
            pass 
            self.mS()
            self.mA()
            self.mV()
            self.mE()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "SAVE"



    # $ANTLR start "NONE"
    def mNONE(self, ):

        try:
            _type = NONE
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1222:17: ( N O N E )
            # sdl92.g:1222:25: N O N E
            pass 
            self.mN()
            self.mO()
            self.mN()
            self.mE()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "NONE"



    # $ANTLR start "FOR"
    def mFOR(self, ):

        try:
            _type = FOR
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1229:17: ( F O R )
            # sdl92.g:1229:25: F O R
            pass 
            self.mF()
            self.mO()
            self.mR()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "FOR"



    # $ANTLR start "ENDFOR"
    def mENDFOR(self, ):

        try:
            _type = ENDFOR
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1230:17: ( E N D F O R )
            # sdl92.g:1230:25: E N D F O R
            pass 
            self.mE()
            self.mN()
            self.mD()
            self.mF()
            self.mO()
            self.mR()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ENDFOR"



    # $ANTLR start "RANGE"
    def mRANGE(self, ):

        try:
            _type = RANGE
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1231:17: ( R A N G E )
            # sdl92.g:1231:25: R A N G E
            pass 
            self.mR()
            self.mA()
            self.mN()
            self.mG()
            self.mE()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "RANGE"



    # $ANTLR start "NEXTSTATE"
    def mNEXTSTATE(self, ):

        try:
            _type = NEXTSTATE
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1232:17: ( N E X T S T A T E )
            # sdl92.g:1232:25: N E X T S T A T E
            pass 
            self.mN()
            self.mE()
            self.mX()
            self.mT()
            self.mS()
            self.mT()
            self.mA()
            self.mT()
            self.mE()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "NEXTSTATE"



    # $ANTLR start "ANSWER"
    def mANSWER(self, ):

        try:
            _type = ANSWER
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1233:17: ( A N S W E R )
            # sdl92.g:1233:25: A N S W E R
            pass 
            self.mA()
            self.mN()
            self.mS()
            self.mW()
            self.mE()
            self.mR()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ANSWER"



    # $ANTLR start "COMMENT"
    def mCOMMENT(self, ):

        try:
            _type = COMMENT
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1234:17: ( C O M M E N T )
            # sdl92.g:1234:25: C O M M E N T
            pass 
            self.mC()
            self.mO()
            self.mM()
            self.mM()
            self.mE()
            self.mN()
            self.mT()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "COMMENT"



    # $ANTLR start "LABEL"
    def mLABEL(self, ):

        try:
            _type = LABEL
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1235:17: ( L A B E L )
            # sdl92.g:1235:25: L A B E L
            pass 
            self.mL()
            self.mA()
            self.mB()
            self.mE()
            self.mL()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "LABEL"



    # $ANTLR start "STOP"
    def mSTOP(self, ):

        try:
            _type = STOP
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1236:17: ( S T O P )
            # sdl92.g:1236:25: S T O P
            pass 
            self.mS()
            self.mT()
            self.mO()
            self.mP()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "STOP"



    # $ANTLR start "IF"
    def mIF(self, ):

        try:
            _type = IF
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1237:17: ( I F )
            # sdl92.g:1237:25: I F
            pass 
            self.mI()
            self.mF()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "IF"



    # $ANTLR start "THEN"
    def mTHEN(self, ):

        try:
            _type = THEN
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1238:17: ( T H E N )
            # sdl92.g:1238:25: T H E N
            pass 
            self.mT()
            self.mH()
            self.mE()
            self.mN()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "THEN"



    # $ANTLR start "ELSE"
    def mELSE(self, ):

        try:
            _type = ELSE
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1239:17: ( E L S E )
            # sdl92.g:1239:25: E L S E
            pass 
            self.mE()
            self.mL()
            self.mS()
            self.mE()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ELSE"



    # $ANTLR start "FI"
    def mFI(self, ):

        try:
            _type = FI
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1240:17: ( F I )
            # sdl92.g:1240:25: F I
            pass 
            self.mF()
            self.mI()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "FI"



    # $ANTLR start "CREATE"
    def mCREATE(self, ):

        try:
            _type = CREATE
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1241:17: ( C R E A T E )
            # sdl92.g:1241:25: C R E A T E
            pass 
            self.mC()
            self.mR()
            self.mE()
            self.mA()
            self.mT()
            self.mE()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "CREATE"



    # $ANTLR start "OUTPUT"
    def mOUTPUT(self, ):

        try:
            _type = OUTPUT
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1242:17: ( O U T P U T )
            # sdl92.g:1242:25: O U T P U T
            pass 
            self.mO()
            self.mU()
            self.mT()
            self.mP()
            self.mU()
            self.mT()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "OUTPUT"



    # $ANTLR start "CALL"
    def mCALL(self, ):

        try:
            _type = CALL
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1243:17: ( C A L L )
            # sdl92.g:1243:25: C A L L
            pass 
            self.mC()
            self.mA()
            self.mL()
            self.mL()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "CALL"



    # $ANTLR start "THIS"
    def mTHIS(self, ):

        try:
            _type = THIS
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1244:17: ( T H I S )
            # sdl92.g:1244:25: T H I S
            pass 
            self.mT()
            self.mH()
            self.mI()
            self.mS()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "THIS"



    # $ANTLR start "SET"
    def mSET(self, ):

        try:
            _type = SET
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1245:17: ( S E T )
            # sdl92.g:1245:25: S E T
            pass 
            self.mS()
            self.mE()
            self.mT()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "SET"



    # $ANTLR start "RESET"
    def mRESET(self, ):

        try:
            _type = RESET
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1246:17: ( R E S E T )
            # sdl92.g:1246:25: R E S E T
            pass 
            self.mR()
            self.mE()
            self.mS()
            self.mE()
            self.mT()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "RESET"



    # $ANTLR start "ENDALTERNATIVE"
    def mENDALTERNATIVE(self, ):

        try:
            _type = ENDALTERNATIVE
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1247:17: ( E N D A L T E R N A T I V E )
            # sdl92.g:1247:25: E N D A L T E R N A T I V E
            pass 
            self.mE()
            self.mN()
            self.mD()
            self.mA()
            self.mL()
            self.mT()
            self.mE()
            self.mR()
            self.mN()
            self.mA()
            self.mT()
            self.mI()
            self.mV()
            self.mE()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ENDALTERNATIVE"



    # $ANTLR start "ALTERNATIVE"
    def mALTERNATIVE(self, ):

        try:
            _type = ALTERNATIVE
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1248:17: ( A L T E R N A T I V E )
            # sdl92.g:1248:25: A L T E R N A T I V E
            pass 
            self.mA()
            self.mL()
            self.mT()
            self.mE()
            self.mR()
            self.mN()
            self.mA()
            self.mT()
            self.mI()
            self.mV()
            self.mE()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ALTERNATIVE"



    # $ANTLR start "DECISION"
    def mDECISION(self, ):

        try:
            _type = DECISION
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1249:17: ( D E C I S I O N )
            # sdl92.g:1249:25: D E C I S I O N
            pass 
            self.mD()
            self.mE()
            self.mC()
            self.mI()
            self.mS()
            self.mI()
            self.mO()
            self.mN()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "DECISION"



    # $ANTLR start "ENDDECISION"
    def mENDDECISION(self, ):

        try:
            _type = ENDDECISION
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1250:17: ( E N D D E C I S I O N )
            # sdl92.g:1250:25: E N D D E C I S I O N
            pass 
            self.mE()
            self.mN()
            self.mD()
            self.mD()
            self.mE()
            self.mC()
            self.mI()
            self.mS()
            self.mI()
            self.mO()
            self.mN()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "ENDDECISION"



    # $ANTLR start "EXPORT"
    def mEXPORT(self, ):

        try:
            _type = EXPORT
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1251:17: ( E X P O R T )
            # sdl92.g:1251:25: E X P O R T
            pass 
            self.mE()
            self.mX()
            self.mP()
            self.mO()
            self.mR()
            self.mT()



            self._state.type = _type
            self._state.channel = _channel

        finally:

            pass

    # $ANTLR end "EXPORT"



    # $ANTLR start "EXTERNAL"
    def mEXTERNAL(self, ):

        try:
            _type = EXTERNAL
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1252:17: ( E X T E R N A L )
            # sdl92.g:1252:25: E X T E R N A L