sdl92Lexer.py

# $ANTLR 3.5.2 sdl92.g 2021-04-13 11:49:19

import sys
from antlr3 import *



# for convenience in actions
HIDDEN = BaseRecognizer.HIDDEN

# token types
EOF=-1
T__228=228
T__229=229
T__230=230
T__231=231
T__232=232
T__233=233
T__234=234
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
EXPORTED=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_EXPRESSION=105
INPUT_NONE=106
INT=107
J=108
JOIN=109
K=110
KEEP=111
L=112
LABEL=113
LE=114
LITERAL=115
LT=116
L_BRACKET=117
L_PAREN=118
M=119
MANTISSA=120
MINUS_INFINITY=121
MKSTRING=122
MOD=123
MONITOR=124
N=125
NEG=126
NEQ=127
NEWTYPE=128
NEXTSTATE=129
NONE=130
NOT=131
NUMBER_OF_INSTANCES=132
O=133
OCTSTR=134
OPEN_RANGE=135
OR=136
OUT=137
OUTPUT=138
OUTPUT_BODY=139
OUTPUT_EXPRESSION=140
P=141
PARAM=142
PARAMNAMES=143
PARAMS=144
PAREN=145
PFPAR=146
PLUS=147
PLUS_INFINITY=148
POINT=149
PRIMARY=150
PRIORITY=151
PROCEDURE=152
PROCEDURE_CALL=153
PROCEDURE_NAME=154
PROCESS=155
PROVIDED=156
Q=157
QUESTION=158
R=159
RANGE=160
REFERENCED=161
REM=162
RESET=163
RETURN=164
RETURNS=165
ROUTE=166
R_BRACKET=167
R_PAREN=168
S=169
SAVE=170
SELECTOR=171
SEMI=172
SEQOF=173
SEQUENCE=174
SET=175
SIGNAL=176
SIGNALROUTE=177
SIGNAL_LIST=178
SORT=179
SPECIFIC=180
START=181
STATE=182
STATELIST=183
STATE_AGGREGATION=184
STATE_PARTITION_CONNECTION=185
STIMULUS=186
STOP=187
STOPIF=188
STR=189
STRING=190
STRUCT=191
SUBSTRUCTURE=192
SYNONYM=193
SYNONYM_LIST=194
SYNTYPE=195
SYSTEM=196
T=197
TASK=198
TASK_BODY=199
TERMINATOR=200
TEXT=201
TEXTAREA=202
TEXTAREA_CONTENT=203
THEN=204
THIS=205
TIMER=206
TO=207
TRANSITION=208
TRUE=209
TYPE=210
TYPE_INSTANCE=211
U=212
USE=213
V=214
VALUE=215
VARIABLE=216
VARIABLES=217
VIA=218
VIAPATH=219
VIEW=220
W=221
WITH=222
WS=223
X=224
XOR=225
Y=226
Z=227

# token names
tokenNamesMap = {
    0: "<invalid>", 1: "<EOR>", 2: "<DOWN>", 3: "<UP>",
    -1: "EOF", 228: "T__228", 229: "T__229", 230: "T__230", 231: "T__231", 
    232: "T__232", 233: "T__233", 234: "T__234", 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: "EXPORTED", 72: "EXPRESSION", 
    73: "EXTERNAL", 74: "Exponent", 75: "F", 76: "FALSE", 77: "FI", 78: "FIELD", 
    79: "FIELDS", 80: "FIELD_NAME", 81: "FLOAT", 82: "FLOAT2", 83: "FLOATING_LABEL", 
    84: "FOR", 85: "FPAR", 86: "FROM", 87: "G", 88: "GE", 89: "GEODE", 90: "GROUND", 
    91: "GT", 92: "H", 93: "HYPERLINK", 94: "I", 95: "ID", 96: "IF", 97: "IFTHENELSE", 
    98: "IMPLIES", 99: "IMPORT", 100: "IN", 101: "INFORMAL_TEXT", 102: "INOUT", 
    103: "INPUT", 104: "INPUTLIST", 105: "INPUT_EXPRESSION", 106: "INPUT_NONE", 
    107: "INT", 108: "J", 109: "JOIN", 110: "K", 111: "KEEP", 112: "L", 
    113: "LABEL", 114: "LE", 115: "LITERAL", 116: "LT", 117: "L_BRACKET", 
    118: "L_PAREN", 119: "M", 120: "MANTISSA", 121: "MINUS_INFINITY", 122: "MKSTRING", 
    123: "MOD", 124: "MONITOR", 125: "N", 126: "NEG", 127: "NEQ", 128: "NEWTYPE", 
    129: "NEXTSTATE", 130: "NONE", 131: "NOT", 132: "NUMBER_OF_INSTANCES", 
    133: "O", 134: "OCTSTR", 135: "OPEN_RANGE", 136: "OR", 137: "OUT", 138: "OUTPUT", 
    139: "OUTPUT_BODY", 140: "OUTPUT_EXPRESSION", 141: "P", 142: "PARAM", 
    143: "PARAMNAMES", 144: "PARAMS", 145: "PAREN", 146: "PFPAR", 147: "PLUS", 
    148: "PLUS_INFINITY", 149: "POINT", 150: "PRIMARY", 151: "PRIORITY", 
    152: "PROCEDURE", 153: "PROCEDURE_CALL", 154: "PROCEDURE_NAME", 155: "PROCESS", 
    156: "PROVIDED", 157: "Q", 158: "QUESTION", 159: "R", 160: "RANGE", 
    161: "REFERENCED", 162: "REM", 163: "RESET", 164: "RETURN", 165: "RETURNS", 
    166: "ROUTE", 167: "R_BRACKET", 168: "R_PAREN", 169: "S", 170: "SAVE", 
    171: "SELECTOR", 172: "SEMI", 173: "SEQOF", 174: "SEQUENCE", 175: "SET", 
    176: "SIGNAL", 177: "SIGNALROUTE", 178: "SIGNAL_LIST", 179: "SORT", 
    180: "SPECIFIC", 181: "START", 182: "STATE", 183: "STATELIST", 184: "STATE_AGGREGATION", 
    185: "STATE_PARTITION_CONNECTION", 186: "STIMULUS", 187: "STOP", 188: "STOPIF", 
    189: "STR", 190: "STRING", 191: "STRUCT", 192: "SUBSTRUCTURE", 193: "SYNONYM", 
    194: "SYNONYM_LIST", 195: "SYNTYPE", 196: "SYSTEM", 197: "T", 198: "TASK", 
    199: "TASK_BODY", 200: "TERMINATOR", 201: "TEXT", 202: "TEXTAREA", 203: "TEXTAREA_CONTENT", 
    204: "THEN", 205: "THIS", 206: "TIMER", 207: "TO", 208: "TRANSITION", 
    209: "TRUE", 210: "TYPE", 211: "TYPE_INSTANCE", 212: "U", 213: "USE", 
    214: "V", 215: "VALUE", 216: "VARIABLE", 217: "VARIABLES", 218: "VIA", 
    219: "VIAPATH", 220: "VIEW", 221: "W", 222: "WITH", 223: "WS", 224: "X", 
    225: "XOR", 226: "Y", 227: "Z"
}
Token.registerTokenNamesMap(tokenNamesMap)

class sdl92Lexer(Lexer):

    grammarFileName = "sdl92.g"
    api_version = 1

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

        self.delegates = []

        self.dfa10 = self.DFA10(
            self, 10,
            eot = self.DFA10_eot,
            eof = self.DFA10_eof,
            min = self.DFA10_min,
            max = self.DFA10_max,
            accept = self.DFA10_accept,
            special = self.DFA10_special,
            transition = self.DFA10_transition
            )

        self.dfa17 = self.DFA17(
            self, 17,
            eot = self.DFA17_eot,
            eof = self.DFA17_eof,
            min = self.DFA17_min,
            max = self.DFA17_max,
            accept = self.DFA17_accept,
            special = self.DFA17_special,
            transition = self.DFA17_transition
            )






    # $ANTLR start "T__228"
    def mT__228(self, ):
        try:
            _type = T__228
            _channel = DEFAULT_CHANNEL

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



            self._state.type = _type
            self._state.channel = _channel
        finally:
            pass

    # $ANTLR end "T__228"



    # $ANTLR start "T__229"
    def mT__229(self, ):
        try:
            _type = T__229
            _channel = DEFAULT_CHANNEL

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




            self._state.type = _type
            self._state.channel = _channel
        finally:
            pass

    # $ANTLR end "T__229"



    # $ANTLR start "T__230"
    def mT__230(self, ):
        try:
            _type = T__230
            _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__230"



    # $ANTLR start "T__231"
    def mT__231(self, ):
        try:
            _type = T__231
            _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__231"



    # $ANTLR start "T__232"
    def mT__232(self, ):
        try:
            _type = T__232
            _channel = DEFAULT_CHANNEL

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




            self._state.type = _type
            self._state.channel = _channel
        finally:
            pass

    # $ANTLR end "T__232"



    # $ANTLR start "T__233"
    def mT__233(self, ):
        try:
            _type = T__233
            _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__233"



    # $ANTLR start "T__234"
    def mT__234(self, ):
        try:
            _type = T__234
            _channel = DEFAULT_CHANNEL

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



            self._state.type = _type
            self._state.channel = _channel
        finally:
            pass

    # $ANTLR end "T__234"



    # $ANTLR start "ASSIG_OP"
    def mASSIG_OP(self, ):
        try:
            _type = ASSIG_OP
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1500:17: ( ':=' )
            # sdl92.g:1500: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:1501:17: ( '{' )
            # sdl92.g:1501: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:1502:17: ( '}' )
            # sdl92.g:1502: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:1503:17: ( '(' )
            # sdl92.g:1503: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:1504:17: ( ')' )
            # sdl92.g:1504: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:1505:17: ( ',' )
            # sdl92.g:1505: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:1506:17: ( ';' )
            # sdl92.g:1506: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:1507:17: ( '-' )
            # sdl92.g:1507: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:1508:17: ( A N Y )
            # sdl92.g:1508: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:1509:17: ( '*' )
            # sdl92.g:1509: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:1510:17: ( D C L )
            # sdl92.g:1510: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 "MONITOR"
    def mMONITOR(self, ):
        try:
            _type = MONITOR
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1511:17: ( M O N I T O R )
            # sdl92.g:1511:25: M O N I T O R
            pass 
            self.mM()


            self.mO()


            self.mN()


            self.mI()


            self.mT()


            self.mO()


            self.mR()




            self._state.type = _type
            self._state.channel = _channel
        finally:
            pass

    # $ANTLR end "MONITOR"



    # $ANTLR start "END"
    def mEND(self, ):
        try:
            _type = END
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1512:17: ( E N D )
            # sdl92.g:1512: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:1513:17: ( K E E P )
            # sdl92.g:1513: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:1514:17: ( P A R A M N A M E S )
            # sdl92.g:1514: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:1515:17: ( S P E C I F I C )
            # sdl92.g:1515: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:1516:17: ( G E O D E )
            # sdl92.g:1516: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:1517:17: ( H Y P E R L I N K )
            # sdl92.g:1517: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 "MKSTRING"
    def mMKSTRING(self, ):
        try:
            _type = MKSTRING
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1518:17: ( M K S T R I N G )
            # sdl92.g:1518:25: M K S T R I N G
            pass 
            self.mM()


            self.mK()


            self.mS()


            self.mT()


            self.mR()


            self.mI()


            self.mN()


            self.mG()




            self._state.type = _type
            self._state.channel = _channel
        finally:
            pass

    # $ANTLR end "MKSTRING"



    # $ANTLR start "ENDTEXT"
    def mENDTEXT(self, ):
        try:
            _type = ENDTEXT
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1519:17: ( E N D T E X T )
            # sdl92.g:1519: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:1520:17: ( R E T U R N )
            # sdl92.g:1520: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 "RETURNS"
    def mRETURNS(self, ):
        try:
            _type = RETURNS
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1521:17: ( R E T U R N S )
            # sdl92.g:1521:25: R E T U R N S
            pass 
            self.mR()


            self.mE()


            self.mT()


            self.mU()


            self.mR()


            self.mN()


            self.mS()




            self._state.type = _type
            self._state.channel = _channel
        finally:
            pass

    # $ANTLR end "RETURNS"



    # $ANTLR start "TIMER"
    def mTIMER(self, ):
        try:
            _type = TIMER
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1522:17: ( T I M E R )
            # sdl92.g:1522: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:1523:17: ( P R O C E S S )
            # sdl92.g:1523: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 "TYPE"
    def mTYPE(self, ):
        try:
            _type = TYPE
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1524:17: ( T Y P E )
            # sdl92.g:1524:25: T Y P E
            pass 
            self.mT()


            self.mY()


            self.mP()


            self.mE()




            self._state.type = _type
            self._state.channel = _channel
        finally:
            pass

    # $ANTLR end "TYPE"



    # $ANTLR start "ENDPROCESS"
    def mENDPROCESS(self, ):
        try:
            _type = ENDPROCESS
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1525:17: ( E N D P R O C E S S )
            # sdl92.g:1525: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:1526:17: ( S T A R T )
            # sdl92.g:1526: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:1527:17: ( S T A T E )
            # sdl92.g:1527: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:1528:17: ( T E X T )
            # sdl92.g:1528: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:1529:17: ( P R O C E D U R E )
            # sdl92.g:1529: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:1530:17: ( E N D P R O C E D U R E )
            # sdl92.g:1530: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()