quercusparser.java

RESIN 3.2 最新源码

        case FUNCTION:
        {
          Function fun = parseFunctionDefinition(0);
          fun.setStatic(false);
          break;
        }

        case CLASS:
          parseClassDefinition(0);
          break;

	    /* quercus/0260
        case VAR:
	      parseClassVarDefinition(false);
	      break;
        */

        case CONST:
          parseClassConstDefinition();
          break;

        case PUBLIC:
        case PRIVATE:
        case PROTECTED:
        case STATIC:
        case FINAL:
        case ABSTRACT:
        {
          _peekToken = token;
          int modifiers = parseModifiers();
          
          int token2 = parseToken();

          if (token2 == FUNCTION) {
            Function fun = parseFunctionDefinition(modifiers);
          }
          else {
            _peekToken = token2;
            
            parseClassVarDefinition(modifiers);
          }
        }
        break;

        case IDENTIFIER:
          if (_lexeme.equals("var")) {
            parseClassVarDefinition(0);
          }
          else {
            _peekToken = token;
            return;
          }
          break;

        case -1:
        case '}':
        default:
          _peekToken = token;
          return;
      }
    }
  }

  /**
   * Parses a function definition
   */
  private void parseClassVarDefinition(int modifiers)
    throws IOException
  {
    int token;
    
    do {
      expect('$');
      String name = parseIdentifier();

      token = parseToken();

      Expr expr = null;

      if (token == '=') {
	expr = parseExpr();
      }
      else {
	_peekToken = token;
	expr = _factory.createNull();
      }

      if ((modifiers & M_STATIC) != 0)
	((ClassScope) _scope).addStaticVar(name, expr);
      else
	((ClassScope) _scope).addVar(name, expr);

      token = parseToken();
    } while (token == ',');

    _peekToken = token;
  }

  /**
   * Parses a const definition
   */
  private void parseClassConstDefinition()
    throws IOException
  {
    int token;
    
    do {
      String name = parseIdentifier();
      
      expect('=');

      Expr expr = parseExpr();

      ((ClassScope) _scope).addConstant(name, expr);

      token = parseToken();
    } while (token == ',');

    _peekToken = token;
  }

  private int parseModifiers()
    throws IOException
  {
    int token;
    int modifiers = 0;

    while (true) {
      token = parseToken();

      switch (token) {
      case PUBLIC:
	modifiers |= M_PUBLIC;
	break;

      case PRIVATE:
	modifiers |= M_PRIVATE;
	break;

      case PROTECTED:
	modifiers |= M_PROTECTED;
	break;

      case FINAL:
	modifiers |= M_FINAL;
	break;

      case STATIC:
	modifiers |= M_STATIC;
	break;

      case ABSTRACT:
	modifiers |= M_ABSTRACT;
	break;

      default:
	_peekToken = token;
	return modifiers;
      }
    }
  }

  /**
   * Parses an expression statement.
   */
  private Statement parseExprStatement()
    throws IOException
  {
    Location location = getLocation();

    Expr expr = parseTopExpr();

    Statement statement = _factory.createExpr(location, expr);

    int token = parseToken();
    _peekToken = token;

    switch (token) {
    case -1:
    case ';':
    case '}':
    case PHP_END:
    case TEXT:
    case TEXT_PHP:
    case TEXT_ECHO:
      break;

    default:
      expect(';');
      break;
    }
    
    return statement;
  }

  /**
   * Parses a top expression.
   */
  private Expr parseTopExpr()
    throws IOException
  {
    return parseExpr();
  }

  /**
   * Parses a top expression.
   */
  private Expr parseTopCommaExpr()
    throws IOException
  {
    return parseCommaExpr();
  }

  /**
   * Parses a comma expression.
   */
  private Expr parseCommaExpr()
    throws IOException
  {
    Expr expr = parseExpr();

    while (true) {
      int token = parseToken();

      switch (token) {
      case ',':
	expr = _factory.createComma(expr, parseExpr());
	break;
      default:
	_peekToken = token;
	return expr;
      }
    }
  }

  /**
   * Parses an expression with optional '&'.
   */
  private Expr parseRefExpr()
    throws IOException
  {
    int token = parseToken();

    boolean isRef = token == '&';

    if (! isRef)
      _peekToken = token;
    
    Expr expr = parseExpr();

    if (isRef)
      expr = _factory.createRef(expr);

    return expr;
  }

  /**
   * Parses an expression.
   */
  private Expr parseExpr()
    throws IOException
  {
    return parseWeakOrExpr();
  }

  /**
   * Parses a logical xor expression.
   */
  private Expr parseWeakOrExpr()
    throws IOException
  {
    Expr expr = parseWeakXorExpr();

    while (true) {
      int token = parseToken();

      switch (token) {
      case OR_RES:
	expr = _factory.createOr(expr, parseWeakXorExpr());
	break;
      default:
	_peekToken = token;
	return expr;
      }
    }
  }

  /**
   * Parses a logical xor expression.
   */
  private Expr parseWeakXorExpr()
    throws IOException
  {
    Expr expr = parseWeakAndExpr();

    while (true) {
      int token = parseToken();

      switch (token) {
      case XOR_RES:
	expr = _factory.createXor(expr, parseWeakAndExpr());
	break;
      default:
	_peekToken = token;
	return expr;
      }
    }
  }

  /**
   * Parses a logical and expression.
   */
  private Expr parseWeakAndExpr()
    throws IOException
  {
    Expr expr = parseConditionalExpr();

    while (true) {
      int token = parseToken();

      switch (token) {
      case AND_RES:
	expr = _factory.createAnd(expr, parseConditionalExpr());
	break;
      default:
	_peekToken = token;
	return expr;
      }
    }
  }

  /**
   * Parses a conditional expression.
   */
  private Expr parseConditionalExpr()
    throws IOException
  {
    Expr expr = parseOrExpr();

    while (true) {
      int token = parseToken();

      switch (token) {
      case '?':
	Expr trueExpr = parseExpr();
	expect(':');
	// php/33c1
	expr = _factory.createConditional(expr, trueExpr, parseOrExpr());
	break;
      default:
	_peekToken = token;
	return expr;
      }
    }
  }

  /**
   * Parses a logical or expression.
   */
  private Expr parseOrExpr()
    throws IOException
  {
    Expr expr = parseAndExpr();

    while (true) {
      int token = parseToken();

      switch (token) {
      case C_OR:
	expr = _factory.createOr(expr, parseAndExpr());
	break;
      default:
	_peekToken = token;
	return expr;
      }
    }
  }

  /**
   * Parses a logical and expression.
   */
  private Expr parseAndExpr()
    throws IOException
  {
    Expr expr = parseBitOrExpr();

    while (true) {
      int token = parseToken();

      switch (token) {
      case C_AND:
	expr = _factory.createAnd(expr, parseBitOrExpr());
	break;
      default:
	_peekToken = token;
	return expr;
      }
    }
  }

  /**
   * Parses a bit or expression.
   */
  private Expr parseBitOrExpr()
    throws IOException
  {
    Expr expr = parseBitXorExpr();

    while (true) {
      int token = parseToken();

      switch (token) {
      case '|':
	expr = _factory.createBitOr(expr, parseBitXorExpr());
	break;
      default:
	_peekToken = token;
	return expr;
      }
    }
  }

  /**
   * Parses a bit xor expression.
   */
  private Expr parseBitXorExpr()
    throws IOException
  {
    Expr expr = parseBitAndExpr();

    while (true) {
      int token = parseToken();

      switch (token) {
      case '^':
	expr = _factory.createBitXor(expr, parseBitAndExpr());
	break;
      default:
	_peekToken = token;
	return expr;
      }
    }
  }

  /**
   * Parses a bit and expression.
   */
  private Expr parseBitAndExpr()
    throws IOException
  {
    Expr expr = parseEqExpr();

    while (true) {
      int token = parseToken();

      switch (token) {
      case '&':
	expr = _factory.createBitAnd(expr, parseEqExpr());
	break;
      default:
	_peekToken = token;
	return expr;
      }
    }
  }

  /**
   * Parses a comparison expression.
   */
  private Expr parseEqExpr()
    throws IOException
  {
    Expr expr = parseCmpExpr();

    int token = parseToken();

    switch (token) {
    case EQ:
      return _factory.createEq(expr, parseCmpExpr());
      
    case NEQ:
      return _factory.createNeq(expr, parseCmpExpr());
      
    case EQUALS:
      return _factory.createEquals(expr, parseCmpExpr());
      
    case NEQUALS:
      return _factory.createNot(_factory.createEquals(expr, parseCmpExpr()));
      
    default:
      _peekToken = token;
      return expr;
    }
  }

  /**
   * Parses a comparison expression.
   */
  private Expr parseCmpExpr()
    throws IOException
  {
    Expr expr = parseShiftExpr();

    int token = parseToken();

    switch (token) {
    case '<':
      return _factory.createLt(expr, parseShiftExpr());

    case '>':
      return _factory.createGt(expr, parseShiftExpr());

    case LEQ:
      return _factory.createLeq(expr, parseShiftExpr());

    case GEQ:
      return _factory.createGeq(expr, parseShiftExpr());

    case INSTANCEOF:
      Location location = getLocation();

      Expr classNameExpr = parseShiftExpr();
      
      if (classNameExpr instanceof ConstExpr)
        return _factory.createInstanceOf(expr, classNameExpr.toString());
      else
        return _factory.createInstanceOfVar(expr, classNameExpr);
      
    default:
      _peekToken = token;
      return expr;
    }
  }

  /**
   * Parses a left/right shift expression.
   */
  private Expr parseShiftExpr()
    throws IOException
  {
    Expr expr = parseAddExpr();

    while (true) {
      int token = parseToken();

      switch (token) {
      case LSHIFT:
	expr = _factory.createLeftShift(expr, parseAddExpr());
	break;
      case RSHIFT:
	expr = _factory.createRightShift(expr, parseAddExpr());
	break;
      default:
	_peekToken = token;
	return expr;
      }
    }
  }

  /**
   * Parses an add/substract expression.
   */
  private Expr parseAddExpr()
    throws IOException
  {
    Expr expr = parseMulExpr();

    while (true) {
      int token = parseToken();

      switch (token) {
      case '+':
	expr = _factory.createAdd(expr, parseMulExpr());
	break;
      case '-':
	expr = _factory.createSub(expr, parseMulExpr());
	break;
      case '.':
	expr = _factory.createAppend(expr, parseMulExpr());
	break;
      default:
	_peekToken = token;
	return expr;
      }
    }
  }

  /**
   * Parses a multiplication/division expression.
   */
  private Expr parseMulExpr()
    throws IOException
  {
    Expr expr = parseAssignExpr();

    while (true) {
      int token = parseToken();

      switch (token) {
      case '*':
	expr = _factory.createMul(expr, parseAssignExpr());
	break;
      case '/':
	expr = _factory.createDiv(expr, parseAssignExpr());
	break;
      case '%':
	expr = _factory.createMod(expr, parseAssignExpr());
	break;
      default:
	_peekToken = token;
	return expr;
      }
    }
  }

  /**
   * Parses an assignment expression.
   */
  private Expr parseAssignExpr()
    throws IOException