expr_err.flex.svn-base

实现的一个简单的语言编译器,可以编译类JAVA 的小语言

                                    // Do nothing.
                                 } else {
                                    boolean preSymbolNotExp = !(preSymbol == ExprESymbol.RPAREN
                                                                || preSymbol == ExprESymbol.INTEGER_LITERL
                                                                || preSymbol == ExprESymbol.IDENTIFIER);
                                    if (preSymbolNotExp) {
                                        addError(ExprError.NoOperandErr,
                                                 "Expect an integer literal, an identifier or"+
                                                 " a parenthesized expression as the left operand of +.",
                                                 yyline+1, yycolumn+1);
                                        yypushback(1);
                                        return symbol(ExprESymbol.NOP);
                                    }
                                 }
                                 
                                 return symbol(ExprESymbol.PLUS); 
                               }
                                
"-"                            { 
                                 if (preSymbol == ExprESymbol.NOP) {
                                    // Do nothing.
                                 } else {
                                    boolean preSymbolNotExp = !(preSymbol == ExprESymbol.RPAREN
                                                                || preSymbol == ExprESymbol.INTEGER_LITERL
                                                                || preSymbol == ExprESymbol.IDENTIFIER);
                                    if (preSymbolNotExp) {
                                        addError(ExprError.NoOperandErr,
                                                 "Expect an integer literal, an identifier or"+
                                                 " a parenthesized expression as the left operand of -.",
                                                 yyline+1, yycolumn+1);
                                        yypushback(1);
                                        return symbol(ExprESymbol.NOP);
                                    }
                                 }
                                 
                                 return symbol(ExprESymbol.MINUS); }

"*"                            {
                                 if (preSymbol == ExprESymbol.NOP) {
                                    // Do nothing.
                                 } else {
                                    boolean preSymbolNotExp = !(preSymbol == ExprESymbol.RPAREN
                                                                || preSymbol == ExprESymbol.INTEGER_LITERL
                                                                || preSymbol == ExprESymbol.IDENTIFIER);
                                    if (preSymbolNotExp) {
                                        addError(ExprError.NoOperandErr,
                                                 "Expect an integer literal, an identifier or"+
                                                 " a parenthesized expression as the left operand of *.",
                                                 yyline+1, yycolumn+1);
                                        yypushback(1);
                                        return symbol(ExprESymbol.NOP);
                                    }
                                 }
                                 
                                 return symbol(ExprESymbol.MULT); 
                               }

"/"                            {
                                 if (preSymbol == ExprESymbol.NOP) {
                                    // Do nothing.
                                 } else {
                                    boolean preSymbolNotExp = !(preSymbol == ExprESymbol.RPAREN
                                                                || preSymbol == ExprESymbol.INTEGER_LITERL
                                                                || preSymbol == ExprESymbol.IDENTIFIER);
                                    if (preSymbolNotExp) {
                                        addError(ExprError.NoOperandErr,
                                                 "Expect an integer literal, an identifier or"+
                                                 " a parenthesized expression as the left operand of /.",
                                                 yyline+1, yycolumn+1);
                                        yypushback(1);
                                        return symbol(ExprESymbol.NOP);
                                    }
                                 }
                                 
                                 return symbol(ExprESymbol.DIV); 
                               }

"="                            {
                                 if (preSymbol == ExprESymbol.NOP) {
                                    // Do nothing.
                                 } else {
                                    boolean preSymbolNotExp = !(preSymbol == ExprESymbol.RPAREN
                                                                || preSymbol == ExprESymbol.INTEGER_LITERL
                                                                || preSymbol == ExprESymbol.IDENTIFIER);
                                    if (preSymbolNotExp) {
                                        addError(ExprError.NoOperandErr,
                                                 "Expect an integer literal, an identifier or"+
                                                 " a parenthesized expression as the left operand of =.",
                                                 yyline+1, yycolumn+1);
                                        yypushback(1);
                                        return symbol(ExprESymbol.NOP);
                                    }
                                 }
                                 
                                 return symbol(ExprESymbol.EQ); 
                               }

/* numeric literals */

{IntegerLiteral}               { 
                                 /* The first three if-else statements detect whether there are integer literals
                                  * before which are identifiers, integer literals or )'s. If so, return a NOP 
                                  * and push integer literal back into the input stream.
                                  */
                                 if (preSymbol == ExprESymbol.IDENTIFIER) {
                                    addError(ExprError.AdjExpErr, 
                                             "Expect an operator between identifier and integer.",
                                             yyline+1, yycolumn+1);
                                    yypushback(yytext().length());
                                    return symbol(ExprESymbol.NOP);
                                 } else if (preSymbol == ExprESymbol.INTEGER_LITERAL) {
                                    addError(ExprError.AdjExpErr, 
                                             "Expect an operator between integers.",
                                             yyline+1, yycolumn+1);
                                    yypushback(yytext().length());
                                    return symbol(ExprESymbol.NOP);
                                 } else if (preSymbol == ExprESymbol.RPAREN) {
                                    addError(ExprError.AdjExpErr, 
                                             "Expect an operator between integer and parenthesized expression.",
                                             yyline+1, yycolumn+1);
                                    yypushback(yytext().length());
                                    return symbol(ExprESymbol.NOP);
                                 }
                                  
                                 return symbol(ExprESymbol.INTEGER_LITERAL, new Integer(yytext())); 
                               }

/* comments */
{Comment}                      { /* ignore */ }

/* whitespace */
{WhiteSpace}                   { /* ignore */ }

/* identifiers */ 
{Identifier}                   { 
                                 /*
                                  * The first if-else statements detect whether there are identifiers before which
                                  * are identifiers, integer literals or )'s. If so, return a NOP and push the
                                  * identifier back into the input stream.
                                  */
                                 if (preSymbol == ExprESymbol.IDENTIFIER) {
                                    addError(ExprError.AdjExpErr,
                                             "Expect an operator or a semicolon between identifiers.",
                                             yyline+1, yycolumn+1);
                                    yypushback(yytext().length());
                                    return symbol(ExprESymbol.NOP);                                    
                                 } else if (preSymbol == ExprESymbol.INTEGER_LITERAL) {
                                    addError(ExprError.AdjExpErr,
                                             "Expect an operator or a semicolon between integer and identifier.",
                                             yyline+1, yycolumn+1);
                                    yypushback(yytext().length());
                                    return symbol(ExprESymbol.NOP);                                    
                                 } else if (preSymbol == ExprESymbol.RPAREN) {
                                    addError(ExprError.AdjExpErr,
                                             "Expect an operator or a semicolon between parenthesized expression and identifier.",
                                             yyline+1, yycolumn+1);
                                    yypushback(yytext().length());
                                    return symbol(ExprESymbol.NOP);                                    
                                 } 
                                 
                                 return symbol(ExprESymbol.IDENTIFIER, yytext()); 
                               }  

}

/* error fallback */
.|\n                           { throw new RuntimeException("Illegal character \""+yytext()+
                                                            "\" at line "+yyline+", column "+yycolumn); }

<<EOF>>                        { return symbol(ExprESymbol.EOF); }