Expressions.cpp

#include "Expressions.h"
 
#include "Parsing.h"
 
#include "Foundation/HashFunctions.h"
#include "Foundation/StringViewFormat.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <glm/glm.hpp>
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("Expressions");
}
 
Cogs::Core::ExpressionContext::ExpressionContext()
{
  clear();
  reserve();
}
 
void Cogs::Core::ExpressionContext::reserve()
{
  values.reserve(kMaxVariables);
  variables.reserve(kMaxVariables);
}
 
void Cogs::Core::ExpressionContext::inherit(ExpressionContext * other)
{
  assert(parent == nullptr);
  parent = other;
 
  assert(scope.parent == nullptr);
  scope.parent = &other->scope;
 
  scope.variables = variables.data();
  scope.var_count = static_cast<int>(variables.size());
}
 
double Cogs::Core::ExpressionContext::eval(std::string_view expression, double defaultValue)
{
  double result = defaultValue;
 
  auto expr = compile(expression, "");
 
  if (expr && expr->expression) {
    result = te_eval(expr->expression);
  }
 
  free(expr);
 
  return result;
}
 
Cogs::Core::Expression * Cogs::Core::ExpressionContext::compile(std::string_view expression, std::string_view variable)
{
  size_t              code = Cogs::hash(expression, Cogs::hash(variable));
  ExpressionVariable* resultVariable = nullptr;
 
  if (variable.size()) {
    for (auto & v : values) {
      if (variable == v.name) {
        resultVariable = &v;
      }
    }
  }
  auto fIt = expressions.find(code);
 
  if (fIt != expressions.end()) {
    return &fIt->second;
  }
 
  int error = 0;
  auto expr = te_compile(expression.data(), expression.size(), &scope, &error);
 
  if (!expr) {
    LOG_ERROR(logger, "Could not compile expression '%.*s' <error> '%.*s'.",
      StringViewFormat(expression.substr(0, error)),
      StringViewFormat(expression.substr(error)));
    return nullptr;
  }
 
  expressions[code] = Expression{ std::string(expression), resultVariable, expr, code };
 
  return &expressions[code];
}
 
void Cogs::Core::ExpressionContext::free(Expression * /*expression*/)
{
  // No freeing for now.
}
 
Cogs::Core::ExpressionVariable& Cogs::Core::ExpressionContext::add(std::string_view name, double value)
{
  // If value already exists, we just update and return.
  for (auto & v : values) {
    if (name == v.name) {
      v.value = value;
      return v;
    }
  }
 
  values.emplace_back();
  variables.emplace_back();
 
  auto & v = values.back();
 
  v.name = std::string(name);
  v.value = value;
 
  auto & var = variables.back();
 
  var.address = &values.back().value;
  var.name = v.name.c_str();
 
  scope.variables = variables.data();
  scope.var_count = static_cast<int>(variables.size());
 
  return v;
}
 
double Cogs::Core::ExpressionContext::update(const Expression * expression, double defaultValue)
{
  if (!expression || !expression->expression) return defaultValue;
 
  auto result = te_eval(expression->expression);
 
  if (expression->resultVariable) {
    expression->resultVariable->value = result;
  }
 
  return result;
}
 
float Cogs::Core::ExpressionContext::update(const Expression * expression, float defaultValue)
{
  return static_cast<float>(update(expression, static_cast<double>(defaultValue)));
}
 
int Cogs::Core::ExpressionContext::update(const Expression * expression, int defaultValue)
{
  return static_cast<int>(update(expression, static_cast<double>(defaultValue)));
}
 
size_t Cogs::Core::ExpressionContext::update(const Expression * expression, size_t defaultValue)
{
  double value = update(expression, static_cast<double>(defaultValue));
 
  if (glm::fract(value) > std::numeric_limits<double>::epsilon()) {
    LOG_TRACE(logger, "Truncating evaluated expression %f", value);
  }
 
  return static_cast<size_t>(value);
}
 
void Cogs::Core::ExpressionContext::link(ExpressionContext * source, std::string_view sourceName, std::string_view destName)
{
 
  while (source != nullptr) {
    int numSourceVars = source->scope.var_count;
    for (int i = 0; i < numSourceVars; ++i) {
      if (sourceName == source->variables[i].name) {
        auto& sourceVariable = source->variables[i];
 
        values.emplace_back();
        variables.emplace_back();
 
        auto& v = values.back();
 
        v.name = std::string(destName);
        v.value = source->values[i].value;
 
        auto& var = variables.back();
 
        // Use the source variable value instead of the "var.address = &values.back().value;"
        // to get updated values from the links
        var.address = &source->values[i].value;
        var.name = v.name.c_str();
        var.link = &sourceVariable;
 
        scope.variables = variables.data();
        scope.var_count = static_cast<int>(variables.size());
 
        return;
      }
    }
    source = source->parent;
  }
 
  LOG_WARNING(logger, "Could not link variable. \"%s\" to \"%s\".", sourceName.data(), destName.data());
}
 
void Cogs::Core::ExpressionContext::clear()
{
  for (auto & e : expressions) {
    te_free(e.second.expression);
  }
  expressions.clear();
 
  parent = nullptr;
  scope.parent = nullptr;
  scope.variables = nullptr;
  scope.var_count = 0;
}
 
std::span<const Cogs::Core::ExpressionVariable> Cogs::Core::ExpressionContext::getValues() const
{
  return std::span(values.data(), values.data() + values.size());
}
 
std::span<Cogs::Core::ExpressionVariable> Cogs::Core::ExpressionContext::getValues()
{
  return std::span(values.data(), values.data() + values.size());
}
 
void Cogs::Core::readSize_t(ExpressionValue<size_t> & value, ExpressionContext * ev, const std::string & prefix, const ParsedValue & parsedValue)
{
  if (parsedValue.type == ParsedDataType::Int) {
    value = parsedValue.intValue;
  } else if (parsedValue.type == ParsedDataType::Float) {
    value = static_cast<size_t>(parsedValue.floatValue);
  } else {
    value = ExpressionValue<size_t>(ev, prefix + "." + parsedValue.key, parsedValue.value, 0);
  }
}