Application: gvSIG desktop

/* Generated By:JavaCC: Do not edit this line. ParseException.java Version 3.0 */

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

/**

 * This exception is thrown when parse errors are encountered.

 * You can explicitly create objects of this exception type by

 * calling the method generateParseException in the generated

 * parser.

 *

 * You can modify this class to customize your error reporting

 * mechanisms so long as you retain the public fields.

 */

public @SuppressWarnings("all") class ParseException extends Exception {

  /**

   * This constructor is used by the method "generateParseException"

   * in the generated parser.  Calling this constructor generates

   * a new object of this type with the fields "currentToken",

   * "expectedTokenSequences", and "tokenImage" set.  The boolean

   * flag "specialConstructor" is also set to true to indicate that

   * this constructor was used to create this object.

   * This constructor calls its super class with the empty string

   * to force the "toString" method of parent class "Throwable" to

   * print the error message in the form:

   *     ParseException: <result of getMessage>

   */

  public ParseException(Token currentTokenVal,

                        int[][] expectedTokenSequencesVal,

                        String[] tokenImageVal

                       )

  {

    super("");

    specialConstructor = true;

    currentToken = currentTokenVal;

    expectedTokenSequences = expectedTokenSequencesVal;

    tokenImage = tokenImageVal;

  }

  /**

   * The following constructors are for use by you for whatever

   * purpose you can think of.  Constructing the exception in this

   * manner makes the exception behave in the normal way - i.e., as

   * documented in the class "Throwable".  The fields "errorToken",

   * "expectedTokenSequences", and "tokenImage" do not contain

   * relevant information.  The JavaCC generated code does not use

   * these constructors.

   */

  public ParseException() {

    super();

    specialConstructor = false;

  }

  public ParseException(String message) {

    super(message);

    specialConstructor = false;

  }

  /**

   * This variable determines which constructor was used to create

   * this object and thereby affects the semantics of the

   * "getMessage" method (see below).

   */

  protected boolean specialConstructor;

  /**

   * This is the last token that has been consumed successfully.  If

   * this object has been created due to a parse error, the token

   * followng this token will (therefore) be the first error token.

   */

  public Token currentToken;

  /**

   * Each entry in this array is an array of integers.  Each array

   * of integers represents a sequence of tokens (by their ordinal

   * values) that is expected at this point of the parse.

   */

  public int[][] expectedTokenSequences;

  /**

   * This is a reference to the "tokenImage" array of the generated

   * parser within which the parse error occurred.  This array is

   * defined in the generated ...Constants interface.

   */

  public String[] tokenImage;

  /**

   * This method has the standard behavior when this object has been

   * created using the standard constructors.  Otherwise, it uses

   * "currentToken" and "expectedTokenSequences" to generate a parse

   * error message and returns it.  If this object has been created

   * due to a parse error, and you do not catch it (it gets thrown

   * from the parser), then this method is called during the printing

   * of the final stack trace, and hence the correct error message

   * gets displayed.

   */

  public String getMessage() {

    if (!specialConstructor) {

      return super.getMessage();

    }

    StringBuffer expected = new StringBuffer();

    int maxSize = 0;

    for (int i = 0; i < expectedTokenSequences.length; i++) {

      if (maxSize < expectedTokenSequences[i].length) {

        maxSize = expectedTokenSequences[i].length;

      }

      for (int j = 0; j < expectedTokenSequences[i].length; j++) {

        expected.append(tokenImage[expectedTokenSequences[i][j]]).append(' ');

      }

      if (expectedTokenSequences[i][expectedTokenSequences[i].length - 1] != 0) {

        expected.append("...");

      }

      expected.append(eol).append("    ");

    }

    String retval = "Encountered \"";

    Token tok = currentToken.next;

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

      if (i != 0) retval += " ";

      if (tok.kind == 0) {

        retval += tokenImage[0];

        break;

      }

      retval += add_escapes(tok.image);

      tok = tok.next; 

    }

    retval += "\" at line " + currentToken.next.beginLine + ", column " + currentToken.next.beginColumn;

    retval += "." + eol;

    if (expectedTokenSequences.length == 1) {

      retval += "Was expecting:" + eol + "    ";

    } else {

      retval += "Was expecting one of:" + eol + "    ";

    }

    retval += expected.toString();

    return retval;

  }

  /**

   * The end of line string for this machine.

   */

  protected String eol = System.getProperty("line.separator", "\n");

  /**

   * Used to convert raw characters to their escaped version

   * when these raw version cannot be used as part of an ASCII

   * string literal.

   */

  protected String add_escapes(String str) {

      StringBuffer retval = new StringBuffer();

      char ch;

      for (int i = 0; i < str.length(); i++) {

        switch (str.charAt(i))

        {

           case 0 :

              continue;

           case '\b':

              retval.append("\\b");

              continue;

           case '\t':

              retval.append("\\t");

              continue;

           case '\n':

              retval.append("\\n");

              continue;

           case '\f':

              retval.append("\\f");

              continue;

           case '\r':

              retval.append("\\r");

              continue;

           case '\"':

              retval.append("\\\"");

              continue;

           case '\'':

              retval.append("\\\'");

              continue;

           case '\\':

              retval.append("\\\\");

              continue;

           default:

              if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {

                 String s = "0000" + Integer.toString(ch, 16);

                 retval.append("\\u" + s.substring(s.length() - 4, s.length()));

              } else {

                 retval.append(ch);

              }

              continue;

        }

      }

      return retval.toString();

   }

}

/**

 * JavaCC file

 */

options {

  JDK_VERSION = "1.5";

  STATIC = false;

}

PARSER_BEGIN(LabelExpressionParser)

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

import org.apache.log4j.Logger;

import com.hardcode.gdbms.engine.instruction.EvaluationException;

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

import java.io.*;

import java.util.*;

import org.gvsig.symbology.fmap.labeling.lang.Symbol;

import org.gvsig.symbology.fmap.labeling.lang.Function;

public class LabelExpressionParser {  

	private static Hashtable<String, Function> function_table = new Hashtable<String, Function>(); 

	private Hashtable<String, Symbol> symbol_table = new Hashtable<String, Symbol>();

	private Stack stack = new Stack();

	public static void addFunction(Class functionClass) {

		try {

			Function f = (Function) functionClass.newInstance();

			function_table.put(f.getName(), f);

		} catch (Exception e) {

			Logger.getLogger(LabelExpressionParser.class).error("couldn't install function '"+functionClass.getName(), e);

		};

	}

	public Object pop() {

		return stack.pop();

	}

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

           LabelExpressionParser parser = new LabelExpressionParser(System.in);

           parser.putSymbol(new Symbol(

           						"TIPNOMCALL", 

           						Symbol.DATA_TYPE_STRING,

           						ValueFactory.createValue("Yaba daba doo...")

           						)

           					); 

           parser.putSymbol(new Symbol(

           						"LONGITUD", 

           						Symbol.DATA_TYPE_FLOATING,

           						ValueFactory.createValue(4.0)

           						)

           					); 

           while (true) {

        	try {

				String[] texts = parser.LabelExpression();

				for (int i = 0; i < texts.length; i++) {

					System.out.println("Text at field "+i+": "+texts[i]);

				}

        	} catch (ParseException e) {

        		System.err.println(e.getMessage());

        		System.exit(-1);

        	}

           }

	}

	public void putSymbol(Symbol sym) {

		symbol_table.put(sym.getName(), sym);

	}

}

class LabelField {

	String text;

	int pos;

	public LabelField(String text, int pos) {

		this.text = text;

		this.pos = pos;

	}

}

class LabelFieldComparator implements Comparator<LabelField> {

	public int compare(LabelField o1, LabelField o2) {

		if (o1 != null && o2 == null) return -1;

		if (o1 == null && o2 != null) return  1;

		if (o1 == null && o2 == null) return  0;

		if (o1.pos <= o2.pos) return -1;

		else return 1;

	}

}

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 : "," >

|	< EOEXPR : ";" >

}

TOKEN : /* CONSTANTS AND IDENTIFIERS */

{

	< BOOLEAN: "true" | "false" >	

|	< 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"] >

}

TOKEN : /* LABELING TOKENS */

{

	< FIELD_IDENTIFIER: <OPEN_SQ_BRACKETS> <CHAR_STRING> <CLOSE_SQ_BRACKETS> >

}

/*

 * The grammar.

 */

/* LABEL EXPRESSION */

String[] LabelExpression() :

{

	ArrayList<String> labelFields = new ArrayList<String>();

	String f;

}

{

	f = FieldExpression() { labelFields.add(f); }

	(

		<COMMA>

		f = FieldExpression() { labelFields.add(f); }

	)*  <EOEXPR>

	{ 

		return labelFields.toArray(new String[0]);

	}

|	<EOEXPR> { return new String[0]; }

}

/* FIELD EXPRESSIONS */

String FieldExpression() :

{

	Token t;

	String value;

}

{

		Expression() { value = stack.pop().toString(); }

		( Expression() { value += stack.pop().toString(); } ) *

		{ return value; }

}

void Expression(): {}

{

	AndExpression() ( <OR> AndExpression() {

		try {

			boolean a = (Boolean) stack.pop();

			boolean b = (Boolean) stack.pop();

			stack.push(ValueFactory.createValue(a || b));

		} catch (ClassCastException ex) {

			throw new SemanticException(SemanticException.TYPE_MISMATCH);

		}

	}

	)*

}

void AndExpression() : {}

{

	EqComparisonExpression() ( <AND> EqComparisonExpression() {

		try {

			boolean a = (Boolean) stack.pop();

			boolean b = (Boolean) stack.pop();

			stack.push(new Boolean(b && a));

		} catch (ClassCastException ex) {

			throw new SemanticException(SemanticException.TYPE_MISMATCH,

				"Trying to perform logical AND with non-boolean data types");

		}

	})*

}

void EqComparisonExpression(): 

{

	Token t;

}

{

	ComparisonExpression() ( ( t = <EQ> | t = <NE> ) ComparisonExpression() {

		try {

			Object A = stack.pop();
+			Object B = stack.pop();
+			boolean aInt = A.getClass().equals(Integer.class);
+			boolean bInt = B.getClass().equals(Integer.class);
+			if (aInt &&	bInt) {
+				int a = (Integer) A;
+				int b = (Integer) B;
+				if (t.kind == EQ)
+					stack.push(new Boolean(b==a));
+				else
+					stack.push(new Boolean(b!=a));
+			} else {
+				double a = (!aInt) ? (Double) A : new Double(A.toString());
+				double b = (!bInt) ? (Double) B : new Double(B.toString());

				if (t.kind == EQ)

					stack.push(new Boolean(b==a));

				else

					stack.push(new Boolean(b!=a));

			}

		} catch (ClassCastException ex) {

			throw new SemanticException(SemanticException.TYPE_MISMATCH,

				"Trying to perform comparison '"+t.image+"' with non-numeric data types");

		}

	})*

}

void ComparisonExpression() :

{

	Token t;

}

{

	AdditiveExpression() ((t = <LT> | t = <GT> | t = <LE> | t = <GE> ) AdditiveExpression() {

		try {

			Object A = stack.pop();
+			Object B = stack.pop();
+			boolean aInt = A.getClass().equals(Integer.class);
+			boolean bInt = B.getClass().equals(Integer.class);
+			if (aInt &&	bInt) {
+				int a = (Integer) A;
+				int b = (Integer) B;
+				if (t.kind == LT)
+					stack.push(new Boolean(b < a));
+				else if (t.kind == GT)
+					stack.push(new Boolean(b > a));
+				else if (t.kind == LE)
+					stack.push(new Boolean(b <= a));
+				else if (t.kind == GE)
+					stack.push(new Boolean(b >= a));
+			} else {
+				 
+				double a = (!aInt) ? (Double) A : new Double(A.toString());
+				double b = (!bInt) ? (Double) B : new Double(B.toString());

				if (t.kind == LT)

					stack.push(new Boolean(b < a));

				else if (t.kind == GT)

					stack.push(new Boolean(b > a));

				else if (t.kind == LE)

					stack.push(new Boolean(b <= a));

				else if (t.kind == GE)

					stack.push(new Boolean(b >= a));

			}

		} catch (ClassCastException ex) {

			throw new SemanticException(SemanticException.TYPE_MISMATCH,

				"Trying to perform relational '"+t.image+"' with non-numeric data types");

		}

	})*

}

void AdditiveExpression(): 

{

	Token t;

}

{

	MultiplicativeExpression() ( ( t = <PLUS> | t = <MINUS> ) MultiplicativeExpression() {

		try {

			Object A = stack.pop();
+			Object B = stack.pop();
+			boolean aInt = A.getClass().equals(Integer.class);
+			boolean bInt = B.getClass().equals(Integer.class);
+			if (aInt &&	bInt) {
+				int a = (Integer) A;
+				int b = (Integer) B;
+				if (t.kind == PLUS)
+					stack.push(new Integer(b + a));
+				else
+					stack.push(new Integer(b - a));
+			} else {
+				 
+				double a = (!aInt) ? (Double) A : new Double(A.toString());
+				double b = (!bInt) ? (Double) B : new Double(B.toString());

				if (t.kind == PLUS)

					stack.push(new Double(b + a));

				else

					stack.push(new Double(b - a));

			}

		} catch (ClassCastException ex) {

			throw new SemanticException(SemanticException.TYPE_MISMATCH,

				"Trying to perform ADD '"+t.image+"' with non-numeric data types");

		}

	})*

}

void MultiplicativeExpression(): 

{

	Token t;

}

{

	ArithmeticUnaryExpression() ( ( t = <MULTIPLY> | t = <DIVIDE> ) ArithmeticUnaryExpression() {

		try {

			Object A = stack.pop();
+			Object B = stack.pop();
+			boolean aInt = A.getClass().equals(Integer.class);
+			boolean bInt = B.getClass().equals(Integer.class);
+			if (aInt &&	bInt) {
+				int a = (Integer) A;
+				int b = (Integer) B;
+				if (t.kind == PLUS)
+					stack.push(new Integer(b * a));
+				else
+					stack.push(new Integer(b / a));
+			} else {
+				
+				double a = (!aInt) ? (Double) A : new Double(A.toString());
+				double b = (!bInt) ? (Double) B : new Double(B.toString());

				if (t.kind == MULTIPLY)

					stack.push(new Double(b * a));

				else

					stack.push(new Double(b / a));

			}

		} catch (ClassCastException ex) {

			throw new SemanticException(SemanticException.TYPE_MISMATCH,

				"Trying to perform MULT '"+t.image+"' with non-numeric data types");

		}

	})*

}

void ArithmeticUnaryExpression(): 

{

	Token t;

}

{

	 ( t = <PLUS> | t = <MINUS> ) ArithmeticUnaryExpression() {

		try {

			Object A = stack.pop();

			if (A.getClass().equals(Integer.class)) {

				int a = (Integer) A;

				if (t.kind == PLUS)

					stack.push(new Integer(a));

				else

					stack.push(new Integer(-a));

			} else {

				double a = (Double) A;

				if (t.kind == PLUS)

					stack.push(new Double(a));

				else

					stack.push(new Double(-a));

			}

		} catch (ClassCastException ex) {

			throw new SemanticException(SemanticException.TYPE_MISMATCH,

				"Trying to perform UNARY '"+t.image+"' with non-numeric data types");

		}

	}

| BooleanUnaryExpression()

}

void BooleanUnaryExpression(): 

{

	Token t;

}

{

	 t = <NOT> ArithmeticUnaryExpression() {

		try {

			boolean a = (Boolean) stack.pop();

			stack.push(new Boolean(!a));

		} catch (ClassCastException ex) {

			throw new SemanticException(SemanticException.TYPE_MISMATCH,

				"Trying to perform UNARY '"+t.image+"' with non-numeric data types");

		}

	}

| PrimitiveExpression()

}

void PrimitiveExpression():

{

	Token t;

}

{

	Literal()

|	LOOKAHEAD(2)

	Function()

|   <OPEN_SQ_BRACKETS> t = <IDENTIFIER> <CLOSE_SQ_BRACKETS>

	{ String name = t.image.trim();  }

	{ Symbol sym = symbol_table.get(name); }

	{ if (sym == null) 

		throw new SemanticException(SemanticException.UNDEFINED_SYMBOL,

				"Symbol "+name+" undefined"); }

	{ switch (sym.getDataType()) {

		case Symbol.DATA_TYPE_INT: 

			stack.push(new Integer(((Value) sym.getValue()).toString()));

			break;

		case Symbol.DATA_TYPE_FLOATING: 

			stack.push(new Double(((Value) sym.getValue()).toString())); 

			break;

		case Symbol.DATA_TYPE_STRING:

			stack.push(((StringValue) sym.getValue()).toString());

			break;

		case Symbol.DATA_TYPE_NULL:

			stack.push(null);

			break;

		case Symbol.DATA_TYPE_BOOLEAN:

			stack.push(new Boolean(((Value) sym.getValue()).toString()));

			break;

		case Symbol.DATA_TYPE_DATE:

			stack.push(((DateValue) sym.getValue()).getValue());

			break;

		default:

		throw new SemanticException(SemanticException.TYPE_MISMATCH,

				"Unknown type for "+name);

	  }

	}

|	<OPEN_PARENTHESIS> Expression() <CLOSE_PARENTHESIS>

}

void Function():

{

	Token t;

	int argCount;

	String name;

}

{

	t = <IDENTIFIER> {name = t.image;} argCount = Arguments() 

		{ Function f = function_table.get(name); 

		  if (f == null) 

			throw new SemanticException(SemanticException.UNDEFINED_SYMBOL,

				"Symbol "+name+" undefined"); 

//		  if (sym.getSymbolType() == Symbol.SYMBOL_TYPE_FUNCTION) {

//		 	Function f = (Function) sym.getValue();

		 	if (f.getArgumentCount() != argCount) {

			 	throw new SemanticException(SemanticException.TYPE_MISMATCH,

		 	    	"Function '"+name+"' requires "+f.getArgumentCount()+", "+argCount+" were provided.");

		 	}

		 	ArrayList<Object> argList = new ArrayList<Object>();

		 	for (int i = 0; i <= argCount-1; i++) {

			 	argList.add(0, stack.pop());

		 	} 

		 	try {

		 		stack.push(f.evaluate(argList.toArray(new Object[0])));

			} catch (EvaluationException evEx) {

				throw new Error("Aquesta excepció no deuria de llançar-se així, deuria de ser una extensió de parse exception (o bé repensar-se el funcinament!!!");

			}

//	  	  } else {
+//			throw new SemanticException(SemanticException.TYPE_MISMATCH,
+//					"Tye symbol '"+name+"' is not a function");
+//	  	  }

		}

}

void Literal() : 

{

	Token t;

}

{

	t = <INTEGER> 		 { stack.push(new Integer(t.image)); }

|	t = <FLOATING_POINT> { stack.push(new Double(t.image));  }

|	t = <BOOLEAN>		 { stack.push(new Boolean(t.image)); }

|	t = <STRING> 		 { stack.push(t.image.substring(1, t.image.length()-1)); }

}

int Arguments():

{

	int argCount = 0;

}

{

	<OPEN_PARENTHESIS> ( Expression()	{ argCount++; }

	(	<COMMA> Expression() 			{ argCount++; }

	)*

	) <CLOSE_PARENTHESIS>

	{ return argCount; }

}

/* Generated By:JavaCC: Do not edit this line. Token.java Version 3.0 */

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

/**

 * Describes the input token stream.

 */

public @SuppressWarnings("all") class Token {

  /**

   * An integer that describes the kind of this token.  This numbering

   * system is determined by JavaCCParser, and a table of these numbers is

   * stored in the file ...Constants.java.

   */

  public int kind;

  /**

   * beginLine and beginColumn describe the position of the first character

   * of this token; endLine and endColumn describe the position of the

   * last character of this token.

   */

  public int beginLine, beginColumn, endLine, endColumn;

  /**

   * The string image of the token.

   */

  public String image;

  /**

   * A reference to the next regular (non-special) token from the input

   * stream.  If this is the last token from the input stream, or if the

   * token manager has not read tokens beyond this one, this field is

   * set to null.  This is true only if this token is also a regular

   * token.  Otherwise, see below for a description of the contents of

   * this field.

   */

  public Token next;

  /**

   * This field is used to access special tokens that occur prior to this

   * token, but after the immediately preceding regular (non-special) token.

   * If there are no such special tokens, this field is set to null.

   * When there are more than one such special token, this field refers

   * to the last of these special tokens, which in turn refers to the next

   * previous special token through its specialToken field, and so on

   * until the first special token (whose specialToken field is null).

   * The next fields of special tokens refer to other special tokens that

   * immediately follow it (without an intervening regular token).  If there

   * is no such token, this field is null.

   */

  public Token specialToken;

  /**

   * Returns the image.

   */

  public String toString()

  {

     return image;

  }

  /**

   * Returns a new Token object, by default. However, if you want, you

   * can create and return subclass objects based on the value of ofKind.

   * Simply add the cases to the switch for all those special cases.

   * For example, if you have a subclass of Token called IDToken that

   * you want to create if ofKind is ID, simlpy add something like :

   *

   *    case MyParserConstants.ID : return new IDToken();

   *

   * to the following switch statement. Then you can cast matchedToken

   * variable to the appropriate type and use it in your lexical actions.

   */

  public static final Token newToken(int ofKind)

  {

     switch(ofKind)

     {

       default : return new Token();

     }

  }

}

/* Generated By:JavaCC: Do not edit this line. TokenMgrError.java Version 3.0 */

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

public @SuppressWarnings("all") class TokenMgrError extends Error

{

   /*

    * Ordinals for various reasons why an Error of this type can be thrown.

    */

   /**

    * Lexical error occurred.

    */

   static final int LEXICAL_ERROR = 0;

   /**

    * An attempt was made to create a second instance of a static token manager.

    */

   static final int STATIC_LEXER_ERROR = 1;

   /**

    * Tried to change to an invalid lexical state.

    */

   static final int INVALID_LEXICAL_STATE = 2;

   /**

    * Detected (and bailed out of) an infinite loop in the token manager.

    */

   static final int LOOP_DETECTED = 3;

   /**

    * Indicates the reason why the exception is thrown. It will have

    * one of the above 4 values.

    */

   int errorCode;

   /**

    * Replaces unprintable characters by their escaped (or unicode escaped)

    * equivalents in the given string

    */

   protected static final String addEscapes(String str) {

      StringBuffer retval = new StringBuffer();

      char ch;

      for (int i = 0; i < str.length(); i++) {

        switch (str.charAt(i))

        {

           case 0 :

              continue;

           case '\b':

              retval.append("\\b");

              continue;

           case '\t':

              retval.append("\\t");

              continue;

           case '\n':

              retval.append("\\n");

              continue;

           case '\f':

              retval.append("\\f");

              continue;

           case '\r':

              retval.append("\\r");

              continue;

           case '\"':

              retval.append("\\\"");

              continue;

           case '\'':

              retval.append("\\\'");

              continue;

           case '\\':

              retval.append("\\\\");

              continue;

           default:

              if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {

                 String s = "0000" + Integer.toString(ch, 16);

                 retval.append("\\u" + s.substring(s.length() - 4, s.length()));

              } else {

                 retval.append(ch);

              }

              continue;

        }

      }

      return retval.toString();

   }

   /**

    * Returns a detailed message for the Error when it is thrown by the

    * token manager to indicate a lexical error.

    * Parameters : 

    *    EOFSeen     : indicates if EOF caused the lexical error

    *    curLexState : lexical state in which this error occurred

    *    errorLine   : line number when the error occurred

    *    errorColumn : column number when the error occurred

    *    errorAfter  : prefix that was seen before this error occurred

    *    curchar     : the offending character

    * Note: You can customize the lexical error message by modifying this method.

    */

   protected static String LexicalError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar) {

      return("Lexical error at line " +

           errorLine + ", column " +

           errorColumn + ".  Encountered: " +

           (EOFSeen ? "<EOF> " : ("\"" + addEscapes(String.valueOf(curChar)) + "\"") + " (" + (int)curChar + "), ") +

           "after : \"" + addEscapes(errorAfter) + "\"");

   }

   /**

    * You can also modify the body of this method to customize your error messages.

    * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not

    * of end-users concern, so you can return something like : 

    *

    *     "Internal Error : Please file a bug report .... "

    *

    * from this method for such cases in the release version of your parser.

    */

   public String getMessage() {

      return super.getMessage();

   }

   /*

    * Constructors of various flavors follow.

    */

   public TokenMgrError() {

   }

   public TokenMgrError(String message, int reason) {

      super(message);

      errorCode = reason;

   }

   public TokenMgrError(boolean EOFSeen, int lexState, int errorLine, int errorColumn, String errorAfter, char curChar, int reason) {

      this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason);

   }

}

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

 *

 * Copyright (C) 2005 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.parse2;

public class SemanticException extends ParseException {

	public static final int TYPE_MISMATCH = -1;

	public static final int UNDEFINED_SYMBOL = -2;

	private int type = 0;

	public SemanticException(int exceptionType) {

		this(exceptionType, "Unknown.");

	}

	public SemanticException(int exceptionType, String message) {

		super(message);

		type = exceptionType;

	}

}

/* Generated By:JavaCC: Do not edit this line. SimpleCharStream.java Version 4.0 */

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

/**

 * An implementation of interface CharStream, where the stream is assumed to

 * contain only ASCII characters (without unicode processing).

 */

public @SuppressWarnings("all") class SimpleCharStream

{

  public static final boolean staticFlag = false;

  int bufsize;

  int available;

  int tokenBegin;

  public int bufpos = -1;

  protected int bufline[];

  protected int bufcolumn[];

  protected int column = 0;

  protected int line = 1;

  protected boolean prevCharIsCR = false;

  protected boolean prevCharIsLF = false;

  protected java.io.Reader inputStream;

  protected char[] buffer;

  protected int maxNextCharInd = 0;

  protected int inBuf = 0;

  protected int tabSize = 8;

  protected void setTabSize(int i) { tabSize = i; }

  protected int getTabSize(int i) { return tabSize; }

  protected void ExpandBuff(boolean wrapAround)

  {

     char[] newbuffer = new char[bufsize + 2048];

     int newbufline[] = new int[bufsize + 2048];

     int newbufcolumn[] = new int[bufsize + 2048];

     try

     {

        if (wrapAround)

        {

           System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);

           System.arraycopy(buffer, 0, newbuffer,

                                             bufsize - tokenBegin, bufpos);

           buffer = newbuffer;

           System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);

           System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);

           bufline = newbufline;

           System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);

           System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);

           bufcolumn = newbufcolumn;

           maxNextCharInd = (bufpos += (bufsize - tokenBegin));

        }

        else

        {

           System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);

           buffer = newbuffer;

           System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);

           bufline = newbufline;

           System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);

           bufcolumn = newbufcolumn;

           maxNextCharInd = (bufpos -= tokenBegin);

        }

     }

     catch (Throwable t)

     {

        throw new Error(t.getMessage());

     }

     bufsize += 2048;

     available = bufsize;

     tokenBegin = 0;

  }

  protected void FillBuff() throws java.io.IOException

  {

     if (maxNextCharInd == available)

     {

        if (available == bufsize)

        {

           if (tokenBegin > 2048)

           {

              bufpos = maxNextCharInd = 0;

              available = tokenBegin;

           }

           else if (tokenBegin < 0)

              bufpos = maxNextCharInd = 0;

           else

              ExpandBuff(false);

        }

        else if (available > tokenBegin)

           available = bufsize;

        else if ((tokenBegin - available) < 2048)

           ExpandBuff(true);

        else

           available = tokenBegin;

     }

     int i;

     try {

        if ((i = inputStream.read(buffer, maxNextCharInd,

                                    available - maxNextCharInd)) == -1)

        {

           inputStream.close();

           throw new java.io.IOException();

        }

        else

           maxNextCharInd += i;

        return;

     }

     catch(java.io.IOException e) {

        --bufpos;

        backup(0);

        if (tokenBegin == -1)

           tokenBegin = bufpos;

        throw e;

     }

  }

  public char BeginToken() throws java.io.IOException

  {

     tokenBegin = -1;

     char c = readChar();

     tokenBegin = bufpos;

     return c;

  }

  protected void UpdateLineColumn(char c)

  {

     column++;

     if (prevCharIsLF)

     {

        prevCharIsLF = false;

        line += (column = 1);

     }

     else if (prevCharIsCR)

     {

        prevCharIsCR = false;

        if (c == '\n')

        {

           prevCharIsLF = true;

        }

        else

           line += (column = 1);

     }

     switch (c)

     {

        case '\r' :

           prevCharIsCR = true;

           break;

        case '\n' :

           prevCharIsLF = true;

           break;

        case '\t' :

           column--;

           column += (tabSize - (column % tabSize));

           break;

        default :

           break;

     }

     bufline[bufpos] = line;

     bufcolumn[bufpos] = column;

  }

  public char readChar() throws java.io.IOException

  {

     if (inBuf > 0)

     {

        --inBuf;

        if (++bufpos == bufsize)

           bufpos = 0;

        return buffer[bufpos];

     }

     if (++bufpos >= maxNextCharInd)

        FillBuff();

     char c = buffer[bufpos];

     UpdateLineColumn(c);

     return c;

  }

  /**

   * @deprecated 

   * @see #getEndColumn

   */

  public int getColumn() {

     return bufcolumn[bufpos];

  }

  /**

   * @deprecated 

   * @see #getEndLine

   */

  public int getLine() {

     return bufline[bufpos];

  }

  public int getEndColumn() {

     return bufcolumn[bufpos];

  }

  public int getEndLine() {

     return bufline[bufpos];

  }

  public int getBeginColumn() {

     return bufcolumn[tokenBegin];

  }

  public int getBeginLine() {

     return bufline[tokenBegin];

  }

  public void backup(int amount) {

    inBuf += amount;

    if ((bufpos -= amount) < 0)

       bufpos += bufsize;

  }

  public SimpleCharStream(java.io.Reader dstream, int startline,

  int startcolumn, int buffersize)

  {

    inputStream = dstream;

    line = startline;

    column = startcolumn - 1;

    available = bufsize = buffersize;

    buffer = new char[buffersize];

    bufline = new int[buffersize];

    bufcolumn = new int[buffersize];

  }

  public SimpleCharStream(java.io.Reader dstream, int startline,

                          int startcolumn)

  {

     this(dstream, startline, startcolumn, 4096);

  }

  public SimpleCharStream(java.io.Reader dstream)

  {

     this(dstream, 1, 1, 4096);

  }

  public void ReInit(java.io.Reader dstream, int startline,

  int startcolumn, int buffersize)

  {

    inputStream = dstream;

    line = startline;

    column = startcolumn - 1;

    if (buffer == null || buffersize != buffer.length)

    {

      available = bufsize = buffersize;

      buffer = new char[buffersize];

      bufline = new int[buffersize];

      bufcolumn = new int[buffersize];

    }

    prevCharIsLF = prevCharIsCR = false;

    tokenBegin = inBuf = maxNextCharInd = 0;

    bufpos = -1;

  }

  public void ReInit(java.io.Reader dstream, int startline,

                     int startcolumn)

  {

     ReInit(dstream, startline, startcolumn, 4096);

  }

  public void ReInit(java.io.Reader dstream)

  {

     ReInit(dstream, 1, 1, 4096);

  }

  public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline,

  int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException

  {

     this(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);

  }

  public SimpleCharStream(java.io.InputStream dstream, int startline,

  int startcolumn, int buffersize)

  {

     this(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);

  }

  public SimpleCharStream(java.io.InputStream dstream, String encoding, int startline,

                          int startcolumn) throws java.io.UnsupportedEncodingException

  {

     this(dstream, encoding, startline, startcolumn, 4096);

  }

  public SimpleCharStream(java.io.InputStream dstream, int startline,

                          int startcolumn)

  {

     this(dstream, startline, startcolumn, 4096);

  }

  public SimpleCharStream(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException

  {

     this(dstream, encoding, 1, 1, 4096);

  }

  public SimpleCharStream(java.io.InputStream dstream)

  {

     this(dstream, 1, 1, 4096);

  }

  public void ReInit(java.io.InputStream dstream, String encoding, int startline,

                          int startcolumn, int buffersize) throws java.io.UnsupportedEncodingException

  {

     ReInit(encoding == null ? new java.io.InputStreamReader(dstream) : new java.io.InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);

  }

  public void ReInit(java.io.InputStream dstream, int startline,

                          int startcolumn, int buffersize)

  {

     ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, buffersize);

  }

  public void ReInit(java.io.InputStream dstream, String encoding) throws java.io.UnsupportedEncodingException

  {

     ReInit(dstream, encoding, 1, 1, 4096);

  }

  public void ReInit(java.io.InputStream dstream)

  {

     ReInit(dstream, 1, 1, 4096);

  }

  public void ReInit(java.io.InputStream dstream, String encoding, int startline,

                     int startcolumn) throws java.io.UnsupportedEncodingException

  {

     ReInit(dstream, encoding, startline, startcolumn, 4096);

  }

  public void ReInit(java.io.InputStream dstream, int startline,

                     int startcolumn)

  {

     ReInit(dstream, startline, startcolumn, 4096);

  }

  public String GetImage()

  {

     if (bufpos >= tokenBegin)

        return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);

     else

        return new String(buffer, tokenBegin, bufsize - tokenBegin) +

                              new String(buffer, 0, bufpos + 1);

  }

  public char[] GetSuffix(int len)

  {

     char[] ret = new char[len];

     if ((bufpos + 1) >= len)

        System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);

     else

     {

        System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,

                                                          len - bufpos - 1);

        System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);

     }

     return ret;

  }

  public void Done()

  {

     buffer = null;

     bufline = null;

     bufcolumn = null;

  }

  /**

   * Method to adjust line and column numbers for the start of a token.

   */

  public void adjustBeginLineColumn(int newLine, int newCol)

  {

     int start = tokenBegin;

     int len;

     if (bufpos >= tokenBegin)

     {

        len = bufpos - tokenBegin + inBuf + 1;

     }

     else

     {

        len = bufsize - tokenBegin + bufpos + 1 + inBuf;

     }

     int i = 0, j = 0, k = 0;

     int nextColDiff = 0, columnDiff = 0;

     while (i < len &&

            bufline[j = start % bufsize] == bufline[k = ++start % bufsize])

     {

        bufline[j] = newLine;

        nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];

        bufcolumn[j] = newCol + columnDiff;

        columnDiff = nextColDiff;

        i++;

     } 

     if (i < len)

     {

        bufline[j] = newLine++;

        bufcolumn[j] = newCol + columnDiff;

        while (i++ < len)

        {

           if (bufline[j = start % bufsize] != bufline[++start % bufsize])

              bufline[j] = newLine++;

           else

              bufline[j] = newLine;

        }

     }

     line = bufline[j];

     column = bufcolumn[j];

  }

}