#ifndef INTERPRETER_ARRAY_ACCESS_EXPRESSION_NODE_HPP
|
#define INTERPRETER_ARRAY_ACCESS_EXPRESSION_NODE_HPP
|
|
#include "ExpressionNode.hpp"
|
#include "Symbols/Value.hpp"
|
#include <stdexcept>
|
#include <string>
|
|
namespace Interpreter {
|
|
/**
|
* @brief Expression node for dynamic array/object indexing: expr[index]
|
*/
|
class ArrayAccessExpressionNode : public ExpressionNode {
|
private:
|
std::unique_ptr<ExpressionNode> arrayExpr_;
|
std::unique_ptr<ExpressionNode> indexExpr_;
|
|
public:
|
ArrayAccessExpressionNode(std::unique_ptr<ExpressionNode> arrayExpr,
|
std::unique_ptr<ExpressionNode> indexExpr)
|
: arrayExpr_(std::move(arrayExpr)), indexExpr_(std::move(indexExpr)) {}
|
|
Symbols::Value evaluate(Interpreter &interpreter) const override {
|
// Evaluate the container (object or array)
|
Symbols::Value container = arrayExpr_->evaluate(interpreter);
|
if (container.getType() != Symbols::Variables::Type::OBJECT) {
|
throw std::runtime_error("Attempted to index non-array");
|
}
|
const auto & map = std::get<Symbols::Value::ObjectMap>(container.get());
|
// Evaluate the index
|
Symbols::Value idxVal = indexExpr_->evaluate(interpreter);
|
std::string key;
|
if (idxVal.getType() == Symbols::Variables::Type::INTEGER) {
|
key = std::to_string(idxVal.get<int>());
|
} else if (idxVal.getType() == Symbols::Variables::Type::STRING) {
|
key = idxVal.get<std::string>();
|
} else {
|
throw std::runtime_error("Array index must be integer or string");
|
}
|
auto it = map.find(key);
|
if (it == map.end()) {
|
throw std::runtime_error("Index not found: " + key);
|
}
|
return it->second;
|
}
|
|
std::string toString() const override {
|
return arrayExpr_->toString() + "[" + indexExpr_->toString() + "]";
|
}
|
};
|
|
} // namespace Interpreter
|
|
#endif // INTERPRETER_ARRAY_ACCESS_EXPRESSION_NODE_HPP
|
