Interpreter Class Reference

The Interpreter class evaluates statements and expressions in the GSC. More...

#include <interpreter.hpp>

Inheritance diagram for Interpreter:

Collaboration diagram for Interpreter:

Public Member Functions
void	interpret (const std::vector< std::shared_ptr< Stmt > > &statements)
	Interpret the given statement list and execute them.
Public Member Functions inherited from ExprVisitor
virtual	~ExprVisitor ()=default
Public Member Functions inherited from StmtVisitor
virtual	~StmtVisitor ()=default

Private Member Functions
std::any	evaluate (std::shared_ptr< Expr > expr)
void	execute (std::shared_ptr< Stmt > stmt)
void	executeBlock (const std::vector< std::shared_ptr< Stmt > > statements, std::shared_ptr< Environment > environment)
std::any	visitBinaryExpr (std::shared_ptr< Binary > expr) override
std::any	visitLogicalExpr (std::shared_ptr< Logical > expr) override
std::any	visitGroupingExpr (std::shared_ptr< Grouping > expr) override
std::any	visitLiteralExpr (std::shared_ptr< Literal > expr) override
std::any	visitUnaryExpr (std::shared_ptr< Unary > expr) override
std::any	visitAssignExpr (std::shared_ptr< Assign > expr) override
std::any	visitVariableExpr (std::shared_ptr< Variable > expr) override
std::any	visitBlockStmt (std::shared_ptr< Block > stmt) override
std::any	visitExpressionStmt (std::shared_ptr< Expression > stmt) override
std::any	visitPrintStmt (std::shared_ptr< Print > stmt) override
std::any	visitIfStmt (std::shared_ptr< If > stmt) override
std::any	visitWhileStmt (std::shared_ptr< While > stmt) override
std::any	visitVarStmt (std::shared_ptr< Var > stmt) override
template<class... N>
void	checkNumberOperands (const Token &op, N... operands)
bool	isTruthy (const std::any &value) const
bool	isEqual (const std::any &a, const std::any &b) const
std::string	stringify (const std::any &value) const

Private Attributes
std::shared_ptr< Environment >	environment {new Environment}

Detailed Description

The Interpreter class evaluates statements and expressions in the GSC.

Note

It implements the ExprVisitor interface to visit different types of expressions and statements, and evaluate them accordingly. The results of the evaluations are returned as std::any types, allowing for flexibility in the types of values that can be returned.

Definition at line 16 of file interpreter.hpp.

Member Function Documentation

checkNumberOperands()

template<class... N>

void Interpreter::checkNumberOperands ( const Token &  op, N...  operands  )

private

Definition at line 42 of file interpreter.cpp.

                                                                    {
  if (((operands.type() != typeid(int)) && ...)) {
    throw RuntimeError(std::make_shared<Token>(op),
                       "Operands must be numbers.");
  }
}

evaluate()

std::any Interpreter::evaluate ( std::shared_ptr< Expr >  expr )

private

Definition at line 17 of file interpreter.cpp.

                                                     {
  return expr->accept(*this);
}

execute()

void Interpreter::execute ( std::shared_ptr< Stmt >  stmt )

private

Definition at line 21 of file interpreter.cpp.

{ stmt->accept(*this); }

executeBlock()

void Interpreter::executeBlock ( const std::vector< std::shared_ptr< Stmt > >  statements, std::shared_ptr< Environment >  environment  )

private

Definition at line 23 of file interpreter.cpp.

                                            {
  std::shared_ptr<Environment> previous = this->environment;
  try {
    this->environment = environment;
 
    for (const std::shared_ptr<Stmt> &stmt : statements) {
      execute(stmt);
    }
  } catch (...) {
    this->environment = previous;
    throw; // Re-throw the exception to be handled by the caller
  }
 
  this->environment = previous;
}

interpret()

void Interpreter::interpret

(

const std::vector< std::shared_ptr< Stmt > > &

statements

)

Interpret the given statement list and execute them.

Parameters

statements

A vector of shared pointers to Stmt objects representing

Note

This method evaluates the provided statements in the context of the GSC interpreter.

If an error occurs during interpretation, it will shown an error message to the user and set the hadRuntimeError variable to true.

Definition at line 6 of file interpreter.cpp.

                                                      {
  try {
    for (const std::shared_ptr<Stmt> &stmt : statements) {
      execute(stmt);
    }
  } catch (RuntimeError &error) {
    runtimeError(error);
  }
}

isEqual()

bool Interpreter::isEqual ( const std::any &  a, const std::any &  b  ) const

private

Definition at line 63 of file interpreter.cpp.

                                                                {
  if (a.type() != b.type()) {
    return false;
  } else if (a.type() == typeid(std::nullptr_t)) {
    return true; // Both are nil
  } else if (a.type() == typeid(bool)) {
    return std::any_cast<bool>(a) == std::any_cast<bool>(b);
  } else if (a.type() == typeid(int)) {
    return std::any_cast<int>(a) == std::any_cast<int>(b);
  } else if (a.type() == typeid(std::string)) {
    return std::any_cast<std::string>(a) == std::any_cast<std::string>(b);
  } else {
    return false; // Unsupported types
  }
}

isTruthy()

bool Interpreter::isTruthy ( const std::any &  value ) const

private

Definition at line 49 of file interpreter.cpp.

                                                    {
  if (value.type() == typeid(std::nullptr_t)) {
    return false;
  } else if (value.type() == typeid(int)) {
    return std::any_cast<int>(value) != 0; // Non-zero integers are truthy
  } else if (value.type() == typeid(std::string)) {
    return !std::any_cast<std::string>(value)
                .empty(); // Non-empty strings are truthy
  } else if (value.type() == typeid(bool)) {
    return std::any_cast<bool>(value);
  }
  return true; // All other values are truthy
}

stringify()

std::string Interpreter::stringify ( const std::any &  value ) const

private

Definition at line 79 of file interpreter.cpp.

                                                          {
  if (value.type() == typeid(std::nullptr_t)) {
    return "nil";
  } else if (value.type() == typeid(bool)) {
    return std::any_cast<bool>(value) ? "true" : "false";
  } else if (value.type() == typeid(int)) {
    return std::to_string(std::any_cast<int>(value));
  } else if (value.type() == typeid(std::string)) {
    return std::any_cast<std::string>(value);
  } else if (value.type() == typeid(const char *)) {
    return std::any_cast<const char *>(value);
  }
  return "Internal error (interpreter): object type not recognized"; // Unsupported
                                                                     // types
}

visitAssignExpr()

std::any Interpreter::visitAssignExpr ( std::shared_ptr< Assign >  expr )

overrideprivatevirtual

Implements ExprVisitor.

Definition at line 185 of file interpreter.cpp.

                                                              {
  std::any value = evaluate(expr->getValue());
  environment->assign(expr->getName(), value);
  return value;
}

visitBinaryExpr()

std::any Interpreter::visitBinaryExpr ( std::shared_ptr< Binary >  expr )

overrideprivatevirtual

Implements ExprVisitor.

Definition at line 120 of file interpreter.cpp.

                                                              {
  std::any left = evaluate(expr->getLeft());
  std::any right = evaluate(expr->getRight());
  Token op = expr->getOp();
 
  switch (op.getType()) {
  case TokenType::PLUS:
    if (left.type() == typeid(int) && right.type() == typeid(int)) {
      return std::any_cast<int>(left) + std::any_cast<int>(right);
    } else if (left.type() == typeid(std::string) &&
               right.type() == typeid(std::string)) {
      return std::any_cast<std::string>(left) +
             std::any_cast<std::string>(right);
    } else {
      throw RuntimeError(std::make_shared<Token>(op),
                         "Operands must be two numbers or two strings.");
    }
  case TokenType::MINUS:
    checkNumberOperands(op, left, right);
    return std::any_cast<int>(left) - std::any_cast<int>(right);
  case TokenType::STAR:
    checkNumberOperands(op, left, right);
    return std::any_cast<int>(left) * std::any_cast<int>(right);
  case TokenType::SLASH:
    checkNumberOperands(op, left, right);
    if (std::any_cast<int>(right) == 0) {
      throw RuntimeError(std::make_shared<Token>(op), "Division by zero.");
    }
    return std::any_cast<int>(left) / std::any_cast<int>(right);
  case TokenType::GREATER:
    checkNumberOperands(op, left, right);
    return std::any_cast<int>(left) > std::any_cast<int>(right);
  case TokenType::GREATER_EQUAL:
    checkNumberOperands(op, left, right);
    return std::any_cast<int>(left) >= std::any_cast<int>(right);
  case TokenType::LESS:
    checkNumberOperands(op, left, right);
    return std::any_cast<int>(left) < std::any_cast<int>(right);
  case TokenType::LESS_EQUAL:
    checkNumberOperands(op, left, right);
    return std::any_cast<int>(left) <= std::any_cast<int>(right);
  case TokenType::EQUAL_EQUAL:
    return isEqual(left, right);
  case TokenType::BANG_EQUAL:
    return !isEqual(left, right);
  default:
    // This should never be reached, but just in case
    assert(false && "Unknown binary operator");
    return {};
  }
}

visitBlockStmt()

std::any Interpreter::visitBlockStmt ( std::shared_ptr< Block >  stmt )

overrideprivatevirtual

Implements StmtVisitor.

Definition at line 195 of file interpreter.cpp.

                                                            {
  executeBlock(stmt->getStatements(),
               std::make_shared<Environment>(environment));
  return {};
}

visitExpressionStmt()

std::any Interpreter::visitExpressionStmt ( std::shared_ptr< Expression >  stmt )

overrideprivatevirtual

Implements StmtVisitor.

Definition at line 201 of file interpreter.cpp.

                                                                      {
  evaluate(stmt->getExpression());
  return {};
}

visitGroupingExpr()

std::any Interpreter::visitGroupingExpr ( std::shared_ptr< Grouping >  expr )

overrideprivatevirtual

Implements ExprVisitor.

Definition at line 95 of file interpreter.cpp.

                                                                  {
  return evaluate(expr->getExpression());
}

visitIfStmt()

std::any Interpreter::visitIfStmt ( std::shared_ptr< If >  stmt )

overrideprivatevirtual

Implements StmtVisitor.

Definition at line 212 of file interpreter.cpp.

                                                      {
  std::any condition = evaluate(stmt->getCondition());
  if (isTruthy(condition)) {
    execute(stmt->getThenBranch());
  } else if (stmt->getElseBranch()) {
    execute(stmt->getElseBranch());
  }
  return {};
}

visitLiteralExpr()

std::any Interpreter::visitLiteralExpr ( std::shared_ptr< Literal >  expr )

overrideprivatevirtual

Implements ExprVisitor.

Definition at line 99 of file interpreter.cpp.

                                                                {
  return expr->getValue();
}

visitLogicalExpr()

std::any Interpreter::visitLogicalExpr ( std::shared_ptr< Logical >  expr )

overrideprivatevirtual

Implements ExprVisitor.

Definition at line 172 of file interpreter.cpp.

                                                                {
  std::any left = evaluate(expr->getLeft());
  Token op = expr->getOp();
 
  // Short-circuit evaluation
  if ((op.getType() == TokenType::OR && isTruthy(left)) ||
      (op.getType() == TokenType::AND && !isTruthy(left))) {
    return left;
  }
 
  return evaluate(expr->getRight());
}

visitPrintStmt()

std::any Interpreter::visitPrintStmt ( std::shared_ptr< Print >  stmt )

overrideprivatevirtual

Implements StmtVisitor.

Definition at line 206 of file interpreter.cpp.

                                                            {
  std::any value = evaluate(stmt->getExpression());
  std::cout << stringify(value) << std::endl;
  return {};
}

visitUnaryExpr()

std::any Interpreter::visitUnaryExpr ( std::shared_ptr< Unary >  expr )

overrideprivatevirtual

Implements ExprVisitor.

Definition at line 103 of file interpreter.cpp.

                                                            {
  std::any right = evaluate(expr->getRight());
  Token op = expr->getOp();
 
  switch (op.getType()) {
  case TokenType::MINUS:
    checkNumberOperands(op, right);
    return -std::any_cast<int>(right);
  case TokenType::BANG:
    return !isTruthy(right);
  default:
    // This should never be reached, but just in case
    assert(false && "Unknown unary operator");
    return {};
  }
}

visitVariableExpr()

std::any Interpreter::visitVariableExpr ( std::shared_ptr< Variable >  expr )

overrideprivatevirtual

Implements ExprVisitor.

Definition at line 191 of file interpreter.cpp.

                                                                  {
  return environment->get(expr->getName());
}

visitVarStmt()

std::any Interpreter::visitVarStmt ( std::shared_ptr< Var >  stmt )

overrideprivatevirtual

Implements StmtVisitor.

Definition at line 229 of file interpreter.cpp.

                                                        {
  std::any value = nullptr;
  if (stmt->getInitializer()) {
    value = evaluate(stmt->getInitializer());
  }
  environment->define(stmt->getName().getLexeme(), std::move(value));
  return {};
}

visitWhileStmt()

std::any Interpreter::visitWhileStmt ( std::shared_ptr< While >  stmt )

overrideprivatevirtual

Implements StmtVisitor.

Definition at line 222 of file interpreter.cpp.

                                                            {
  while (isTruthy(evaluate(stmt->getCondition()))) {
    execute(stmt->getBody());
  }
  return {};
}

Member Data Documentation

environment

std::shared_ptr<Environment> Interpreter::environment {new Environment}

private

Definition at line 18 of file interpreter.hpp.

{new Environment};

---

The documentation for this class was generated from the following files:

• lib/gsc/interpreter.hpp
• src/interpreter.cpp