elparser.java

来自「RESIN 3.2 最新源码」· Java 代码 · 共 883 行 · 第 1/2 页

      }
      
      case '(':
      {
        ArrayList<Expr> argList = new ArrayList<Expr>();

        int ch = skipWhitespace(read());

        while (ch > 0 && ch != ')') {
          unread();
          argList.add(parseExpr());
          
          token = scanToken();
          
          if (token != ',') {
            ch = token;
            break;
          }
          
          ch = skipWhitespace(read());
        }
        
	if (ch != ')')
	  throw error(L.l("Expected `)' at {0}.  All functions must have matching closing parenthesis.", badChar(ch)));

        // token = scanToken();

        Expr []args = (Expr []) argList.toArray(new Expr[argList.size()]);

	Expr expr = term.createMethod(args);
        if (expr == null)
	  throw error(L.l("Method call not supported in this context `{0}'.",
                          term));
        term = expr;
        break;
      }

      case '.':
      {
        int ch = skipWhitespace(read());
        
        if (! Character.isJavaIdentifierStart((char) ch))
	  throw error(L.l("Expected `]' at {0}.  Field references must be identifiers.", badChar(ch)));

        String field = readName(ch);

        term = term.createField(field);
        break;
      }
        
      default:
        _peek = token;
        return term;
      }
    }
  }

  /**
   * simple-term ::= number
   *             ::= '(' expr ')'
   *             ::= variable
   *             ::= '"' string '"'
   *             ::= true | false | null
   */
  private Expr parseSimpleTerm()
    throws ELParseException
  {
    int ch = read();
    
    ch = skipWhitespace(ch);

    switch (ch) {
    case '.':
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
      {
	long value = 0;
	double exp = 1;
        int digits = 0;

	for (; ch >= '0' && ch <= '9'; ch = read())
	  value = 10 * value + ch - '0';

        if (ch != '.' && ch != 'e' && ch != 'E') {
          unread();
          return new LongLiteral(value);
        }
        
	if (ch == '.') {
	  for (ch = read(); ch >= '0' && ch <= '9'; ch = read()) {
	    value = 10 * value + ch - '0';
	    exp *= 10;
            digits--;
	  }
	}

        if (ch == 'e' || ch == 'E') {
          int sign = 1;
          int expValue = 0;
          
          ch = read();
          if (ch == '-') {
            sign = -1;
            ch = read();
          }
          else if (ch == '+')
            ch = read();
          
          for (; ch >= '0' && ch <= '9'; ch = read())
            expValue = 10 * expValue + ch - '0';

          exp = Math.pow(10, digits + sign * expValue);

          unread();
          
          return new DoubleLiteral((double) value * (double) exp);
        }
        
	unread();
	return new DoubleLiteral((double) value / (double) exp);
      }

    case '-':
      return new MinusExpr(parseTerm());

    case '!':
      return UnaryExpr.create(Expr.NOT, parseTerm());

    case '+':
      return parseTerm();

    case '(':
      {
	Expr expr = parseExpr();
	if ((ch = scanToken()) != ')')
	  throw error(L.l("Expected `)' at {0}.  All open parentheses must have matching closing parentheses.", badChar(ch)));
	
	return expr;
      }

    case '\'': case '"':
      {
	int end = ch;
	CharBuffer cb = new CharBuffer();
        for (ch = read(); ch >= 0; ch = read()) {
          if (ch == '\\')
            cb.append((char) read());
          else if (ch != end)
            cb.append((char) ch);
          else if ((ch = read()) == end)
            cb.append((char) ch);
          else {
            unread();
            break;
          }
        }

	return new StringLiteral(cb.toString());
      }

    default:
      if (! Character.isJavaIdentifierStart((char) ch) && ch != ':')
	throw error(L.l("Unexpected character at {0}.", badChar(ch)));
      
      CharBuffer cb = CharBuffer.allocate();
      for (;
           Character.isJavaIdentifierPart((char) ch) || ch == ':';
           ch = read())
        cb.append((char) ch);

      unread();

      String name = cb.close();

      if (name.equals("null"))
        return new NullLiteral();
      else if (name.equals("true"))
        return new BooleanLiteral(true);
      else if (name.equals("false"))
        return new BooleanLiteral(false);
      else if (name.equals("not"))
        return UnaryExpr.create(Expr.NOT, parseTerm());
      else if (name.equals("empty"))
        return UnaryExpr.create(Expr.EMPTY, parseTerm());
      else {
	VariableMapper varMapper = _elContext.getVariableMapper();
	
	ValueExpression valueExpr = null;

	if (varMapper != null)
	  valueExpr = varMapper.resolveVariable(name);

	if (valueExpr != null)
	  return new ValueExpr(name, valueExpr);
	
        Expr expr = createImplicitObjectExpr(name);

        if (expr != null)
          return expr;

	try {
	  Method method = getStaticMethod(name);

	  if (method != null)
	    return new StaticMethodExpr(method);
	  else
	    return new IdExpr(name);
	} catch (Exception e) {
	  log.log(Level.FINEST, e.toString(), e);
	  
	  return new IdExpr(name);
	}
      }
    }
  }

  /**
   * Creates the implicit object for the name.
   */
  protected Expr createImplicitObjectExpr(String name)
  {
    return null;
  }

  /**
   * Creates the implicit object for the name.
   */
  protected Method getStaticMethod(String name)
    throws ELParseException
  {
    Method method = null;

    FunctionMapper funMapper = _elContext.getFunctionMapper();

    if (funMapper != null) {
      String prefix = "";
      String localName = name;

      int p = name.indexOf(':');
      if (p > 0) {
	prefix = name.substring(0, p);
	localName = name.substring(p + 1);
      }
      
      method = funMapper.resolveFunction(prefix, localName);
    }
    
    return method;
  }

  /**
   * Scans the next token.
   *
   * @return token code, expressed as an Expr enumeration.
   */
  private int scanToken()
    throws ELParseException
  {
    if (_peek >= 0) {
      int value = _peek;
      _peek = -1;
      return value;
    }

    int ch = skipWhitespace(read());

    switch (ch) {
    case '+': return Expr.ADD;
    case '-': return Expr.SUB;
    case '*': return Expr.MUL;
    case '/': return Expr.DIV;
    case '%': return Expr.MOD;

    case '!':
      ch = read();
      if (ch == '=')
	return Expr.NE;
      else
        return Expr.NOT;
      
    case '=':
      ch = read();
      if (ch == '=')
	return Expr.EQ;
      else
	throw error(L.l("expected '==' at '={0}'", badChar(ch)));
      
    case '&':
      ch = read();
      if (ch == '&')
	return Expr.AND;
      else
	throw error(L.l("expected '&&' at '&{0}'", badChar(ch)));
      
    case '|':
      ch = read();
      if (ch == '|')
	return Expr.OR;
      else
	throw error(L.l("expected '||' at '|{0}'", badChar(ch)));

    case '<':
      ch = read();
      if (ch == '=')
	return Expr.LE;
      else {
	unread();
	return Expr.LT;
      }

    case '>':
      ch = read();
      if (ch == '=')
	return Expr.GE;
      else {
	unread();
	return Expr.GT;
      }

    case '[':
      return '[';
      
    case ']':
      return ']';
      
    case ')':
      return ')';
      
    case '(':
      return '(';
      
    case '.':
      return '.';
      
    case ',':
      return ',';
      
    case '?':
    case ':':
      return ch;

    default:
      if (Character.isJavaIdentifierStart((char) ch)) {
	String name = readName(ch);

	if (name.equals("div"))
	  return Expr.DIV;
	else if (name.equals("mod"))
	  return Expr.MOD;
	else if (name.equals("eq"))
	  return Expr.EQ;
	else if (name.equals("ne"))
	  return Expr.NE;
	else if (name.equals("lt"))
	  return Expr.LT;
	else if (name.equals("le"))
	  return Expr.LE;
	else if (name.equals("gt"))
	  return Expr.GT;
	else if (name.equals("ge"))
	  return Expr.GE;
	else if (name.equals("and"))
	  return Expr.AND;
	else if (name.equals("or"))
	  return Expr.OR;
	else
	  throw error(L.l("expected binary operation at `{0}'", name));
      }

      unread();
      return -1;
    }
  }

  private String readName(int ch)
  {
    CharBuffer cb = CharBuffer.allocate();

    for (; Character.isJavaIdentifierPart((char) ch); ch = read())
      cb.append((char) ch);

    unread();

    return cb.toString();
  }

  /**
   * Skips whitespace, returning the next meaningful character.
   */
  private int skipWhitespace(int ch)
    throws ELParseException
  {
    for (; ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r'; ch = read()) {
    }

    return ch;
  }

  /**
   * Reads the next character, returning -1 on end of file.
   */
  private int read()
  {
    if (_index < _string.length())
      return _string.charAt(_index++);
    else {
      _index++;
      return -1;
    }
  }

  /**
   * Unread the last character.
   */
  private void unread()
  {
    _index--;
  }

  /**
   * Returns a readable version of the character.
   */
  private String badChar(int ch)
  {
    if (ch < 0)
      return L.l("end of file");
    else if (ch == '\n')
      return L.l("end of line");
    else
      return "`" + (char) ch + "'";
  }

  /**
   * Returns an new exception.
   */
  private ELParseException error(String message)
  {
    return new ELParseException(message + " in " + _string);
  }
}