prolexer.java

使用antlr实现c和pascal的转换

                switch (alt27) {
            	case 1 :
            	    // PRO.g:208:16: DIGIT
            	    {
            	    mDIGIT(); 

            	    }
            	    break;

            	default :
            	    break loop27;
                }
            } while (true);


            }

            this.type = _type;
        }
        finally {
        }
    }
    // $ANTLR end DIGITS

    // $ANTLR start LETTER
    public final void mLETTER() throws RecognitionException {
        try {
            int _type = LETTER;
            // PRO.g:209:10: ( ( 'a' .. 'z' | 'A' .. 'Z' ) )
            // PRO.g:209:10: ( 'a' .. 'z' | 'A' .. 'Z' )
            {
            if ( (input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                input.consume();

            }
            else {
                MismatchedSetException mse =
                    new MismatchedSetException(null,input);
                recover(mse);    throw mse;
            }


            }

            this.type = _type;
        }
        finally {
        }
    }
    // $ANTLR end LETTER

    // $ANTLR start DIGIT
    public final void mDIGIT() throws RecognitionException {
        try {
            int _type = DIGIT;
            // PRO.g:210:9: ( '0' .. '9' )
            // PRO.g:210:9: '0' .. '9'
            {
            matchRange('0','9'); 

            }

            this.type = _type;
        }
        finally {
        }
    }
    // $ANTLR end DIGIT

    // $ANTLR start WS
    public final void mWS() throws RecognitionException {
        try {
            int _type = WS;
            // PRO.g:212:5: ( ( ' ' | '\\t' | '\\f' | ( '\\r\\n' | '\\r' | '\\n' ) ) )
            // PRO.g:212:5: ( ' ' | '\\t' | '\\f' | ( '\\r\\n' | '\\r' | '\\n' ) )
            {
            // PRO.g:212:5: ( ' ' | '\\t' | '\\f' | ( '\\r\\n' | '\\r' | '\\n' ) )
            int alt29=4;
            switch ( input.LA(1) ) {
            case ' ':
                {
                alt29=1;
                }
                break;
            case '\t':
                {
                alt29=2;
                }
                break;
            case '\f':
                {
                alt29=3;
                }
                break;
            case '\n':
            case '\r':
                {
                alt29=4;
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("212:5: ( ' ' | '\\t' | '\\f' | ( '\\r\\n' | '\\r' | '\\n' ) )", 29, 0, input);

                throw nvae;
            }

            switch (alt29) {
                case 1 :
                    // PRO.g:212:7: ' '
                    {
                    match(' '); 

                    }
                    break;
                case 2 :
                    // PRO.g:213:7: '\\t'
                    {
                    match('\t'); 

                    }
                    break;
                case 3 :
                    // PRO.g:214:7: '\\f'
                    {
                    match('\f'); 

                    }
                    break;
                case 4 :
                    // PRO.g:217:7: ( '\\r\\n' | '\\r' | '\\n' )
                    {
                    // PRO.g:217:7: ( '\\r\\n' | '\\r' | '\\n' )
                    int alt28=3;
                    int LA28_0 = input.LA(1);

                    if ( (LA28_0=='\r') ) {
                        int LA28_1 = input.LA(2);

                        if ( (LA28_1=='\n') ) {
                            alt28=1;
                        }
                        else {
                            alt28=2;}
                    }
                    else if ( (LA28_0=='\n') ) {
                        alt28=3;
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("217:7: ( '\\r\\n' | '\\r' | '\\n' )", 28, 0, input);

                        throw nvae;
                    }
                    switch (alt28) {
                        case 1 :
                            // PRO.g:217:9: '\\r\\n'
                            {
                            match("\r\n"); 


                            }
                            break;
                        case 2 :
                            // PRO.g:218:9: '\\r'
                            {
                            match('\r'); 

                            }
                            break;
                        case 3 :
                            // PRO.g:219:9: '\\n'
                            {
                            match('\n'); 

                            }
                            break;

                    }


                    }
                    break;

            }

             skip(); 

            }

            this.type = _type;
        }
        finally {
        }
    }
    // $ANTLR end WS

    public void mTokens() throws RecognitionException {
        // PRO.g:1:10: ( T45 | T46 | T47 | T48 | T49 | T50 | T51 | T52 | T53 | T54 | PROGRAM | VAR | ARRAY | OF | FUNCTION | PROCEDURE | BEGIN | END | IF | THEN | ELSE | WHILE | DO | NOT | EQUAL | NEQ | SMALL | GRAT | NB | NS | ADDOPA | ADDOPB | OR | MULOPA | MULOPB | DIV | MOD | AND | ASSIGNOP | INTEGER | REAL | SEPARATOR | NEWLINE | NUM | OPTIONAL_FRACTION | OPTIONAL_EXPONENT | ID | DIGITS | LETTER | DIGIT | WS )
        int alt30=51;
        alt30 = dfa30.predict(input);
        switch (alt30) {
            case 1 :
                // PRO.g:1:10: T45
                {
                mT45(); 

                }
                break;
            case 2 :
                // PRO.g:1:14: T46
                {
                mT46(); 

                }
                break;
            case 3 :
                // PRO.g:1:18: T47
                {
                mT47(); 

                }
                break;
            case 4 :
                // PRO.g:1:22: T48
                {
                mT48(); 

                }
                break;
            case 5 :
                // PRO.g:1:26: T49
                {
                mT49(); 

                }
                break;
            case 6 :
                // PRO.g:1:30: T50
                {
                mT50(); 

                }
                break;
            case 7 :
                // PRO.g:1:34: T51
                {
                mT51(); 

                }
                break;
            case 8 :
                // PRO.g:1:38: T52
                {
                mT52(); 

                }
                break;
            case 9 :
                // PRO.g:1:42: T53
                {
                mT53(); 

                }
                break;
            case 10 :
                // PRO.g:1:46: T54
                {
                mT54(); 

                }
                break;
            case 11 :
                // PRO.g:1:50: PROGRAM
                {
                mPROGRAM(); 

                }
                break;
            case 12 :
                // PRO.g:1:58: VAR
                {
                mVAR(); 

                }
                break;
            case 13 :
                // PRO.g:1:62: ARRAY
                {
                mARRAY(); 

                }
                break;
            case 14 :
                // PRO.g:1:68: OF
                {
                mOF(); 

                }
                break;
            case 15 :
                // PRO.g:1:71: FUNCTION
                {
                mFUNCTION(); 

                }
                break;
            case 16 :
                // PRO.g:1:80: PROCEDURE
                {
                mPROCEDURE(); 

                }
                break;
            case 17 :
                // PRO.g:1:90: BEGIN
                {
                mBEGIN(); 

                }
                break;
            case 18 :
                // PRO.g:1:96: END
                {
                mEND(); 

                }
                break;
            case 19 :
                // PRO.g:1:100: IF
                {
                mIF(); 

                }
                break;
            case 20 :
                // PRO.g:1:103: THEN
                {
                mTHEN(); 

                }
                break;
            case 21 :
                // PRO.g:1:108: ELSE
                {
                mELSE(); 

                }
                break;
            case 22 :
                // PRO.g:1:113: WHILE
                {
                mWHILE(); 

                }
                break;
            case 23 :
                // PRO.g:1:119: DO
                {
                mDO(); 

                }
                break;
            case 24 :
                // PRO.g:1:122: NOT
                {
                mNOT(); 

                }
                break;
            case 25 :
                // PRO.g:1:126: EQUAL
                {
                mEQUAL(); 

                }
                break;
            case 26 :
                // PRO.g:1:132: NEQ
                {
                mNEQ(); 

                }
                break;
            case 27 :
                // PRO.g:1:136: SMALL
                {
                mSMALL(); 

                }
                break;
            case 28 :
                // PRO.g:1:142: GRAT
                {
                mGRAT(); 

                }
                break;
            case 29 :
                // PRO.g:1:147: NB
                {
                mNB(); 

                }
                break;
            case 30 :
                // PRO.g:1:150: NS
                {
                mNS(); 

                }
                break;
            case 31 :
                // PRO.g:1:153: ADDOPA
                {
                mADDOPA(); 

                }
                break;
            case 32 :
                // PRO.g:1:160: ADDOPB
                {
                mADDOPB(); 

                }
                break;
            case 33 :
                // PRO.g:1:167: OR
                {
                mOR(); 

                }
                break;
            case 34 :
                // PRO.g:1:170: MULOPA
                {
                mMULOPA(); 

                }
                break;
            case 35 :
                // PRO.g:1:177: MULOPB
                {
                mMULOPB(); 

                }
                break;
            case 36 :
                // PRO.g:1:184: DIV
                {
                mDIV(); 

                }
                break;
            case 37 :
                // PRO.g:1:188: MOD
                {
                mMOD(); 

                }
                break;
            case 38 :
                // PRO.g:1:192: AND
                {
                mAND(); 

                }
                break;
            case 39 :
                // PRO.g:1:196: ASSIGNOP
                {
                mASSIGNOP(); 

                }
                break;
            case 40 :
                // PRO.g:1:205: INTEGER
                {
                mINTEGER(); 

                }
                break;
            case 41 :
                // PRO.g:1:213: REAL
                {
                mREAL(); 

                }
                break;
            case 42 :
                // PRO.g:1:218: SEPARATOR
                {
                mSEPARATOR(); 

                }
                break;
            case 43 :
                // PRO.g:1:228: NEWLINE
                {
                mNEWLINE(); 

                }
                break;
            case 44 :
                // PRO.g:1:236: NUM
                {
                mNUM(); 

                }
                break;
            case 45 :
                // PRO.g:1:240: OPTIONAL_FRACTION
                {
                mOPTIONAL_FRACTION(); 

                }
                break;
            case 46 :
                // PRO.g:1:258: OPTIONAL_EXPONENT
                {
                mOPTIONAL_EXPONENT(); 

                }
                break;
            case 47 :
                // PRO.g:1:276: ID
                {
                mID(); 

                }
                break;
            case 48 :
                // PRO.g:1:279: