Esempio n. 1
0
Token
TokenEvalContext::evalDivide(const Token& lexpr, const Token& rexpr) const
{
  Token left = evalToken(lexpr);
  Token right = evalToken(rexpr);

  if (left.isInt()) {
    int value = left.intValue();
    if (value == 0)
      throw DivisionByZeroException();

    if (right.isInt())
      return Token::newInt(left.srcpos(),
                           left.bitwidth(), value / right.intValue());
    else if (right.isFloat())
      return Token(left.srcpos(),
                   kFloat, double(value) / right.floatValue());
    else if (right.isRational())
      return Token(left.srcpos(),
                   kRational, Rational(value, 1) / right.rationalValue());
    else
      throw BadExpressionException(fromInt(__LINE__));
  }
  else if (left.isFloat()) {
    double value = left.floatValue();
    if (value == 0)
      throw DivisionByZeroException();

    if (right.isInt())
      return Token(left.srcpos(),
                   kFloat, value / double(right.intValue()));
    else if (right.isFloat())
      return Token(left.srcpos(),
                   kFloat, value / right.floatValue());
    else if (right.isRational())
      return Token(left.srcpos(),
                   kFloat, value / right.rationalValue().toFloat());
    else
      throw BadExpressionException(fromInt(__LINE__));
  }
  else if (left.isRational()) {
    Rational value = left.rationalValue();
    if (value.numerator() == 0)
      throw DivisionByZeroException();

    if (right.isInt())
      return Token(left.srcpos(),
                   kRational, value / Rational(right.intValue(), 1));
    else if (right.isFloat())
      return Token(left.srcpos(),
                   kFloat, value.toFloat() / right.floatValue());
    else if (right.isRational())
      return Token(left.srcpos(),
                   kRational, value / right.rationalValue());
    else
      throw BadExpressionException(fromInt(__LINE__));
  }

  throw BadExpressionException(fromInt(__LINE__));
}
Esempio n. 2
0
Token
TokenEvalContext::evalMinus(const Token& lexpr, const Token& rexpr) const
{
  Token left = evalToken(lexpr);
  Token right = evalToken(rexpr);

  if (left.isInt()) {
    int value = left.intValue();
    if (right.isInt())
      return Token::newInt(left.srcpos(),
                   left.bitwidth(), value - right.intValue());
    else if (right.isFloat())
      return Token(left.srcpos(),
                   kFloat, double(value) - right.floatValue());
    else if (right.isRational())
      return Token(left.srcpos(),
                   kRational, Rational(value, 1) - right.rationalValue());
    else
      throw BadExpressionException(fromInt(__LINE__));
  }
  else if (left.isFloat()) {
    double value = left.floatValue();
    if (right.isInt())
      return Token(left.srcpos(),
                   kFloat, value - double(right.intValue()));
    else if (right.isFloat())
      return Token(left.srcpos(),
                   kFloat, value - right.floatValue());
    else if (right.isRational())
      return Token(left.srcpos(),
                   kFloat, value - right.rationalValue().toFloat());
    else
      throw BadExpressionException(fromInt(__LINE__));
  }
  else if (left.isRational()) {
    Rational value = left.rationalValue();
    if (right.isInt())
      return Token(left.srcpos(),
                   kRational, value - Rational(right.intValue(), 1));
    else if (right.isFloat())
      return Token(left.srcpos(),
                   kFloat, value.toFloat() - right.floatValue());
    else if (right.isRational())
      return Token(left.srcpos(),
                   kRational, value - right.rationalValue());
    else
      throw BadExpressionException(fromInt(__LINE__));
  }

  throw BadExpressionException(fromInt(__LINE__));
}