Statement.cpp

#include "Statement.h"

#include <sstream>
#include <stdexcept>

// ========================
// Statement.cpp
// 各种 BASIC 语句节点的语法树文本生成实现。
// ========================

namespace {
// 工具函数：生成指定空格数的缩进，供语法树文本使用。
std::string indent(int value) {
    return std::string(value, ' ');
}
}

void Statement::resetRuntimeStats() noexcept {
    m_execCount = 0;
}

void Statement::collectVarUses(std::map<std::string, int> &counter) const {
    (void)counter;
    // 默认实现什么也不做，具体语句自行覆盖
}

std::string Statement::headerWithStats() const {
    return header() + " " + std::to_string(m_execCount);
}
// ========================
// REM 语句：注释
// ========================
RemStatement::RemStatement(std::string comment) : m_comment(std::move(comment)) {}


// 返回语句类型头部
std::string RemStatement::header() const {
    return "REM";
}


// 语法树内容：输出注释内容
std::string RemStatement::bodyToTreeString(int indentSize,
                                           const std::map<std::string, int>* useCount) const {
    (void)useCount;
    if (m_comment.empty()) {
        return "";
    }
    return indent(indentSize) + m_comment + "\n";
}

void RemStatement::execute(EvalState &state)
{
    (void)state;
    markExecuted();
}


// ========================
// LET 语句：赋值
// ========================
LetStatement::LetStatement(std::string variable, std::unique_ptr<Expression> expression)
    : m_variable(std::move(variable)), m_expression(std::move(expression)) {}


// 返回语句类型头部
std::string LetStatement::header() const {
    return "LET";
}


// 语法树内容：先输出变量名，再递归输出表达式树
std::string LetStatement::bodyToTreeString(int indentSize,
                                           const std::map<std::string, int>* useCount) const {
    std::ostringstream oss;
    oss << indent(indentSize) << m_variable;

    // 如果要输出这个变量用了几次，useCount非null
    if (useCount) {
        auto it = useCount->find(m_variable);
        if (it != useCount->end()) {
            oss << " " << it->second;
        }
    }
    oss << "\n";
    if (m_expression) {
        oss << m_expression->toTreeString(indentSize);
    }
    return oss.str();
}

void LetStatement::execute(EvalState &state)
{
    markExecuted();
    if (!m_expression) {
        throw std::runtime_error("LET statement missing expression");
    }

    int value = m_expression->eval(state);
    state.setValue(m_variable, value);
}

void LetStatement::collectVarUses(std::map<std::string, int> &counter) const
{
    if (m_expression) {
        m_expression->collectVarUses(counter);
    }
}

const std::string& LetStatement::getVariable() const noexcept
{
    return m_variable;
}

const Expression* LetStatement::getExpression() const noexcept
{
    return m_expression.get();
}


// ========================
// PRINT 语句：输出
// ========================
PrintStatement::PrintStatement(std::unique_ptr<Expression> expression)
    : m_expression(std::move(expression)) {}


// 返回语句类型头部
std::string PrintStatement::header() const {
    return "PRINT";
}


// 语法树内容：递归输出表达式树
std::string PrintStatement::bodyToTreeString(int indentSize,
                                             const std::map<std::string, int>* useCount) const {
    (void)useCount;
    return m_expression ? m_expression->toTreeString(indentSize) : std::string();
    // 如果m_expression不存在，返回空字符串 std::string()
}

void PrintStatement::execute(EvalState &state)
{
    markExecuted();
    if (!m_expression) {
        throw std::runtime_error("PRINT statement missing expression");
    }
    int value = m_expression->eval(state);
    throw PrintSignal(std::to_string(value));
}

void PrintStatement::collectVarUses(std::map<std::string, int> &counter) const
{
    if (m_expression) {
        m_expression->collectVarUses(counter);
    }
}


// ========================
// INPUT 语句：输入
// ========================
InputStatement::InputStatement(std::string variable) : m_variable(std::move(variable)) {}


// 返回语句类型头部
std::string InputStatement::header() const {
    return "INPUT";
}


// 语法树内容：输出变量名
std::string InputStatement::bodyToTreeString(int indentSize,
                                             const std::map<std::string, int>* useCount) const {
    (void)useCount;
    return indent(indentSize) + m_variable + "\n";
}

void InputStatement::execute(EvalState &state)
{
    (void)state;
    markExecuted();
    throw InputSignal(m_variable);
}


// ========================
// GOTO 语句：无条件跳转
// ========================
GotoStatement::GotoStatement(int targetLine) : m_targetLine(targetLine) {}


// 返回语句类型头部
std::string GotoStatement::header() const {
    return "GOTO";
}


// 语法树内容：输出目标行号
std::string GotoStatement::bodyToTreeString(int indentSize,
                                            const std::map<std::string, int>* useCount) const {
    (void)useCount;
    return indent(indentSize) + std::to_string(m_targetLine) + "\n";
}

void GotoStatement::execute(EvalState &state)
{
    (void)state;
    markExecuted();
    // 把参数强制转换成 void 是一种常见写法
    // 意思是“我知道这个参数存在但有意不使用”，从而消除警告，
    // 同时让读者清楚地看到这是刻意的。
    throw JumpSignal(m_targetLine);
    // INPUT execute 现在只负责抛信号
}


// ========================
// IF 语句：条件跳转
// ========================
IfStatement::IfStatement(std::unique_ptr<Expression> left,
                         std::string op,
                         std::unique_ptr<Expression> right,
                         int targetLine)
    : m_left(std::move(left)), m_right(std::move(right)), m_operator(std::move(op)), m_targetLine(targetLine) {}


// 返回语句类型头部
std::string IfStatement::header() const {
    return "IF THEN";
}

std::string IfStatement::headerWithStats() const {
    return std::string("IF THEN ") + std::to_string(m_trueCount) + " " + std::to_string(m_falseCount);
}


// 语法树内容：先输出比较符，再递归输出左右表达式，最后输出目标行号
std::string IfStatement::bodyToTreeString(int indentSize,
                                          const std::map<std::string, int>* useCount) const {
    (void)useCount;
    std::ostringstream oss;

    if (m_left) {
        oss << m_left->toTreeString(indentSize);
    }

    oss << indent(indentSize) << m_operator << "\n";

    if (m_right) {
        oss << m_right->toTreeString(indentSize);
    }
    // 最后一行显示跳转目标行号。
    oss << indent(indentSize) << m_targetLine << "\n";
    return oss.str();
}

void IfStatement::execute(EvalState &state)
{
    markExecuted();
    if (!m_left || !m_right) {
        throw std::runtime_error("IF statement missing expression");
    }
    int leftValue = m_left->eval(state);
    int rightValue = m_right->eval(state);
    bool condition = false;
    if (m_operator == "=") {
        condition = (leftValue == rightValue);
    } else if (m_operator == "<") {
        condition = (leftValue < rightValue);
    } else if (m_operator == ">") {
        condition = (leftValue > rightValue);
    } else {
        throw std::runtime_error("Unsupported comparison operator in IF");
    }
    if (condition) {
        ++m_trueCount;
        throw JumpSignal(m_targetLine);
    }
    ++m_falseCount;
}

void IfStatement::resetRuntimeStats() noexcept
{
    Statement::resetRuntimeStats();
    m_trueCount = 0;
    m_falseCount = 0;
}

void IfStatement::collectVarUses(std::map<std::string, int> &counter) const
{
    if (m_left) {
        m_left->collectVarUses(counter);
    }
    if (m_right) {
        m_right->collectVarUses(counter);
    }
}


// ========================
// END 语句：程序结束
// ========================
// 返回语句类型头部
std::string EndStatement::header() const {
    return "END";
}


// 语法树内容：END 无内容
std::string EndStatement::bodyToTreeString(int,
                                           const std::map<std::string, int>* useCount) const {
    (void)useCount;
    return "";
}

void EndStatement::execute(EvalState &state)
{
    (void)state;
    markExecuted();
    throw EndSignal();
}