Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import org.gvsig.expressionevaluator.ExpressionSyntaxException;

import org.gvsig.expressionevaluator.spi.AbstractLexicalAnalyzer;

import org.gvsig.expressionevaluator.LexicalAnalyzer;

public class SQLLexicalAnalyzer extends AbstractLexicalAnalyzer {

    public SQLLexicalAnalyzer(String source) {

        super(source);

        this.tokens.put("null", Token.NULL);

        this.tokens.put("true", Token.TRUE);

        this.tokens.put("false", Token.FALSE);

        this.tokens.put("not", Token.OP_NOT);

        this.tokens.put("like", Token.PRED_LIKE);

        this.tokens.put("ilike", Token.PRED_ILIKE);

        this.tokens.put("is", Token.PRED_IS);

        this.tokens.put("between", Token.PRED_BETWEEN);

        this.tokens.put("and", Token.OP_AND);

        this.tokens.put("or", Token.OP_OR);

        this.tokens.put("isnull", Token.ISNULL);

        this.tokens.put("notnull", Token.NOTNULL);

    }

    public SQLLexicalAnalyzer() {

        this(null);

    }

    @Override

    public LexicalAnalyzer clone() throws CloneNotSupportedException {

        // As this implementation does not add state to the abstract class, we 

        // just call the super class.

        SQLLexicalAnalyzer other = (SQLLexicalAnalyzer) super.clone();

        return other;

    }

    private void skipcomments() {

        if (isEOF()) {

            return;

        }

        char ch = getch();

        while( ch == '-' ) {

            ch = lookch();

            if( ch == '-' ) {

                while( ch != EOF && ch != '\n' ) {

                    ch = getch();

                }

                ungetch();

                skipblanks();

                ch = getch();

            }

        }

        ungetch();

    }

    @Override

    protected Token getToken() {

        skipblanks();

        skipcomments();

        char ch = getch();

        switch( ch ) {

        case EOF:

            token.set(Token.EOF, null, null);

            return token;

        case '~':

            token.set(Token.OP_REGEXP, "~");

            return token;

        case '*':

            token.set(Token.OP_MULT, "*");

            return token;

        case '/':

            token.set(Token.OP_DIV, "/");

            return token;

        case '%':

            token.set(Token.OP_MOD, "%");

            return token;

        case '=':

            ch = getch();

            switch( ch ) {

            case EOF:

                throw new ExpressionSyntaxException(I18N.unexpected_end_of_source(), this);

            case '>':

                token.set(Token.ARGUMENT_ASSIGNMENT, "=>");

                return token;

            }

            ungetch();

            token.set(Token.OP_EQ, "=");

            return token;

        case ':':

            ch = getch();

            switch( ch ) {

            case EOF:

                throw new ExpressionSyntaxException(I18N.unexpected_end_of_source(), this);

            case '=':

                token.set(Token.ASSIGNMENT, ":=");

                return token;

            }

            ungetch();

            token.set(Token.COLON, ":");

            return token;

        case '<':

            ch = getch();

            switch( ch ) {

            case EOF:

                throw new ExpressionSyntaxException(I18N.unexpected_end_of_source(), this);

            case '>':

                token.set(Token.OP_NE, "<>");

                return token;

            case '=':

                token.set(Token.OP_LE, "<=");

                return token;

            }

            ungetch();

            token.set(Token.OP_LT, "<");

            return token;

        case '>':

            ch = getch();

            switch( ch ) {

            case EOF:

                throw new ExpressionSyntaxException(I18N.unexpected_end_of_source(), this);

            case '=':

                token.set(Token.OP_GE, ">=");

                return token;

            }

            ungetch();

            token.set(Token.OP_GT, ">");

            return token;

        case '|':

            ch = getch();

            switch( ch ) {

            case EOF:

                throw new ExpressionSyntaxException(I18N.unexpected_end_of_source(), this);

            case '|':

                token.set(Token.OP_CONCAT, "||");

                return token;

            }

            ungetch();

            break;

        case '.': // SQL Extension to access object methods and attributes

            token.set(Token.OP_GETATTR, ".");

            return token;

        case ',':

            token.set(Token.COMA, ",");

            return token;

        case '(':

            token.set(Token.PARENTHESIS_OPEN, "(");

            return token;

        case ')':

            token.set(Token.PARENTHESIS_CLOSE, ")");

            return token;

        case '+':

            token.set(Token.OP_ADD, "+");

            return token;

//            ch = getch();

//            if( ch == EOF ) {

//                throw new ExpressionSyntaxException(I18N.unexpected_end_of_source(), this);

//            }

//            if( !Character.isDigit(ch) ) {

//                ungetch();

//                token.set(Token.OP_ADD, "+");

//                return token;

//            }

//            ungetch();

//            parseNumber();

//            token.setLiteral("+" + token.getLiteral());

//            return token;

        case '-':

            ch = getch();

            switch( ch ) {

            case EOF:

                throw new ExpressionSyntaxException(I18N.unexpected_end_of_source(), this);

            case '>':

                // SQL Extension to access object methods and attributes

                token.set(Token.OP_GETATTR, "->");

                return token;

            }

//            if( Character.isDigit(ch) ) {

//                ungetch();

//                ungetch();

//                parseNumber();

//                return token;

//            }

            ungetch();

            token.set(Token.OP_SUBST, "-");

            return token;

        case '"':

            buffer.clear();

            ch = getch();

            while( ch != '"' ) {

                if( ch == EOF ) {

                    throw new ExpressionSyntaxException(I18N.End_of_string_was_expected_and_end_of_source_was_found(), this);

                }

                buffer.add(ch);

                ch = getch();

            }

            if( buffer.length() < 1 ) {

                throw new ExpressionSyntaxException(I18N.Incorrect_string_length(), this);

            }

            token.set(Token.IDENTIFIER, buffer.toString());

            return token;

        case ']':

            token.set(Token.CLOSED_BRACKET, "]");

            return token;

        case '[':

            if( !this.useBracketsForIdentifiers ) {

                token.set(Token.OPEN_BRACKET, "[");

                return token;

            }

            buffer.clear();

            ch = getch();

            while( ch != ']' ) {

                if( ch == EOF ) {

                    throw new ExpressionSyntaxException(I18N.Closing_square_bracket_was_expected_and_end_of_source_was_found(), this);

                }

                buffer.add(ch);

                ch = getch();

            }

            if( buffer.length() < 1 ) {

                throw new ExpressionSyntaxException(I18N.Incorrect_identifier_length(), this);

            }

            token.set(Token.IDENTIFIER, buffer.toString());

            return token;

        case '\'':

            parseString();

            return token;

        case '@':

            ungetch();

            parseDMSNumber();

            return token;

        }

        if( Character.isDigit(ch) ) {

            ungetch();

            parseNumber();

            return token;

        }

        if( Character.isAlphabetic(ch) || ch =='$' ) {

            buffer.clear();

            while( Character.isLetterOrDigit(ch) || ch =='$' || ch == '_' ) {

                buffer.add(ch);

                ch = getch();

            }

            if( ch != EOF ) {

                ungetch();

            }

            String id = buffer.toString();

            int type = this.tokens.getOrDefault(id.toLowerCase(), Token.IDENTIFIER);

            token.set(type, id);

            return token;

        }

        token.set(Token.CHAR, Character.toString(ch), Character.toString(ch));

        return token;

    }

}