Application: gvSIG desktop

options{

  STATIC = false;

  LOOKAHEAD = 1;

}

PARSER_BEGIN(LabelExpressionParser)

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.symbology.fmap.labeling.parse;

import java.util.*;

import java.io.*;

import com.hardcode.gdbms.engine.values.*;

import org.gvsig.symbology.fmap.rendering.filter.operations.*;

import org.gvsig.symbology.fmap.labeling.parse.*;

import org.gvsig.symbology.fmap.labeling.lang.functions.*;

/**

 * @author Pepe Vidal Salvador - jose.vidal.salvador@iver.es

 * @author Jaume Dominguez Faus - jaume.dominguez@gmail.com

 *

 */

public class LabelExpressionParser{

	private Stack stack = new Stack();

	private static OperatorsFactory operators = OperatorsFactory.getInstance();

	private Hashtable<String, Value> symbols = new Hashtable<String, Value>();

	private ArrayList<String> classNames = new ArrayList<String>();

	public ArrayList<String> getClassNames (){

		return classNames;

	}

	public void addClassName(String name){

		for (int i = 0; i < classNames.size(); i++) {

			if(classNames.get(i).compareTo(name)==0)

				return;

		}

		classNames.add(name);

	}

	public Hashtable<String,Value> getSymbols(){

		return symbols;

	}

	public Object pop() throws ExpressionException {

		Object popObject = stack.pop();

		Object result = ((Expression)popObject).evaluate();

		if(result instanceof String) {

			return new String (result.toString());

		}

		else if (result instanceof Boolean) {

			return new Boolean (result.toString());

		}

		else if (result instanceof Double) {

			return Double.valueOf(result.toString());

		}

		else if (result instanceof Integer) {

			return Integer.valueOf(result.toString());

		}

		return null;

	}

	public Stack getStack(){

		return this.stack;

	}

	public LabelExpressionParser(StringReader reader, Hashtable<String, Value> symbolsTable) {

		this(reader);

		this.symbols = symbolsTable;

	}

	/**

	 * it is default because it is used in the unit tests

	 * but this method is not part of the public API, so

	 * don't use it!

	 */

	void putSymbol(String string, Value value){

		this.symbols.put(string,value);

	}

	public static String tokenFor(int tokenCode) {

		return tokenImage[tokenCode].replaceAll("\"", "");

	}

	public void setOperatorsFactory (OperatorsFactory opFac) {

		this.operators = opFac;

	}

        public static void main(String[]args)throws ParseException,ExpressionException{

        	LabelExpressionParser parser = new LabelExpressionParser(new StringReader("([RD_6]+3)*5;"));

        	parser.symbols.put("RD_6",ValueFactory.createValue(2));

        	operators.addOperator(IndexOfFunction.class);

        	operators.addOperator(SubstringFunction.class);

        	parser.setOperatorsFactory(operators);

        	parser.LabelExpression();

        	System.out.print(((Expression)(parser.getStack().pop())).evaluate().toString());

        }

}

PARSER_END(LabelExpressionParser)

SKIP :

{

 	" "

|	"\r"

|	"\t"

|	"\n"

}

TOKEN : /* OPERATORS */

{

	< PLUS: "+" >

|	< MINUS: "-" >

|	< MULTIPLY: "*" >

|	< DIVIDE: "/" >

|	< GT: ">" >

|	< LT: "<" >

|	< NOT: "!" >

|	< EQ: "==" >

|	< LE: "<=" >

|	< GE: ">=" >

|	< NE: "!=" >

|	< OR: "||" >

|	< AND: "&&" >

}

TOKEN : /* MISC */

{

	< #DOT: "." >

|	< OPEN_SQ_BRACKETS : "[" >

|	< CLOSE_SQ_BRACKETS : "]" >

|	< OPEN_PARENTHESIS : "(" >

|	< CLOSE_PARENTHESIS : ")" >

|	< DOUBLE_QUOTE : "\"" >

|	< COMMA : "," >

|   < EOFIELD : ":" >

|	< EOEXPR : ";" >

}

TOKEN : /* CONSTANTS AND IDENTIFIERS */

{

	< BOOLEAN: "true" | "false" >

|   < NULL: "null">

|	< IDENTIFIER: ( <LETTER> ) ( <LETTER>|<DIGIT> )* >

|	< #LETTER: ( ["_","$","%"] | ( ["a"-"z"] ) | ( ["A"-"Z"] ) |("?")|("?")|("?")|("?")|("?")|("?")|("?")|("?")|("?")|("?")|("?")|("?")|("?")|("?")|("?")|("?")) >

}

TOKEN : /* NUMBER */

{

    < #DIGIT: ["0"-"9"] >

|	< INTEGER: ( <DIGIT> )+ >

|	< FLOATING_POINT: (<DIGIT>)+ "." (<DIGIT>)* (<EXPONENT>)? (["f","F","d","D"])?

      | <DOT> (<DIGIT>)+ (<EXPONENT>)? (["f","F","d","D"])?

      | (<DIGIT>)+ <EXPONENT> (["f","F","d","D"])?

      | (<DIGIT>)+ (<EXPONENT>)? ["f","F","d","D"] >

|	< #EXPONENT: ["e","E"] (["+","-"])? (<DIGIT>)+ >

}

TOKEN: /* STRING */

{

	< STRING: ( <DOUBLE_QUOTE> ( <CHAR_STRING> )* <DOUBLE_QUOTE> )>

|	< CHAR_STRING : ~[ "\"", ";","\n","\r"] >

}

/* LABEL EXPRESSION */

//We have to use this function if we want to evaluate an String which contains different Expressions

//inside

void LabelExpression() :

{

}

{

	Expression() (

	LOOKAHEAD(2)<EOFIELD> Expression() {

			 Expression leftExpression = (Expression)stack.pop();

    		 Expression rightExpression = (Expression)stack.pop();

 			 Expression labelExpr = new LabelExpressionOperator(symbols);

 			 labelExpr.addArgument(0, rightExpression);

 			 labelExpr.addArgument(0, leftExpression);

    		stack.push(labelExpr);

	}

 	| Expression(){

            Expression leftExpression2 = (Expression)stack.pop();

    		Expression rightExpression2 = (Expression)stack.pop();

 			Expression fieldExpr = new FieldExpressionOperator(symbols);

 			fieldExpr.addArgument(0, rightExpression2);

 			fieldExpr.addArgument(0, leftExpression2);

    		stack.push(fieldExpr);

   })*

   // <EOEXPR>

//|	<EOEXPR>

}

void Expression():{}{

  AndExpression()(<OR>AndExpression(){

    Expression leftExpression = (Expression)stack.pop();

    Expression rightExpression = (Expression)stack.pop();

 	Expression orExpr = new OrOperator(symbols);

 	orExpr.addArgument(0, rightExpression);

 	orExpr.addArgument(0, leftExpression);

    stack.push(orExpr);

  }

  )*

}

void AndExpression():{

  Token x;

}

{

  EqCompExpression()((x = <AND>)EqCompExpression(){

    Expression rightExpression = (Expression)stack.pop();

    Expression leftExpression = (Expression)stack.pop();

    Expression func = new AndOperator(symbols);

    func.addArgument(0, rightExpression);

    func.addArgument(0, leftExpression);

    stack.push(func);

  }

  )*

}

void EqCompExpression():{

  Token x;

}

{

  ComparisonExpression()((x = <EQ>

  | x = <NE>)ComparisonExpression(){

    Expression rightExpression = (Expression)stack.pop();

    Expression leftExpression = (Expression)stack.pop();

    Expression func = null;

    if (x.kind == EQ)func = new EqOperator(symbols);

    else if (x.kind == NE)func = new NeOperator(symbols);

    func.addArgument(0, rightExpression);

    func.addArgument(0, leftExpression);

    stack.push(func);

  }

  )*

}

void ComparisonExpression():{

  Token x;

}

{

  AdditiveExpression()((x = <LT>

  | x = <LE>

  | x = <GT>

  | x = <GE>)AdditiveExpression(){

    Expression rightExpression = (Expression)stack.pop();

    Expression leftExpression = (Expression)stack.pop();

    Expression func = null;

    if (x.kind == LT)func = new LessThanOperator(symbols);

    else if (x.kind == LE)func = new LessThanOrEqualsOperator(symbols);

    else if (x.kind == GT)func = new GreaterThanOperator(symbols);

    else if (x.kind == GE)func = new GreaterThanOrEqualsOperator(symbols);

    func.addArgument(0, rightExpression);

    func.addArgument(0, leftExpression);

    stack.push(func);

  }

  )*

}

void AdditiveExpression():{

  Token x;

}

{

  MultiplicativeExpression()((x = <PLUS>

  | x = <MINUS>)MultiplicativeExpression(){

    Expression rightExpression = (Expression)stack.pop();

    Expression leftExpression = (Expression)stack.pop();

    Expression func = null;

    if (x.kind == PLUS)func = new AddOperator(symbols);

    else func = new MinusOperator(symbols);

    func.addArgument(0, rightExpression);

    func.addArgument(0, leftExpression);

    stack.push(func);

  }

  )*

}

//void MultiplicativeExpression():{

//  Token x;

//}

//{

//  UnaryElement()((x = <MULTIPLY>

//  | x = <DIVIDE>)UnaryElement(){

//  	try{

//  			Expression A = (Expression) stack.pop();

//			Expression B = (Expression) stack.pop();

//			 boolean aInt = (((Expression) A).evaluate() instanceof Integer);

//			 boolean bInt = (((Expression) B).evaluate() instanceof Integer);

//			if (aInt &&	bInt) {

//				int a = (Integer) A.evaluate();

//				int b = (Integer) B.evaluate();

//				if (x.kind == MULTIPLY)

//					stack.push(new NumericalConstant(new Integer(b * a),symbols));

//				else

//					stack.push(new NumericalConstant(new Integer(b / a),symbols));

//			} else {

//

//				double a = new Double(((Expression)A).evaluate().toString());

//                double b = new Double(((Expression)B).evaluate().toString());

//				if (x.kind == MULTIPLY)

//					stack.push(new NumericalConstant(new Double(b * a),symbols));

//				else

//					stack.push(new NumericalConstant(new Double(b / a),symbols));

//			}}catch (ClassCastException ex) {

//                  ex.printStackTrace();

//            } catch (ExpressionException e) {

//				  e.printStackTrace();

//			}

//

//	})*

//}

void MultiplicativeExpression():{

  Token x;

}

{

 	UnaryElement()((x = <MULTIPLY>

  	| x = <DIVIDE>)UnaryElement(){

    Expression rightExpression = (Expression)stack.pop();

    Expression leftExpression = (Expression)stack.pop();

    Expression func = null;

    if (x.kind == MULTIPLY)func = new MultOperator(symbols);

    else func = new DivOperator(symbols);

    func.addArgument(0, rightExpression);

    func.addArgument(0, leftExpression);

    stack.push(func);

  }

  )*

}

void UnaryElement():{

  Token x = null;

}

{

  (x = <PLUS>

  | x = <MINUS>)UnaryElement(){

  	      try{

                 Object A = stack.pop();

                         if ((((Expression) A).evaluate() instanceof Integer)) {

                                int a = (Integer) ((Expression) A).evaluate();

                                if (x.kind == PLUS)

                                        stack.push(new NumericalConstant(new Integer(a),symbols));

                                else

                                        stack.push(new NumericalConstant(new Integer(-a),symbols));

                        } else {

                                double a = (Double) ((Expression) A).evaluate();

                                if (x.kind == PLUS)

                                        stack.push(new NumericalConstant(new Double(a),symbols));

                                else

                                        stack.push(new NumericalConstant(new Double(-a),symbols));

                        }

                         } catch (ClassCastException ex) {

               ex.printStackTrace();

             }catch (ExpressionException ex) {

                 ex.printStackTrace();

             }

  }

  | BooleanUnaryElement()

}

void BooleanUnaryElement():

{

	Token t;

}

{

	 t = <NOT> UnaryElement() {

	 	Expression rightExpression = (Expression)stack.pop();

		Expression func = new NotOperator(symbols);

		func.addArgument(0, rightExpression);

		stack.push(func);

	}

| Element()

}

void Element():{

  Token x;

  String y =  "[$,A-Z,_,a-z]([$,A-Z,_,a-z]|[0-9])*";

}

{

  ("["x = <IDENTIFIER>"]"){

    ReplaceOperator func = new ReplaceOperator(symbols);

     func.addArgument(x.image);

   	stack.push(func);

	addClassName(x.image);

  }

  | (x = <INTEGER>){

  	NumericalConstant intC = new NumericalConstant(Integer.valueOf(x.image),symbols);

   	stack.push(intC);

  }

  | (x = <FLOATING_POINT>){

  	NumericalConstant doubleC = new NumericalConstant(Double.valueOf(x.image),symbols);

   	stack.push(doubleC);

  }

  |(x = <STRING>) {

    StringConstant stringValue = new StringConstant(x.image.substring(1, x.image.length()-1),symbols);

    stack.push(stringValue);

  }

  | (x = <BOOLEAN>){

    BooleanConstant boolValue = new BooleanConstant(x.image,symbols);

    stack.push(boolValue);

  }

  | x = <NULL>{

  	NullConstant nullValue = new NullConstant(symbols);

    stack.push(nullValue);

  }

  | LOOKAHEAD(2)function()

  | "("Expression()")"

}

void function():{

  String functionName;

  int argCount = 0;

  Expression function;

  Token x;

}

{

 LOOKAHEAD(2)

  <IDENTIFIER>{

    functionName = token.image;

  }

  argCount = Arguments(){

    try {

    	function = (Expression) operators.functions.get(functionName).getConstructor(new Class[] { Hashtable.class }).newInstance( new Hashtable<String, Value>());

    }

    catch (Exception e){

      throw new ParseException("Problem with function '"+functionName+"': "+e.toString());

    }

    if (function == null)throw new ParseException("Nonexisting function name '"+functionName+"'");

    for (int i = 0;

    i<argCount;

    i++){

      Expression arg = (Expression)stack.pop();

      function.addArgument(0, arg);

    }

    stack.push(function);

  }

  |(x = <IDENTIFIER>){

    StringConstant stringValue = new StringConstant(x.image,symbols);

    stack.push(stringValue);

  }

}

int Arguments():{

  int argCount = 0;

}

{

  <OPEN_PARENTHESIS>[argCount = ArgumentList()]<CLOSE_PARENTHESIS>{

    return argCount;

  }

}

int ArgumentList():{

  int argCount = 0;

}

{

  Expression(){

    argCount++;

  }

  (<COMMA>Expression(){

    argCount++;

  }

  )*{

    return argCount;

  }

}