2098 lines
62 KiB
C++
2098 lines
62 KiB
C++
#include <sstream>
|
|
#include <algorithm>
|
|
#include <optional>
|
|
#include "./debug_printer.hpp"
|
|
|
|
namespace lsp::language::ast
|
|
{
|
|
// ===== 便捷函数实现 =====
|
|
|
|
std::string DebugString(const ASTNode* node, const PrintOptions& opts)
|
|
{
|
|
std::ostringstream oss;
|
|
DebugPrinter printer(oss, opts);
|
|
if (node)
|
|
{
|
|
printer.Print(node);
|
|
}
|
|
return oss.str();
|
|
}
|
|
|
|
std::string DebugString(const ParseResult& result, const PrintOptions& opts)
|
|
{
|
|
std::ostringstream oss;
|
|
DebugPrinter printer(oss, opts);
|
|
printer.PrintParseResult(result);
|
|
return oss.str();
|
|
}
|
|
|
|
void DebugPrint(const ASTNode* node, const PrintOptions& opts)
|
|
{
|
|
DebugPrinter printer(std::cout, opts);
|
|
if (node)
|
|
{
|
|
printer.Print(node);
|
|
}
|
|
}
|
|
|
|
void DebugPrint(const ParseResult& result, const PrintOptions& opts)
|
|
{
|
|
DebugPrinter printer(std::cout, opts);
|
|
printer.PrintParseResult(result);
|
|
}
|
|
|
|
void DebugPrint(const ASTNode* node, const std::string& source, const PrintOptions& opts)
|
|
{
|
|
DebugPrinter printer(std::cout, opts);
|
|
printer.SetSourceCode(&source);
|
|
if (node)
|
|
{
|
|
printer.Print(node);
|
|
}
|
|
}
|
|
|
|
void DebugPrint(const ParseResult& result, const std::string& source, const PrintOptions& opts)
|
|
{
|
|
DebugPrinter printer(std::cout, opts);
|
|
printer.SetSourceCode(&source);
|
|
printer.PrintParseResult(result);
|
|
}
|
|
|
|
// ===== DebugPrinter 主要方法 =====
|
|
|
|
void DebugPrinter::Print(const ASTNode* node)
|
|
{
|
|
if (!node)
|
|
{
|
|
os_ << GetColor(Color::Red) << "nullptr" << GetColor(Color::Reset) << "\n";
|
|
return;
|
|
}
|
|
|
|
const_cast<ASTNode*>(node)->Accept(*this);
|
|
}
|
|
|
|
void DebugPrinter::PrintStatements(const std::vector<StatementPtr>& statements)
|
|
{
|
|
if (statements.empty())
|
|
{
|
|
PrintColored("(empty)", Color::Gray);
|
|
os_ << "\n";
|
|
return;
|
|
}
|
|
|
|
for (size_t i = 0; i < statements.size(); ++i)
|
|
{
|
|
bool is_last = (i == statements.size() - 1);
|
|
PrintStatement(statements[i].get(), "", is_last);
|
|
}
|
|
}
|
|
|
|
void DebugPrinter::PrintParseResult(const ParseResult& result)
|
|
{
|
|
PrintColored("=== Parse Result ===", Color::BrightCyan);
|
|
os_ << "\n\n";
|
|
|
|
if (result.root)
|
|
{
|
|
Print(result.root.get());
|
|
}
|
|
else
|
|
{
|
|
PrintColored("No root node", Color::Red);
|
|
os_ << "\n";
|
|
}
|
|
|
|
if (!result.errors.empty())
|
|
{
|
|
os_ << "\n";
|
|
PrintColored("=== Errors ===", Color::BrightRed);
|
|
os_ << "\n";
|
|
for (const auto& error : result.errors)
|
|
{
|
|
PrintError(error);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ===== 辅助方法实现 =====
|
|
|
|
void DebugPrinter::PrintIndent(std::optional<bool> is_last)
|
|
{
|
|
if (!options_.use_tree_chars)
|
|
{
|
|
os_ << std::string(current_indent_, ' ');
|
|
return;
|
|
}
|
|
|
|
// Determine actual is_last value
|
|
bool actual_is_last = false;
|
|
if (is_last.has_value())
|
|
{
|
|
// Explicitly provided - use it
|
|
actual_is_last = *is_last;
|
|
}
|
|
else if (!is_last_child_stack_.empty())
|
|
{
|
|
// Not provided - read from stack
|
|
actual_is_last = is_last_child_stack_.back();
|
|
}
|
|
// else: stack is empty and no value provided, use false (root level)
|
|
|
|
PrintTreePrefix(actual_is_last);
|
|
}
|
|
|
|
void DebugPrinter::PrintTreePrefix(bool is_last)
|
|
{
|
|
bool use_ascii = false;
|
|
|
|
#ifdef _WIN32
|
|
// Windows 环境默认使用 ASCII
|
|
use_ascii = true;
|
|
#endif
|
|
|
|
// 定义树形字符
|
|
const char* vertical = use_ascii ? "|" : "│";
|
|
const char* corner = use_ascii ? "`--" : "└──";
|
|
const char* branch = use_ascii ? "|--" : "├──";
|
|
|
|
// ===== 关键修复：使用 stack 大小作为实际深度 =====
|
|
// stack 的大小代表了我们在树结构中的实际深度
|
|
// 每个元素表示该层级的父节点是否是最后一个子节点
|
|
size_t depth = is_last_child_stack_.size();
|
|
|
|
// 打印每个祖先层级的竖线或空格
|
|
for (size_t i = 0; i < depth; ++i)
|
|
{
|
|
if (is_last_child_stack_[i])
|
|
{
|
|
// 该层级的父节点是最后一个子节点，所以不需要竖线
|
|
os_ << " ";
|
|
}
|
|
else
|
|
{
|
|
// 该层级的父节点不是最后一个子节点，需要显示竖线
|
|
os_ << vertical << " ";
|
|
}
|
|
}
|
|
|
|
// 打印当前节点的分支字符（如果不是根节点）
|
|
// 根节点（depth = 0）不打印分支字符
|
|
if (depth > 0 || current_indent_ > 0)
|
|
{
|
|
if (is_last)
|
|
os_ << corner << " ";
|
|
else
|
|
os_ << branch << " ";
|
|
}
|
|
}
|
|
|
|
std::string DebugPrinter::GetIndent() const
|
|
{
|
|
return std::string(current_indent_, ' ');
|
|
}
|
|
|
|
const char* DebugPrinter::GetColor(const char* color) const
|
|
{
|
|
return options_.use_colors ? color : "";
|
|
}
|
|
|
|
void DebugPrinter::PrintColored(const std::string& text, const char* color)
|
|
{
|
|
if (color)
|
|
{
|
|
os_ << GetColor(color);
|
|
}
|
|
os_ << text;
|
|
if (color)
|
|
{
|
|
os_ << GetColor(Color::Reset);
|
|
}
|
|
}
|
|
|
|
void DebugPrinter::PrintNodeHeader(const std::string& type_name, const Location& loc)
|
|
{
|
|
PrintColored(type_name, Color::BrightYellow);
|
|
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(loc);
|
|
}
|
|
|
|
if (options_.show_source_code && source_code_)
|
|
{
|
|
os_ << " ";
|
|
PrintSourceSnippet(loc);
|
|
}
|
|
|
|
os_ << "\n";
|
|
}
|
|
|
|
void DebugPrinter::PrintLocation(const Location& loc)
|
|
{
|
|
os_ << GetColor(Color::Gray) << "@"
|
|
<< loc.start_line << ":" << loc.start_column
|
|
<< "-" << loc.end_line << ":" << loc.end_column
|
|
<< GetColor(Color::Reset);
|
|
}
|
|
|
|
void DebugPrinter::PrintSourceSnippet(const Location& loc)
|
|
{
|
|
if (!source_code_ || loc.start_byte >= source_code_->length())
|
|
{
|
|
return;
|
|
}
|
|
|
|
std::string snippet = GetSourceText(loc);
|
|
snippet = TruncateString(snippet, options_.max_source_length);
|
|
snippet = EscapeString(snippet);
|
|
|
|
os_ << GetColor(Color::Cyan) << "«" << snippet << "»" << GetColor(Color::Reset);
|
|
}
|
|
|
|
void DebugPrinter::PrintKeyValue(const std::string& key, const std::string& value, const Location& location, const char* value_color)
|
|
{
|
|
PrintIndent();
|
|
PrintColored(key, Color::Green);
|
|
os_ << ": ";
|
|
PrintColored(value, value_color);
|
|
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(location);
|
|
}
|
|
|
|
os_ << "\n";
|
|
}
|
|
|
|
void DebugPrinter::PrintKeyValue(const std::string& key, const std::string& value, const char* value_color)
|
|
{
|
|
PrintIndent();
|
|
PrintColored(key, Color::Green);
|
|
os_ << ": ";
|
|
PrintColored(value, value_color);
|
|
os_ << "\n";
|
|
}
|
|
|
|
void DebugPrinter::PrintKeyValue(const std::string& key, int value)
|
|
{
|
|
PrintIndent();
|
|
PrintColored(key, Color::Green);
|
|
os_ << ": ";
|
|
PrintColored(std::to_string(value), Color::BrightMagenta);
|
|
os_ << "\n";
|
|
}
|
|
|
|
void DebugPrinter::PrintKeyValue(const std::string& key, bool value)
|
|
{
|
|
PrintIndent();
|
|
PrintColored(key, Color::Green);
|
|
os_ << ": ";
|
|
PrintColored(value ? "true" : "false", Color::BrightMagenta);
|
|
os_ << "\n";
|
|
}
|
|
|
|
void DebugPrinter::PrintExpression(const Expression* expr, const std::string& label, bool is_last)
|
|
{
|
|
if (!expr)
|
|
{
|
|
PrintIndent(is_last);
|
|
if (!label.empty())
|
|
{
|
|
PrintColored(label, Color::Green);
|
|
os_ << ": ";
|
|
}
|
|
PrintColored("nullptr", Color::Red);
|
|
os_ << "\n";
|
|
return;
|
|
}
|
|
|
|
if (!label.empty())
|
|
{
|
|
// Print the label with proper tree characters
|
|
PrintIndent(is_last);
|
|
PrintColored(label, Color::Green);
|
|
os_ << ":\n";
|
|
|
|
// ===== 修复：只 push 一次 =====
|
|
// 标签不是树节点，不占用层级
|
|
// 我们 push is_last，然后增加缩进，直接 Accept
|
|
is_last_child_stack_.push_back(is_last);
|
|
IncreaseIndent();
|
|
|
|
// 直接调用 Accept，不再 push
|
|
const_cast<Expression*>(expr)->Accept(*this);
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
else
|
|
{
|
|
// No label - just print the expression directly
|
|
// 节点自己需要知道它是否是父节点的最后子节点
|
|
is_last_child_stack_.push_back(is_last);
|
|
const_cast<Expression*>(expr)->Accept(*this);
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
}
|
|
|
|
void DebugPrinter::PrintStatement(const Statement* stmt, const std::string& label, bool is_last)
|
|
{
|
|
if (!stmt)
|
|
{
|
|
PrintIndent(is_last);
|
|
if (!label.empty())
|
|
{
|
|
PrintColored(label, Color::Green);
|
|
os_ << ": ";
|
|
}
|
|
PrintColored("nullptr", Color::Red);
|
|
os_ << "\n";
|
|
return;
|
|
}
|
|
|
|
if (!label.empty())
|
|
{
|
|
// Print the label with proper tree characters
|
|
PrintIndent(is_last);
|
|
PrintColored(label, Color::Green);
|
|
os_ << ":\n";
|
|
|
|
// ===== 修复：只 push 一次 =====
|
|
// 标签不是树节点，不占用层级
|
|
is_last_child_stack_.push_back(is_last);
|
|
IncreaseIndent();
|
|
|
|
// 直接调用 Accept，不再 push
|
|
const_cast<Statement*>(stmt)->Accept(*this);
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
else
|
|
{
|
|
// No label - just print the statement directly
|
|
is_last_child_stack_.push_back(is_last);
|
|
const_cast<Statement*>(stmt)->Accept(*this);
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
}
|
|
|
|
void DebugPrinter::PrintSignature(const Signature& sig)
|
|
{
|
|
// ===== 修复：不再自行打印 "signature:" 标签，由调用者管理 =====
|
|
// 调用者会打印标签并管理 stack，这里只负责打印 signature 的子项
|
|
|
|
bool has_params = !sig.parameters.empty();
|
|
bool has_return = sig.return_type.has_value();
|
|
|
|
if (has_params)
|
|
{
|
|
// parameters 是否是最后一个子项：取决于后面是否还有 return_type
|
|
bool params_is_last = !has_return;
|
|
|
|
PrintIndent(params_is_last);
|
|
PrintColored("parameters", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(params_is_last);
|
|
IncreaseIndent();
|
|
|
|
for (size_t i = 0; i < sig.parameters.size(); ++i)
|
|
{
|
|
bool is_last = (i == sig.parameters.size() - 1);
|
|
PrintParameter(sig.parameters[i], is_last);
|
|
}
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
if (has_return)
|
|
{
|
|
PrintKeyValue("return_type", sig.return_type->name, sig.return_type->location, Color::BrightBlue);
|
|
}
|
|
}
|
|
|
|
void DebugPrinter::PrintParameter(const Parameter& param, bool is_last)
|
|
{
|
|
PrintIndent(is_last);
|
|
PrintColored("param", Color::Yellow);
|
|
os_ << " ";
|
|
PrintColored(param.name, Color::BrightCyan);
|
|
|
|
if (param.type)
|
|
{
|
|
os_ << ": ";
|
|
PrintColored(param.type->name, Color::BrightBlue);
|
|
}
|
|
|
|
if (param.is_var)
|
|
os_ << " " << GetColor(Color::Magenta) << "[var]" << GetColor(Color::Reset);
|
|
|
|
if (param.is_out)
|
|
os_ << " " << GetColor(Color::Magenta) << "[out]" << GetColor(Color::Reset);
|
|
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(param.location);
|
|
}
|
|
|
|
os_ << "\n";
|
|
|
|
if (param.default_value)
|
|
{
|
|
is_last_child_stack_.push_back(is_last);
|
|
IncreaseIndent();
|
|
PrintExpression(param.default_value.get(), "default", true);
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
}
|
|
|
|
void DebugPrinter::PrintLeftHandSide(const LeftHandSide& lhs, const std::string& label, bool is_last)
|
|
{
|
|
if (!label.empty())
|
|
{
|
|
PrintIndent(is_last);
|
|
PrintColored(label, Color::Green);
|
|
os_ << ":\n";
|
|
|
|
// ===== 修复：只 push 一次 =====
|
|
is_last_child_stack_.push_back(is_last);
|
|
IncreaseIndent();
|
|
|
|
// 直接 visit，不再额外 push
|
|
std::visit([this](auto&& arg) {
|
|
if (arg)
|
|
{
|
|
arg->Accept(*this);
|
|
}
|
|
else
|
|
{
|
|
PrintIndent();
|
|
PrintColored("nullptr", Color::Red);
|
|
os_ << "\n";
|
|
}
|
|
},
|
|
lhs);
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
else
|
|
{
|
|
// 无 label 的情况：直接 push 并 visit
|
|
is_last_child_stack_.push_back(is_last);
|
|
|
|
std::visit([this](auto&& arg) {
|
|
if (arg)
|
|
{
|
|
arg->Accept(*this);
|
|
}
|
|
else
|
|
{
|
|
PrintIndent();
|
|
PrintColored("nullptr", Color::Red);
|
|
os_ << "\n";
|
|
}
|
|
},
|
|
lhs);
|
|
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
}
|
|
|
|
void DebugPrinter::PrintOperator(BinaryOperator op)
|
|
{
|
|
os_ << GetColor(Color::BrightYellow) << GetBinaryOperatorSymbol(op) << GetColor(Color::Reset);
|
|
}
|
|
|
|
void DebugPrinter::PrintOperator(UnaryOperator op)
|
|
{
|
|
std::string symbol;
|
|
switch (op)
|
|
{
|
|
case UnaryOperator::kPlus:
|
|
symbol = "+";
|
|
break;
|
|
case UnaryOperator::kMinus:
|
|
symbol = "-";
|
|
break;
|
|
case UnaryOperator::kNot:
|
|
symbol = "not";
|
|
break;
|
|
case UnaryOperator::kBitwiseNot:
|
|
symbol = "~";
|
|
break;
|
|
case UnaryOperator::kDotNot:
|
|
symbol = ".not";
|
|
break;
|
|
case UnaryOperator::kMatrixTranspose:
|
|
symbol = "'";
|
|
break;
|
|
case UnaryOperator::kDerivative:
|
|
symbol = "∂";
|
|
break;
|
|
case UnaryOperator::kExprAt:
|
|
symbol = "@";
|
|
break;
|
|
case UnaryOperator::kExprRef:
|
|
symbol = "&";
|
|
break;
|
|
default:
|
|
symbol = "unknown";
|
|
break;
|
|
}
|
|
os_ << GetColor(Color::BrightYellow) << symbol << GetColor(Color::Reset);
|
|
}
|
|
|
|
void DebugPrinter::PrintOperator(AssignmentOperator op)
|
|
{
|
|
os_ << GetColor(Color::BrightYellow) << GetAssignmentOperatorSymbol(op) << GetColor(Color::Reset);
|
|
}
|
|
|
|
void DebugPrinter::PrintLiteralKind(LiteralKind kind)
|
|
{
|
|
std::string kind_str;
|
|
const char* color = Color::Cyan;
|
|
|
|
switch (kind)
|
|
{
|
|
case LiteralKind::kNumber:
|
|
kind_str = "number";
|
|
color = Color::BrightMagenta;
|
|
break;
|
|
case LiteralKind::kString:
|
|
kind_str = "string";
|
|
color = Color::BrightGreen;
|
|
break;
|
|
case LiteralKind::kBoolean:
|
|
kind_str = "boolean";
|
|
color = Color::BrightBlue;
|
|
break;
|
|
case LiteralKind::kNil:
|
|
kind_str = "nil";
|
|
color = Color::Gray;
|
|
break;
|
|
case LiteralKind::kInfinity:
|
|
kind_str = "infinity";
|
|
color = Color::BrightMagenta;
|
|
break;
|
|
case LiteralKind::kEllipsis:
|
|
kind_str = "ellipsis";
|
|
color = Color::Gray;
|
|
break;
|
|
default:
|
|
kind_str = "unknown";
|
|
break;
|
|
}
|
|
|
|
PrintColored(kind_str, color);
|
|
}
|
|
|
|
void DebugPrinter::PrintAccessModifier(AccessModifier modifier)
|
|
{
|
|
std::string mod_str;
|
|
switch (modifier)
|
|
{
|
|
case AccessModifier::kPublic:
|
|
mod_str = "public";
|
|
break;
|
|
case AccessModifier::kProtected:
|
|
mod_str = "protected";
|
|
break;
|
|
case AccessModifier::kPrivate:
|
|
mod_str = "private";
|
|
break;
|
|
default:
|
|
mod_str = "unknown";
|
|
break;
|
|
}
|
|
PrintColored(mod_str, Color::Magenta);
|
|
}
|
|
|
|
void DebugPrinter::PrintMethodModifier(MethodModifier modifier)
|
|
{
|
|
std::string mod_str;
|
|
switch (modifier)
|
|
{
|
|
case MethodModifier::kNone:
|
|
return;
|
|
case MethodModifier::kVirtual:
|
|
mod_str = "virtual";
|
|
break;
|
|
case MethodModifier::kOverride:
|
|
mod_str = "override";
|
|
break;
|
|
case MethodModifier::kOverload:
|
|
mod_str = "overload";
|
|
break;
|
|
default:
|
|
mod_str = "unknown";
|
|
break;
|
|
}
|
|
os_ << " " << GetColor(Color::Magenta) << "[" << mod_str << "]" << GetColor(Color::Reset);
|
|
}
|
|
|
|
void DebugPrinter::PrintReferenceModifier(ReferenceModifier modifier)
|
|
{
|
|
std::string mod_str;
|
|
switch (modifier)
|
|
{
|
|
case ReferenceModifier::kNone:
|
|
return;
|
|
case ReferenceModifier::kWeakRef:
|
|
mod_str = "weakref";
|
|
break;
|
|
case ReferenceModifier::kAutoRef:
|
|
mod_str = "autoref";
|
|
break;
|
|
default:
|
|
mod_str = "unknown";
|
|
break;
|
|
}
|
|
os_ << " " << GetColor(Color::Magenta) << "[" << mod_str << "]" << GetColor(Color::Reset);
|
|
}
|
|
|
|
void DebugPrinter::PrintConditionalCompilationType(ConditionalCompilationType type)
|
|
{
|
|
std::string type_str;
|
|
switch (type)
|
|
{
|
|
case ConditionalCompilationType::kIfDef:
|
|
type_str = "IFDEF";
|
|
break;
|
|
case ConditionalCompilationType::kIfNDef:
|
|
type_str = "IFNDEF";
|
|
break;
|
|
case ConditionalCompilationType::kDef:
|
|
type_str = "DEFINE";
|
|
break;
|
|
case ConditionalCompilationType::kUndef:
|
|
type_str = "UNDEF";
|
|
break;
|
|
default:
|
|
type_str = "unknown";
|
|
break;
|
|
}
|
|
PrintColored(type_str, Color::Magenta);
|
|
}
|
|
|
|
void DebugPrinter::PrintError(const ParseError& error)
|
|
{
|
|
const char* severity_color = (error.severity == ErrorSeverity::Error) ? Color::BrightRed : Color::BrightYellow;
|
|
const char* severity_str = (error.severity == ErrorSeverity::Error) ? "Error" : "Warning";
|
|
|
|
PrintColored(severity_str, severity_color);
|
|
os_ << " at ";
|
|
PrintLocation(error.location);
|
|
os_ << " in " << GetColor(Color::Yellow) << error.node_type << GetColor(Color::Reset);
|
|
os_ << ": " << error.message << "\n";
|
|
|
|
if (options_.show_source_code && source_code_)
|
|
{
|
|
os_ << " ";
|
|
PrintSourceSnippet(error.location);
|
|
os_ << "\n";
|
|
}
|
|
}
|
|
|
|
std::string DebugPrinter::EscapeString(const std::string& str) const
|
|
{
|
|
std::string result;
|
|
result.reserve(str.length());
|
|
for (char c : str)
|
|
{
|
|
switch (c)
|
|
{
|
|
case '\n':
|
|
result += "\\n";
|
|
break;
|
|
case '\r':
|
|
result += "\\r";
|
|
break;
|
|
case '\t':
|
|
result += "\\t";
|
|
break;
|
|
case '\\':
|
|
result += "\\\\";
|
|
break;
|
|
default:
|
|
result += c;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::string DebugPrinter::TruncateString(const std::string& str, size_t max_len) const
|
|
{
|
|
if (str.length() <= max_len)
|
|
{
|
|
return str;
|
|
}
|
|
return str.substr(0, max_len) + "...";
|
|
}
|
|
|
|
std::string DebugPrinter::GetSourceText(const Location& loc) const
|
|
{
|
|
if (!source_code_ || loc.start_byte >= source_code_->length())
|
|
{
|
|
return "";
|
|
}
|
|
|
|
size_t end = std::min(loc.end_byte, static_cast<uint32_t>(source_code_->length()));
|
|
return source_code_->substr(loc.start_byte, end - loc.start_byte);
|
|
}
|
|
|
|
// ===== Visitor 方法实现 =====
|
|
|
|
void DebugPrinter::VisitProgram(Program& node)
|
|
{
|
|
PrintIndent();
|
|
PrintNodeHeader("Program", node.span);
|
|
|
|
IncreaseIndent();
|
|
PrintStatements(node.statements);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitUnitDefinition(UnitDefinition& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("UnitDefinition", Color::BrightYellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << node.name << GetColor(Color::Reset);
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(node.location);
|
|
}
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
|
|
// 判断哪个是最后一个非空的子项
|
|
bool has_implementation = !node.implementation_statements.empty();
|
|
bool has_initialization = !node.initialization_statements.empty();
|
|
bool has_finalization = !node.finalization_statements.empty();
|
|
|
|
if (!node.interface_statements.empty())
|
|
{
|
|
bool is_last = !has_implementation && !has_initialization && !has_finalization;
|
|
PrintIndent(is_last);
|
|
PrintColored("interface", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(is_last);
|
|
IncreaseIndent();
|
|
PrintStatements(node.interface_statements);
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
if (!node.implementation_statements.empty())
|
|
{
|
|
bool is_last = !has_initialization && !has_finalization;
|
|
PrintIndent(is_last);
|
|
PrintColored("implementation", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(is_last);
|
|
IncreaseIndent();
|
|
PrintStatements(node.implementation_statements);
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
if (!node.initialization_statements.empty())
|
|
{
|
|
bool is_last = !has_finalization;
|
|
PrintIndent(is_last);
|
|
PrintColored("initialization", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(is_last);
|
|
IncreaseIndent();
|
|
PrintStatements(node.initialization_statements);
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
if (!node.finalization_statements.empty())
|
|
{
|
|
PrintIndent(true); // 最后一个子项
|
|
PrintColored("finalization", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(true);
|
|
IncreaseIndent();
|
|
PrintStatements(node.finalization_statements);
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitClassDefinition(ClassDefinition& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("ClassDefinition", Color::BrightYellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << node.name << GetColor(Color::Reset);
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(node.location);
|
|
}
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
|
|
if (!node.parent_classes.empty())
|
|
{
|
|
PrintIndent(node.members.empty()); // is_last if no members follow
|
|
PrintColored("inherits", Color::Green);
|
|
os_ << ": ";
|
|
for (size_t i = 0; i < node.parent_classes.size(); ++i)
|
|
{
|
|
const auto& parent = node.parent_classes[i];
|
|
if (i > 0)
|
|
os_ << ", ";
|
|
|
|
if (parent.qualifier)
|
|
{
|
|
PrintColored(*parent.qualifier, Color::BrightBlue);
|
|
os_ << ".";
|
|
}
|
|
PrintColored(parent.name, Color::BrightCyan);
|
|
}
|
|
os_ << "\n";
|
|
}
|
|
|
|
if (!node.members.empty())
|
|
{
|
|
PrintIndent(true); // members is the last section
|
|
PrintColored("members", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
// Push state BEFORE incrementing indent (for the members section itself)
|
|
is_last_child_stack_.push_back(false); // Will be updated in loop
|
|
IncreaseIndent();
|
|
|
|
// Print each member - update stack top instead of push/pop
|
|
for (size_t i = 0; i < node.members.size(); ++i)
|
|
{
|
|
bool is_last = (i == node.members.size() - 1);
|
|
// Update the stack top to reflect whether this member is the last one
|
|
is_last_child_stack_.back() = is_last;
|
|
|
|
node.members[i]->Accept(*this);
|
|
}
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitClassMember(ClassMember& node)
|
|
{
|
|
std::visit([this, &node](auto&& arg) {
|
|
if (arg)
|
|
{
|
|
bool is_last = !is_last_child_stack_.empty() ? is_last_child_stack_.back() : false;
|
|
PrintIndent(is_last);
|
|
PrintColored("[", Color::Gray);
|
|
PrintAccessModifier(node.access_modifier);
|
|
PrintColored("]", Color::Gray);
|
|
os_ << " ";
|
|
|
|
// Inline the node header without indentation
|
|
if (auto* method = dynamic_cast<MethodDeclaration*>(arg.get()))
|
|
{
|
|
PrintColored("MethodDeclaration", Color::BrightYellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << method->name << GetColor(Color::Reset);
|
|
PrintMethodModifier(method->modifier);
|
|
if (method->is_class_method)
|
|
os_ << " " << GetColor(Color::Magenta) << "[class]" << GetColor(Color::Reset);
|
|
if (method->is_operator_overload)
|
|
os_ << " " << GetColor(Color::Magenta) << "[operator]" << GetColor(Color::Reset);
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(method->location);
|
|
}
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
bool signature_is_last = !method->body;
|
|
is_last_child_stack_.push_back(signature_is_last);
|
|
PrintSignature(method->signature);
|
|
is_last_child_stack_.pop_back();
|
|
if (method->body)
|
|
PrintStatement(method->body.get(), "body", true);
|
|
DecreaseIndent();
|
|
}
|
|
else if (auto* field = dynamic_cast<FieldDeclaration*>(arg.get()))
|
|
{
|
|
PrintColored("FieldDeclaration", Color::Yellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << field->name << GetColor(Color::Reset);
|
|
PrintReferenceModifier(field->reference_modifier);
|
|
if (field->type)
|
|
os_ << ": " << GetColor(Color::BrightBlue) << field->type->name << GetColor(Color::Reset);
|
|
os_ << "\n";
|
|
|
|
if (field->initial_value)
|
|
{
|
|
IncreaseIndent();
|
|
PrintExpression(field->initial_value.get(), "initial_value", true);
|
|
DecreaseIndent();
|
|
}
|
|
}
|
|
else if (auto* prop = dynamic_cast<PropertyDeclaration*>(arg.get()))
|
|
{
|
|
PrintColored("PropertyDeclaration", Color::BrightYellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << prop->name << GetColor(Color::Reset);
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(prop->location);
|
|
}
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
if (prop->type_name)
|
|
PrintKeyValue("type", *prop->type_name, Color::BrightBlue);
|
|
if (prop->index_value)
|
|
PrintKeyValue("index", *prop->index_value);
|
|
if (prop->read_accessor)
|
|
PrintKeyValue("read", *prop->read_accessor);
|
|
if (prop->write_accessor)
|
|
PrintKeyValue("write", *prop->write_accessor);
|
|
DecreaseIndent();
|
|
}
|
|
}
|
|
},
|
|
node.member);
|
|
}
|
|
|
|
void DebugPrinter::VisitMethodDeclaration(MethodDeclaration& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("MethodDeclaration", Color::BrightYellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << node.name << GetColor(Color::Reset);
|
|
PrintMethodModifier(node.modifier);
|
|
|
|
if (node.is_class_method)
|
|
{
|
|
os_ << " " << GetColor(Color::Magenta) << "[class]" << GetColor(Color::Reset);
|
|
}
|
|
|
|
if (node.is_operator_overload)
|
|
{
|
|
os_ << " " << GetColor(Color::Magenta) << "[operator]" << GetColor(Color::Reset);
|
|
}
|
|
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(node.location);
|
|
}
|
|
os_ << "\n";
|
|
|
|
// ===== 修复：不需要外层 IncreaseIndent =====
|
|
|
|
bool signature_is_last = !node.body;
|
|
|
|
PrintIndent(signature_is_last);
|
|
PrintColored("signature", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(signature_is_last);
|
|
IncreaseIndent();
|
|
|
|
PrintSignature(node.signature);
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
|
|
if (node.body)
|
|
PrintStatement(node.body.get(), "body", true);
|
|
}
|
|
|
|
void DebugPrinter::VisitPropertyDeclaration(PropertyDeclaration& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("PropertyDeclaration", Color::BrightYellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << node.name << GetColor(Color::Reset);
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(node.location);
|
|
}
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
|
|
if (node.type_name)
|
|
{
|
|
PrintKeyValue("type", *node.type_name, Color::BrightBlue);
|
|
}
|
|
|
|
if (node.index_value)
|
|
{
|
|
PrintKeyValue("index", *node.index_value);
|
|
}
|
|
|
|
if (node.read_accessor)
|
|
{
|
|
PrintKeyValue("read", *node.read_accessor);
|
|
}
|
|
|
|
if (node.write_accessor)
|
|
{
|
|
PrintKeyValue("write", *node.write_accessor);
|
|
}
|
|
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitExternalMethodDefinition(ExternalMethodDefinition& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("ExternalMethodDefinition", Color::BrightYellow);
|
|
os_ << " " << GetColor(Color::BrightBlue) << node.owner_class.name << GetColor(Color::Reset);
|
|
os_ << "." << GetColor(Color::BrightCyan) << node.name << GetColor(Color::Reset);
|
|
PrintMethodModifier(node.modifier);
|
|
|
|
if (node.is_class_method)
|
|
{
|
|
os_ << " " << GetColor(Color::Magenta) << "[class]" << GetColor(Color::Reset);
|
|
}
|
|
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(node.location);
|
|
}
|
|
os_ << "\n";
|
|
|
|
// ===== 修复：不需要外层 IncreaseIndent =====
|
|
|
|
bool signature_is_last = !node.body;
|
|
|
|
PrintIndent(signature_is_last);
|
|
PrintColored("signature", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(signature_is_last);
|
|
IncreaseIndent();
|
|
|
|
PrintSignature(node.signature);
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
|
|
if (node.body)
|
|
PrintStatement(node.body.get(), "body", true);
|
|
}
|
|
|
|
void DebugPrinter::VisitIdentifier(Identifier& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("Identifier", Color::Yellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << node.name << GetColor(Color::Reset);
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(node.location);
|
|
}
|
|
os_ << "\n";
|
|
}
|
|
|
|
void DebugPrinter::VisitLiteral(Literal& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("Literal", Color::Yellow);
|
|
os_ << " [";
|
|
PrintLiteralKind(node.literal_kind);
|
|
os_ << "] " << GetColor(Color::BrightGreen) << node.name << GetColor(Color::Reset);
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(node.location);
|
|
}
|
|
os_ << "\n";
|
|
}
|
|
|
|
void DebugPrinter::VisitBinaryExpression(BinaryExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("BinaryExpression", Color::Yellow);
|
|
os_ << " ";
|
|
PrintOperator(node.op);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.left.get(), "left", false);
|
|
PrintExpression(node.right.get(), "right", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitComparisonExpression(ComparisonExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("ComparisonExpression", Color::Yellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.left.get(), "left", false);
|
|
|
|
for (size_t i = 0; i < node.comparisons.size(); ++i)
|
|
{
|
|
bool is_last = (i == node.comparisons.size() - 1);
|
|
const auto& comp = node.comparisons[i];
|
|
|
|
PrintIndent(is_last);
|
|
PrintColored("comparison", Color::Green);
|
|
os_ << " ";
|
|
PrintOperator(comp.op);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(is_last);
|
|
IncreaseIndent();
|
|
PrintExpression(comp.right.get(), "", true);
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitUnaryExpression(UnaryExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("UnaryExpression", Color::Yellow);
|
|
os_ << " ";
|
|
PrintOperator(node.op);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.argument.get(), "argument", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitTernaryExpression(TernaryExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("TernaryExpression", Color::Yellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.condition.get(), "condition", false);
|
|
PrintExpression(node.consequence.get(), "consequence", false);
|
|
PrintExpression(node.alternative.get(), "alternative", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitCallExpression(CallExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("CallExpression", Color::Yellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.callee.get(), "callee", false);
|
|
|
|
if (!node.arguments.empty())
|
|
{
|
|
PrintIndent(true);
|
|
PrintColored("arguments", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(true);
|
|
IncreaseIndent();
|
|
|
|
for (size_t i = 0; i < node.arguments.size(); ++i)
|
|
{
|
|
bool is_last = (i == node.arguments.size() - 1);
|
|
const auto& arg = node.arguments[i];
|
|
|
|
PrintIndent(is_last);
|
|
if (arg.name)
|
|
{
|
|
PrintColored(*arg.name, Color::BrightCyan);
|
|
os_ << " = ";
|
|
}
|
|
os_ << "\n";
|
|
|
|
is_last_child_stack_.push_back(is_last);
|
|
IncreaseIndent();
|
|
PrintExpression(arg.value.get(), "", true);
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitAttributeExpression(AttributeExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("AttributeExpression", Color::Yellow);
|
|
os_ << " ." << GetColor(Color::BrightCyan) << node.name << GetColor(Color::Reset);
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(node.location);
|
|
}
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.object.get(), "object", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitSubscriptExpression(SubscriptExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("SubscriptExpression", Color::Yellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.value.get(), "value", false);
|
|
|
|
if (!node.indices.empty())
|
|
{
|
|
PrintIndent(true);
|
|
PrintColored("indices", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(true);
|
|
IncreaseIndent();
|
|
|
|
for (size_t i = 0; i < node.indices.size(); ++i)
|
|
{
|
|
bool is_last = (i == node.indices.size() - 1);
|
|
const auto& idx = node.indices[i];
|
|
|
|
PrintIndent(is_last);
|
|
if (idx.is_slice)
|
|
{
|
|
PrintColored("slice", Color::Magenta);
|
|
}
|
|
else
|
|
{
|
|
PrintColored("index", Color::Magenta);
|
|
}
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(is_last);
|
|
IncreaseIndent();
|
|
|
|
if (idx.start)
|
|
{
|
|
PrintExpression(idx.start.get(), "start", !idx.end && !idx.step);
|
|
}
|
|
|
|
if (idx.end)
|
|
{
|
|
PrintExpression(idx.end.get(), "end", !idx.step);
|
|
}
|
|
|
|
if (idx.step)
|
|
{
|
|
PrintExpression(idx.step.get(), "step", true);
|
|
}
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitArrayExpression(ArrayExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("ArrayExpression", Color::Yellow);
|
|
os_ << "\n";
|
|
|
|
if (node.elements.empty())
|
|
{
|
|
IncreaseIndent();
|
|
PrintIndent();
|
|
PrintColored("(empty)", Color::Gray);
|
|
os_ << "\n";
|
|
DecreaseIndent();
|
|
return;
|
|
}
|
|
|
|
IncreaseIndent();
|
|
|
|
for (size_t i = 0; i < node.elements.size(); ++i)
|
|
{
|
|
bool is_last = (i == node.elements.size() - 1);
|
|
const auto& elem = node.elements[i];
|
|
|
|
PrintIndent(is_last);
|
|
PrintColored("element", Color::Green);
|
|
if (elem.is_nested)
|
|
{
|
|
os_ << " " << GetColor(Color::Magenta) << "[nested]" << GetColor(Color::Reset);
|
|
}
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(is_last);
|
|
IncreaseIndent();
|
|
|
|
if (elem.key)
|
|
{
|
|
PrintExpression(elem.key.get(), "key", false);
|
|
PrintExpression(elem.value.get(), "value", true);
|
|
}
|
|
else
|
|
{
|
|
PrintExpression(elem.value.get(), "", true);
|
|
}
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitAnonymousFunctionExpression(AnonymousFunctionExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("AnonymousFunctionExpression", Color::Yellow);
|
|
os_ << "\n";
|
|
|
|
// ===== 修复：不需要外层 IncreaseIndent =====
|
|
|
|
bool signature_is_last = !node.body;
|
|
|
|
PrintIndent(signature_is_last);
|
|
PrintColored("signature", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(signature_is_last);
|
|
IncreaseIndent();
|
|
|
|
PrintSignature(node.signature);
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
|
|
if (node.body)
|
|
{
|
|
PrintStatement(node.body.get(), "body", true);
|
|
}
|
|
}
|
|
|
|
void DebugPrinter::VisitPrefixIncrementExpression(PrefixIncrementExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("PrefixIncrementExpression", Color::Yellow);
|
|
os_ << " ++\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.argument.get(), "argument", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitPrefixDecrementExpression(PrefixDecrementExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("PrefixDecrementExpression", Color::Yellow);
|
|
os_ << " --\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.argument.get(), "argument", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitPostfixIncrementExpression(PostfixIncrementExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("PostfixIncrementExpression", Color::Yellow);
|
|
os_ << " ++\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.argument.get(), "argument", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitPostfixDecrementExpression(PostfixDecrementExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("PostfixDecrementExpression", Color::Yellow);
|
|
os_ << " --\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.argument.get(), "argument", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitFunctionPointerExpression(FunctionPointerExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("FunctionPointerExpression", Color::Yellow);
|
|
os_ << " @\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.argument.get(), "argument", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitAssignmentExpression(AssignmentExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("AssignmentExpression", Color::Yellow);
|
|
os_ << " ";
|
|
PrintOperator(node.op);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintLeftHandSide(node.left, "left", false);
|
|
PrintExpression(node.right.get(), "right", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitExpressionStatement(ExpressionStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("ExpressionStatement", Color::BrightYellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.expression.get(), "", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitVarStatement(VarStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("VarStatement", Color::BrightYellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
for (size_t i = 0; i < node.declarations.size(); ++i)
|
|
{
|
|
bool is_last = (i == node.declarations.size() - 1);
|
|
is_last_child_stack_.push_back(is_last);
|
|
node.declarations[i]->Accept(*this);
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitStaticStatement(StaticStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("StaticStatement", Color::BrightYellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
for (size_t i = 0; i < node.declarations.size(); ++i)
|
|
{
|
|
bool is_last = (i == node.declarations.size() - 1);
|
|
is_last_child_stack_.push_back(is_last);
|
|
node.declarations[i]->Accept(*this);
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitGlobalStatement(GlobalStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("GlobalStatement", Color::BrightYellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
for (size_t i = 0; i < node.declarations.size(); ++i)
|
|
{
|
|
bool is_last = (i == node.declarations.size() - 1);
|
|
is_last_child_stack_.push_back(is_last);
|
|
node.declarations[i]->Accept(*this);
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitConstStatement(ConstStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("ConstStatement", Color::BrightYellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << node.name << GetColor(Color::Reset);
|
|
if (node.type_name)
|
|
{
|
|
os_ << ": " << GetColor(Color::BrightBlue) << *node.type_name << GetColor(Color::Reset);
|
|
}
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.value.get(), "value", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitAssignmentStatement(AssignmentStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("AssignmentStatement", Color::BrightYellow);
|
|
os_ << " ";
|
|
PrintOperator(node.op);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintLeftHandSide(node.left, "left", false);
|
|
PrintExpression(node.right.get(), "right", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitBlockStatement(BlockStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("BlockStatement", Color::BrightYellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintStatements(node.statements);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitIfStatement(IfStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("IfStatement", Color::BrightYellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
|
|
for (size_t i = 0; i < node.branches.size(); ++i)
|
|
{
|
|
bool is_last = (i == node.branches.size() - 1);
|
|
const auto& branch = node.branches[i];
|
|
|
|
PrintIndent(is_last);
|
|
PrintColored(i == 0 ? "if" : "elif", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(is_last);
|
|
IncreaseIndent();
|
|
|
|
PrintExpression(branch.condition.get(), "condition", false);
|
|
PrintStatement(branch.body.get(), "body", true);
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitForInStatement(ForInStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("ForInStatement", Color::BrightYellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
|
|
PrintIndent();
|
|
PrintColored("iterator", Color::Green);
|
|
os_ << ": ";
|
|
if (!node.key.empty())
|
|
{
|
|
PrintColored(node.key, Color::BrightCyan);
|
|
os_ << ", ";
|
|
}
|
|
PrintColored(node.value, Color::BrightCyan);
|
|
os_ << "\n";
|
|
|
|
PrintExpression(node.collection.get(), "collection", false);
|
|
PrintStatement(node.body.get(), "body", true);
|
|
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitForToStatement(ForToStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("ForToStatement", Color::BrightYellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << node.counter << GetColor(Color::Reset);
|
|
if (node.is_downto)
|
|
{
|
|
os_ << " " << GetColor(Color::Magenta) << "[downto]" << GetColor(Color::Reset);
|
|
}
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.start.get(), "start", false);
|
|
PrintExpression(node.end.get(), "end", false);
|
|
PrintStatement(node.body.get(), "body", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitWhileStatement(WhileStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("WhileStatement", Color::BrightYellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.condition.get(), "condition", false);
|
|
PrintStatement(node.body.get(), "body", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitRepeatStatement(RepeatStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("RepeatStatement", Color::BrightYellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
|
|
if (!node.body.empty())
|
|
{
|
|
PrintIndent();
|
|
PrintColored("body", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
IncreaseIndent();
|
|
PrintStatements(node.body);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
PrintExpression(node.condition.get(), "condition", true);
|
|
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitCaseStatement(CaseStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("CaseStatement", Color::BrightYellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
|
|
PrintExpression(node.discriminant.get(), "discriminant", false);
|
|
|
|
if (!node.branches.empty())
|
|
{
|
|
PrintIndent(!node.default_case);
|
|
PrintColored("branches", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(!node.default_case);
|
|
IncreaseIndent();
|
|
|
|
for (size_t i = 0; i < node.branches.size(); ++i)
|
|
{
|
|
bool is_last = (i == node.branches.size() - 1);
|
|
const auto& branch = node.branches[i];
|
|
|
|
PrintIndent(is_last);
|
|
PrintColored("case", Color::Magenta);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(is_last);
|
|
IncreaseIndent();
|
|
|
|
if (!branch.values.empty())
|
|
{
|
|
PrintIndent(false);
|
|
PrintColored("values", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(false); // values 不是最后一个（body 在后面）
|
|
IncreaseIndent();
|
|
for (size_t j = 0; j < branch.values.size(); ++j)
|
|
{
|
|
bool val_is_last = (j == branch.values.size() - 1);
|
|
is_last_child_stack_.push_back(val_is_last);
|
|
PrintExpression(branch.values[j].get(), "", val_is_last);
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
PrintStatement(branch.body.get(), "body", true);
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
if (node.default_case)
|
|
{
|
|
PrintStatement(node.default_case.get(), "default", true);
|
|
}
|
|
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitTryStatement(TryStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("TryStatement", Color::BrightYellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintStatement(node.try_body.get(), "try", false);
|
|
PrintStatement(node.except_body.get(), "except", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitBreakStatement(BreakStatement&)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("BreakStatement", Color::BrightYellow);
|
|
os_ << "\n";
|
|
}
|
|
|
|
void DebugPrinter::VisitContinueStatement(ContinueStatement&)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("ContinueStatement", Color::BrightYellow);
|
|
os_ << "\n";
|
|
}
|
|
|
|
void DebugPrinter::VisitReturnStatement(ReturnStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("ReturnStatement", Color::BrightYellow);
|
|
os_ << "\n";
|
|
|
|
if (node.value)
|
|
{
|
|
IncreaseIndent();
|
|
PrintExpression(node.value.get(), "value", true);
|
|
DecreaseIndent();
|
|
}
|
|
}
|
|
|
|
void DebugPrinter::VisitUsesStatement(UsesStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("UsesStatement", Color::BrightYellow);
|
|
os_ << ": ";
|
|
for (size_t i = 0; i < node.units.size(); ++i)
|
|
{
|
|
if (i > 0)
|
|
os_ << ", ";
|
|
PrintColored(node.units[i], Color::BrightCyan);
|
|
}
|
|
os_ << "\n";
|
|
}
|
|
|
|
void DebugPrinter::VisitFunctionDefinition(FunctionDefinition& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("FunctionDefinition", Color::BrightYellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << node.name << GetColor(Color::Reset);
|
|
if (node.is_overload)
|
|
{
|
|
os_ << " " << GetColor(Color::Magenta) << "[overload]" << GetColor(Color::Reset);
|
|
}
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(node.location);
|
|
}
|
|
os_ << "\n";
|
|
|
|
// ===== 修复：不需要 IncreaseIndent，缩进由 stack 管理 =====
|
|
|
|
bool signature_is_last = !node.body;
|
|
|
|
PrintIndent(signature_is_last);
|
|
PrintColored("signature", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(signature_is_last);
|
|
IncreaseIndent(); // 这个保留，因为有对应的 push
|
|
|
|
PrintSignature(node.signature);
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
|
|
if (node.body)
|
|
PrintStatement(node.body.get(), "body", true);
|
|
}
|
|
|
|
void DebugPrinter::VisitFunctionDeclaration(FunctionDeclaration& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("FunctionDeclaration", Color::BrightYellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << node.name << GetColor(Color::Reset);
|
|
if (node.is_overload)
|
|
{
|
|
os_ << " " << GetColor(Color::Magenta) << "[overload]" << GetColor(Color::Reset);
|
|
}
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(node.location);
|
|
}
|
|
os_ << "\n";
|
|
|
|
// ===== 修复：不需要外层 IncreaseIndent =====
|
|
|
|
PrintIndent(true); // signature 是唯一子项
|
|
PrintColored("signature", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(true);
|
|
IncreaseIndent();
|
|
|
|
PrintSignature(node.signature);
|
|
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
void DebugPrinter::VisitVarDeclaration(VarDeclaration& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("VarDeclaration", Color::Yellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << node.name << GetColor(Color::Reset);
|
|
if (node.type)
|
|
{
|
|
os_ << ": " << GetColor(Color::BrightBlue) << node.type->name << GetColor(Color::Reset);
|
|
}
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(node.location);
|
|
}
|
|
os_ << "\n";
|
|
|
|
if (node.initial_value)
|
|
{
|
|
IncreaseIndent();
|
|
PrintExpression(node.initial_value.get(), "initial_value", true);
|
|
DecreaseIndent();
|
|
}
|
|
}
|
|
|
|
void DebugPrinter::VisitStaticDeclaration(StaticDeclaration& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("StaticDeclaration", Color::Yellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << node.name << GetColor(Color::Reset);
|
|
PrintReferenceModifier(node.reference_modifier);
|
|
if (node.type)
|
|
{
|
|
os_ << ": " << GetColor(Color::BrightBlue) << node.type->name << GetColor(Color::Reset);
|
|
}
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(node.location);
|
|
}
|
|
os_ << "\n";
|
|
|
|
if (node.initial_value)
|
|
{
|
|
IncreaseIndent();
|
|
PrintExpression(node.initial_value.get(), "initial_value", true);
|
|
DecreaseIndent();
|
|
}
|
|
}
|
|
|
|
void DebugPrinter::VisitGlobalDeclaration(GlobalDeclaration& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("GlobalDeclaration", Color::Yellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << node.name << GetColor(Color::Reset);
|
|
if (node.type)
|
|
{
|
|
os_ << ": " << GetColor(Color::BrightBlue) << node.type->name << GetColor(Color::Reset);
|
|
}
|
|
if (options_.show_location)
|
|
{
|
|
os_ << " ";
|
|
PrintLocation(node.location);
|
|
}
|
|
os_ << "\n";
|
|
|
|
if (node.initial_value)
|
|
{
|
|
IncreaseIndent();
|
|
PrintExpression(node.initial_value.get(), "initial_value", true);
|
|
DecreaseIndent();
|
|
}
|
|
}
|
|
|
|
void DebugPrinter::VisitFieldDeclaration(FieldDeclaration& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("FieldDeclaration", Color::Yellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << node.name << GetColor(Color::Reset);
|
|
PrintReferenceModifier(node.reference_modifier);
|
|
if (node.type)
|
|
{
|
|
os_ << ": " << GetColor(Color::BrightBlue) << node.type->name << GetColor(Color::Reset);
|
|
}
|
|
os_ << "\n";
|
|
|
|
if (node.initial_value)
|
|
{
|
|
IncreaseIndent();
|
|
PrintExpression(node.initial_value.get(), "initial_value", true);
|
|
DecreaseIndent();
|
|
}
|
|
}
|
|
|
|
void DebugPrinter::VisitUnpackPattern(UnpackPattern& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("UnpackPattern", Color::Yellow);
|
|
os_ << " [";
|
|
for (size_t i = 0; i < node.names.size(); ++i)
|
|
{
|
|
if (i > 0)
|
|
os_ << ", ";
|
|
PrintColored(node.names[i], Color::BrightCyan);
|
|
}
|
|
os_ << "]\n";
|
|
}
|
|
|
|
void DebugPrinter::VisitTSSQLExpression(TSSQLExpression& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("TSSQLExpression", Color::Yellow);
|
|
|
|
std::string type_str;
|
|
switch (node.sql_type)
|
|
{
|
|
case TSSQLExpressionType::kSelect:
|
|
type_str = "SELECT";
|
|
break;
|
|
case TSSQLExpressionType::kSSelect:
|
|
type_str = "SSELECT";
|
|
break;
|
|
case TSSQLExpressionType::kVSelect:
|
|
type_str = "VSELECT";
|
|
break;
|
|
case TSSQLExpressionType::kMSelect:
|
|
type_str = "MSELECT";
|
|
break;
|
|
case TSSQLExpressionType::kUpdate:
|
|
type_str = "UPDATE";
|
|
break;
|
|
case TSSQLExpressionType::kDelete:
|
|
type_str = "DELETE";
|
|
break;
|
|
case TSSQLExpressionType::kInsert:
|
|
type_str = "INSERT";
|
|
break;
|
|
default:
|
|
type_str = "UNKNOWN";
|
|
break;
|
|
}
|
|
|
|
os_ << " [" << GetColor(Color::BrightBlue) << type_str << GetColor(Color::Reset) << "]\n";
|
|
|
|
IncreaseIndent();
|
|
PrintIndent();
|
|
PrintColored("sql", Color::Green);
|
|
os_ << ": " << GetColor(Color::BrightGreen) << EscapeString(node.raw_sql) << GetColor(Color::Reset) << "\n";
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitMatrixIterationStatement(MatrixIterationStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("MatrixIterationStatement", Color::BrightYellow);
|
|
os_ << "\n";
|
|
|
|
IncreaseIndent();
|
|
PrintExpression(node.target.get(), "target", false);
|
|
PrintStatement(node.body.get(), "body", true);
|
|
DecreaseIndent();
|
|
}
|
|
|
|
void DebugPrinter::VisitCompilerDirectiveStatement(CompilerDirectiveStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("CompilerDirectiveStatement", Color::BrightYellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << "{$" << node.name;
|
|
if (node.switch_value)
|
|
{
|
|
os_ << *node.switch_value;
|
|
}
|
|
os_ << "}" << GetColor(Color::Reset) << "\n";
|
|
}
|
|
|
|
void DebugPrinter::VisitConditionalDirectiveStatement(ConditionalDirectiveStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("ConditionalDirectiveStatement", Color::BrightYellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << "{$";
|
|
PrintConditionalCompilationType(node.type);
|
|
os_ << " " << node.name << "}" << GetColor(Color::Reset) << "\n";
|
|
}
|
|
|
|
void DebugPrinter::VisitConditionalBlockStatement(ConditionalBlockStatement& node)
|
|
{
|
|
PrintIndent();
|
|
PrintColored("ConditionalBlockStatement", Color::BrightYellow);
|
|
os_ << " " << GetColor(Color::BrightCyan) << "{$";
|
|
PrintConditionalCompilationType(node.type);
|
|
os_ << " " << node.name << "}" << GetColor(Color::Reset) << "\n";
|
|
|
|
IncreaseIndent();
|
|
|
|
if (!node.consequence.empty())
|
|
{
|
|
PrintIndent(!node.alternative.empty());
|
|
PrintColored("consequence", Color::Green);
|
|
os_ << ":\n";
|
|
|
|
is_last_child_stack_.push_back(!node.alternative.empty());
|
|
IncreaseIndent();
|
|
PrintStatements(node.consequence);
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
if (!node.alternative.empty())
|
|
{
|
|
PrintIndent(true);
|
|
PrintColored("alternative", Color::Green);
|
|
os_ << " " << GetColor(Color::Cyan) << "{$ELSE}" << GetColor(Color::Reset) << ":\n";
|
|
|
|
is_last_child_stack_.push_back(true);
|
|
IncreaseIndent();
|
|
PrintStatements(node.alternative);
|
|
DecreaseIndent();
|
|
is_last_child_stack_.pop_back();
|
|
}
|
|
|
|
DecreaseIndent();
|
|
}
|
|
}
|