Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.util.HashMap;

import java.util.Map;

import java.util.Stack;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Compiler;

import org.gvsig.expressionevaluator.LexicalAnalyzer;

import org.gvsig.expressionevaluator.LexicalAnalyzer.Token;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Callable;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.Codes;

import static org.gvsig.expressionevaluator.ExpressionBuilder.FUNCTION_DICT;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionSyntaxException;

import org.gvsig.expressionevaluator.GrammarSet;

import org.gvsig.expressionevaluator.Statement;

import org.gvsig.expressionevaluator.Statement.StatementContext;

import org.gvsig.expressionevaluator.impl.DefaultCodeBuilder.BaseCodes;

import org.gvsig.expressionevaluator.impl.DefaultCodeBuilder.BaseConstant;

import org.gvsig.expressionevaluator.impl.function.operator.NegOperator;

import org.gvsig.expressionevaluator.impl.function.programming.CodeBlockFunction;

import org.gvsig.expressionevaluator.spi.AbstractLexicalAnalyzer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultCompiler implements Compiler {

    protected static final Logger LOGGER = LoggerFactory.getLogger(DefaultCompiler.class);

    class DefaultStatementContext implements StatementContext {

        private class State {

          public String codeClassifier;

          public Map<String,Code> codes;

        }

        private State state;

        private final Stack<State> states;

        public DefaultStatementContext() {

          this.state = new State();

          this.states = new Stack<>();

        }

        @Override

        public void save_state() {

          this.trace("save_state");

          ((AbstractLexicalAnalyzer)lexer).save_state();

          this.states.push(state);

        }

        @Override

        public void restore_state() {

          ((AbstractLexicalAnalyzer)lexer).restore_state();

          state = this.states.pop();

          this.trace("restore_state");

        }

        @Override

        public void drop_state() {

          ((AbstractLexicalAnalyzer)lexer).drop_state();

          this.states.pop();

          this.trace("drop_state");

        }

        @Override

        public Compiler getCompiler() {

            return DefaultCompiler.this;

        }

        @Override

        public LexicalAnalyzer getLexicalAnalyzer() {

            return lexer;

        }

        @Override

        public void setCode(String id, Code code) {

            if( this.state.codes == null ) {

                this.state.codes = new HashMap<>();

            }

            if( !StringUtils.isBlank(this.state.codeClassifier) ) {

                if( id.contains("#") ) {

                    id = StringUtils.replace(id,"#",this.state.codeClassifier,1);

                }

            }

            this.state.codes.put(id.toUpperCase(), code);

        }

        @Override

        public Code getCode(String id) {

            if( this.state==null || this.state.codes==null ) {

                return null;

            }

            if( StringUtils.isBlank(id) ) {

                return null;

            }

            return this.state.codes.get(id.toUpperCase());

        }

        @Override

        public void setCodeClassifier(String classifier) {

            this.state.codeClassifier = classifier;

        }

        @Override

        public String getCodeClassifier() {

            return this.state.codeClassifier;

        }

        @Override

        public CodeBuilder getCodeBuilder() {

            return codeBuilder;

        }

        @Override

        public Token look_token() {

            return lexer.look();

        }

        @Override

        public Token next_token() {

            return lexer.next();

        }

        @Override

        public Code parse_expression(boolean allow_assignement) {

            return DefaultCompiler.this.parse_expression(allow_assignement);

        }

        @Override

        public Codes parse_expressions(String separator) {

            return DefaultCompiler.this.parse_expressions(separator);

        }

        @Override

        public boolean isReservedWord(String s) {

            return grammars.isReservedWord(s);

        }

        @Override

        public void trace(String msg) {

//            LexicalAnalyzer lex = this.getLexicalAnalyzer();

//            String s = StringUtils.left(lex.getSource(), lex.getPosition()) + "[*]" + StringUtils.mid(lex.getSource(), lex.getPosition(), 200);

//            if( s.length()>200 ) {

//                s = "..."+StringUtils.mid(s, lex.getPosition()-100, 200)+"...";

//            }

//            System.out.println(msg+". "+s);

        }

    }

    private boolean objectAccessSupported;

    private LexicalAnalyzer lexer;

    private CodeBuilder codeBuilder;

    private final GrammarSet grammars;

    protected ExpressionEvaluatorManager manager;

    //

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

    //

    public DefaultCompiler(ExpressionEvaluatorManager manager) {

        this.manager = manager;

        this.grammars = new DefaultGrammarSet();

        this.lexer = new SQLLexicalAnalyzer();

        this.codeBuilder = new DefaultCodeBuilder(manager);

        this.objectAccessSupported = true;

    }

    @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 LexicalAnalyzer getLexicalAnalyzer() {

        return this.lexer;

    }

    @Override

    public void setCodeBuilder(CodeBuilder codeBuilder) {

        this.codeBuilder = codeBuilder;

    }

    @Override

    public CodeBuilder getCodeBuilder() {

        return this.codeBuilder;

    }

    @Override

    public boolean isObjectAccessSupported() {

        return this.objectAccessSupported;

    }

    @Override

    public void setObjectAccessSupported(boolean objectAccessSupported) {

        this.objectAccessSupported = objectAccessSupported;

    }

    @Override

    public GrammarSet getGrammars() {

        return this.grammars;

    }

    @Override

    public Code compileExpression(String expression) {

        if( StringUtils.isBlank(expression) ) {

            return this.getCodeBuilder().constant(null);

        }

        this.lexer.setSource(expression.trim());

        Code code = parse_expression();

        if( !this.lexer.isEOF() ) {

            throw new ExpressionSyntaxException(lexer);

        }

        return code;

    }

    public Code parse_expression() {

        return this.parse_expression(true);

    }

    public Code parse_expression(boolean allow_assignement) {

        Code code = parse_relational();

        if( code != null && allow_assignement) {

            Token token = lexer.look();

            if( token.is("AS") ) {

                lexer.next();

                token = lexer.look();

                if( token.getType() != Token.IDENTIFIER ) {

                    throw new ExpressionSyntaxException(

                        I18N.An_identifier_was_expected_and_XliteralX_was_found(token.getLiteral()),

                        lexer

                    );

                }

                token = lexer.next();

                code = codeBuilder.let(token.getLiteral(),code);

            }

        }

        return code;

    }

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

                if( op2==null ) {

                    throw new ExpressionSyntaxException(I18N.Cant_recognize_the_second_operand_of_OR_operator(),lexer);

                }

                op1 = codeBuilder.or(op1, op2);

                break;

            case Token.OP_AND:

                lexer.next();

                op2 = parse_not();

                if( op2==null ) {

                    throw new ExpressionSyntaxException(I18N.Cant_recognize_the_second_operand_of_AND_operator(),lexer);

                }

                op1 = codeBuilder.and(op1, op2);

                break;

            default:

                return op1;

            }

        }

    }

    public 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;

    }

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

                if( op2==null ) {

                    throw new ExpressionSyntaxException(I18N.Cant_recognize_the_second_operand_of_LT_operator(),lexer);

                }

                op1 = codeBuilder.lt(op1, op2);

                break;

            case Token.OP_GT:

                lexer.next();

                op2 = parse_sum();

                if( op2==null ) {

                    throw new ExpressionSyntaxException(I18N.Cant_recognize_the_second_operand_of_GT_operator(),lexer);

                }

                op1 = codeBuilder.gt(op1, op2);

                break;

            case Token.OP_LE:

                lexer.next();

                op2 = parse_sum();

                if( op2==null ) {

                    throw new ExpressionSyntaxException(I18N.Cant_recognize_the_second_operand_of_LE_operator(),lexer);

                }

                op1 = codeBuilder.le(op1, op2);

                break;

            case Token.OP_GE:

                lexer.next();

                op2 = parse_sum();

                if( op2==null ) {

                    throw new ExpressionSyntaxException(I18N.Cant_recognize_the_second_operand_of_GE_operator(),lexer);

                }

                op1 = codeBuilder.ge(op1, op2);

                break;

            case Token.OP_EQ:

                lexer.next();

                op2 = parse_sum();

                if( op2==null ) {

                    token = lexer.look();

                    String tip = null;

                    switch(token.getType()) {

                        case Token.OP_GT:

                            tip = I18N.The_operator_greater_than_or_equal_is_ge();

                            break;

                        case Token.OP_LT:

                            tip = I18N.The_operator_less_than_or_equal_is_ge();

                            break;

                    }

                    throw new ExpressionSyntaxException(

                            I18N.Cant_recognize_the_second_operand_of_EQ_operator(),

                            lexer,

                            tip

                    );

                }

                op1 = codeBuilder.eq(op1, op2);

                break;

            case Token.OP_NE:

                lexer.next();

                op2 = parse_sum();

                if( op2==null ) {

                    throw new ExpressionSyntaxException(I18N.Cant_recognize_the_second_operand_of_NEQ_operator(),lexer);

                }

                op1 = codeBuilder.ne(op1, op2);

                break;

            case Token.PRED_IS: {

                    lexer.next();

                    Token next = lexer.look();

                    switch(next.getType()) {

                        case Token.NOTNULL:

                            lexer.next();

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

                            op1 = codeBuilder.not(op1);

                            break;

                        case Token.OP_NOT:

                            lexer.next();

                            next = lexer.look();

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

                                lexer.next();

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

                            } else {

                                op2 = parse_sum();

                                if( op2==null ) {

                                    throw new ExpressionSyntaxException(I18N.Cant_recognize_the_second_operand_of_IS_operator(),lexer);

                                }

                                op1 = codeBuilder.is(op1, op2);

                            }

                            op1 = codeBuilder.not(op1);

                            break;

                        case Token.NULL:

                            lexer.next();

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

                            break;

                        default:

                            op2 = parse_sum();

                            if( op2==null ) {

                                throw new ExpressionSyntaxException(I18N.Cant_recognize_the_second_operand_of_IS_operator(),lexer);

                            }

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

                if( op2==null ) {

                    throw new ExpressionSyntaxException(I18N.Cant_recognize_the_second_operand_of_REGEXP_operator(),lexer);

                }

                op1 = codeBuilder.regexp(op1, op2);

                break;

            case Token.PRED_LIKE:

                lexer.next();

                op2 = parse_sum();

                if( op2==null ) {

                    throw new ExpressionSyntaxException(I18N.Cant_recognize_the_second_operand_of_LIKE_operator(),lexer);

                }

                op1 = codeBuilder.like(op1, op2);

                break;

            case Token.PRED_ILIKE:

                lexer.next();

                op2 = parse_sum();

                if( op2==null ) {

                    throw new ExpressionSyntaxException(I18N.Cant_recognize_the_second_operand_of_ILIKE_operator(),lexer);

                }

                op1 = codeBuilder.ilike(op1, op2);

                break;

            default:

                return op1;

            }

        }

    }

    public Code parse_sum() {

        Code op1 = parse_factor();

        Code op2;

        while( true ) {

            Token token = lexer.look();

            switch( token.getType() ) {

            case Token.OP_CONCAT:

                lexer.next();

                op2 = parse_factor();

                op1 = codeBuilder.concat(op1, op2);

                break;

            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;

            }

        }

    }

    public Code parse_factor() {

        Code op1 = parse_getattr();

        Code op2;

        while( true ) {

            Token token = lexer.look();

            switch( token.getType() ) {

            case Token.OP_MULT:

                lexer.next();

                op2 = parse_getattr();

                if( op2==null ) {

                    throw new ExpressionSyntaxException(I18N.Cant_recognize_the_second_operand_of_MULT_operator(),lexer);

                }

                op1 = codeBuilder.mult(op1, op2);

                break;

            case Token.OP_DIV:

                lexer.next();

                op2 = parse_getattr();

                if( op2==null ) {

                    throw new ExpressionSyntaxException(I18N.Cant_recognize_the_second_operand_of_DIV_operator(),lexer);

                }

                op1 = codeBuilder.div(op1, op2);

                break;

            case Token.OP_MOD:

                lexer.next();

                op2 = parse_getattr();

                if( op2==null ) {

                    throw new ExpressionSyntaxException(I18N.Cant_recognize_the_second_operand_of_MOD_operator(),lexer);

                }

                op1 = codeBuilder.mod(op1, op2);

                break;

            case Token.OPEN_BRACKET:

                lexer.next();

                Code codeIndex = parse_expression();

                if( codeIndex == null ) {

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

                }

                token = lexer.look();

                if( token.getType()!=Token.CLOSED_BRACKET) {

                    throw new ExpressionSyntaxException(I18N.A_XTokenX_was_expected_and_XliteralX_was_found("]", token.getLiteral()),lexer);

                }

                lexer.next();

                Code code = codeBuilder.getitem(op1, codeIndex);

                return code;

            default:

                return op1;

            }

        }

    }

    public Code parse_getattr() {

        Code op1 = parse_termino();

        if( !isObjectAccessSupported() ) {

            return op1;

        }

        while( true ) {

            Token next = lexer.look();

            switch( next.getType() ) {

            case Token.OP_GETATTR:

                lexer.next();

                next = lexer.look();

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

                    throw new ExpressionSyntaxException(

                        I18N.An_attribute_identifier_was_expected_and_XliteralX_was_found(next.getLiteral()),

                        lexer

                    );

                }

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

                lexer.next();

                next = lexer.look();

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

                    lexer.next();

                    Codes args = parse_expressions(",");

                    next = lexer.next();

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

                        throw new ExpressionSyntaxException(

                            I18N.Closing_parenthesis_was_expected_and_XliteralX_was_found(next.getLiteral()),

                            lexer

                        );

                    }

                    op1 = codeBuilder.method(op1, id, args);

                } else {

                    op1 = codeBuilder.getattr(op1, id);

                }

                break;

            default:

                return op1;

            }

        }

    }

    @SuppressWarnings("UnusedAssignment")

    public Code parse_termino() {

        Token token = lexer.look();

        switch( token.getType() ) {

        case Token.PARENTHESIS_OPEN: {

                lexer.next();

                Code value = parse_expression();

                Token next = lexer.next();

                switch(next.getType()) {

                    case Token.PARENTHESIS_CLOSE:

                        break;

                    case Token.EOF:

                        throw new ExpressionSyntaxException(

                            I18N.Closing_parenthesis_was_expected_and_end_of_source_was_found(),

                            lexer

                        );

                    default:

                        throw new ExpressionSyntaxException(

                            I18N.Closing_parenthesis_was_expected_and_XliteralX_was_found(next.getLiteral()),

                            lexer

                        );

                }

                return value;

            }

        case Token.IDENTIFIER: {

                Code code = parse_grammars();

                if( code!=null ) {

                    return code;

                }

                if( this.grammars.isReservedWord(token.getLiteral()) ) {

                    return null;

                }

                lexer.next();

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

                Token next = lexer.look();

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

                    next = lexer.next();

                    Codes args = parse_arguments();

                    next = lexer.next();

                    switch(next.getType()) {

                        case Token.PARENTHESIS_CLOSE:

                            break;

                        case Token.EOF:

                            throw new ExpressionSyntaxException(

                                I18N.Closing_parenthesis_was_expected_and_end_of_source_was_found(),

                                lexer

                            );

                        default:

                            throw new ExpressionSyntaxException(

                                I18N.Closing_parenthesis_was_expected_and_XliteralX_was_found(next.getLiteral()),

                                lexer

                            );

                    }

                    // Optimizacion para cuando se esta invocando a la funcion dict

                    if( StringUtils.equalsIgnoreCase(id, FUNCTION_DICT) && args!=null && args.size()==1 ) {

                        code = args.get(0);

                        if( code.code()==Code.CALLABLE &&

                            StringUtils.equalsIgnoreCase(((Callable)code).name(),FUNCTION_DICT) ) {

                            return code;

                        }

                    }

                    return codeBuilder.function(id, args);

                } else {

                    if( StringUtils.equalsIgnoreCase(id, "TRUE") ) {

                        return codeBuilder.constant(true);

                    }

                    if( StringUtils.equalsIgnoreCase(id, "FALSE") ) {

                        return codeBuilder.constant(false);

                    }

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

        case Token.OP_SUBST:

            lexer.next();

            Code code = parse_termino();

            if( code.code()==Code.CONSTANT ) {

                BaseConstant c = (BaseConstant)code;

                if( c.value() instanceof Number ) {

                    c.value(NegOperator.negate((Number) c.value()));

                    return code;

                }

                throw new ExpressionSyntaxException(I18N.A_numeric_constant_was_expected_after_the_unary_operator_minus(),lexer);

            }

            return codeBuilder.negate(code);

        case Token.EOF:

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

        default:

            return parse_grammars();

        }

    }

    public Codes parse_expressions(String sep) {

        BaseCodes codes = null;

        while( true ) {

            Code code = parse_expression();

            if( code!=null ) {

                if( codes == null ) {

                    codes = (BaseCodes) codeBuilder.args();

                }

                codes.add(code);

            }

            Token next = lexer.look();

            String literal = next.getLiteral();

            if( literal == null ) {

                return codes;

            }

            literal = literal.trim();

            if( sep.equals(literal) ) {

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

            } else {

                return codes;

            }

        }

    }

    private String getKeyArgument() {

        ((AbstractLexicalAnalyzer)lexer).save_state();

        Token next = lexer.look();

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

            String key = next.getLiteral();

            lexer.next();

            next = lexer.next();

            if( next.is(":","=","=>") ) {

                ((AbstractLexicalAnalyzer)lexer).drop_state();

                return key;

            }

        }

        ((AbstractLexicalAnalyzer)lexer).restore_state();

        return null;

    }

    public Codes parse_arguments() {

        String sep = ",";

        BaseCodes codes = null;

        Map<String,Code> kwargs = null;

        while( true ) {

            String key = getKeyArgument();

            if( key == null ) {

                if( kwargs != null ) {

                    throw new ExpressionSyntaxException(I18N.nonkeyword_arg_after_keyword_arg(),lexer);

                }

                Code code = parse_expression();

                if( code!=null ) {

                    if( codes == null ) {

                        codes = (BaseCodes) codeBuilder.args();

                    }

                    codes.add(code);

                }

            } else {

                if( kwargs == null ) {

                    kwargs = new HashMap<>();

                }

                Code code = parse_expression();

                kwargs.put(key, code);

            }

            Token next = lexer.look();

            if( !next.is(sep) ) {

                break;

            }

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

        }

        if( kwargs!=null ) {

            if( codes == null ) {

                codes = (BaseCodes) codeBuilder.args();

            }

            Code code = codeBuilder.dict(kwargs);

            codes.add(code);

        }

        return codes;

    }

    private Code parse_grammars() {

        StatementContext context = new DefaultStatementContext();

        Code code;

        BaseCodes args = (BaseCodes) this.codeBuilder.args();

        context.trace("compiler.parse_gramars");

        Statement stmt = this.grammars.getApplicableStatement(context);

        while( stmt!=null ) {

            code = stmt.parse(context);

            args.add(code);

            stmt = this.grammars.getApplicableStatement(context);

        }

        switch(args.size()) {

            case 0 :

                code = null;

                break;

            case 1 :

                code = args.get(0);

                break;

            default:

                code = this.codeBuilder.function(CodeBlockFunction.NAME, args);

                break;

        }

        return code;

    }

}