fmparser.java

freemaker安装软件

                  plus = false;
        break;
      default:
        jj_la1[4] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      rhs = MultiplicativeExpression();
         if (plus) {
           // plus is treated separately, since it is also
           // used for concatenation.
             result = new AddConcatExpression(lhs, rhs);
         }
         else {
             numberLiteralOnly(lhs);
             numberLiteralOnly(rhs);
             result = new ArithmeticExpression(lhs,
                                            rhs,
                                            ArithmeticExpression.SUBSTRACTION);
         }
         result.setLocation(template, lhs, rhs);
         lhs = result;
    }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

/**
 * A unary expression followed by zero or more
 * unary expressions with operators in between.
 */
  final public Expression MultiplicativeExpression() throws ParseException {
   Expression lhs, rhs, result;
   int operation = ArithmeticExpression.MULTIPLICATION;
    lhs = UnaryExpression();
                          result = lhs;
    label_4:
    while (true) {
      if (jj_2_3(2147483647)) {
        ;
      } else {
        break label_4;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TIMES:
        jj_consume_token(TIMES);
                  operation = ArithmeticExpression.MULTIPLICATION;
        break;
      case DIVIDE:
        jj_consume_token(DIVIDE);
                   operation = ArithmeticExpression.DIVISION;
        break;
      case PERCENT:
        jj_consume_token(PERCENT);
                   operation = ArithmeticExpression.MODULUS;
        break;
      default:
        jj_la1[5] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      rhs = UnaryExpression();
         numberLiteralOnly(lhs);
         numberLiteralOnly(rhs);
         result = new ArithmeticExpression(lhs, rhs, operation);
         result.setLocation(template, lhs, rhs);
         lhs = result;
    }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public Expression EqualityExpression() throws ParseException {
   Expression lhs, rhs, result;
   Token t;
    lhs = RelationalExpression();
                               result = lhs;
    if (jj_2_4(2147483647)) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NOT_EQUALS:
        t = jj_consume_token(NOT_EQUALS);
        break;
      case EQUALS:
        t = jj_consume_token(EQUALS);
        break;
      case DOUBLE_EQUALS:
        t = jj_consume_token(DOUBLE_EQUALS);
        break;
      default:
        jj_la1[6] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      rhs = RelationalExpression();
        notHashLiteral(lhs, "scalar");
        notHashLiteral(rhs, "scalar");
        notListLiteral(lhs, "scalar");
        notListLiteral(rhs, "scalar");
        result = new ComparisonExpression(lhs, rhs, t.image);
        result.setLocation(template, lhs, rhs);
    } else {
      ;
    }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public Expression RelationalExpression() throws ParseException {
   Expression lhs, rhs, result;
   Token t;
    lhs = RangeExpression();
                          result = lhs;
    if (jj_2_5(2147483647)) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NATURAL_GTE:
        t = jj_consume_token(NATURAL_GTE);
        break;
      case ESCAPED_GTE:
        t = jj_consume_token(ESCAPED_GTE);
        break;
      case NATURAL_GT:
        t = jj_consume_token(NATURAL_GT);
        break;
      case ESCAPED_GT:
        t = jj_consume_token(ESCAPED_GT);
        break;
      case LESS_THAN_EQUALS:
        t = jj_consume_token(LESS_THAN_EQUALS);
        break;
      case LESS_THAN:
        t = jj_consume_token(LESS_THAN);
        break;
      default:
        jj_la1[7] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      rhs = RangeExpression();
        notHashLiteral(lhs, "scalar");
        notHashLiteral(rhs, "scalar");
        notListLiteral(lhs, "scalar");
        notListLiteral(rhs, "scalar");
        notStringLiteral(lhs, "number");
        notStringLiteral(rhs, "number");
        result = new ComparisonExpression(lhs, rhs, t.image);
        result.setLocation(template, lhs, rhs);
    } else {
      ;
    }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public Expression RangeExpression() throws ParseException {
   Expression lhs, rhs=null, result;
    lhs = AdditiveExpression();
                              result = lhs;
    if (jj_2_7(2147483647)) {
      jj_consume_token(DOT_DOT);
      if (jj_2_6(2147483647)) {
        rhs = AdditiveExpression();
      } else {
        ;
      }
           numberLiteralOnly(lhs);
           if (rhs != null) {
               numberLiteralOnly(rhs);
           }
           Range range = new Range(lhs, rhs);
           if (rhs != null) {
               range.setLocation(template, lhs, rhs);
           } else {
              range.setLocation(template, lhs, lhs);
           }
           result = range;
    } else {
      ;
    }
        {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public Expression AndExpression() throws ParseException {
   Expression lhs, rhs, result;
    lhs = EqualityExpression();
                             result = lhs;
    label_5:
    while (true) {
      if (jj_2_8(2147483647)) {
        ;
      } else {
        break label_5;
      }
      jj_consume_token(AND);
      rhs = EqualityExpression();
         booleanLiteralOnly(lhs);
         booleanLiteralOnly(rhs);
         result = new AndExpression(lhs, rhs);
         result.setLocation(template, lhs, rhs);
         lhs = result;
    }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public Expression OrExpression() throws ParseException {
   Expression lhs, rhs, result;
    lhs = AndExpression();
                        result = lhs;
    label_6:
    while (true) {
      if (jj_2_9(2147483647)) {
        ;
      } else {
        break label_6;
      }
      jj_consume_token(OR);
      rhs = AndExpression();
         booleanLiteralOnly(lhs);
         booleanLiteralOnly(rhs);
         result = new OrExpression(lhs, rhs);
         result.setLocation(template, lhs, rhs);
         lhs = result;
    }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public ListLiteral ListLiteral() throws ParseException {
   ArrayList values = new ArrayList();
   Token begin, end;
    begin = jj_consume_token(OPEN_BRACKET);
    values = PositionalArgs();
    end = jj_consume_token(CLOSE_BRACKET);
        ListLiteral result = new ListLiteral(values);
        result.setLocation(template, begin, end);
        {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public Expression NumberLiteral() throws ParseException {
   Token op = null, t;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case INTEGER:
      t = jj_consume_token(INTEGER);
      break;
    case DECIMAL:
      t = jj_consume_token(DECIMAL);
      break;
    default:
      jj_la1[8] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
       String s = t.image;
       Expression result = new NumberLiteral(template.getArithmeticEngine().toNumber(s));
       Token startToken = (op != null) ? op : t;
       result.setLocation(template, startToken, t);
       {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public Identifier Identifier() throws ParseException {
    Token t;
    t = jj_consume_token(ID);
        Identifier id = new Identifier(t.image);
        id.setLocation(template, t, t);
        {if (true) return id;}
    throw new Error("Missing return statement in function");
  }

  final public Expression IdentifierOrStringLiteral() throws ParseException {
   Expression exp;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ID:
      exp = Identifier();
      break;
    case STRING_LITERAL:
    case RAW_STRING:
      exp = StringLiteral(false);
      break;
    default:
      jj_la1[9] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
      {if (true) return exp;}
    throw new Error("Missing return statement in function");
  }

  final public BuiltinVariable BuiltinVariable() throws ParseException {
   Token dot, name;
    dot = jj_consume_token(DOT);
    name = jj_consume_token(ID);
      BuiltinVariable result = null;
      try {
          result = new BuiltinVariable(name.image);
      } catch (ParseException pe) {
          pe.lineNumber = dot.beginLine;
          pe.columnNumber = dot.beginColumn;
          {if (true) throw pe;}
      }
      result.setLocation(template, dot, name);
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

/**
 * Production that builds up an expression
 * using the dot or dynamic key name
 * or the args list if this is a method invocation.
 */
  final public Expression AddSubExpression(Expression exp) throws ParseException {
   Expression result = null;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case DOT:
      result = DotVariable(exp);
      break;
    case OPEN_BRACKET:
      result = DynamicKey(exp);
      break;
    case OPEN_PAREN:
      result = MethodArgs(exp);
      break;
    case BUILT_IN:
      result = BuiltIn(exp);
      break;
    case EXCLAM:
      result = DefaultTo(exp);
      break;
    case EXISTS:
      result = Exists(exp);
      break;
    default:
      jj_la1[10] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
        {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public Expression DefaultTo(Expression exp) throws ParseException {
   Expression rhs = null;
   Token t;
    t = jj_consume_token(EXCLAM);
    if (jj_2_10(2147483647)) {
      rhs = Expression();
    } else {
      ;
    }
      DefaultToExpression result = new DefaultToExpression(exp, rhs);
      if (rhs ==null) {
          result.setLocation(template, exp, t);
      }
      else {
          result.setLocation(template, exp, rhs);
      }
      {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public Expression Exists(Expression exp) throws ParseException {
   Token t;
    t = jj_consume_token(EXISTS);
       ExistsExpression result = new ExistsExpression(exp);
       result.setLocation(template, exp, t);
       {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

  final public Expression BuiltIn(Expression exp) throws ParseException {
   Token t=null;
    jj_consume_token(BUILT_IN);
    t = jj_consume_token(ID);
       BuiltIn result = null;
       try {
           result = BuiltIn.newBuiltIn(exp, t.image, t, templateName);
       } catch (ParseException pe) {
           pe.lineNumber = t.beginLine;
           pe.columnNumber = t.beginColumn;
           {if (true) throw pe;}
       }
       result.setLocation(template, exp, t);
       {if (true) return result;}
    throw new Error("Missing return statement in function");
  }

/**
 * production for when a key is specified by <DOT> + keyname
 */
  final public Expression DotVariable(Expression exp) throws ParseException {
  Token t;
    jj_consume_token(DOT);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ID:
      t = jj_consume_token(ID);
      break;
    case TIMES:
      t = jj_consume_token(TIMES);