packToken calculator::eval(TokenMap vars, bool keep_refs) const {
TokenBase* value = calculate(this->RPN, vars, opMap());
packToken p = packToken(value->clone());
if (keep_refs) {
return packToken(value);
} else {
return packToken(resolve_reference(value));
}
}
void TokenMap::assign(std::string key, TokenBase* value) {
if (value) {
value = value->clone();
} else {
throw std::invalid_argument("TokenMap assignment expected a non NULL argument as value!");
}
packToken* variable = find(key);
if (variable) {
(*variable) = packToken(value);
} else {
map()[key] = packToken(value);
}
}
packToken lazy_class_init(packMap scope) {
packMap _this = scope->find("this")->asMap();
(*_this)["func"] = packToken(scope->find("func")->asFunc()->clone());
(*_this)["args"] = scope->find("arglist")->asList();
return packToken::None;
}
packToken calculator::calculate(const char* expr, TokenMap vars,
const char* delim, const char** rest) {
// Convert to RPN with Dijkstra's Shunting-yard algorithm.
RAII_TokenQueue_t rpn = calculator::toRPN(expr, vars, delim, rest);
TokenBase* ret = calculator::calculate(rpn, vars);
return packToken(resolve_reference(ret));
}
packToken* TokenMap::MapIterator::next() {
if (it != map.end()) {
last = packToken(it->first);
++it;
return &last;
} else {
it = map.begin();
return NULL;
}
}
std::string calculator::str(TokenQueue_t rpn) {
std::stringstream ss;
ss << "calculator { RPN: [ ";
while (rpn.size()) {
ss << packToken(resolve_reference(rpn.front()->clone())).str();
rpn.pop();
ss << (rpn.size() ? ", ":"");
}
ss << " ] }";
return ss.str();
}
void TokenMap::insert(std::string key, TokenBase* value) {
(*this)[key] = packToken(value->clone());
}
TokenBase* calculator::calculate(const TokenQueue_t& rpn, TokenMap scope,
const opMap_t& opMap) {
evaluationData data(rpn, scope, opMap);
// Evaluate the expression in RPN form.
std::stack<TokenBase*> evaluation;
while (!data.rpn.empty()) {
TokenBase* base = data.rpn.front()->clone();
data.rpn.pop();
// Operator:
if (base->type == OP) {
data.op = static_cast<Token<std::string>*>(base)->val;
delete base;
/* * * * * Resolve operands Values and References: * * * * */
if (evaluation.size() < 2) {
cleanStack(evaluation);
throw std::domain_error("Invalid equation.");
}
TokenBase* b_right = evaluation.top(); evaluation.pop();
TokenBase* b_left = evaluation.top(); evaluation.pop();
if (b_right->type == VAR) {
std::string var_name = static_cast<Token<std::string>*>(b_right)->val;
delete b_right;
delete resolve_reference(b_left);
cleanStack(evaluation);
throw std::domain_error("Unable to find the variable '" + var_name + "'.");
} else {
b_right = resolve_reference(b_right, &data.scope);
}
packToken r_left;
packToken m_left;
if (b_left->type & REF) {
RefToken* left = static_cast<RefToken*>(b_left);
r_left = left->key;
m_left = left->source;
b_left = resolve_reference(left, &data.scope);
} else if (b_left->type == VAR) {
r_left = static_cast<Token<std::string>*>(b_left)->val;
}
/* * * * * Resolve Asign Operation * * * * */
if (!data.op.compare("=")) {
delete b_left;
// If the left operand has a variable name:
if (r_left->type == STR) {
if (m_left->type == MAP) {
TokenMap& map = m_left.asMap();
std::string& key = r_left.asString();
map[key] = packToken(b_right->clone());
} else {
TokenMap* map = data.scope.findMap(r_left.asString());
if (!map || *map == TokenMap::default_global()) {
// Assign on the local scope.
// The user should not be able to implicitly overwrite
// variables he did not declare, since it's error prone.
data.scope[r_left.asString()] = packToken(b_right->clone());
} else {
(*map)[r_left.asString()] = packToken(b_right->clone());
}
}
evaluation.push(b_right);
// If the left operand has an index number:
} else if (r_left->type & NUM) {
if (m_left->type == LIST) {
TokenList& list = m_left.asList();
size_t index = r_left.asInt();
list[index] = packToken(b_right->clone());
} else {
delete b_right;
cleanStack(evaluation);
throw std::domain_error("Left operand of assignment is not a list!");
}
evaluation.push(b_right);
} else {
packToken p_right(b_right->clone());
delete b_right;
cleanStack(evaluation);
throw undefined_operation(data.op, r_left, p_right);
}
} else if (b_left->type == FUNC && data.op == "()") {
Function* f_left = static_cast<Function*>(b_left);
if (!data.op.compare("()")) {
// Collect the parameter tuple:
Tuple right;
if (b_right->type == TUPLE) {
right = *static_cast<Tuple*>(b_right);
} else {
right = Tuple(b_right);
}
delete b_right;
packToken _this;
if (m_left->type != NONE) {
_this = m_left;
} else {
_this = data.scope;
}
// Execute the function:
packToken ret;
try {
ret = Function::call(_this, f_left, &right, data.scope);
} catch (...) {
cleanStack(evaluation);
delete f_left;
throw;
}
delete f_left;
evaluation.push(ret->clone());
} else {
packToken p_right(b_right->clone());
packToken p_left(b_left->clone());
delete b_right;
cleanStack(evaluation);
throw undefined_operation(data.op, p_left, p_right);
}
} else {
data.opID = Operation::build_mask(b_left->type, b_right->type);
packToken p_left(b_left);
packToken p_right(b_right);
TokenBase* result = 0;
try {
// Resolve the operation:
result = exec_operation(p_left, p_right, &data, data.op);
if (!result) {
result = exec_operation(p_left, p_right, &data, ANY_OP);
}
} catch (...) {
cleanStack(evaluation);
throw;
}
if (result) {
evaluation.push(result);
} else {
cleanStack(evaluation);
throw undefined_operation(data.op, p_left, p_right);
}
}
} else if (base->type == VAR) { // Variable
packToken* value = NULL;
std::string key = static_cast<Token<std::string>*>(base)->val;
value = data.scope.find(key);
if (value) {
TokenBase* copy = (*value)->clone();
evaluation.push(new RefToken(key, copy));
delete base;
} else {
evaluation.push(base);
}
} else {
evaluation.push(base);
}
}
return evaluation.top();
}
