elparser.java

来自「jakarta-taglibs」· Java 代码 · 共 1,205 行 · 第 1/3 页

          jj_la1[15] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
                          operator = LessThanOrEqualsOperator.SINGLETON;
        break;
      default:
        jj_la1[16] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      expression = AddExpression();
        if (operators == null) {
          operators = new ArrayList ();
          expressions = new ArrayList ();
        }
        operators.add (operator);
        expressions.add (expression);
    }
    if (operators != null) {
      {if (true) return new BinaryOperatorExpression (startExpression,
                                           operators,
                                           expressions);}
    }
    else {
      {if (true) return startExpression;}
    }
    throw new Error("Missing return statement in function");
  }

  final public Expression AddExpression() throws ParseException {
  Expression startExpression;
  BinaryOperator operator;
  Expression expression;
  List operators = null;
  List expressions = null;
    startExpression = MultiplyExpression();
    label_6:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PLUS:
      case MINUS:
        ;
        break;
      default:
        jj_la1[17] = jj_gen;
        break label_6;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PLUS:
        jj_consume_token(PLUS);
               operator = PlusOperator.SINGLETON;
        break;
      case MINUS:
        jj_consume_token(MINUS);
                  operator = MinusOperator.SINGLETON;
        break;
      default:
        jj_la1[18] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      expression = MultiplyExpression();
        if (operators == null) {
          operators = new ArrayList ();
          expressions = new ArrayList ();
        }
        operators.add (operator);
        expressions.add (expression);
    }
    if (operators != null) {
      {if (true) return new BinaryOperatorExpression (startExpression,
                                           operators,
                                           expressions);}
    }
    else {
      {if (true) return startExpression;}
    }
    throw new Error("Missing return statement in function");
  }

  final public Expression MultiplyExpression() throws ParseException {
  Expression startExpression;
  BinaryOperator operator;
  Expression expression;
  List operators = null;
  List expressions = null;
    startExpression = UnaryExpression();
    label_7:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MULTIPLY:
      case DIVIDE1:
      case DIVIDE2:
      case MODULUS1:
      case MODULUS2:
        ;
        break;
      default:
        jj_la1[19] = jj_gen;
        break label_7;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MULTIPLY:
        jj_consume_token(MULTIPLY);
                   operator = MultiplyOperator.SINGLETON;
        break;
      case DIVIDE1:
      case DIVIDE2:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case DIVIDE1:
          jj_consume_token(DIVIDE1);
          break;
        case DIVIDE2:
          jj_consume_token(DIVIDE2);
          break;
        default:
          jj_la1[20] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
                                  operator = DivideOperator.SINGLETON;
        break;
      case MODULUS1:
      case MODULUS2:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case MODULUS1:
          jj_consume_token(MODULUS1);
          break;
        case MODULUS2:
          jj_consume_token(MODULUS2);
          break;
        default:
          jj_la1[21] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
                                    operator = ModulusOperator.SINGLETON;
        break;
      default:
        jj_la1[22] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      expression = UnaryExpression();
        if (operators == null) {
          operators = new ArrayList ();
          expressions = new ArrayList ();
        }
        operators.add (operator);
        expressions.add (expression);
    }
    if (operators != null) {
      {if (true) return new BinaryOperatorExpression (startExpression,
                                           operators,
                                           expressions);}
    }
    else {
      {if (true) return startExpression;}
    }
    throw new Error("Missing return statement in function");
  }

  final public Expression UnaryExpression() throws ParseException {
  Expression expression;
  UnaryOperator singleOperator = null;
  UnaryOperator operator;
  List operators = null;
    label_8:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MINUS:
      case NOT1:
      case NOT2:
      case EMPTY:
        ;
        break;
      default:
        jj_la1[23] = jj_gen;
        break label_8;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NOT1:
      case NOT2:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NOT1:
          jj_consume_token(NOT1);
          break;
        case NOT2:
          jj_consume_token(NOT2);
          break;
        default:
          jj_la1[24] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
                        operator = NotOperator.SINGLETON;
        break;
      case MINUS:
        jj_consume_token(MINUS);
                operator = UnaryMinusOperator.SINGLETON;
        break;
      case EMPTY:
        jj_consume_token(EMPTY);
                operator = EmptyOperator.SINGLETON;
        break;
      default:
        jj_la1[25] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    if (singleOperator == null) {
      singleOperator = operator;
    }
    else if (operators == null) {
      operators = new ArrayList ();
      operators.add (singleOperator);
      operators.add (operator);
    }
    else {
      operators.add (operator);
    }
    }
    expression = Value();
    if (operators != null) {
      {if (true) return new UnaryOperatorExpression (null, operators, expression);}
    }
    else if (singleOperator != null) {
      {if (true) return new UnaryOperatorExpression (singleOperator, null, expression);}
    }
    else {
      {if (true) return expression;}
    }
    throw new Error("Missing return statement in function");
  }

  final public Expression Value() throws ParseException {
  Expression prefix;
  ValueSuffix suffix;
  List suffixes = null;
    prefix = ValuePrefix();
    label_9:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case DOT:
      case LBRACKET:
        ;
        break;
      default:
        jj_la1[26] = jj_gen;
        break label_9;
      }
      suffix = ValueSuffix();
        if (suffixes == null) {
          suffixes = new ArrayList ();
        }
        suffixes.add (suffix);
    }
    if (suffixes == null) {
      {if (true) return prefix;}
    }
    else {
      {if (true) return new ComplexValue (prefix, suffixes);}
    }
    throw new Error("Missing return statement in function");
  }

/**
 * This is an element that can start a value
 **/
  final public Expression ValuePrefix() throws ParseException {
  Expression ret;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case INTEGER_LITERAL:
    case FLOATING_POINT_LITERAL:
    case STRING_LITERAL:
    case TRUE:
    case FALSE:
    case NULL:
      ret = Literal();
      break;
    case LPAREN:
      jj_consume_token(LPAREN);
      ret = Expression();
      jj_consume_token(RPAREN);
      break;
    default:
      jj_la1[27] = jj_gen;
      if (jj_2_1(2147483647)) {
        ret = FunctionInvocation();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case IDENTIFIER:
          ret = NamedValue();
          break;
        default:
          jj_la1[28] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    }
      {if (true) return ret;}
    throw new Error("Missing return statement in function");
  }

  final public NamedValue NamedValue() throws ParseException {
  Token t;
    t = jj_consume_token(IDENTIFIER);
                     {if (true) return new NamedValue (t.image);}
    throw new Error("Missing return statement in function");
  }

  final public FunctionInvocation FunctionInvocation() throws ParseException {
  String qualifiedName;
  List argumentList = new ArrayList();
  Expression exp;
    qualifiedName = QualifiedName();
    jj_consume_token(LPAREN);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case INTEGER_LITERAL:
    case FLOATING_POINT_LITERAL:
    case STRING_LITERAL:
    case TRUE:
    case FALSE:
    case NULL:
    case LPAREN:
    case MINUS:
    case NOT1:
    case NOT2:
    case EMPTY:
    case IDENTIFIER:
      exp = Expression();
          argumentList.add(exp);
      label_10:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[29] = jj_gen;
          break label_10;
        }
        jj_consume_token(COMMA);
        exp = Expression();
          argumentList.add(exp);
      }
      break;
    default:
      jj_la1[30] = jj_gen;
      ;
    }
    jj_consume_token(RPAREN);
    String allowed = System.getProperty("javax.servlet.jsp.functions.allowed");
    if (allowed == null || !allowed.equalsIgnoreCase("true"))
      {if (true) throw new ParseException("EL functions are not supported.");}
    {if (true) return new FunctionInvocation(qualifiedName, argumentList);}
    throw new Error("Missing return statement in function");
  }

  final public ValueSuffix ValueSuffix() throws ParseException {
  ValueSuffix suffix;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case DOT:
      suffix = PropertySuffix();
      break;
    case LBRACKET:
      suffix = ArraySuffix();
      break;
    default:
      jj_la1[31] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
      {if (true) return suffix;}
    throw new Error("Missing return statement in function");
  }

  final public PropertySuffix PropertySuffix() throws ParseException {
  Token t;
  String property;
    jj_consume_token(DOT);
    property = Identifier();
      {if (true) return new PropertySuffix (property);}
    throw new Error("Missing return statement in function");
  }

  final public ArraySuffix ArraySuffix() throws ParseException {
  Expression index;
    jj_consume_token(LBRACKET);
    index = Expression();
    jj_consume_token(RBRACKET);
     {if (true) return new ArraySuffix (index);}
    throw new Error("Missing return statement in function");
  }

  final public Literal Literal() throws ParseException {
  Literal ret;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case TRUE:
    case FALSE: