C++ Evaluator::eval方法代码示例

void ui()
{
    Evaluator eval;
    std::string input;

    std::cout << "\ntype an expression, \"exit\" to end\n";

    while (true)
    {
        std::cout << ">>> ";
        std::getline(std::cin, input);

        if (input[0] == 'e' || input[0] == 'E')
            break;

        try
        {
            std::cout << eval.eval(input) << std::endl;
        }
        catch (std::invalid_argument err)
        {
            std::cout << "Error: " << err.what() << std::endl;
        }
    }
}

int main()
{
		Evaluator eval;
		vector<string> expression = { "1+2*3","2+2^2*3" ,"1==2", "1+3 > 2", "(4>=4) && 0", "(1+2)*3" }; //<--expressions we wish to evaluate go here
		vector<string>::iterator exprItr;

		for (exprItr = expression.begin();
		exprItr != expression.end();
			exprItr++)
		{
			try
			{
				int result = eval.eval(*exprItr);

				cout << eval.infix_expression.c_str() << " = " << result << endl << endl;
			}
			catch (Syntax_Error e)
			{
				cout << eval.infix_expression.c_str() << endl << e.what() << " " << "@ char: " << eval.position << endl << endl;
			}
		}

		system("pause");
	return 0;
}

int evaluate(T& src) {
  Evaluator e;
  try {
    e.eval(src);
    return 0;
  } catch (const Error& e) {
    std::cerr << DASHES << std::endl;
    std::cerr << "Unhandled exception!" << std::endl << std::endl;
    std::cerr << e.what() << std::endl;
    std::cerr << DASHES << std::endl;
    return 1;
  }
}

Expr*
get_length(Layout_decl const* layout)
{
  Evaluator eval;

  Expr* e = 0;
  for (Decl* d : layout->fields()) {
    Type const* t1 = d->type();

    // If member is constant, just add in the constant value
    if (has_constant_length(t1))
      e = add(e, make_int(precision(t1)));

    // Otherwise, we have to form a call to the function
    // that would compute this type.
    else {
      // FIXME: Do this right!
      throw std::runtime_error("unimplemented dynamic length calc.");
      e = add(e, zero());
    }
  }


  // Compute ceil(e / 8).
  Expr* b = make_int(8); // bits per byte
  Expr* r = div(sub(add(e, b), one()), b);

  // Try folding the result. If it works, good. If not,
  // just return the previously computed expression.
  //
  // TODO: Maximally reduce the expression so that we only
  // add the constant bits to the non-constant bits. Since
  // addition is associative and commutative, we can
  // partition the sequence of terms into constants and
  // non-constants, and then sum the constant parts.
  try {
    Value v = eval.eval(r);
    if (v.is_integer())
      return make_int(v.get_integer());
    else
      throw std::runtime_error("failed to synth length");
  }
  catch(...) {
    return r;
  }
}

Expr*
gather(Expr_seq const& subkeys)
{
  // maintain the largest allowable key buffer
  uint512_t buf = 0;

  Evaluator ev;

  // maintain the position to start writing
  int pos = 0;
  for (auto subkey : subkeys) {
    // get the precision of the subkey
    int prec = precision(subkey->type());
    Value const& val = ev.eval(subkey);
    // FIXME: for now we're only dealing with unsigned integer values
    assert(val.is_integer());
    std::stringstream ss;
    ss << val.get_integer().decimal_str();
    uint512_t i = 0;
    ss >> i;
    // shift the integer over by the amount already written
    i = i << pos;
    // add the length of the current integer to the pos
    pos += prec;
    // log-and the integer into the buffer
    buf |= i;
  }

  char* bytes = new char[pos / 8];
  char* key = reinterpret_cast<char*>(&buf);
  std::copy(key, key + (pos / 8), bytes);

  Array_value arr { bytes, (size_t) pos / 8 };
  Type const* z = get_integer_type();
  Expr* n = new Literal_expr(z, arr.len + 1);
  // Create the array type.
  Type const* c = get_character_type();
  Type const* t = get_array_type(c, n);

  return new Literal_expr(t, arr);
}

// Evaluate the given expression.
inline Value
evaluate(Expr const* e)
{
  Evaluator ev;
  return ev.eval(e);
}