Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

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;

    }

    @Override

    protected Token getToken() {

        skipblanks();

        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 '=':

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

            return token;

        case '<':

            ch = getch();

            switch( ch ) {

            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();

            if( ch == '=' ) {

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

                return token;

            }

            ungetch();

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

            return token;

        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 '+':

            ch = getch();

            if( !Character.isDigit(ch) ) {

                ungetch();

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

                return token;

            }

            ungetch();

            parseNumber();

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

            return token;

        case '-':

            ch = getch();

            if( ch=='>' ) {

                // SQL Extension to access object methods and attributes

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

                return token;

            }

            if( Character.isDigit(ch) ) {

                ungetch();

                ungetch();

                parseNumber();

                return token;

            }

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

            return token;

        case '"':

            buffer.clear();

            ch = getch();

            while( ch != '"' ) {

                if( ch == EOF ) {

                    throw new RuntimeException("Found end of source and expected end of string");

                }

                buffer.add(ch);

                ch = getch();

            }

            if( buffer.length() < 1 ) {

                throw new RuntimeException();

            }

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

            return token;

        case '[':

            buffer.clear();

            ch = getch();

            while( ch != ']' ) {

                if( ch == EOF ) {

                    throw new RuntimeException("Found end of source and expected end of string");

                }

                buffer.add(ch);

                ch = getch();

            }

            if( buffer.length() < 1 ) {

                throw new RuntimeException();

            }

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

            return token;

        case '\'':

            parseString();

            return token;

        }

        if( Character.isDigit(ch) ) {

            ungetch();

            parseNumber();

            return token;

        }

        if( Character.isAlphabetic(ch) ) {

            buffer.clear();

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

                buffer.add(ch);

                ch = getch();

            }

            ungetch();

            String id = buffer.toString();

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

            token.set(type, id);

            return token;

        }

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

        return token;

    }

}