Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

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.Stack;

import org.gvsig.tools.lang.Cloneable;

public abstract class AbstractLexicalAnalyzer implements LexicalAnalyzer {

    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;

    protected Buffer buffer;

    protected DefaultToken token;

    protected Map<String, Integer> tokens;

    public AbstractLexicalAnalyzer(String source) {

        this.position = 0;

        this.source = source;

        this.states = new Stack<>();

        this.buffer = new Buffer();

        this.token = new DefaultToken();

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

        this.nfPos = new ParsePosition(0);

        this.tokens = new HashMap<>();

    }

    public AbstractLexicalAnalyzer() {

        this(null);

    }

    @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 = (DefaultToken) 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 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();

    }

    protected int getPosition() {

        return position;

    }

    protected boolean isEOF() {

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

    }

    protected void skipblanks() {

        if( isEOF() ) {

            return;

        }

        char ch = getch();

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

            ch = getch();

        }

        ungetch();

    }

    protected char getch() {

        if( this.position+1 > this.source.length() ) {

            return EOF;

        }

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

    }

    protected void ungetch() {

        this.position--;

        if( this.position < 0 ) {

            this.position = 0;

        }

    }

    protected void parseString() {

        buffer.clear();

        char ch = getch();

        while( true ) {

            if( ch == EOF ) {

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

            }

            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 parseNumber() {

        this.nfPos.setIndex(this.position);

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

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

            throw new RuntimeException("Expected a number at position " + this.nfPos.getIndex() + ".");

        }

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

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

        if( n instanceof Long || n instanceof Integer ) {

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

        } else {

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

        }

    }

}