expressionparser.jj

用applet实现很多应用小程序

      (   (~["'","\\","\n","\r"])
        | ("\\"
            ( ["n","t","b","r","f","\\","'","\""]
            | ["0"-"7"] ( ["0"-"7"] )?
            | ["0"-"3"] ["0"-"7"] ["0"-"7"]
            )
          )
      )*
      "'"
    >
}

/* identifiers */
TOKEN : {
    < QUOTED: "[" (~["]"])+ "]" >
|   < IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>)* >
|   < #LETTER:
      [
       "\u0024",
       "\u0041"-"\u005a",
       "\u005f",
       "\u0061"-"\u007a",
       "\u00c0"-"\u00d6",
       "\u00d8"-"\u00f6",
       "\u00f8"-"\u00ff",
       "\u0100"-"\u1fff",
       "\u3040"-"\u318f",
       "\u3300"-"\u337f",
       "\u3400"-"\u3d2d",
       "\u4e00"-"\u9fff",
       "\uf900"-"\ufaff"
      ]
    >
|   < #DIGIT:
      [
       "\u0030"-"\u0039",
       "\u0660"-"\u0669",
       "\u06f0"-"\u06f9",
       "\u0966"-"\u096f",
       "\u09e6"-"\u09ef",
       "\u0a66"-"\u0a6f",
       "\u0ae6"-"\u0aef",
       "\u0b66"-"\u0b6f",
       "\u0be7"-"\u0bef",
       "\u0c66"-"\u0c6f",
       "\u0ce6"-"\u0cef",
       "\u0d66"-"\u0d6f",
       "\u0e50"-"\u0e59",
       "\u0ed0"-"\u0ed9",
       "\u1040"-"\u1049"
      ]
    >
}

/* separators */
TOKEN : {
    < LPAREN: "(" >
|   < RPAREN: ")" >
}

/* operators */
TOKEN : {
  < EQ: "=" | "==" >
| < GT: ">" >
| < LT: "<" >
| < LE: "<=" >
| < GE: ">=" >
| < NE: "!=" | "<>" >
| < ADD: "+" >
| < SUB: "-" >
| < MUL: "*" >
| < DIV: "/" >
| < POW: "^" >
| < MOD: "%" >
}

  // ----------------------------------------------------------------------------
  // Grammar definitions

String Name() :
{ Token t; }
{
  t=<IDENTIFIER> { return t.image; }
}

String Quoted() :
{ Token t; }
{
  t=<QUOTED> { return t.image.substring(1,t.image.length()-1); }
}

Expression Parse() :
{ Expression e; }
{
  e=Expression() <EOF> { return e; }
| <EOF> { throw new ParseException("No expression provided"); }
}

Expression Expression() :
{ Expression e; }
{
  e=OrExpression() { return e; }
}

Expression OrExpression() :
{ Expression l, r; }
{
  l=XorExpression() ( <OR> r=XorExpression()
  {
      if ( l instanceof OrPredicate ) {
          ((OrPredicate)l).add((Predicate)r);
      } else {
          l = new OrPredicate((Predicate)l,(Predicate)r);
      }
  }
  )* { return l; }
}

Expression XorExpression() :
{ Expression l, r; }
{
  l=AndExpression() ( <XOR> r=AndExpression()
  {
      if ( l instanceof XorPredicate ) {
          ((XorPredicate)l).add((Predicate)r);
      } else {
          l = new XorPredicate((Predicate)l,(Predicate)r);
      }
  }
  )* { return l; }
}

Expression AndExpression() :
{ Expression l, r; }
{
  l=EqualityExpression() ( <AND> r=EqualityExpression()
  {
      if ( l instanceof AndPredicate ) {
          ((AndPredicate)l).add((Predicate)r);
      } else {
          l = new AndPredicate((Predicate)l,(Predicate)r);
      }
  }
  )* { return l; }
}

Expression EqualityExpression() :
{ Expression l, r; Token t; int op; }
{
  l=RelationalExpression() (
      ( t=<EQ> | t=<NE> ) r=RelationalExpression()
  {
      op = (t.kind==EQ ? ComparisonPredicate.EQ : ComparisonPredicate.NEQ);
      l = new ComparisonPredicate(op, l, r);
  }
      )* { return l; }
}

Expression RelationalExpression() :
{ Expression l, r; Token t; int op=-1; }
{
  l=AdditiveExpression() ( 
      ( t=<LT> | t=<GT> | t=<LE> | t=<GE> ) r=AdditiveExpression()
  {
      switch ( t.kind ) {
      case LT:
          op = ComparisonPredicate.LT;
          break;
      case GT:
          op = ComparisonPredicate.GT;
          break;
      case LE:
          op = ComparisonPredicate.LTEQ;
          break;
      case GE:
          op = ComparisonPredicate.GTEQ;
          break;
      }
      l = new ComparisonPredicate(op, l, r);
  }
      )* { return l; }
}

Expression AdditiveExpression() :
{ Expression l, r; Token t; int op=-1; }
{
  l=MultiplicativeExpression() (
      ( t=<ADD> | t=<SUB> | t=<MOD> ) r=MultiplicativeExpression()
  {
      switch ( t.kind ) {
      case ADD:
        op = ArithmeticExpression.ADD;
        break;
      case SUB:
        op = ArithmeticExpression.SUB;
        break;
      case MOD:
        op = ArithmeticExpression.MOD;
        break;
      }
      l = new ArithmeticExpression(op, l, r);
  }
      )* { return l; }
}

Expression MultiplicativeExpression() :
{ Expression l, r; Token t; int op=-1; }
{
  l=UnaryExpression() ( 
     ( t=<MUL> | t=<DIV> | t=<POW> ) r=UnaryExpression()
  {
      switch ( t.kind ) {
      case MUL:
        op = ArithmeticExpression.MUL;
        break;
      case DIV:
        op = ArithmeticExpression.DIV;
        break;
      case POW:
        op = ArithmeticExpression.POW;
        break;
      }
      l = new ArithmeticExpression(op, l, r);
  }
      )* { return l; }
}

Expression UnaryExpression() :
{ Expression e; Token t;}
{
    ( t=<ADD> | t=<SUB> ) e=UnaryExpression() {
    	if ( t.kind == SUB  && e instanceof NumericLiteral ) {
    	  Number n = (Number)e.get(null);
    	  if ( n instanceof Integer ) {
    	      return new NumericLiteral(-1*n.intValue());
    	  } if ( n instanceof Double ) {
    	      return new NumericLiteral(-1*n.doubleValue());
    	  } if ( n instanceof Long ) {
    	      return new NumericLiteral(-1*n.longValue());
    	  } if ( n instanceof Float ) {
    	      return new NumericLiteral(-1*n.floatValue());
    	  } else {
    	      return new ArithmeticExpression(ArithmeticExpression.MUL,
    	                                      new NumericLiteral(-1), e);
    	  }
    	} else if ( t.kind == SUB ) {
    	  return new ArithmeticExpression(ArithmeticExpression.MUL,
    	                                  new NumericLiteral(-1), e);
    	} else {
    	  return e;
    	}
    } 
|   e=UnaryExpressionNotPlusMinus() { return e; }
|   e=PrimaryExpression() { return e; }
}

Expression UnaryExpressionNotPlusMinus() :
{ Expression e; }
{
    <NOT> e=UnaryExpression() {
        if ( e instanceof NotPredicate ) {
            return ((NotPredicate)e).getPredicate();
        } else {
            if ( !(e instanceof Predicate) ) {
                throw new ParseException("Can't negate a non-predicate");
            } else {
                return new NotPredicate((Predicate)e);
            }
        }
    }
}

Expression PrimaryExpression() :
{ Expression e; }
{
    e=Literal() { return e; }
|   e=IfStatement() { return e; }
|   e=Identifier() { return e; }
|   <LPAREN> e=Expression() <RPAREN> { return e; }
}

Expression Literal() :
{ Token t; }
{
    t=<INT> { return new NumericLiteral(Integer.parseInt(t.image)); }
|   t=<LONG> { return new NumericLiteral(Long.parseLong(t.image.substring(0,t.image.length()-1))); }
|   t=<FLOAT> { return new NumericLiteral(Float.parseFloat(t.image)); }
|   t=<DOUBLE> { return new NumericLiteral(Double.parseDouble(t.image)); }
|   t=<STRING> {
		String s = unescape(t.image.substring(1, t.image.length()-1));
		return new ObjectLiteral(s); }
|   <TRUE> { return new BooleanLiteral(true); }
|   <FALSE> { return new BooleanLiteral(false); }
|   <NULL> { return new ObjectLiteral(null); }
}

Expression Identifier() :
{ String s; Function f=null; Expression e; }
{
    s=Quoted() { return new ColumnExpression(s); }
|   s=Name()
    ( <LPAREN> { f = FunctionTable.createFunction(s); }
      ( e=Expression() { f.addParameter(e); } 
        ("," e=Expression() { f.addParameter(e); } )* )?
      <RPAREN> )?
    { return f==null ? new ColumnExpression(s) : (Expression)f; }
}

Expression IfStatement() :
/*
 * The disambiguating algorithm of JavaCC automatically binds dangling
 * else's to the innermost if statement.  The LOOKAHEAD specification
 * is to tell JavaCC that we know what we are doing.
 */
{ Expression p, t, e; }
{
  <IF> p=Expression() <THEN> t=Expression() <ELSE> e=Expression()
  {
      if ( !(p instanceof Predicate) )
          throw new ParseException("IF-statement test must be a predicate");
      return new IfExpression((Predicate)p, t, e);
  }
}