Logo Search packages:      
Sourcecode: kayali version File versions  Download package

MaximaParser.py

### $ANTLR 2.7.6 (20060120): "maxima.g" -> "MaximaParser.py"$
### import antlr and other modules ..
import sys
import antlr

version = sys.version.split()[0]
if version < '2.2.1':
    False = 0
if version < '2.3':
    True = not False
### header action >>> 
import nodesubclasses
### header action <<< 
### preamble action>>>

### preamble action <<<

### import antlr.Token 
from antlr import Token
### >>>The Known Token Types <<<
SKIP                = antlr.SKIP
INVALID_TYPE        = antlr.INVALID_TYPE
EOF_TYPE            = antlr.EOF_TYPE
EOF                 = antlr.EOF
NULL_TREE_LOOKAHEAD = antlr.NULL_TREE_LOOKAHEAD
MIN_USER_TYPE       = antlr.MIN_USER_TYPE
NOOP = 4
FOR = 5
IF = 6
THEN = 7
ELSE = 8
THRU = 9
WHILE = 10
UNLESS = 11
DO = 12
STEP = 13
IN = 14
LABEL = 15
COMMA = 16
ASSIGN = 17
ASSIGN2 = 18
MACRODEF = 19
FUNCDEF = 20
COMPARE = 21
OR = 22
AND = 23
NOT = 24
POWER = 25
POWER2 = 26
TIMES = 27
DIVIDE = 28
MINUS = 29
PLUS = 30
DOT = 31
EQUALS = 32
NOTEQUALS = 33
MATRIX = 34
NUM = 35
BRACKET = 36
SQBRACKET = 37
VAR = 38
INTEGRATE = 39
DIFFERENTIATE = 40
SUM = 41
SQRT = 42
NEG = 43
FACTORIAL = 44
FUNCTION = 45
LIMIT = 46
RPAREN = 47
WS = 48
DIGIT = 49
INT = 50
LOWER = 51
UPPER = 52
LETTER = 53
PERCENT = 54
SEMICOLON = 55

class Parser(antlr.LLkParser):
    ### user action >>>
    ### user action <<<
    
    def __init__(self, *args, **kwargs):
        antlr.LLkParser.__init__(self, *args, **kwargs)
        self.tokenNames = _tokenNames
        self.buildTokenTypeASTClassMap()
        self.astFactory = antlr.ASTFactory(self.getTokenTypeToASTClassMap())
        self.astFactory.setASTNodeClass()
        
    def sentence(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        sentence_AST = None
        a = None
        a_AST = None
        e_AST = None
        try:      ## for error handling
            synPredMatched3 = False
            if (self.LA(1)==VAR) and (self.LA(2)==ASSIGN) and (_tokenSet_0.member(self.LA(3))):
                _m3 = self.mark()
                synPredMatched3 = True
                self.inputState.guessing += 1
                try:
                    pass
                    self.match(VAR)
                    self.match(ASSIGN)
                except antlr.RecognitionException, pe:
                    synPredMatched3 = False
                self.rewind(_m3)
                self.inputState.guessing -= 1
            if synPredMatched3:
                pass
                a = self.LT(1)
                a_AST = self.astFactory.create(a, nodesubclasses.VARNode)
                self.match(VAR)
                tmp1_AST = None
                tmp1_AST = self.astFactory.create(self.LT(1), nodesubclasses.EQUALSNode)
                self.match(ASSIGN)
                self.comma()
                e_AST = self.returnAST
                if not self.inputState.guessing:
                    sentence_AST = currentAST.root
                    sentence_AST = antlr.make(self.astFactory.create(LABEL, "", nodesubclasses.LABELNode), a_AST, e_AST)
                    currentAST.root = sentence_AST
                    if (sentence_AST != None) and (sentence_AST.getFirstChild() != None):
                        currentAST.child = sentence_AST.getFirstChild()
                    else:
                        currentAST.child = sentence_AST
                    currentAST.advanceChildToEnd()
            elif (_tokenSet_0.member(self.LA(1))) and (_tokenSet_1.member(self.LA(2))) and (_tokenSet_2.member(self.LA(3))):
                pass
                self.comma()
                self.addASTChild(currentAST, self.returnAST)
                sentence_AST = currentAST.root
            else:
                raise antlr.NoViableAltException(self.LT(1), self.getFilename())
            
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_3)
            else:
                raise ex
        
        self.returnAST = sentence_AST
    
    def comma(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        comma_AST = None
        try:      ## for error handling
            pass
            self.forop()
            self.addASTChild(currentAST, self.returnAST)
            while True:
                if (self.LA(1)==COMMA):
                    pass
                    tmp2_AST = None
                    tmp2_AST = self.astFactory.create(self.LT(1), nodesubclasses.COMMANode)
                    self.makeASTRoot(currentAST, tmp2_AST)
                    self.match(COMMA)
                    self.forop()
                    self.addASTChild(currentAST, self.returnAST)
                else:
                    break
                
            comma_AST = currentAST.root
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_4)
            else:
                raise ex
        
        self.returnAST = comma_AST
    
    def forop(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        forop_AST = None
        try:      ## for error handling
            la1 = self.LA(1)
            if False:
                pass
            elif la1 and la1 in [FOR]:
                pass
                tmp3_AST = None
                tmp3_AST = self.astFactory.create(self.LT(1), nodesubclasses.PROGCONTROLNode)
                self.makeASTRoot(currentAST, tmp3_AST)
                self.match(FOR)
                self.orop()
                self.addASTChild(currentAST, self.returnAST)
                la1 = self.LA(1)
                if False:
                    pass
                elif la1 and la1 in [IN]:
                    pass
                    tmp4_AST = None
                    tmp4_AST = self.astFactory.create(self.LT(1), nodesubclasses.PROGCONTROLNode)
                    self.addASTChild(currentAST, tmp4_AST)
                    self.match(IN)
                elif la1 and la1 in [STEP]:
                    pass
                    tmp5_AST = None
                    tmp5_AST = self.astFactory.create(self.LT(1), nodesubclasses.PROGCONTROLNode)
                    self.addASTChild(currentAST, tmp5_AST)
                    self.match(STEP)
                    self.orop()
                    self.addASTChild(currentAST, self.returnAST)
                elif la1 and la1 in [IF,THRU,WHILE,UNLESS,DO,OR,AND,NOT,MINUS,MATRIX,NUM,BRACKET,SQBRACKET,VAR,INTEGRATE,DIFFERENTIATE,SUM,SQRT,LIMIT]:
                    pass
                else:
                        raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                    
                self.thru()
                self.addASTChild(currentAST, self.returnAST)
                forop_AST = currentAST.root
            elif la1 and la1 in [IF,THRU,WHILE,UNLESS,DO,OR,AND,NOT,MINUS,MATRIX,NUM,BRACKET,SQBRACKET,VAR,INTEGRATE,DIFFERENTIATE,SUM,SQRT,LIMIT]:
                pass
                self.thru()
                self.addASTChild(currentAST, self.returnAST)
                forop_AST = currentAST.root
            else:
                    raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_5)
            else:
                raise ex
        
        self.returnAST = forop_AST
    
    def flattenedcomma(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        flattenedcomma_AST = None
        try:      ## for error handling
            pass
            self.forop()
            self.addASTChild(currentAST, self.returnAST)
            while True:
                if (self.LA(1)==COMMA):
                    pass
                    self.match(COMMA)
                    self.forop()
                    self.addASTChild(currentAST, self.returnAST)
                else:
                    break
                
            flattenedcomma_AST = currentAST.root
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_6)
            else:
                raise ex
        
        self.returnAST = flattenedcomma_AST
    
    def orop(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        orop_AST = None
        try:      ## for error handling
            la1 = self.LA(1)
            if False:
                pass
            elif la1 and la1 in [OR]:
                pass
                tmp7_AST = None
                tmp7_AST = self.astFactory.create(self.LT(1), nodesubclasses.EQUALSNode)
                self.makeASTRoot(currentAST, tmp7_AST)
                self.match(OR)
                self.andop()
                self.addASTChild(currentAST, self.returnAST)
                orop_AST = currentAST.root
            elif la1 and la1 in [AND,NOT,MINUS,MATRIX,NUM,BRACKET,SQBRACKET,VAR,INTEGRATE,DIFFERENTIATE,SUM,SQRT,LIMIT]:
                pass
                self.andop()
                self.addASTChild(currentAST, self.returnAST)
                orop_AST = currentAST.root
            else:
                    raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_7)
            else:
                raise ex
        
        self.returnAST = orop_AST
    
    def thru(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        thru_AST = None
        try:      ## for error handling
            la1 = self.LA(1)
            if False:
                pass
            elif la1 and la1 in [THRU,WHILE,UNLESS]:
                pass
                la1 = self.LA(1)
                if False:
                    pass
                elif la1 and la1 in [THRU]:
                    pass
                    tmp8_AST = None
                    tmp8_AST = self.astFactory.create(self.LT(1), nodesubclasses.PROGCONTROLNode)
                    self.makeASTRoot(currentAST, tmp8_AST)
                    self.match(THRU)
                elif la1 and la1 in [WHILE]:
                    pass
                    tmp9_AST = None
                    tmp9_AST = self.astFactory.create(self.LT(1), nodesubclasses.PROGCONTROLNode)
                    self.makeASTRoot(currentAST, tmp9_AST)
                    self.match(WHILE)
                elif la1 and la1 in [UNLESS]:
                    pass
                    tmp10_AST = None
                    tmp10_AST = self.astFactory.create(self.LT(1), nodesubclasses.PROGCONTROLNode)
                    self.makeASTRoot(currentAST, tmp10_AST)
                    self.match(UNLESS)
                else:
                        raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                    
                self.orop()
                self.addASTChild(currentAST, self.returnAST)
                la1 = self.LA(1)
                if False:
                    pass
                elif la1 and la1 in [STEP]:
                    pass
                    tmp11_AST = None
                    tmp11_AST = self.astFactory.create(self.LT(1), nodesubclasses.PROGCONTROLNode)
                    self.addASTChild(currentAST, tmp11_AST)
                    self.match(STEP)
                    self.orop()
                    self.addASTChild(currentAST, self.returnAST)
                elif la1 and la1 in [IF,DO,OR,AND,NOT,MINUS,MATRIX,NUM,BRACKET,SQBRACKET,VAR,INTEGRATE,DIFFERENTIATE,SUM,SQRT,LIMIT]:
                    pass
                else:
                        raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                    
                self.doop()
                self.addASTChild(currentAST, self.returnAST)
                thru_AST = currentAST.root
            elif la1 and la1 in [IF,DO,OR,AND,NOT,MINUS,MATRIX,NUM,BRACKET,SQBRACKET,VAR,INTEGRATE,DIFFERENTIATE,SUM,SQRT,LIMIT]:
                pass
                self.doop()
                self.addASTChild(currentAST, self.returnAST)
                thru_AST = currentAST.root
            else:
                    raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_5)
            else:
                raise ex
        
        self.returnAST = thru_AST
    
    def doop(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        doop_AST = None
        try:      ## for error handling
            la1 = self.LA(1)
            if False:
                pass
            elif la1 and la1 in [DO]:
                pass
                tmp12_AST = None
                tmp12_AST = self.astFactory.create(self.LT(1), nodesubclasses.PROGCONTROLNode)
                self.addASTChild(currentAST, tmp12_AST)
                self.match(DO)
                self.ifop()
                self.addASTChild(currentAST, self.returnAST)
                doop_AST = currentAST.root
            elif la1 and la1 in [IF,OR,AND,NOT,MINUS,MATRIX,NUM,BRACKET,SQBRACKET,VAR,INTEGRATE,DIFFERENTIATE,SUM,SQRT,LIMIT]:
                pass
                self.ifop()
                self.addASTChild(currentAST, self.returnAST)
                doop_AST = currentAST.root
            else:
                    raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_5)
            else:
                raise ex
        
        self.returnAST = doop_AST
    
    def ifop(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        ifop_AST = None
        try:      ## for error handling
            la1 = self.LA(1)
            if False:
                pass
            elif la1 and la1 in [IF]:
                pass
                tmp13_AST = None
                tmp13_AST = self.astFactory.create(self.LT(1), nodesubclasses.PROGCONTROLNode)
                self.makeASTRoot(currentAST, tmp13_AST)
                self.match(IF)
                self.orop()
                self.addASTChild(currentAST, self.returnAST)
                tmp14_AST = None
                tmp14_AST = self.astFactory.create(self.LT(1), nodesubclasses.PROGCONTROLNode)
                self.addASTChild(currentAST, tmp14_AST)
                self.match(THEN)
                self.ifop()
                self.addASTChild(currentAST, self.returnAST)
                if (self.LA(1)==ELSE) and (_tokenSet_8.member(self.LA(2))) and (_tokenSet_9.member(self.LA(3))):
                    pass
                    tmp15_AST = None
                    tmp15_AST = self.astFactory.create(self.LT(1), nodesubclasses.PROGCONTROLNode)
                    self.addASTChild(currentAST, tmp15_AST)
                    self.match(ELSE)
                    self.ifop()
                    self.addASTChild(currentAST, self.returnAST)
                elif (_tokenSet_10.member(self.LA(1))) and (_tokenSet_11.member(self.LA(2))) and (_tokenSet_11.member(self.LA(3))):
                    pass
                else:
                    raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                
                ifop_AST = currentAST.root
            elif la1 and la1 in [OR,AND,NOT,MINUS,MATRIX,NUM,BRACKET,SQBRACKET,VAR,INTEGRATE,DIFFERENTIATE,SUM,SQRT,LIMIT]:
                pass
                self.orop()
                self.addASTChild(currentAST, self.returnAST)
                ifop_AST = currentAST.root
            else:
                    raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_10)
            else:
                raise ex
        
        self.returnAST = ifop_AST
    
    def andop(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        andop_AST = None
        try:      ## for error handling
            la1 = self.LA(1)
            if False:
                pass
            elif la1 and la1 in [AND]:
                pass
                tmp16_AST = None
                tmp16_AST = self.astFactory.create(self.LT(1), nodesubclasses.EQUALSNode)
                self.makeASTRoot(currentAST, tmp16_AST)
                self.match(AND)
                self.notop()
                self.addASTChild(currentAST, self.returnAST)
                andop_AST = currentAST.root
            elif la1 and la1 in [NOT,MINUS,MATRIX,NUM,BRACKET,SQBRACKET,VAR,INTEGRATE,DIFFERENTIATE,SUM,SQRT,LIMIT]:
                pass
                self.notop()
                self.addASTChild(currentAST, self.returnAST)
                andop_AST = currentAST.root
            else:
                    raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_7)
            else:
                raise ex
        
        self.returnAST = andop_AST
    
    def notop(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        notop_AST = None
        try:      ## for error handling
            la1 = self.LA(1)
            if False:
                pass
            elif la1 and la1 in [NOT]:
                pass
                tmp17_AST = None
                tmp17_AST = self.astFactory.create(self.LT(1), nodesubclasses.NEGNode)
                self.makeASTRoot(currentAST, tmp17_AST)
                self.match(NOT)
                self.compare()
                self.addASTChild(currentAST, self.returnAST)
                notop_AST = currentAST.root
            elif la1 and la1 in [MINUS,MATRIX,NUM,BRACKET,SQBRACKET,VAR,INTEGRATE,DIFFERENTIATE,SUM,SQRT,LIMIT]:
                pass
                self.compare()
                self.addASTChild(currentAST, self.returnAST)
                notop_AST = currentAST.root
            else:
                    raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_7)
            else:
                raise ex
        
        self.returnAST = notop_AST
    
    def compare(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        compare_AST = None
        try:      ## for error handling
            pass
            self.assign()
            self.addASTChild(currentAST, self.returnAST)
            while True:
                if (self.LA(1)==COMPARE):
                    pass
                    tmp18_AST = None
                    tmp18_AST = self.astFactory.create(self.LT(1), nodesubclasses.EQUALSNode)
                    self.makeASTRoot(currentAST, tmp18_AST)
                    self.match(COMPARE)
                    self.assign()
                    self.addASTChild(currentAST, self.returnAST)
                else:
                    break
                
            compare_AST = currentAST.root
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_7)
            else:
                raise ex
        
        self.returnAST = compare_AST
    
    def assign(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        assign_AST = None
        try:      ## for error handling
            pass
            self.equals()
            self.addASTChild(currentAST, self.returnAST)
            while True:
                if ((self.LA(1) >= ASSIGN and self.LA(1) <= FUNCDEF)):
                    pass
                    la1 = self.LA(1)
                    if False:
                        pass
                    elif la1 and la1 in [ASSIGN]:
                        pass
                        tmp19_AST = None
                        tmp19_AST = self.astFactory.create(self.LT(1), nodesubclasses.EQUALSNode)
                        self.makeASTRoot(currentAST, tmp19_AST)
                        self.match(ASSIGN)
                    elif la1 and la1 in [ASSIGN2]:
                        pass
                        tmp20_AST = None
                        tmp20_AST = self.astFactory.create(self.LT(1), nodesubclasses.EQUALSNode)
                        self.makeASTRoot(currentAST, tmp20_AST)
                        self.match(ASSIGN2)
                    elif la1 and la1 in [MACRODEF]:
                        pass
                        tmp21_AST = None
                        tmp21_AST = self.astFactory.create(self.LT(1), nodesubclasses.EQUALSNode)
                        self.makeASTRoot(currentAST, tmp21_AST)
                        self.match(MACRODEF)
                    elif la1 and la1 in [FUNCDEF]:
                        pass
                        tmp22_AST = None
                        tmp22_AST = self.astFactory.create(self.LT(1), nodesubclasses.EQUALSNode)
                        self.makeASTRoot(currentAST, tmp22_AST)
                        self.match(FUNCDEF)
                    else:
                            raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                        
                    self.equals()
                    self.addASTChild(currentAST, self.returnAST)
                else:
                    break
                
            assign_AST = currentAST.root
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_12)
            else:
                raise ex
        
        self.returnAST = assign_AST
    
    def equals(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        equals_AST = None
        try:      ## for error handling
            synPredMatched31 = False
            if (_tokenSet_13.member(self.LA(1))) and (_tokenSet_14.member(self.LA(2))) and (_tokenSet_15.member(self.LA(3))):
                _m31 = self.mark()
                synPredMatched31 = True
                self.inputState.guessing += 1
                try:
                    pass
                    self.expr()
                    la1 = self.LA(1)
                    if False:
                        pass
                    elif la1 and la1 in [EQUALS]:
                        pass
                        self.match(EQUALS)
                    elif la1 and la1 in [NOTEQUALS]:
                        pass
                        self.match(NOTEQUALS)
                    else:
                            raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                        
                except antlr.RecognitionException, pe:
                    synPredMatched31 = False
                self.rewind(_m31)
                self.inputState.guessing -= 1
            if synPredMatched31:
                pass
                self.expr()
                self.addASTChild(currentAST, self.returnAST)
                la1 = self.LA(1)
                if False:
                    pass
                elif la1 and la1 in [EQUALS]:
                    pass
                    tmp23_AST = None
                    tmp23_AST = self.astFactory.create(self.LT(1), nodesubclasses.EQUALSNode)
                    self.makeASTRoot(currentAST, tmp23_AST)
                    self.match(EQUALS)
                elif la1 and la1 in [NOTEQUALS]:
                    pass
                    tmp24_AST = None
                    tmp24_AST = self.astFactory.create(self.LT(1), nodesubclasses.EQUALSNode)
                    self.makeASTRoot(currentAST, tmp24_AST)
                    self.match(NOTEQUALS)
                else:
                        raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                    
                self.expr()
                self.addASTChild(currentAST, self.returnAST)
                equals_AST = currentAST.root
            elif (_tokenSet_13.member(self.LA(1))) and (_tokenSet_16.member(self.LA(2))) and (_tokenSet_11.member(self.LA(3))):
                pass
                self.expr()
                self.addASTChild(currentAST, self.returnAST)
                equals_AST = currentAST.root
            else:
                raise antlr.NoViableAltException(self.LT(1), self.getFilename())
            
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_17)
            else:
                raise ex
        
        self.returnAST = equals_AST
    
    def expr(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        expr_AST = None
        try:      ## for error handling
            pass
            self.mexpr()
            self.addASTChild(currentAST, self.returnAST)
            while True:
                if (self.LA(1)==MINUS or self.LA(1)==PLUS) and (_tokenSet_13.member(self.LA(2))) and (_tokenSet_11.member(self.LA(3))):
                    pass
                    la1 = self.LA(1)
                    if False:
                        pass
                    elif la1 and la1 in [MINUS]:
                        pass
                        tmp25_AST = None
                        tmp25_AST = self.astFactory.create(self.LT(1), nodesubclasses.PLUSMINUSNode)
                        self.makeASTRoot(currentAST, tmp25_AST)
                        self.match(MINUS)
                    elif la1 and la1 in [PLUS]:
                        pass
                        tmp26_AST = None
                        tmp26_AST = self.astFactory.create(self.LT(1), nodesubclasses.PLUSMINUSNode)
                        self.makeASTRoot(currentAST, tmp26_AST)
                        self.match(PLUS)
                    else:
                            raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                        
                    self.mexpr()
                    self.addASTChild(currentAST, self.returnAST)
                else:
                    break
                
            expr_AST = currentAST.root
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_18)
            else:
                raise ex
        
        self.returnAST = expr_AST
    
    def mexpr(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        mexpr_AST = None
        try:      ## for error handling
            pass
            self.dot()
            self.addASTChild(currentAST, self.returnAST)
            while True:
                if (self.LA(1)==TIMES or self.LA(1)==DIVIDE):
                    pass
                    la1 = self.LA(1)
                    if False:
                        pass
                    elif la1 and la1 in [TIMES]:
                        pass
                        tmp27_AST = None
                        tmp27_AST = self.astFactory.create(self.LT(1), nodesubclasses.TIMESNode)
                        self.makeASTRoot(currentAST, tmp27_AST)
                        self.match(TIMES)
                    elif la1 and la1 in [DIVIDE]:
                        pass
                        tmp28_AST = None
                        tmp28_AST = self.astFactory.create(self.LT(1), nodesubclasses.DIVIDENode)
                        self.makeASTRoot(currentAST, tmp28_AST)
                        self.match(DIVIDE)
                    else:
                            raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                        
                    self.dot()
                    self.addASTChild(currentAST, self.returnAST)
                else:
                    break
                
            mexpr_AST = currentAST.root
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_19)
            else:
                raise ex
        
        self.returnAST = mexpr_AST
    
    def dot(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        dot_AST = None
        try:      ## for error handling
            pass
            self.powr()
            self.addASTChild(currentAST, self.returnAST)
            while True:
                if (self.LA(1)==DOT):
                    pass
                    tmp29_AST = None
                    tmp29_AST = self.astFactory.create(self.LT(1), nodesubclasses.PLUSMINUSNode)
                    self.makeASTRoot(currentAST, tmp29_AST)
                    self.match(DOT)
                    self.powr()
                    self.addASTChild(currentAST, self.returnAST)
                else:
                    break
                
            dot_AST = currentAST.root
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_20)
            else:
                raise ex
        
        self.returnAST = dot_AST
    
    def powr(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        powr_AST = None
        try:      ## for error handling
            pass
            self.pfactorial()
            self.addASTChild(currentAST, self.returnAST)
            while True:
                if (self.LA(1)==POWER or self.LA(1)==POWER2):
                    pass
                    la1 = self.LA(1)
                    if False:
                        pass
                    elif la1 and la1 in [POWER]:
                        pass
                        tmp30_AST = None
                        tmp30_AST = self.astFactory.create(self.LT(1), nodesubclasses.POWERNode)
                        self.makeASTRoot(currentAST, tmp30_AST)
                        self.match(POWER)
                    elif la1 and la1 in [POWER2]:
                        pass
                        tmp31_AST = None
                        tmp31_AST = self.astFactory.create(self.LT(1), nodesubclasses.POWERNode)
                        self.makeASTRoot(currentAST, tmp31_AST)
                        self.match(POWER2)
                    else:
                            raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                        
                    self.pfactorial()
                    self.addASTChild(currentAST, self.returnAST)
                else:
                    break
                
            powr_AST = currentAST.root
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_21)
            else:
                raise ex
        
        self.returnAST = powr_AST
    
    def pfactorial(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        pfactorial_AST = None
        try:      ## for error handling
            pass
            self.atom()
            self.addASTChild(currentAST, self.returnAST)
            while True:
                if (self.LA(1)==FACTORIAL):
                    pass
                    tmp32_AST = None
                    tmp32_AST = self.astFactory.create(self.LT(1), nodesubclasses.FACTORIALNode)
                    self.makeASTRoot(currentAST, tmp32_AST)
                    self.match(FACTORIAL)
                else:
                    break
                
            pfactorial_AST = currentAST.root
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_22)
            else:
                raise ex
        
        self.returnAST = pfactorial_AST
    
    def atom(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        atom_AST = None
        m_AST = None
        e_AST = None
        a_AST = None
        try:      ## for error handling
            la1 = self.LA(1)
            if False:
                pass
            elif la1 and la1 in [NUM]:
                pass
                tmp33_AST = None
                tmp33_AST = self.astFactory.create(self.LT(1), nodesubclasses.NUMNode)
                self.addASTChild(currentAST, tmp33_AST)
                self.match(NUM)
                atom_AST = currentAST.root
            elif la1 and la1 in [SQRT]:
                pass
                tmp34_AST = None
                tmp34_AST = self.astFactory.create(self.LT(1), nodesubclasses.SQRTNode)
                self.makeASTRoot(currentAST, tmp34_AST)
                self.match(SQRT)
                self.match(BRACKET)
                self.comma()
                self.addASTChild(currentAST, self.returnAST)
                self.match(RPAREN)
                atom_AST = currentAST.root
            elif la1 and la1 in [BRACKET,SQBRACKET]:
                pass
                la1 = self.LA(1)
                if False:
                    pass
                elif la1 and la1 in [BRACKET]:
                    pass
                    tmp37_AST = None
                    tmp37_AST = self.astFactory.create(self.LT(1), nodesubclasses.BRACKETNode)
                    self.makeASTRoot(currentAST, tmp37_AST)
                    self.match(BRACKET)
                elif la1 and la1 in [SQBRACKET]:
                    pass
                    tmp38_AST = None
                    tmp38_AST = self.astFactory.create(self.LT(1), nodesubclasses.BRACKETNode)
                    self.makeASTRoot(currentAST, tmp38_AST)
                    self.match(SQBRACKET)
                else:
                        raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                    
                self.comma()
                self.addASTChild(currentAST, self.returnAST)
                self.match(RPAREN)
                atom_AST = currentAST.root
            elif la1 and la1 in [MATRIX]:
                pass
                tmp40_AST = None
                tmp40_AST = self.astFactory.create(self.LT(1), nodesubclasses.MATRIXNode)
                self.match(MATRIX)
                self.matrixcontents()
                m_AST = self.returnAST
                if not self.inputState.guessing:
                    atom_AST = currentAST.root
                    atom_AST = antlr.make(self.astFactory.create(SQBRACKET, "", nodesubclasses.BRACKETNode), antlr.make(self.astFactory.create(tmp40_AST), m_AST))
                    currentAST.root = atom_AST
                    if (atom_AST != None) and (atom_AST.getFirstChild() != None):
                        currentAST.child = atom_AST.getFirstChild()
                    else:
                        currentAST.child = atom_AST
                    currentAST.advanceChildToEnd()
            elif la1 and la1 in [INTEGRATE,DIFFERENTIATE]:
                pass
                la1 = self.LA(1)
                if False:
                    pass
                elif la1 and la1 in [INTEGRATE]:
                    pass
                    tmp41_AST = None
                    tmp41_AST = self.astFactory.create(self.LT(1), nodesubclasses.INTEGRATENode)
                    self.makeASTRoot(currentAST, tmp41_AST)
                    self.match(INTEGRATE)
                elif la1 and la1 in [DIFFERENTIATE]:
                    pass
                    tmp42_AST = None
                    tmp42_AST = self.astFactory.create(self.LT(1), nodesubclasses.DIFFERENTIATENode)
                    self.makeASTRoot(currentAST, tmp42_AST)
                    self.match(DIFFERENTIATE)
                else:
                        raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                    
                self.match(BRACKET)
                self.flattenedcomma()
                self.addASTChild(currentAST, self.returnAST)
                self.match(RPAREN)
                atom_AST = currentAST.root
            elif la1 and la1 in [SUM]:
                pass
                tmp45_AST = None
                tmp45_AST = self.astFactory.create(self.LT(1), nodesubclasses.SUMNode)
                self.makeASTRoot(currentAST, tmp45_AST)
                self.match(SUM)
                self.match(BRACKET)
                self.flattenedcomma()
                self.addASTChild(currentAST, self.returnAST)
                self.match(RPAREN)
                atom_AST = currentAST.root
            elif la1 and la1 in [MINUS]:
                pass
                tmp48_AST = None
                tmp48_AST = self.astFactory.create(self.LT(1), nodesubclasses.PLUSMINUSNode)
                self.match(MINUS)
                self.atom()
                e_AST = self.returnAST
                if not self.inputState.guessing:
                    atom_AST = currentAST.root
                    atom_AST = antlr.make(self.astFactory.create(NEG,"-", nodesubclasses.NEGNode), e_AST)
                    currentAST.root = atom_AST
                    if (atom_AST != None) and (atom_AST.getFirstChild() != None):
                        currentAST.child = atom_AST.getFirstChild()
                    else:
                        currentAST.child = atom_AST
                    currentAST.advanceChildToEnd()
            elif la1 and la1 in [LIMIT]:
                pass
                tmp49_AST = None
                tmp49_AST = self.astFactory.create(self.LT(1), nodesubclasses.LIMITNode)
                self.makeASTRoot(currentAST, tmp49_AST)
                self.match(LIMIT)
                self.match(BRACKET)
                self.flattenedcomma()
                self.addASTChild(currentAST, self.returnAST)
                self.match(RPAREN)
                atom_AST = currentAST.root
            else:
                synPredMatched55 = False
                if (self.LA(1)==VAR) and (self.LA(2)==BRACKET) and (_tokenSet_0.member(self.LA(3))):
                    _m55 = self.mark()
                    synPredMatched55 = True
                    self.inputState.guessing += 1
                    try:
                        pass
                        self.match(VAR)
                        self.match(BRACKET)
                    except antlr.RecognitionException, pe:
                        synPredMatched55 = False
                    self.rewind(_m55)
                    self.inputState.guessing -= 1
                if synPredMatched55:
                    pass
                    tmp52_AST = None
                    tmp52_AST = self.astFactory.create(self.LT(1), nodesubclasses.VARNode)
                    self.match(VAR)
                    tmp53_AST = None
                    tmp53_AST = self.astFactory.create(self.LT(1), nodesubclasses.BRACKETNode)
                    self.match(BRACKET)
                    self.comma()
                    a_AST = self.returnAST
                    tmp54_AST = None
                    tmp54_AST = self.astFactory.create(self.LT(1))
                    self.match(RPAREN)
                    if not self.inputState.guessing:
                        atom_AST = currentAST.root
                        atom_AST = antlr.make(self.astFactory.create(FUNCTION,"FUNCTION", nodesubclasses.FUNCTIONNode), tmp52_AST, antlr.make(self.astFactory.create(tmp53_AST), a_AST))
                        currentAST.root = atom_AST
                        if (atom_AST != None) and (atom_AST.getFirstChild() != None):
                            currentAST.child = atom_AST.getFirstChild()
                        else:
                            currentAST.child = atom_AST
                        currentAST.advanceChildToEnd()
                elif (self.LA(1)==VAR) and (_tokenSet_23.member(self.LA(2))) and (_tokenSet_11.member(self.LA(3))):
                    pass
                    tmp55_AST = None
                    tmp55_AST = self.astFactory.create(self.LT(1), nodesubclasses.VARNode)
                    self.addASTChild(currentAST, tmp55_AST)
                    self.match(VAR)
                    atom_AST = currentAST.root
                else:
                    raise antlr.NoViableAltException(self.LT(1), self.getFilename())
                
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_23)
            else:
                raise ex
        
        self.returnAST = atom_AST
    
    def matrixcontents(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        matrixcontents_AST = None
        try:      ## for error handling
            pass
            self.match(BRACKET)
            self.flattenedsqbracket()
            self.addASTChild(currentAST, self.returnAST)
            while True:
                if (self.LA(1)==COMMA):
                    pass
                    self.match(COMMA)
                    self.flattenedsqbracket()
                    self.addASTChild(currentAST, self.returnAST)
                else:
                    break
                
            self.match(RPAREN)
            matrixcontents_AST = currentAST.root
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_23)
            else:
                raise ex
        
        self.returnAST = matrixcontents_AST
    
    def flattenedsqbracket(self):    
        
        self.returnAST = None
        currentAST = antlr.ASTPair()
        flattenedsqbracket_AST = None
        f_AST = None
        try:      ## for error handling
            pass
            tmp59_AST = None
            tmp59_AST = self.astFactory.create(self.LT(1), nodesubclasses.BRACKETNode)
            self.match(SQBRACKET)
            self.flattenedcomma()
            f_AST = self.returnAST
            self.match(RPAREN)
            if not self.inputState.guessing:
                flattenedsqbracket_AST = currentAST.root
                flattenedsqbracket_AST = antlr.make(self.astFactory.create(NOOP,"NOOP", nodesubclasses.NOOPNode), f_AST)
                currentAST.root = flattenedsqbracket_AST
                if (flattenedsqbracket_AST != None) and (flattenedsqbracket_AST.getFirstChild() != None):
                    currentAST.child = flattenedsqbracket_AST.getFirstChild()
                else:
                    currentAST.child = flattenedsqbracket_AST
                currentAST.advanceChildToEnd()
        
        except antlr.RecognitionException, ex:
            if not self.inputState.guessing:
                self.reportError(ex)
                self.consume()
                self.consumeUntil(_tokenSet_24)
            else:
                raise ex
        
        self.returnAST = flattenedsqbracket_AST
    
    
    def buildTokenTypeASTClassMap(self):
        self.tokenTypeToASTClassMap = {}
        self.tokenTypeToASTClassMap[4] = nodesubclasses.NOOPNode
        self.tokenTypeToASTClassMap[5] = nodesubclasses.PROGCONTROLNode
        self.tokenTypeToASTClassMap[6] = nodesubclasses.PROGCONTROLNode
        self.tokenTypeToASTClassMap[7] = nodesubclasses.PROGCONTROLNode
        self.tokenTypeToASTClassMap[8] = nodesubclasses.PROGCONTROLNode
        self.tokenTypeToASTClassMap[9] = nodesubclasses.PROGCONTROLNode
        self.tokenTypeToASTClassMap[10] = nodesubclasses.PROGCONTROLNode
        self.tokenTypeToASTClassMap[11] = nodesubclasses.PROGCONTROLNode
        self.tokenTypeToASTClassMap[12] = nodesubclasses.PROGCONTROLNode
        self.tokenTypeToASTClassMap[13] = nodesubclasses.PROGCONTROLNode
        self.tokenTypeToASTClassMap[14] = nodesubclasses.PROGCONTROLNode
        self.tokenTypeToASTClassMap[15] = nodesubclasses.LABELNode
        self.tokenTypeToASTClassMap[16] = nodesubclasses.COMMANode
        self.tokenTypeToASTClassMap[17] = nodesubclasses.EQUALSNode
        self.tokenTypeToASTClassMap[18] = nodesubclasses.EQUALSNode
        self.tokenTypeToASTClassMap[19] = nodesubclasses.EQUALSNode
        self.tokenTypeToASTClassMap[20] = nodesubclasses.EQUALSNode
        self.tokenTypeToASTClassMap[21] = nodesubclasses.EQUALSNode
        self.tokenTypeToASTClassMap[22] = nodesubclasses.EQUALSNode
        self.tokenTypeToASTClassMap[23] = nodesubclasses.EQUALSNode
        self.tokenTypeToASTClassMap[24] = nodesubclasses.NEGNode
        self.tokenTypeToASTClassMap[25] = nodesubclasses.POWERNode
        self.tokenTypeToASTClassMap[26] = nodesubclasses.POWERNode
        self.tokenTypeToASTClassMap[27] = nodesubclasses.TIMESNode
        self.tokenTypeToASTClassMap[28] = nodesubclasses.DIVIDENode
        self.tokenTypeToASTClassMap[29] = nodesubclasses.PLUSMINUSNode
        self.tokenTypeToASTClassMap[30] = nodesubclasses.PLUSMINUSNode
        self.tokenTypeToASTClassMap[31] = nodesubclasses.PLUSMINUSNode
        self.tokenTypeToASTClassMap[32] = nodesubclasses.EQUALSNode
        self.tokenTypeToASTClassMap[33] = nodesubclasses.EQUALSNode
        self.tokenTypeToASTClassMap[34] = nodesubclasses.MATRIXNode
        self.tokenTypeToASTClassMap[35] = nodesubclasses.NUMNode
        self.tokenTypeToASTClassMap[36] = nodesubclasses.BRACKETNode
        self.tokenTypeToASTClassMap[37] = nodesubclasses.BRACKETNode
        self.tokenTypeToASTClassMap[38] = nodesubclasses.VARNode
        self.tokenTypeToASTClassMap[39] = nodesubclasses.INTEGRATENode
        self.tokenTypeToASTClassMap[40] = nodesubclasses.DIFFERENTIATENode
        self.tokenTypeToASTClassMap[41] = nodesubclasses.SUMNode
        self.tokenTypeToASTClassMap[42] = nodesubclasses.SQRTNode
        self.tokenTypeToASTClassMap[43] = nodesubclasses.NEGNode
        self.tokenTypeToASTClassMap[44] = nodesubclasses.FACTORIALNode
        self.tokenTypeToASTClassMap[45] = nodesubclasses.FUNCTIONNode
        self.tokenTypeToASTClassMap[46] = nodesubclasses.LIMITNode

_tokenNames = [
    "<0>", 
    "EOF", 
    "<2>", 
    "NULL_TREE_LOOKAHEAD", 
    "NOOP", 
    "FOR", 
    "IF", 
    "THEN", 
    "ELSE", 
    "THRU", 
    "WHILE", 
    "UNLESS", 
    "DO", 
    "STEP", 
    "IN", 
    "LABEL", 
    "COMMA", 
    "ASSIGN", 
    "ASSIGN2", 
    "MACRODEF", 
    "FUNCDEF", 
    "COMPARE", 
    "OR", 
    "AND", 
    "NOT", 
    "POWER", 
    "POWER2", 
    "TIMES", 
    "DIVIDE", 
    "MINUS", 
    "PLUS", 
    "DOT", 
    "EQUALS", 
    "NOTEQUALS", 
    "MATRIX", 
    "NUM", 
    "BRACKET", 
    "SQBRACKET", 
    "VAR", 
    "INTEGRATE", 
    "DIFFERENTIATE", 
    "SUM", 
    "SQRT", 
    "NEG", 
    "FACTORIAL", 
    "FUNCTION", 
    "LIMIT", 
    "RPAREN", 
    "WS", 
    "DIGIT", 
    "INT", 
    "LOWER", 
    "UPPER", 
    "LETTER", 
    "PERCENT", 
    "SEMICOLON"
]
    

### generate bit set
def mk_tokenSet_0(): 
    ### var1
    data = [ 79148223569504L, 0L]
    return data
_tokenSet_0 = antlr.BitSet(mk_tokenSet_0())

### generate bit set
def mk_tokenSet_1(): 
    ### var1
    data = [ 96757023186530L, 0L]
    return data
_tokenSet_1 = antlr.BitSet(mk_tokenSet_1())

### generate bit set
def mk_tokenSet_2(): 
    ### var1
    data = [ 237494511566562L, 0L]
    return data
_tokenSet_2 = antlr.BitSet(mk_tokenSet_2())

### generate bit set
def mk_tokenSet_3(): 
    ### var1
    data = [ 2L, 0L]
    return data
_tokenSet_3 = antlr.BitSet(mk_tokenSet_3())

### generate bit set
def mk_tokenSet_4(): 
    ### var1
    data = [ 140737488355330L, 0L]
    return data
_tokenSet_4 = antlr.BitSet(mk_tokenSet_4())

### generate bit set
def mk_tokenSet_5(): 
    ### var1
    data = [ 140737488420866L, 0L]
    return data
_tokenSet_5 = antlr.BitSet(mk_tokenSet_5())

### generate bit set
def mk_tokenSet_6(): 
    ### var1
    data = [ 140737488355328L, 0L]
    return data
_tokenSet_6 = antlr.BitSet(mk_tokenSet_6())

### generate bit set
def mk_tokenSet_7(): 
    ### var1
    data = [ 219885712015298L, 0L]
    return data
_tokenSet_7 = antlr.BitSet(mk_tokenSet_7())

### generate bit set
def mk_tokenSet_8(): 
    ### var1
    data = [ 79148223561792L, 0L]
    return data
_tokenSet_8 = antlr.BitSet(mk_tokenSet_8())

### generate bit set
def mk_tokenSet_9(): 
    ### var1
    data = [ 237494511542114L, 0L]
    return data
_tokenSet_9 = antlr.BitSet(mk_tokenSet_9())

### generate bit set
def mk_tokenSet_10(): 
    ### var1
    data = [ 140737488421122L, 0L]
    return data
_tokenSet_10 = antlr.BitSet(mk_tokenSet_10())

### generate bit set
def mk_tokenSet_11(): 
    ### var1
    data = [ 237494511566818L, 0L]
    return data
_tokenSet_11 = antlr.BitSet(mk_tokenSet_11())

### generate bit set
def mk_tokenSet_12(): 
    ### var1
    data = [ 219885714112450L, 0L]
    return data
_tokenSet_12 = antlr.BitSet(mk_tokenSet_12())

### generate bit set
def mk_tokenSet_13(): 
    ### var1
    data = [ 79148194201600L, 0L]
    return data
_tokenSet_13 = antlr.BitSet(mk_tokenSet_13())

### generate bit set
def mk_tokenSet_14(): 
    ### var1
    data = [ 96757019057760L, 0L]
    return data
_tokenSet_14 = antlr.BitSet(mk_tokenSet_14())

### generate bit set
def mk_tokenSet_15(): 
    ### var1
    data = [ 237494511541856L, 0L]
    return data
_tokenSet_15 = antlr.BitSet(mk_tokenSet_15())

### generate bit set
def mk_tokenSet_16(): 
    ### var1
    data = [ 237481626664930L, 0L]
    return data
_tokenSet_16 = antlr.BitSet(mk_tokenSet_16())

### generate bit set
def mk_tokenSet_17(): 
    ### var1
    data = [ 219885716078530L, 0L]
    return data
_tokenSet_17 = antlr.BitSet(mk_tokenSet_17())

### generate bit set
def mk_tokenSet_18(): 
    ### var1
    data = [ 219898600980418L, 0L]
    return data
_tokenSet_18 = antlr.BitSet(mk_tokenSet_18())

### generate bit set
def mk_tokenSet_19(): 
    ### var1
    data = [ 219899674722242L, 0L]
    return data
_tokenSet_19 = antlr.BitSet(mk_tokenSet_19())

### generate bit set
def mk_tokenSet_20(): 
    ### var1
    data = [ 219900077375426L, 0L]
    return data
_tokenSet_20 = antlr.BitSet(mk_tokenSet_20())

### generate bit set
def mk_tokenSet_21(): 
    ### var1
    data = [ 219902224859074L, 0L]
    return data
_tokenSet_21 = antlr.BitSet(mk_tokenSet_21())

### generate bit set
def mk_tokenSet_22(): 
    ### var1
    data = [ 219902325522370L, 0L]
    return data
_tokenSet_22 = antlr.BitSet(mk_tokenSet_22())

### generate bit set
def mk_tokenSet_23(): 
    ### var1
    data = [ 237494511566786L, 0L]
    return data
_tokenSet_23 = antlr.BitSet(mk_tokenSet_23())

### generate bit set
def mk_tokenSet_24(): 
    ### var1
    data = [ 140737488420864L, 0L]
    return data
_tokenSet_24 = antlr.BitSet(mk_tokenSet_24())
    

Generated by  Doxygen 1.6.0   Back to index