sdl92Lexer.py

# $ANTLR 3.1.3 Mar 18, 2009 10:09:25 sdl92.g 2014-06-19 11:20:30

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


# for convenience in actions
HIDDEN = BaseRecognizer.HIDDEN

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


class sdl92Lexer(Lexer):

    grammarFileName = "sdl92.g"
    antlr_version = version_str_to_tuple("3.1.3 Mar 18, 2009 10:09:25")
    antlr_version_str = "3.1.3 Mar 18, 2009 10:09:25"

    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__211"
    def mT__211(self, ):

        try:
            _type = T__211
            _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__211"



    # $ANTLR start "T__212"
    def mT__212(self, ):

        try:
            _type = T__212
            _channel = DEFAULT_CHANNEL

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



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

        finally:

            pass

    # $ANTLR end "T__212"



    # $ANTLR start "T__213"
    def mT__213(self, ):

        try:
            _type = T__213
            _channel = DEFAULT_CHANNEL

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



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

        finally:

            pass

    # $ANTLR end "T__213"



    # $ANTLR start "T__214"
    def mT__214(self, ):

        try:
            _type = T__214
            _channel = DEFAULT_CHANNEL

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



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

        finally:

            pass

    # $ANTLR end "T__214"



    # $ANTLR start "T__215"
    def mT__215(self, ):

        try:
            _type = T__215
            _channel = DEFAULT_CHANNEL

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



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

        finally:

            pass

    # $ANTLR end "T__215"



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

        try:
            _type = T__216
            _channel = DEFAULT_CHANNEL

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



            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:13:8: ( '.)' )
            # sdl92.g:13:10: '.)'
            pass 
            self.match(".)")



            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:14:8: ( 'ERROR' )
            # sdl92.g:14:10: 'ERROR'
            pass 
            self.match("ERROR")



            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:15:8: ( 'ACTIVE' )
            # sdl92.g:15:10: 'ACTIVE'
            pass 
            self.match("ACTIVE")



            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:16:8: ( 'ANY' )
            # sdl92.g:16:10: 'ANY'
            pass 
            self.match("ANY")



            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:17:8: ( 'IMPORT' )
            # sdl92.g:17:10: 'IMPORT'
            pass 
            self.match("IMPORT")



            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:18:8: ( 'VIEW' )
            # sdl92.g:18:10: 'VIEW'
            pass 
            self.match("VIEW")



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

        finally:

            pass

    # $ANTLR end "T__222"



    # $ANTLR start "T__223"
    def mT__223(self, ):

        try:
            _type = T__223
            _channel = DEFAULT_CHANNEL

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



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

        finally:

            pass

    # $ANTLR end "T__223"



    # $ANTLR start "T__224"
    def mT__224(self, ):

        try:
            _type = T__224
            _channel = DEFAULT_CHANNEL

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



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

        finally:

            pass

    # $ANTLR end "T__224"



    # $ANTLR start "BitStringLiteral"
    def mBitStringLiteral(self, ):

        try:
            _type = BitStringLiteral
            _channel = DEFAULT_CHANNEL

            # sdl92.g:844:9: ( '\"' ( '0' | '1' | ' ' | '\\t' | '\\r' | '\\n' )* '\"B' )
            # sdl92.g:844:17: '\"' ( '0' | '1' | ' ' | '\\t' | '\\r' | '\\n' )* '\"B'
            pass 
            self.match(34)
            # sdl92.g:844:21: ( '0' | '1' | ' ' | '\\t' | '\\r' | '\\n' )*
            while True: #loop1
                alt1 = 2
                LA1_0 = self.input.LA(1)

                if ((9 <= LA1_0 <= 10) or LA1_0 == 13 or LA1_0 == 32 or (48 <= LA1_0 <= 49)) :
                    alt1 = 1


                if alt1 == 1:
                    # sdl92.g:
                    pass 
                    if (9 <= self.input.LA(1) <= 10) or self.input.LA(1) == 13 or self.input.LA(1) == 32 or (48 <= self.input.LA(1) <= 49):
                        self.input.consume()
                    else:
                        mse = MismatchedSetException(None, self.input)
                        self.recover(mse)
                        raise mse



                else:
                    break #loop1
            self.match("\"B")



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

        finally:

            pass

    # $ANTLR end "BitStringLiteral"



    # $ANTLR start "OctetStringLiteral"
    def mOctetStringLiteral(self, ):

        try:
            _type = OctetStringLiteral
            _channel = DEFAULT_CHANNEL

            # sdl92.g:848:9: ( '\"' ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | ' ' | '\\t' | '\\r' | '\\n' )* '\"H' )
            # sdl92.g:848:17: '\"' ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | ' ' | '\\t' | '\\r' | '\\n' )* '\"H'
            pass 
            self.match(34)
            # sdl92.g:848:21: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | ' ' | '\\t' | '\\r' | '\\n' )*
            while True: #loop2
                alt2 = 2
                LA2_0 = self.input.LA(1)

                if ((9 <= LA2_0 <= 10) or LA2_0 == 13 or LA2_0 == 32 or (48 <= LA2_0 <= 57) or (65 <= LA2_0 <= 70) or (97 <= LA2_0 <= 102)) :
                    alt2 = 1


                if alt2 == 1:
                    # sdl92.g:
                    pass 
                    if (9 <= self.input.LA(1) <= 10) or self.input.LA(1) == 13 or self.input.LA(1) == 32 or (48 <= self.input.LA(1) <= 57) or (65 <= self.input.LA(1) <= 70) or (97 <= self.input.LA(1) <= 102):
                        self.input.consume()
                    else:
                        mse = MismatchedSetException(None, self.input)
                        self.recover(mse)
                        raise mse



                else:
                    break #loop2
            self.match("\"H")



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

        finally:

            pass

    # $ANTLR end "OctetStringLiteral"



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

        try:
            _type = ASSIG_OP
            _channel = DEFAULT_CHANNEL

            # sdl92.g:1154:17: ( ':=' )
            # sdl92.g:1154: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:1155:17: ( '{' )
            # sdl92.g:1155: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:1156:17: ( '}' )
            # sdl92.g:1156: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:1157:17: ( '(' )
            # sdl92.g:1157: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:1158:17: ( ')' )
            # sdl92.g:1158: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:1159:17: ( ',' )
            # sdl92.g:1159: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:1160:17: ( ';' )
            # sdl92.g:1160: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:1161:17: ( '-' )
            # sdl92.g:1161: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:1162:17: ( A N Y )
            # sdl92.g:1162: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:1163:17: ( '*' )
            # sdl92.g:1163: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:1164:17: ( D C L )
            # sdl92.g:1164:25: D C L
            pass 
            self.mD()
            self.mC()
            self.mL()



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

        finally:

            pass

    # $ANTLR end "DCL"