Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import org.gvsig.expressionevaluator.Compiler;

import org.gvsig.expressionevaluator.Code.Caller.Arguments;

import org.gvsig.expressionevaluator.LexicalAnalyzer;

import org.gvsig.expressionevaluator.LexicalAnalyzer.Token;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.CodeBuilder;

public class DefaultCompiler implements Compiler {

    private LexicalAnalyzer lexer;

    private CodeBuilder codeBuilder;

    //

    // https://www.postgresql.org/docs/9.1/static/functions.html

    //

    public DefaultCompiler() {

        this.lexer = new SQLLexicalAnalyzer();

        this.codeBuilder = new DefaultCodeBuilder();

    }

    @Override

    public Compiler clone() throws CloneNotSupportedException {

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

        other.lexer = lexer.clone();

        other.codeBuilder = codeBuilder.clone();

        return other;

    }

    @Override

    public void setLexicalAnalyzer(LexicalAnalyzer lexer) {

        this.lexer = lexer;

    }

    @Override

    public void setCodeBuilder(CodeBuilder codeBuilder) {

        this.codeBuilder = codeBuilder;

    }

    @Override

    public CodeBuilder getCodeBuilder() {

        return this.codeBuilder;

    }

    @Override

    public Code compileExpression(String expression) {

        this.lexer.setSource(expression);

        return parseExpression();

    }

    private Code parseExpression() {

        return parse_relational();

    }

    private Code parse_relational() {

        Code op1 = parse_not();

        Code op2;

        while( true ) {

            Token token = lexer.look();

            switch( token.getType() ) {

            case Token.OP_OR:

                lexer.next();

                op2 = parse_not();

                op1 = codeBuilder.or(op1, op2);

                break;

            case Token.OP_AND:

                lexer.next();

                op2 = parse_not();

                op1 = codeBuilder.and(op1, op2);

                break;

            default:

                return op1;

            }

        }

    }

    private Code parse_not() {

        Code op1;

        Token token = lexer.look();

        if( token.getType() == Token.OP_NOT ) {

            lexer.next();

            op1 = parse_conditional();

            op1 = codeBuilder.not(op1);

        } else {

            op1 = parse_conditional();

        }

        return op1;

    }

    private Code parse_conditional() {

        Code op1 = parse_sum();

        Code op2;

        while( true ) {

            Token token = lexer.look();

            switch( token.getType() ) {

            case Token.OP_LT:

                lexer.next();

                op2 = parse_sum();

                op1 = codeBuilder.lt(op1, op2);

                break;

            case Token.OP_GT:

                lexer.next();

                op2 = parse_sum();

                op1 = codeBuilder.gt(op1, op2);

                break;

            case Token.OP_LE:

                lexer.next();

                op2 = parse_sum();

                op1 = codeBuilder.le(op1, op2);

                break;

            case Token.OP_GE:

                lexer.next();

                op2 = parse_sum();

                op1 = codeBuilder.ge(op1, op2);

                break;

            case Token.OP_EQ:

                lexer.next();

                op2 = parse_sum();

                op1 = codeBuilder.eq(op1, op2);

                break;

            case Token.OP_NE:

                lexer.next();

                op2 = parse_sum();

                op1 = codeBuilder.ne(op1, op2);

                break;

            case Token.PRED_IS: {

                    lexer.next();

                    Token next = lexer.look();

                    if( next.getType() == Token.NOTNULL ) {

                        op1 = codeBuilder.is(op1, codeBuilder.constant(null));

                        op1 = codeBuilder.not(op1);

                    } else {

                        op2 = parse_sum();

                        op1 = codeBuilder.is(op1, op2);

                    }

                }

                break;

            case Token.ISNULL:

                lexer.next();

                op1 = codeBuilder.is(op1, codeBuilder.constant(null));

                break;

            case Token.OP_REGEXP:

                lexer.next();

                op2 = parse_sum();

                op1 = codeBuilder.regexp(op1, op2);

                break;

            case Token.PRED_LIKE:

                lexer.next();

                op2 = parse_sum();

                op1 = codeBuilder.like(op1, op2);

                break;

            case Token.PRED_ILIKE:

                lexer.next();

                op2 = parse_sum();

                op1 = codeBuilder.ilike(op1, op2);

                break;

            default:

                return op1;

            }

        }

    }

    private Code parse_sum() {

        Code op1 = parse_factor();

        Code op2;

        while( true ) {

            Token token = lexer.look();

            switch( token.getType() ) {

            case Token.OP_ADD:

                lexer.next();

                op2 = parse_factor();

                op1 = codeBuilder.add(op1, op2);

                break;

            case Token.OP_SUBST:

                lexer.next();

                op2 = parse_factor();

                op1 = codeBuilder.subst(op1, op2);

                break;

            default:

                return op1;

            }

        }

    }

    private Code parse_factor() {

        Code op1 = parse_termino();

        Code op2;

        while( true ) {

            Token token = lexer.look();

            switch( token.getType() ) {

            case Token.OP_MULT:

                lexer.next();

                op2 = parse_termino();

                op1 = codeBuilder.mult(op1, op2);

                break;

            case Token.OP_DIV:

                lexer.next();

                op2 = parse_termino();

                op1 = codeBuilder.div(op1, op2);

                break;

            case Token.OP_MOD:

                lexer.next();

                op2 = parse_termino();

                op1 = codeBuilder.mod(op1, op2);

                break;

            default:

                return op1;

            }

        }

    }

    private Code parse_termino() {

        Token token = lexer.look();

        switch( token.getType() ) {

        case Token.PARENTHESIS_OPEN: {

                lexer.next();

                Code value = parseExpression();

                Token next = lexer.next();

                if( next.getType() != Token.PARENTHESIS_CLOSE ) {

                    throw new RuntimeException();

                }

                return value;

            }

        case Token.IDENTIFIER: {

                lexer.next();

                String id = (String) token.getLiteral();

                Token next = lexer.look();

                if( next.getType() == Token.PARENTHESIS_OPEN ) {

                    lexer.next();

                    Arguments args = parseArgs();

                    next = lexer.next();

                    if( next.getType() != Token.PARENTHESIS_CLOSE ) {

                        throw new RuntimeException("Expected ')'.");

                    }

                    return codeBuilder.function(id, args);

                } else {

                    return codeBuilder.identifier(id);

                }

            }

        case Token.STRING_LITERAL:

            lexer.next();

            return codeBuilder.constant(token.getValue());

        case Token.INTEGER_LITERAL:

            lexer.next();

            return codeBuilder.constant(token.getValue());

        case Token.FLOATING_POINT_LITERAL:

            lexer.next();

            return codeBuilder.constant(token.getValue());

        case Token.NULL:

            lexer.next();

            return codeBuilder.constant(null);

        case Token.TRUE:

            lexer.next();

            return codeBuilder.constant(true);

        case Token.FALSE:

            lexer.next();

            return codeBuilder.constant(false);

        }

        return null;

    }

    private Arguments parseArgs() {

        Arguments args = null;

        while( true ) {

            Code arg = parseExpression();

            if( arg!=null ) {

                if( args == null ) {

                    args = codeBuilder.args();

                }

                ((DefaultCodeBuilder.BaseArguments)args).add(arg);

            }

            Token next = lexer.look();

            switch( next.getType() ) {

            case Token.COMA:

                lexer.next(); // Consume el ",".

                break;

            default:

                return args;

            }

        }

    }

}