#ifndef INTERPRETER_HPP
|
#define INTERPRETER_HPP
|
#include <iostream>
|
#include <memory>
|
#include <stdexcept>
|
|
#include "Interpreter/Operation.hpp"
|
#include "Interpreter/OperationContainer.hpp"
|
#include "Symbols/SymbolContainer.hpp"
|
#include "BaseException.hpp"
|
|
// Exception type for runtime errors, includes file, line, and column context
|
namespace Interpreter {
|
class Exception : public BaseException {
|
public:
|
Exception(const std::string &msg, const std::string &filename, int line, size_t column) {
|
rawMessage_ = msg;
|
context_ = std::string(" in file \"") + filename + "\" at line: " + std::to_string(line)
|
+ ", column: " + std::to_string(column);
|
formattedMessage_ = formatMessage();
|
}
|
std::string formatMessage() const override {
|
return std::string("[Runtime ERROR] >>") + context_ + " << : " + rawMessage_;
|
}
|
};
|
} // namespace Interpreter
|
|
namespace Interpreter {
|
|
class Interpreter {
|
private:
|
bool debug_ = false;
|
public:
|
/**
|
* @brief Construct interpreter with optional debug output
|
* @param debug enable interpreter debug output
|
*/
|
Interpreter(bool debug = false) : debug_(debug) {}
|
|
/**
|
* @brief Execute all operations in the current namespace (e.g., file-level or function-level).
|
*/
|
void run() {
|
// Determine namespace to execute
|
const std::string ns = Symbols::SymbolContainer::instance()->currentScopeName();
|
for (const auto & operation : Operations::Container::instance()->getAll(ns)) {
|
runOperation(*operation);
|
}
|
}
|
|
void runOperation(const Operations::Operation & op) {
|
if (debug_) {
|
std::cerr << "[Debug][Interpreter] Operation: " << op.toString() << "\n";
|
}
|
|
switch (op.type) {
|
case Operations::Type::Declaration:
|
if (op.statement) {
|
op.statement->interpret(*this);
|
}
|
break;
|
case Operations::Type::FuncDeclaration:
|
{
|
op.statement->interpret(*this);
|
}
|
break;
|
|
case Operations::Type::Assignment:
|
{
|
op.statement->interpret(*this);
|
break;
|
}
|
|
case Operations::Type::Expression:
|
{
|
op.statement->interpret(*this); // csak side effect miatt
|
break;
|
}
|
|
case Operations::Type::FunctionCall:
|
if (op.statement) {
|
op.statement->interpret(*this);
|
}
|
break;
|
case Operations::Type::Conditional:
|
// if-else conditional block
|
if (op.statement) {
|
op.statement->interpret(*this);
|
}
|
break;
|
case Operations::Type::Return:
|
// return statement
|
if (op.statement) {
|
op.statement->interpret(*this);
|
}
|
break;
|
case Operations::Type::Loop:
|
// for-in or while loop
|
if (op.statement) {
|
op.statement->interpret(*this);
|
}
|
break;
|
case Operations::Type::Break:
|
case Operations::Type::Continue:
|
case Operations::Type::Block:
|
case Operations::Type::Import:
|
case Operations::Type::Error:
|
// TODO: implement these operations later
|
break;
|
default:
|
throw std::runtime_error("Not implemented operation type");
|
}
|
}
|
|
}; // class Interpreter
|
|
} // namespace Interpreter
|
#endif // INTERPRETER_HPP
|
