// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
// --------------------------------------------------------------------------------
//
// JavaCC options. When this file is changed, run "ant compileparser" to rebuild
// the parser classes.
//
// --------------------------------------------------------------------------------
options {
    CACHE_TOKENS       = true;
    STATIC             = false;
    DEBUG_PARSER       = false;
    USER_TOKEN_MANAGER = false;
    USER_CHAR_STREAM   = true;
    ERROR_REPORTING    = true;
}

// --------------------------------------------------------------------------------
//
// Parser body.
//
// --------------------------------------------------------------------------------
PARSER_BEGIN(GroupingParser)

package com.yahoo.search.grouping.request.parser;

import java.util.List;
import java.util.LinkedList;
import com.yahoo.javacc.UnicodeUtilities;
import com.yahoo.search.grouping.request.*;

@SuppressWarnings({ "ConstantIfStatement", "UnnecessarySemicolon", "Convert2Diamond", "FinalPrivateMethod" })
public class GroupingParser {

    private static Number resolveNumber(String str) {
        if (str.indexOf('.') >= 0) {
            return Double.valueOf(str);
        }
        return Long.valueOf(str);
    }
}

PARSER_END(GroupingParser)
        
TOKEN :
{
    <INTEGER: <DECIMAL> (["l","L"])? | <HEX> (["l","L"])? | <OCTAL> (["l","L"])?> |
        <#DECIMAL: ["1"-"9"] (["0"-"9"])*> |
        <#HEX: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+> |
        <#OCTAL: "0" (["0"-"7"])*> |
    <FLOAT: (["0"-"9"])+ ("." (["0"-"9"])*)? (<EXPONENT>)? (["f","F","d","D"])?> |  
        <#EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+>
}

//
// NOTE: Whenever you add a new token, you need to also add it do the identifier() rule at the bottom of this grammar.
// NOTE: Failure to do so will cause the token image to become a reserved word. To prevent regression on this, add the
// NOTE: new token to the GroupingParserTestCase#requireThatTokenImagesAreNotReservedWords() test.
//
TOKEN :
{
    <SPACE: [" ","\n","\r","\t"]> |
    <SCOLON: ";"> |
    <COMMA: ","> |
    <DOLLAR: "$"> |
    <DOT: "."> |
    <EQ: "="> |
    <INFIX_ADD: "+"> |
    <INFIX_DIV: "/"> |
    <INFIX_MOD: "%"> |
    <INFIX_MUL: "*"> |
    <INFIX_SUB: "-"> |
    <LBRACE: "("> |
    <RBRACE: ")"> |
    <LCURLY: "{"> |
    <RCURLY: "}"> |
    <LT: "<"> |
    <GT: ">"> |
    <LBRACKET: "["> |
    <RBRACKET: "]"> |
    <INF: "inf"> |
    <NEGINF: "-inf"> |
    <STRING: ("\"" (~["\""] | "\\\"")* "\"") | 
             ("'" (~["'"] | "\\'")* "'")> |
    <ACOS: "acos"> |
    <ACOSH: "acosh"> |
    <ACCURACY: "accuracy"> |
    <ADD: "add"> |
    <ALIAS: "alias"> |
    <ALL: "all"> |
    <AND: "and"> |
    <ARRAY: "array"> |
    <AS: "as"> |
    <AT: "at"> |
    <ASIN: "asin"> |
    <ASINH: "asinh"> |
    <ATAN: "atan"> |
    <ATANH: "atanh"> |
    <ATTRIBUTE: "attribute"> |
    <AVG: "avg"> |
    <BUCKET: "bucket"> |
    <CAT: "cat"> |
    <CBRT: "cbrt"> |
    <COS: "cos"> |
    <COSH: "cosh"> |
    <COUNT: "count"> |
    <DEBUGWAIT: "debugwait"> |
    <DIV: "div"> |
    <DOCIDNSSPECIFIC: "docidnsspecific"> |
    <EACH: "each"> |
    <EXP: "exp"> |
    <FIXEDWIDTH: "fixedwidth"> |
    <FLOOR: "floor"> |
    <GROUP: "group"> |
    <HINT: "hint"> |
    <HYPOT: "hypot"> |
    <LOG: "log"> |
    <LOG1P: "log1p"> |
    <LOG10: "log10"> |
    <MATH: "math"> |
    <MAX: "max"> |
    <MD5: "md5"> |
    <MIN: "min"> |
    <MOD: "mod"> |
    <MUL: "mul"> |
    <NEG: "neg"> |
    <NORMALIZESUBJECT: "normalizesubject"> |
    <NOW: "now"> |
    <OR: "or"> |
    <ORDER: "order"> |
    <OUTPUT: "output"> |
    <POW: "pow"> |
    <PRECISION: "precision"> |
    <PREDEFINED: "predefined"> |
    <RELEVANCE: "relevance"> |
    <REVERSE: "reverse"> |
    <SIN: "sin"> |
    <SINH: "sinh"> |
    <SIZE: "size"> |
    <SORT: "sort"> |
    <INTERPOLATEDLOOKUP: "interpolatedlookup"> |
    <SQRT: "sqrt"> |
    <STDDEV: "stddev"> |
    <STRCAT: "strcat"> |
    <STRLEN: "strlen"> |
    <SUB: "sub"> |
    <SUM: "sum"> |
    <SUMMARY: "summary"> |
    <TAN: "tan"> |
    <TANH: "tanh"> |
    <TIME: "time"> |
    <TIME_DATE: "date"> |
    <TIME_DAYOFMONTH: "dayofmonth"> |
    <TIME_DAYOFWEEK: "dayofweek"> |
    <TIME_DAYOFYEAR: "dayofyear"> |
    <TIME_HOUROFDAY: "hourofday"> |
    <TIME_MINUTEOFHOUR: "minuteofhour"> |
    <TIME_MONTHOFYEAR: "monthofyear"> |
    <TIME_SECONDOFMINUTE: "secondofminute"> |
    <TIME_YEAR: "year"> |
    <TODOUBLE: "todouble"> |
    <TOLONG: "tolong"> |
    <TORAW: "toraw"> |
    <TOSTRING: "tostring"> |
    <TRUE: "true"> |
    <FALSE: "false"> |
    <UCA: "uca"> |
    <WHERE: "where"> |
    <X: "x"> |
    <XOR: "xor"> |
    <XORBIT: "xorbit"> |
    <Y: "y"> |
    <ZCURVE: "zcurve"> |
    <IDENTIFIER: ["A"-"Z","a"-"z"](["A"-"Z","a"-"z","0"-"9","_","@"])*>
}

// --------------------------------------------------------------------------------
//
// Production rules.
//
// --------------------------------------------------------------------------------

List<GroupingOperation> requestList() :
{
    List<GroupingOperation> lst = new LinkedList<GroupingOperation>();
    GroupingOperation val;
}
{
    ( space() val = root() { lst.add(val); } ( scolon() val = root() { lst.add(val); } )* <EOF> )
    { return lst;}
}

GroupingOperation request() :
{
    GroupingOperation val;
}
{
    ( space() val = root() <EOF> )
    { return val; }
}

GroupingOperation root() :
{
    String str;
    GroupingOperation ret;
}
{
    ( ret = operation(null)
      [ <WHERE> lbrace() str = where() rbrace() { GroupingOperation grp = new AllOperation();
                                                  grp.setWhere(str);
                                                  grp.addChild(ret);
                                                  ret = grp; } ] )
    { return ret; }
}

GroupingOperation operation(GroupingOperation parent) :
{
    GroupingOperation ret;
}
{
    ( ret = allOperation(parent) | ret = eachOperation(parent) )
    { return ret; }
}

GroupingOperation allOperation(GroupingOperation parent) :
{
    GroupingOperation ret;
}
{
    ( <ALL> { ret = new AllOperation(); if (parent != null) { parent.addChild(ret); } }
      lbrace() operationBody(ret) rbrace() )
    { return ret; }
}

GroupingOperation eachOperation(GroupingOperation parent) :
{
    String str;
    GroupingOperation ret;
}
{
    ( <EACH> { ret = new EachOperation(); if (parent != null) { parent.addChild(ret); } }
      lbrace() operationBody(ret) rbrace()
      [ <AS> lbrace() str = string() rbrace() { ret.setLabel(str); } ] )
    { return ret; }
}

void operationBody(GroupingOperation parent) :
{
    String str;
    Number num;
    GroupingExpression exp;
    List<GroupingExpression> lst;
}
{
    [   <GROUP>     lbrace() exp = exp(parent)                            rbrace() { parent.setGroupBy(exp); }                  ]
    ( ( <ACCURACY>  lbrace() num = number()                               rbrace() { parent.setAccuracy(num.doubleValue()); } ) |
      ( <ALIAS>     lbrace() str = identifier() comma() exp = exp(parent) rbrace() { parent.putAlias(str, exp); }             ) |
      ( <HINT>      lbrace() str = identifier()                           rbrace() { parent.addHint(str); }                   ) |
      ( <MAX>       lbrace() num = number()                               rbrace() { parent.setMax(num.intValue()); }         ) |
      ( <ORDER>     lbrace() lst = expList(parent)                        rbrace() { parent.addOrderBy(lst); }                ) |
      ( <OUTPUT>    lbrace() lst = expList(parent)                        rbrace() { parent.addOutputs(lst); }                ) |
      ( <PRECISION> lbrace() num = number()                               rbrace() { parent.setPrecision(num.intValue()); }   ) |
      ( <WHERE>     lbrace() str = where()                                rbrace() { parent.setWhere(str); }                  ) )*
    (                              operation(parent)                                                                            )*
}

String where() :
{
    StringBuilder ret = new StringBuilder();
    String str;
}
{
    ( [ <DOLLAR> { ret.append(token.image); } ] str = identifier() { ret.append(str); } )
    { return ret.toString(); }
}

List<GroupingExpression> expList(GroupingOperation grp) :
{
    GroupingExpression exp;
    List<GroupingExpression> ret = new LinkedList<GroupingExpression>();
}
{
    ( exp = exp(grp) { ret.add(exp); } ( comma() exp = exp(grp) { ret.add(exp); } )* )
    { return ret; }
}

GroupingExpression exp(GroupingOperation grp) :
{
    String str;
    boolean neg = false;
    GroupingExpression exp;
}
{
    ( [ add() | sub()                         { neg = true; } ]
      exp = expAlias(grp)                     { if (neg) { exp = new NegFunction(exp); } }
      [ <AS> lbrace() str = string() rbrace() { exp.setLabel(str); } ] )
    { return exp; }
}

GroupingExpression expAlias(GroupingOperation grp) :
{
    String str;
    GroupingExpression exp;
}
{
    ( ( <DOLLAR> str = identifier() [ eq() exp = expMath(grp) { grp.putAlias(str, exp); } ] { exp = grp.getAlias(str); } ) |
      ( exp = expMath(grp) ) )
    { return exp; }
}

GroupingExpression expMath(GroupingOperation grp) :
{
    MathResolver.Type type = MathResolver.Type.ADD;
    MathResolver math = new MathResolver();
    GroupingExpression exp;
}
{
    ( exp = value(grp) { math.push(type, exp); }
      ( ( add() { type = MathResolver.Type.ADD; } |
          div() { type = MathResolver.Type.DIV; } |
          mod() { type = MathResolver.Type.MOD; } |
          mul() { type = MathResolver.Type.MUL; } |
          sub() { type = MathResolver.Type.SUB; } ) exp = value(grp) { math.push(type, exp); } )* )
    { return math.resolve(); }
}

GroupingExpression value(GroupingOperation grp) :
{
    GroupingExpression exp;
}
{
    ( LOOKAHEAD(2)
      ( ( lbrace() exp = exp(grp) rbrace() )           |
                   exp = addFunction(grp)              |
                   exp = andFunction(grp)              |
                   exp = attributeFunction()           |
                   exp = avgExpression(grp)            |
                   exp = catFunction(grp)              |
                   exp = constantValue()               |
                   exp = countAggregator()             |
                   exp = debugWaitFunction(grp)        |
                   exp = divFunction(grp)              |
                   exp = docIdNsSpecificValue()        |
                   exp = fixedWidthFunction(grp)       |
                   exp = mathFunction(grp)             |
                   exp = maxExpression(grp)            |
                   exp = md5Function(grp)              |
                   exp = minExpression(grp)            |
                   exp = modFunction(grp)              |
                   exp = mulFunction(grp)              |
                   exp = negFunction(grp)              |
                   exp = normalizeSubjectFunction(grp) |
                   exp = nowFunction()                 |
                   exp = orFunction(grp)               |
                   exp = predefinedFunction(grp)       |
                   exp = relevanceValue()              |
                   exp = reverseFunction(grp)          |
                   exp = sizeFunction(grp)             |
                   exp = sortFunction(grp)             |
                   exp = arrayAtLookup(grp)            |
                   exp = interpolatedLookup(grp)       |
                   exp = stddevAggregator(grp)         |
                   exp = stringValue()                 |
                   exp = strCatFunction(grp)           |
                   exp = strLenFunction(grp)           |
                   exp = subFunction(grp)              |
                   exp = sumAggregator(grp)            |
                   exp = summaryValue()                |
                   exp = timeFunction(grp)             |
                   exp = toDoubleFunction(grp)         |
                   exp = toLongFunction(grp)           |
                   exp = toRawFunction(grp)            |
                   exp = toStringFunction(grp)         |
                   exp = ucaFunction(grp)              |
                   exp = xorExpression(grp)            |
                   exp = xorBitFunction(grp)           |
                   exp = zcurveFunction(grp)           ) |
      (            exp = attributeValue()              ) )
    { return exp; }
}

AddFunction addFunction(GroupingOperation grp) :
{
    List<GroupingExpression> argN = null;
    GroupingExpression arg1, arg2;
}
{
    ( <ADD> lbrace() arg1 = exp(grp) comma() arg2 = exp(grp) [ comma() argN = expList(grp) ] rbrace() )
    { if (argN == null) return new AddFunction(arg1, arg2);
      return new AddFunction(arg1, arg2, argN.toArray(new GroupingExpression[argN.size()])); }
}

AndFunction andFunction(GroupingOperation grp) :
{
    List<GroupingExpression> argN = null;
    GroupingExpression arg1, arg2;
}
{
    ( <AND> lbrace() arg1 = exp(grp) comma() arg2 = exp(grp) [ comma() argN = expList(grp) ] rbrace() )
    { if (argN == null) return new AndFunction(arg1, arg2);
      return new AndFunction(arg1, arg2, argN.toArray(new GroupingExpression[argN.size()])); }
}

AttributeValue attributeValue() :
{
    StringBuilder prefix = new StringBuilder();
    StringBuilder suffix = new StringBuilder();
    String str;
    String key = null;
    AttributeFunction keySourceAttr = null;
}
{
    ( str = identifier() { prefix.append(str); }
      ( LOOKAHEAD(2) <DOT> { prefix.append(token.image); } ( str = identifier() { prefix.append(str); } ) )*
      ( LOOKAHEAD(3)
          ( lcurly() key = string() rcurly() ) |
          ( lcurly() keySourceAttr = attributeFunction() rcurly() )
      )?
      ( <DOT> { suffix.append(token.image); } ( str = identifier() { suffix.append(str); } ) )*
    )
    {
        if (key != null) {
            return AttributeMapLookupValue.fromKey(prefix.toString(), key, suffix.toString());
        } else if (keySourceAttr != null) {
            return AttributeMapLookupValue.fromKeySourceAttribute(prefix.toString(), keySourceAttr.getAttributeName(), suffix.toString());
        } else {
            prefix.append(suffix.toString());
            return new AttributeValue(prefix.toString());
        }
    }
}

AttributeFunction attributeFunction() :
{
    AttributeValue val;
}
{
    ( <ATTRIBUTE> lbrace() val = attributeValue() rbrace() )
    { return new AttributeFunction(val.getAttributeName()); }
}

ArrayAtLookup arrayAtLookup(GroupingOperation parent) :
{
    AttributeValue val = null;
    GroupingExpression arg2 = null;
}
{
    ( <ARRAY> <DOT> <AT> lbrace() val = attributeValue() comma() arg2 = exp(parent) rbrace() )
    {
        return new ArrayAtLookup(val.getAttributeName(), arg2);
    }
}

InterpolatedLookup interpolatedLookup(GroupingOperation parent) :
{
    AttributeValue val = null;
    GroupingExpression arg2 = null;
}
{
    ( <INTERPOLATEDLOOKUP> lbrace() val = attributeValue() comma() arg2 = exp(parent) rbrace() )
    {
        return new InterpolatedLookup(val.getAttributeName(), arg2);
    }
}

GroupingExpression avgExpression(GroupingOperation grp) :
{
    List<GroupingExpression> argN = null;
    GroupingExpression arg1, arg2 = null;
}
{
    ( <AVG> lbrace() arg1 = exp(grp) [ comma() arg2 = exp(grp) [ comma() argN = expList(grp) ] ] rbrace() )
    { if (arg2 == null) return new AvgAggregator(arg1);
      if (argN == null) return new AvgFunction(arg1, arg2);
      return new AvgFunction(arg1, arg2, argN.toArray(new GroupingExpression[argN.size()])); }
}

CatFunction catFunction(GroupingOperation grp) :
{
    List<GroupingExpression> argN = null;
    GroupingExpression arg1, arg2;
}
{
    ( <CAT> lbrace() arg1 = exp(grp) comma() arg2 = exp(grp) [ comma() argN = expList(grp) ] rbrace() )
    { if (argN == null) return new CatFunction(arg1, arg2);
      return new CatFunction(arg1, arg2, argN.toArray(new GroupingExpression[argN.size()])); }
}

ConstantValue constantValue() :
{
    Number num;
}
{
    ( num = number() )
    { return num instanceof Double ? new DoubleValue((Double)num) : new LongValue((Long)num); }
}

ConstantValue constantValueSigned() :
{
    Number num;
}
{
    ( num = signedNumber() )
    { return num instanceof Double ? new DoubleValue((Double)num) : new LongValue((Long)num); }
}

InfiniteValue infiniteNegativeValue() : { }
{
    ( neginf() { return new InfiniteValue(new Infinite(true)); } )
}

InfiniteValue infinitePositiveValue() : { }
{
    ( inf() { return new InfiniteValue(new Infinite(false)); } )
}

CountAggregator countAggregator() : { }
{
    ( <COUNT> lbrace() rbrace() )
    { return new CountAggregator(); }
}

DebugWaitFunction debugWaitFunction(GroupingOperation grp) :
{
	GroupingExpression arg;
	Number waitTime;
	BooleanValue busy;
}
{   ( <DEBUGWAIT> lbrace() arg = exp(grp) comma()
                           waitTime = number() comma()
                           busy = booleanValue()
                  rbrace() )
  	{ return new DebugWaitFunction(arg, new DoubleValue(waitTime.doubleValue()), busy); }
}

DivFunction divFunction(GroupingOperation grp) :
{
    List<GroupingExpression> argN = null;
    GroupingExpression arg1, arg2;
}
{
    ( <DIV> lbrace() arg1 = exp(grp) comma() arg2 = exp(grp) [ comma() argN = expList(grp) ] rbrace() )
    { if (argN == null) return new DivFunction(arg1, arg2);
      return new DivFunction(arg1, arg2, argN.toArray(new GroupingExpression[argN.size()])); }
}

DocIdNsSpecificValue docIdNsSpecificValue() : { }
{
    ( <DOCIDNSSPECIFIC> lbrace() rbrace() )
    { return new DocIdNsSpecificValue(); }
}

FixedWidthFunction fixedWidthFunction(GroupingOperation grp) :
{
    GroupingExpression exp;
    Number num;
}
{
    ( <FIXEDWIDTH> lbrace() exp = exp(grp) comma() num = number() rbrace() )
    { return new FixedWidthFunction(exp, num); }
}

GroupingExpression maxExpression(GroupingOperation grp) :
{
    List<GroupingExpression> argN = null;
    GroupingExpression arg1, arg2 = null;
}
{
    ( <MAX> lbrace() arg1 = exp(grp) [ comma() arg2 = exp(grp) [ comma() argN = expList(grp) ] ] rbrace() )
    { if (arg2 == null) return new MaxAggregator(arg1);
      if (argN == null) return new MaxFunction(arg1, arg2);
      return new MaxFunction(arg1, arg2, argN.toArray(new GroupingExpression[argN.size()])); }
}

GroupingExpression md5Function(GroupingOperation grp) :
{
    GroupingExpression exp;
    Number num;
}
{
    ( <MD5> lbrace() exp = exp(grp) comma() num = number() rbrace() )
    { return new Md5Function(exp, num.intValue()); }
}

GroupingExpression minExpression(GroupingOperation grp) :
{
    List<GroupingExpression> argN = null;
    GroupingExpression arg1, arg2 = null;
}
{
    ( <MIN> lbrace() arg1 = exp(grp) [ comma() arg2 = exp(grp) [ comma() argN = expList(grp) ] ] rbrace() )
    { if (arg2 == null) return new MinAggregator(arg1);
      if (argN == null) return new MinFunction(arg1, arg2);
      return new MinFunction(arg1, arg2, argN.toArray(new GroupingExpression[argN.size()])); }
}

ModFunction modFunction(GroupingOperation grp) :
{
    List<GroupingExpression> argN = null;
    GroupingExpression arg1, arg2;
}
{
    ( <MOD> lbrace() arg1 = exp(grp) comma() arg2 = exp(grp) [ comma() argN = expList(grp) ] rbrace() )
    { if (argN == null) return new ModFunction(arg1, arg2);
      return new ModFunction(arg1, arg2, argN.toArray(new GroupingExpression[argN.size()])); }
}

MulFunction mulFunction(GroupingOperation grp) :
{
    List<GroupingExpression> argN = null;
    GroupingExpression arg1, arg2;
}
{
    ( <MUL> lbrace() arg1 = exp(grp) comma() arg2 = exp(grp) [ comma() argN = expList(grp) ] rbrace() )
    { if (argN == null) return new MulFunction(arg1, arg2);
      return new MulFunction(arg1, arg2, argN.toArray(new GroupingExpression[argN.size()])); }
}

NegFunction negFunction(GroupingOperation grp) :
{
    GroupingExpression exp;
}
{
    ( <NEG> lbrace() exp = exp(grp) rbrace() )
    { return new NegFunction(exp); }
}

NormalizeSubjectFunction normalizeSubjectFunction(GroupingOperation grp) :
{
    GroupingExpression exp;
}
{
    ( <NORMALIZESUBJECT> lbrace() exp = exp(grp) rbrace() )
    { return new NormalizeSubjectFunction(exp); }
}

NowFunction nowFunction() : { }
{
    ( <NOW> lbrace() rbrace() )
    { return new NowFunction(); }
}

OrFunction orFunction(GroupingOperation grp) :
{
    List<GroupingExpression> argN = null;
    GroupingExpression arg1, arg2;
}
{
    ( <OR> lbrace() arg1 = exp(grp) comma() arg2 = exp(grp) [ comma() argN = expList(grp) ] rbrace() )
    { if (argN == null) return new OrFunction(arg1, arg2);
      return new OrFunction(arg1, arg2, argN.toArray(new GroupingExpression[argN.size()])); }
}

PredefinedFunction predefinedFunction(GroupingOperation grp) :
{
    GroupingExpression exp;
    BucketResolver resolver = new BucketResolver();
}
{
    ( <PREDEFINED> lbrace() exp = exp(grp) comma()
      bucket(grp, resolver) ( comma() bucket(grp, resolver) )* rbrace() )
    { return resolver.resolve(exp); }
}

RelevanceValue relevanceValue() : { }
{
    ( <RELEVANCE> lbrace() rbrace() )
    { return new RelevanceValue(); }
}

ReverseFunction reverseFunction(GroupingOperation grp) :
{
    GroupingExpression exp;
}
{
    ( <REVERSE> lbrace() exp = exp(grp) rbrace() )
    { return new ReverseFunction(exp); }
}

SizeFunction sizeFunction(GroupingOperation grp) :
{
    GroupingExpression exp;
}
{
    ( <SIZE> lbrace() exp = exp(grp) rbrace() )
    { return new SizeFunction(exp); }
}

SortFunction sortFunction(GroupingOperation grp) :
{
    GroupingExpression exp;
}
{
    ( <SORT> lbrace() exp = exp(grp) rbrace() )
    { return new SortFunction(exp); }
}

StringValue stringValue() :
{
    String str;
}
{
    ( <STRING> { str = UnicodeUtilities.unquote(token.image); } space() )
    { return new StringValue(str); }
}

RawValue rawValue(GroupingOperation grp) :
{
    RawBuffer buffer = new RawBuffer();
}
{
    ( lcurly() byteValue(buffer) ( comma() byteValue(buffer) )* rcurly() )
    { return new RawValue(buffer); }
}

StandardDeviationAggregator stddevAggregator(GroupingOperation grp) :
{
    GroupingExpression exp;
}
{
    ( <STDDEV> lbrace() exp = exp(grp) rbrace() )
    { return new StandardDeviationAggregator(exp); }
}

StringValue stringValueUnquoted() :
{
    String str;
}
{
    ( str = string() )
    { return new StringValue(str); }
}

StrCatFunction strCatFunction(GroupingOperation grp) :
{
    List<GroupingExpression> argN = null;
    GroupingExpression arg1, arg2;
}
{
    ( <STRCAT> lbrace() arg1 = exp(grp) comma() arg2 = exp(grp) [ comma() argN = expList(grp) ] rbrace() )
    { if (argN == null) return new StrCatFunction(arg1, arg2);
      return new StrCatFunction(arg1, arg2, argN.toArray(new GroupingExpression[argN.size()])); }
}

StrLenFunction strLenFunction(GroupingOperation grp) :
{
    GroupingExpression exp;
}
{
    ( <STRLEN> lbrace() exp = exp(grp) rbrace() )
    { return new StrLenFunction(exp); }
}

SubFunction subFunction(GroupingOperation grp) :
{
    List<GroupingExpression> argN = null;
    GroupingExpression arg1, arg2;
}
{
    ( <SUB> lbrace() arg1 = exp(grp) comma() arg2 = exp(grp) [ comma() argN = expList(grp) ] rbrace() )
    { if (argN == null) return new SubFunction(arg1, arg2);
      return new SubFunction(arg1, arg2, argN.toArray(new GroupingExpression[argN.size()])); }
}

SumAggregator sumAggregator(GroupingOperation grp) :
{
    GroupingExpression exp;
}
{
    ( <SUM> lbrace() exp = exp(grp) rbrace() )
    { return new SumAggregator(exp); }
}

SummaryValue summaryValue() :
{
    String str = null;
}
{
    ( <SUMMARY> lbrace() [ str = string() ] rbrace() )
    { return str == null ? new SummaryValue() : new SummaryValue(str); }
}

FunctionNode timeFunction(GroupingOperation grp) :
{
    TimeFunctions.Type type;
    GroupingExpression exp;
}
{
    ( <TIME> <DOT> ( <TIME_DATE>           { type = TimeFunctions.Type.DATE;             } |
                     <TIME_DAYOFMONTH>     { type = TimeFunctions.Type.DAY_OF_MONTH;     } |
                     <TIME_DAYOFWEEK>      { type = TimeFunctions.Type.DAY_OF_WEEK;      } |
                     <TIME_DAYOFYEAR>      { type = TimeFunctions.Type.DAY_OF_YEAR;      } |
                     <TIME_HOUROFDAY>      { type = TimeFunctions.Type.HOUR_OF_DAY;      } |
                     <TIME_MINUTEOFHOUR>   { type = TimeFunctions.Type.MINUTE_OF_HOUR;   } |
                     <TIME_MONTHOFYEAR>    { type = TimeFunctions.Type.MONTH_OF_YEAR;    } |
                     <TIME_SECONDOFMINUTE> { type = TimeFunctions.Type.SECOND_OF_MINUTE; } |
                     <TIME_YEAR>           { type = TimeFunctions.Type.YEAR;             } )
      lbrace() exp = exp(grp) rbrace() )
    { return TimeFunctions.newInstance(type, exp); }
}

FunctionNode mathFunction(GroupingOperation grp) :
{
    GroupingExpression arg1, arg2 = null;
    MathFunctions.Function func;
}
{
    ( <MATH> <DOT> ( ( ( <POW>   { func = MathFunctions.Function.POW;   } |
                         <HYPOT> { func = MathFunctions.Function.HYPOT; } ) lbrace() arg1 = exp(grp) <COMMA>
                                                                                     arg2 = exp(grp) rbrace() ) |
                     ( ( <EXP>   { func = MathFunctions.Function.EXP;   } |
                         <LOG>   { func = MathFunctions.Function.LOG;   } |
                         <LOG1P> { func = MathFunctions.Function.LOG1P; } |
                         <LOG10> { func = MathFunctions.Function.LOG10; } |
                         <SIN>   { func = MathFunctions.Function.SIN;   } |
                         <ASIN>  { func = MathFunctions.Function.ASIN;  } |
                         <COS>   { func = MathFunctions.Function.COS;   } |
                         <ACOS>  { func = MathFunctions.Function.ACOS;  } |
                         <TAN>   { func = MathFunctions.Function.TAN;   } |
                         <ATAN>  { func = MathFunctions.Function.ATAN;  } |
                         <SQRT>  { func = MathFunctions.Function.SQRT;  } |
                         <SINH>  { func = MathFunctions.Function.SINH;  } |
                         <ASINH> { func = MathFunctions.Function.ASINH; } |
                         <COSH>  { func = MathFunctions.Function.COSH;  } |
                         <ACOSH> { func = MathFunctions.Function.ACOSH; } |
                         <TANH>  { func = MathFunctions.Function.TANH;  } |
                         <ATANH> { func = MathFunctions.Function.ATANH; } |
                         <FLOOR> { func = MathFunctions.Function.FLOOR; } |
                         <CBRT>  { func = MathFunctions.Function.CBRT;  } ) lbrace() arg1 = exp(grp) rbrace() ) ) )
    { return MathFunctions.newInstance(func, arg1, arg2); }
}

FunctionNode ucaFunction(GroupingOperation grp) :
{
    GroupingExpression arg;
    String locale;
    String strength = null;
}
{
    ( <UCA> lbrace() arg = exp(grp) comma() locale = string() [ comma() strength = string() ] rbrace() )
    { return (strength == null ? new UcaFunction(arg, locale)
                               : new UcaFunction(arg, locale, strength)); }
}

FunctionNode zcurveFunction(GroupingOperation grp) :
{
    GroupingExpression exp;
    int dim;
}
{
    ( <ZCURVE> <DOT> ( <X> { dim = 0; } | <Y> { dim = 1; } ) lbrace() exp = exp(grp) rbrace() )
    { return dim == 0 ? new ZCurveXFunction(exp) : new ZCurveYFunction(exp); }
}

ToDoubleFunction toDoubleFunction(GroupingOperation grp) :
{
    GroupingExpression exp;
}
{
    ( <TODOUBLE> lbrace() exp = exp(grp) rbrace() )
    { return new ToDoubleFunction(exp); }
}

ToLongFunction toLongFunction(GroupingOperation grp) :
{
    GroupingExpression exp;
}
{
    ( <TOLONG> lbrace() exp = exp(grp) rbrace() )
    { return new ToLongFunction(exp); }
}

ToRawFunction toRawFunction(GroupingOperation grp) :
{
    GroupingExpression exp;
}
{
    ( <TORAW> lbrace() exp = exp(grp) rbrace() )
    { return new ToRawFunction(exp); }
}


ToStringFunction toStringFunction(GroupingOperation grp) :
{
    GroupingExpression exp;
}
{
    ( <TOSTRING> lbrace() exp = exp(grp) rbrace() )
    { return new ToStringFunction(exp); }
}

GroupingExpression xorExpression(GroupingOperation grp) :
{
    List<GroupingExpression> argN = null;
    GroupingExpression arg1, arg2 = null;
}
{
    ( <XOR> lbrace() arg1 = exp(grp) [ comma() arg2 = exp(grp) [ comma() argN = expList(grp) ] ] rbrace() )
    { if (arg2 == null) return new XorAggregator(arg1);
      if (argN == null) return new XorFunction(arg1, arg2);
      return new XorFunction(arg1, arg2, argN.toArray(new GroupingExpression[argN.size()])); }
}

XorBitFunction xorBitFunction(GroupingOperation grp) :
{
    GroupingExpression exp;
    Number num;
}
{
    ( <XORBIT> lbrace() exp = exp(grp) comma() num = number() rbrace() )
    { return new XorBitFunction(exp, num.intValue()); }
}

void bucket(GroupingOperation grp, BucketResolver resolver) :
{
    ConstantValue from, to = null;
    boolean inclusiveFrom, inclusiveTo;
}
{
    ( <BUCKET> ( ( ( lbrace() | lbracket() ) { inclusiveFrom = true; } ) |
                 ( lt() { inclusiveFrom = false; } )
               )
               ( ( from = infiniteNegativeValue() | from = rawValue(grp) | from = constantValueSigned() | from = stringValueUnquoted() )
                 ( [ comma() ( to = infinitePositiveValue() | to = rawValue(grp) | to = constantValueSigned() | to = stringValueUnquoted() ) ] )
               )
               ( ( ( gt() | rbrace() ) { inclusiveTo = false; } ) |
                 ( rbracket() { inclusiveTo = true; } )
               )
    )
    { resolver.push(from, inclusiveFrom); resolver.push((to == null) ? from : to, inclusiveTo || to == null); }
}

Number signedNumber() :
{
    String str;
    boolean neg = false;
}
{
    ([ <INFIX_SUB> { neg = true; }]( <INTEGER> | <FLOAT> ) { str = neg ? "-" + token.image : token.image; } space() )
    { return resolveNumber(str); }
}


Number number() :
{
    String str;
}
{
    ( ( <INTEGER> | <FLOAT> ) { str = token.image; } space() )
    { return resolveNumber(str); }
}

BooleanValue booleanValue() :
{
    String str;
}
{
    ( ( <TRUE> | <FALSE> ) { str = token.image; } space() )
    { return new BooleanValue(Boolean.parseBoolean(str)); }
}

void byteValue(RawBuffer buffer) : { }
{
    ( ( <INTEGER> { buffer.put(Byte.parseByte(token.image)); } ) |
      ( <STRING> { buffer.put(token.image.getBytes()); } )
    )
}

String string() :
{
    String ret;
}
{
    ( ret = identifier() | ( <STRING> { ret = UnicodeUtilities.unquote(token.image); } space() ) )
    { return ret; }
}

String identifier() : 
{
    String ret;
}
{
    ( ( <ACOS> |
        <ACOSH> |
        <ACCURACY> |
        <ADD> |
        <ALIAS> |
        <ALL> |
        <AND> |
        <ARRAY> |
        <AS> |
        <AT> |
        <ASIN> |
        <ASINH> |
        <ATAN> |
        <ATANH> |
        <ATTRIBUTE> |
        <AVG> |
        <BUCKET> |
        <CAT> |
        <CBRT> |
        <COS> |
        <COSH> |
        <COUNT> |
        <DEBUGWAIT> |
        <DIV> |
        <DOCIDNSSPECIFIC> |
        <EACH> |
        <EXP> |
        <FIXEDWIDTH> |
        <FLOOR> |
        <GROUP> |
        <HINT> |
        <HYPOT> |
        <IDENTIFIER> |
        <LOG> |
        <LOG1P> |
        <LOG10> |
        <MATH> |
        <MAX> |
        <MD5> |
        <MIN> |
        <MOD> |
        <MUL> |
        <NEG> |
        <NORMALIZESUBJECT> |
        <NOW> |
        <OR> |
        <ORDER> |
        <OUTPUT> |
        <POW> |
        <PRECISION> |
        <PREDEFINED> |
        <RELEVANCE> |
        <REVERSE> |
        <SIN> |
        <SINH> |
        <SIZE> |
        <SORT> |
        <INTERPOLATEDLOOKUP> |
        <SQRT> |
        <STDDEV> |
        <STRCAT> |
        <STRLEN> |
        <SUB> |
        <SUM> |
        <SUMMARY> |
        <TAN> |
        <TANH> |
        <TIME> |
        <TIME_DATE> |
        <TIME_DAYOFMONTH> |
        <TIME_DAYOFWEEK> |
        <TIME_DAYOFYEAR> |
        <TIME_HOUROFDAY> |
        <TIME_MINUTEOFHOUR> |
        <TIME_MONTHOFYEAR> |
        <TIME_SECONDOFMINUTE> |
        <TIME_YEAR> |
        <TODOUBLE> |
        <TOLONG> |
        <TORAW> |
        <TOSTRING> |
        <TRUE> |
        <FALSE> |
        <UCA> |
        <WHERE> |
        <X> |
        <XOR> |
        <XORBIT> |
        <Y> |
        <ZCURVE> ) { ret = token.image; } space() )
    { return ret; }
}

void add() : { }
{
    ( <INFIX_ADD> space() )
}

void comma() : { }
{
    ( <COMMA> space() )
}

void div() : { }
{
    ( <INFIX_DIV> space() )
}

void eq() : { }
{
    ( <EQ> space() )
}

void lt() : { }
{
    ( <LT> space() )
}

void gt() : { }
{
    ( <GT> space() )
}

void inf() : { }
{
    ( <INF> space() )
}

void neginf() : { }
{
    ( <NEGINF> space() )
}

void lbracket() : { }
{
    ( <LBRACKET> space() )
}

void rbracket() : { }
{
    ( <RBRACKET> space() )
}

void lbrace() : { }
{
    ( <LBRACE> space() )
}

void lcurly() : { }
{
    ( <LCURLY> space() )
}

void mod() : { }
{
    ( <INFIX_MOD> space() )
}

void mul() : { }
{
    ( <INFIX_MUL> space() )
}

void rbrace() : { }
{
    ( <RBRACE> space() )
}

void rcurly() : { }
{
    ( <RCURLY> space() )
}

void sub() : { }
{
    ( <INFIX_SUB> space() )
}

void scolon() : { }
{
    ( <SCOLON> space() )
}

void space() : { }
{ 
    ( <SPACE> )*
}