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"