Application: gvSIG desktop

package org.gvsig.expressionevaluator.spi;

import org.gvsig.expressionevaluator.LexicalAnalyzer;

import java.text.NumberFormat;

import java.text.ParsePosition;

import java.util.HashMap;

import java.util.Locale;

import java.util.Map;

import java.util.Objects;

import java.util.Stack;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionRuntimeException;

import org.gvsig.expressionevaluator.ExpressionSyntaxException;

import org.gvsig.expressionevaluator.I18N;

import org.gvsig.tools.lang.Cloneable;

public abstract class AbstractLexicalAnalyzer implements LexicalAnalyzer {

    protected class DefaultToken implements Token {

        private int type;

        private String literal;

        private Object value;

        public DefaultToken() {

        }

        @Override

        public Token clone() throws CloneNotSupportedException {

            // We will assume that the properties of the class are immutable, so 

            // it would suffice to call the super class.

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

            return other;

        }

        @Override

        public void set(int type, String literal) {

            this.set(type, literal, literal);

        }

        @Override

        public void set(int type, String literal, Object value) {

            this.literal = literal;

            this.type = type;

            this.value = value;

        }

        @Override

        public int getType() {

            return type;

        }

        @Override

        public Object getValue() {

            return value;

        }

        @Override

        public String getLiteral() {

            return literal;

        }

        @Override

        public void setLiteral(String literal) {

            this.literal = literal;

        }

        @Override

        public boolean is(String... values) {

            for (String theValue : values) {

                if( StringUtils.isBlank(literal) ) {

                    if( StringUtils.isBlank(theValue) ) {

                        return true;

                    }

                    continue;

                }

                if( StringUtils.isBlank(theValue) ) {

                    continue;

                }

                if( theValue.trim().equalsIgnoreCase(this.literal.trim()) ) {

                    return true;

                }

            }

            return false;

        }

        @Override

        public String toString() {

            return String.format("{%d,%s,%s}", this.type, Objects.toString(this.literal), Objects.toString(value));

        }

    }

    protected class Buffer implements Cloneable {

        StringBuilder builder;

        public Buffer() {

            this.builder = new StringBuilder();

        }

        @Override

        public Buffer clone() throws CloneNotSupportedException {

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

            other.builder = new StringBuilder(builder);

            return other;

        }

        public void clear() {

            builder.delete(0, builder.length());

        }

        public void add(char ch) {

            builder.append(ch);

        }

        public int length() {

            return this.builder.length();

        }

        @Override

        public String toString() {

            return this.builder.toString();

        }

    }

    protected static final char EOF = 0;

    private NumberFormat nf;

    private ParsePosition nfPos;

    private Stack<Integer> states;

    private String source;

    private int position;

    private int lineno;

    private int column;

    protected Buffer buffer;

    protected Token token;

    protected Map<String, Integer> tokens;

    protected boolean useBracketsForIdentifiers;

    public AbstractLexicalAnalyzer(String source) {

        this.useBracketsForIdentifiers = false;

        this.position = 0;

        this.source = source;

        this.states = new Stack<>();

        this.buffer = new Buffer();

        this.token = this.createToken();

        this.nf = NumberFormat.getInstance(Locale.UK);

        this.nf.setGroupingUsed(false);

        this.nfPos = new ParsePosition(0);

        this.tokens = new HashMap<>();

    }

    public AbstractLexicalAnalyzer() {

        this(null);

    }

    protected Token createToken() {

        return new DefaultToken();

    }

    @Override

    public LexicalAnalyzer clone() throws CloneNotSupportedException {

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

        other.nf = NumberFormat.getInstance(Locale.UK);

        other.nfPos = new ParsePosition(0);

        other.buffer = buffer.clone();

        other.token = token.clone();

        other.states = new Stack<>();

        other.states.addAll(states);

        other.tokens = new HashMap<>(tokens);

        return other;

    }

    @Override

    public void setSource(String source) {

        this.source = source;

        this.position = 0;

    }

    @Override

    public String getSource() {

        return this.source;

    }

    @Override

    public Token next() {

        return getToken();

    }

    @Override

    public Token look() {

        push_state();

        try {

            return getToken();

        } finally {

            pop_state();

        }

    }

    abstract protected Token getToken();

    protected void push_state() {

        this.states.push(position);

    }

    protected void pop_state() {

        position = this.states.pop();

    }

    @Override

    public int getPosition() {

        return position;

    }

    private void calcualteLineAndColumn() {

        final String s = this.source;

        int max = s.length();

        if( max > this.position ) {

            max = this.position;

        }

        int line = 1;

        int col = 0;

        for (int i = 0; i < max ; i++) {

            if( s.charAt(i)=='\n' ) {

                line++;

                col = 0;

            } 

            col++;

        }

        this.lineno = line;

        this.column = col;

    }

    @Override

    public int getLine() {

        this.calcualteLineAndColumn();

        return lineno;

    }

    @Override

    public int getColumn() {

        this.calcualteLineAndColumn();

        return column;

    }

    @Override

    public boolean isEOF() {

        return this.position >= this.source.length();

    }

    protected void skipblanks() {

        if (isEOF()) {

            return;

        }

        char ch = getch();

        while (ch != EOF && Character.isWhitespace(ch)) {

            ch = getch();

        }

        ungetch();

    }

    protected char lookch() {

        if (this.position >= this.source.length()) {

            return EOF;

        }

        return this.source.charAt(this.position);

    }

    protected char getch() {

        if (this.position >= this.source.length()) {

            return EOF;

        }

        this.column++;

        return this.source.charAt(this.position++);

    }

    protected void ungetch() {

        this.position--;

        if (this.position < 0) {

            this.position = 0;

        }

        this.column--;

        if (this.column < 0) {

            this.column = 0;

        }

    }

    protected void parseString() {

        buffer.clear();

        char ch = getch();

        while (true) {

            if (ch == EOF) {

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

            }

            if (ch == '\'') {

                ch = getch();

                if (ch == EOF) {

                    break;

                }

                if (ch != '\'') {

                    ungetch();

                    break;

                }

            }

            buffer.add(ch);

            ch = getch();

        }

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

    }

    protected void parseDMSNumber() {

        int d;

        int m;

        int s_i;

        double s_d;

        double s;

        char ch;

        Integer sign = null;

        skipblanks();

        ch = getch();

        if( ch!='@' ) {

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

        }

        // Parseamos los grados

        skipblanks();

        ch = getch();

        if( ch=='+' ) {

            sign = 1;

            ch = getch();

        } else if ( ch=='-' ) {

            sign = -1;

            ch = getch();

        }

        buffer.clear();

        if( !Character.isDigit(ch) ) {

            throw new ExpressionSyntaxException(I18N.Expected_a_number_at_position_XpositionX(this.getPosition()), this);        

        }

        while (true) {

            if (ch == EOF) {

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

            }

            if( !Character.isDigit(ch) ) {

                break;

            }

            buffer.add(ch);

            ch = getch();

        }

        if( !StringUtils.contains(" ?:", ch) ) {

            throw new ExpressionSyntaxException(I18N.Expected_XexpectedX_and_found_XfoundX(" ", String.valueOf(ch)), this);

        }

        d = Integer.parseInt(buffer.toString());

        // Parseamos los minutos

        skipblanks();

        ch = getch();

        buffer.clear();

        if( !Character.isDigit(ch) ) {

            throw new ExpressionSyntaxException(I18N.Expected_a_number_at_position_XpositionX(this.getPosition()), this);        

        }

        while (true) {

            if (ch == EOF) {

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

            }

            if( !Character.isDigit(ch) ) {

                break;

            }

            buffer.add(ch);

            ch = getch();

        }

        if( !StringUtils.contains(" ':", ch) ) {

            throw new ExpressionSyntaxException(I18N.Expected_XexpectedX_and_found_XfoundX(" ", String.valueOf(ch)), this);

        }

        m = Integer.parseInt(buffer.toString());

        // Parseamos la parte entera de los segundos

        skipblanks();

        ch = getch();

        buffer.clear();

        if( !Character.isDigit(ch) ) {

            throw new ExpressionSyntaxException(I18N.Expected_a_number_at_position_XpositionX(this.getPosition()), this);        

        }

        while (true) {

            if (ch == EOF) {

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

            }

            if( !Character.isDigit(ch) ) {

                break;

            }

            buffer.add(ch);

            ch = getch();

        }

        s_i = Integer.parseInt(buffer.toString());

        if( ch == '.' ) {

            // Parseamos la parte decimal de los segundos

            skipblanks();

            ch = getch();

            buffer.clear();

            if( !Character.isDigit(ch) ) {

                throw new ExpressionSyntaxException(I18N.Expected_a_number_at_position_XpositionX(this.getPosition()), this);        

            }

            while (true) {

                if (ch == EOF) {

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

                    break;

                }

                if( !Character.isDigit(ch) ) {

                    break;

                }

                buffer.add(ch);

                ch = getch();

            }            

            String ss = buffer.toString();

            s_d = (double) Integer.parseInt(ss) / Math.pow(10, ss.length());

        } else {

            s_d = 0;

        }

        if( ch!=EOF && !StringUtils.contains(" \"", ch) ) {

            throw new ExpressionSyntaxException(I18N.Expected_XexpectedX_and_found_XfoundX(" ", String.valueOf(ch)), this);

        }

        s = s_i + s_d; 

        double dd = d + m / 60.0 + s / 3600.0;

        if( sign==null ) {

            skipblanks();

            ch = getch();

            switch(ch) {

                case 'N':

                case 'n':

                    if( dd>90 ) {

                        throw new ExpressionSyntaxException(I18N.Incorrect_value_for_latitude(dd), this);

                    }

                    sign = 1;

                    break;

                case 'S':

                case 's':

                    if( dd>90 ) {

                        throw new ExpressionSyntaxException(I18N.Incorrect_value_for_latitude(dd), this);

                    }

                    sign = -1;

                    break;

                case 'E':

                case 'e':

                    if( dd>180 ) {

                        throw new ExpressionSyntaxException(I18N.Incorrect_value_for_latitude(dd), this);

                    }

                    sign = 1;

                    break;

                case 'O':

                case 'o':

                case 'W':

                case 'w':

                    if( dd>180 ) {

                        throw new ExpressionSyntaxException(I18N.Incorrect_value_for_longitude(dd), this);

                    }

                    sign = -1;

                    break;

                default:

                    throw new ExpressionSyntaxException(I18N.Expected_XexpectedX_and_found_XfoundX("N/S/E/W", String.valueOf(ch)), this);

            }

        } 

        dd = dd * sign;

        token.set(

                Token.FLOATING_POINT_LITERAL,

                String.format("@%s%d? %d' %f\"", sign<0? "-":"+", d,m,s) ,

                dd

        );

    }

    protected void parseNumber() {

        this.nfPos.setIndex(this.position);

        Number n = nf.parse(source, this.nfPos);

        if (this.nfPos.getIndex() == this.position) {

            throw new ExpressionRuntimeException(I18N.Expected_a_number_at_position_XpositionX(this.nfPos.getIndex()));

        }

        String literal = source.substring(this.position, this.nfPos.getIndex());

        this.position = this.nfPos.getIndex();

        if( n instanceof Long ) {

            long l = ((Long)n);

            if( l>Integer.MIN_VALUE && l<Integer.MAX_VALUE ) {

                token.set(Token.INTEGER_LITERAL, literal, (int)l);

            } else {

                token.set(Token.INTEGER_LITERAL, literal, n);

            }

        } else if( n instanceof Integer) {

            token.set(Token.INTEGER_LITERAL, literal, n);

        } else {

            token.set(Token.FLOATING_POINT_LITERAL, literal, n);

        }

    }

    @Override

    public void setUseBracketsForIdentifiers(boolean useBracketsForIdentifiers) {

        this.useBracketsForIdentifiers = useBracketsForIdentifiers;

    }

    @Override

    public boolean getUseBracketsForIdentifiers() {

        return this.useBracketsForIdentifiers;

    }

}