sdl92Lexer.py

# $ANTLR 3.5.2 sdl92.g 2020-07-09 14:22:50

import sys
from antlr3 import *



# for convenience in actions
HIDDEN = BaseRecognizer.HIDDEN

# token types
EOF=-1
T__224=224
T__225=225
T__226=226
T__227=227
T__228=228
T__229=229
T__230=230
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
MKSTRING=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=223

# token names
tokenNamesMap = {
    0: "<invalid>", 1: "<EOR>", 2: "<DOWN>", 3: "<UP>",
    -1: "EOF", 224: "T__224", 225: "T__225", 226: "T__226", 227: "T__227", 
    228: "T__228", 229: "T__229", 230: "T__230", 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: "MKSTRING", 121: "MOD", 
    122: "N", 123: "NEG", 124: "NEQ", 125: "NEWTYPE", 126: "NEXTSTATE", 
    127: "NONE", 128: "NOT", 129: "NUMBER_OF_INSTANCES", 130: "O", 131: "OCTSTR", 
    132: "OPEN_RANGE", 133: "OR", 134: "OUT", 135: "OUTPUT", 136: "OUTPUT_BODY", 
    137: "P", 138: "PARAM", 139: "PARAMNAMES", 140: "PARAMS", 141: "PAREN", 
    142: "PFPAR", 143: "PLUS", 144: "PLUS_INFINITY", 145: "POINT", 146: "PRIMARY", 
    147: "PRIORITY", 148: "PROCEDURE", 149: "PROCEDURE_CALL", 150: "PROCEDURE_NAME", 
    151: "PROCESS", 152: "PROVIDED", 153: "Q", 154: "QUESTION", 155: "R", 
    156: "RANGE", 157: "REFERENCED", 158: "REM", 159: "RESET", 160: "RETURN", 
    161: "RETURNS", 162: "ROUTE", 163: "R_BRACKET", 164: "R_PAREN", 165: "S", 
    166: "SAVE", 167: "SELECTOR", 168: "SEMI", 169: "SEQOF", 170: "SEQUENCE", 
    171: "SET", 172: "SIGNAL", 173: "SIGNALROUTE", 174: "SIGNAL_LIST", 175: "SORT", 
    176: "SPECIFIC", 177: "START", 178: "STATE", 179: "STATELIST", 180: "STATE_AGGREGATION", 
    181: "STATE_PARTITION_CONNECTION", 182: "STIMULUS", 183: "STOP", 184: "STOPIF", 
    185: "STR", 186: "STRING", 187: "STRUCT", 188: "SUBSTRUCTURE", 189: "SYNONYM", 
    190: "SYNONYM_LIST", 191: "SYNTYPE", 192: "SYSTEM", 193: "T", 194: "TASK", 
    195: "TASK_BODY", 196: "TERMINATOR", 197: "TEXT", 198: "TEXTAREA", 199: "TEXTAREA_CONTENT", 
    200: "THEN", 201: "THIS", 202: "TIMER", 203: "TO", 204: "TRANSITION", 
    205: "TRUE", 206: "TYPE", 207: "TYPE_INSTANCE", 208: "U", 209: "USE", 
    210: "V", 211: "VALUE", 212: "VARIABLE", 213: "VARIABLES", 214: "VIA", 
    215: "VIAPATH", 216: "VIEW", 217: "W", 218: "WITH", 219: "WS", 220: "X", 
    221: "XOR", 222: "Y", 223: "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__224"
    def mT__224(self, ):
        try:
            _type = T__224
            _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__224"



    # $ANTLR start "T__225"
    def mT__225(self, ):
        try:
            _type = T__225
            _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__225"



    # $ANTLR start "T__226"
    def mT__226(self, ):
        try:
            _type = T__226
            _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__226"



    # $ANTLR start "T__227"
    def mT__227(self, ):
        try:
            _type = T__227
            _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__227"



    # $ANTLR start "T__228"
    def mT__228(self, ):
        try:
            _type = T__228
            _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__228"



    # $ANTLR start "T__229"
    def mT__229(self, ):
        try:
            _type = T__229
            _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__229"



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



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

            # sdl92.g:1463:17: ( ':=' )
            # sdl92.g:1463: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:1464:17: ( '{' )
            # sdl92.g:1464: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:1465:17: ( '}' )
            # sdl92.g:1465: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:1466:17: ( '(' )
            # sdl92.g:1466: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:1467:17: ( ')' )
            # sdl92.g:1467: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:1468:17: ( ',' )
            # sdl92.g:1468: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:1469:17: ( ';' )
            # sdl92.g:1469: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:1470:17: ( '-' )
            # sdl92.g:1470: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:1471:17: ( A N Y )
            # sdl92.g:1471: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:1472:17: ( '*' )
            # sdl92.g:1472: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:1473:17: ( D C L )
            # sdl92.g:1473: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:1474:17: ( E N D )
            # sdl92.g:1474: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:1475:17: ( K E E P )
            # sdl92.g:1475: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:1476:17: ( P A R A M N A M E S )
            # sdl92.g:1476: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:1477:17: ( S P E C I F I C )
            # sdl92.g:1477: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:1478:17: ( G E O D E )
            # sdl92.g:1478: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:1479:17: ( H Y P E R L I N K )
            # sdl92.g:1479: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:1480:17: ( M K S T R I N G )
            # sdl92.g:1480: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:1481:17: ( E N D T E X T )
            # sdl92.g:1481: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:1482:17: ( R E T U R N )
            # sdl92.g:1482: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:1483:17: ( R E T U R N S )
            # sdl92.g:1483: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:1484:17: ( T I M E R )
            # sdl92.g:1484: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:1485:17: ( P R O C E S S )
            # sdl92.g:1485: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:1486:17: ( T Y P E )
            # sdl92.g:1486: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:1487:17: ( E N D P R O C E S S )
            # sdl92.g:1487: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:1488:17: ( S T A R T )
            # sdl92.g:1488: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:1489:17: ( S T A T E )
            # sdl92.g:1489: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:1490:17: ( T E X T )
            # sdl92.g:1490: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:1491:17: ( P R O C E D U R E )
            # sdl92.g:1491: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:1492:17: ( E N D P R O C E D U R E )
            # sdl92.g:1492: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()