100 lines
2.8 KiB
C++
100 lines
2.8 KiB
C++
#ifndef CAMELLYA_COMPILER_H
|
|
#define CAMELLYA_COMPILER_H
|
|
|
|
#include "ast.h"
|
|
#include "chunk.h"
|
|
#include "value.h"
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
namespace camellya {
|
|
|
|
// Local variable information
|
|
struct Local {
|
|
std::string name;
|
|
int depth;
|
|
bool is_captured;
|
|
};
|
|
|
|
// Loop information for break/continue
|
|
struct LoopInfo {
|
|
size_t start; // Loop start position (for continue)
|
|
std::vector<size_t> breaks; // Break jump positions to patch
|
|
int scope_depth; // Scope depth at loop start
|
|
};
|
|
|
|
// Compiler class for converting AST to bytecode
|
|
class Compiler {
|
|
public:
|
|
Compiler();
|
|
|
|
// Compile a program into a chunk
|
|
std::shared_ptr<Chunk> compile(const Program &program);
|
|
|
|
// Get the last error message
|
|
const std::string &get_error() const { return error_message; }
|
|
|
|
private:
|
|
std::shared_ptr<Chunk> current_chunk;
|
|
std::vector<Local> locals;
|
|
std::vector<LoopInfo> loops; // Stack of loop information
|
|
int scope_depth;
|
|
std::string error_message;
|
|
bool had_error;
|
|
|
|
// Compilation methods for expressions
|
|
void compile_expr(const Expr &expr);
|
|
void compile_binary(const BinaryExpr &expr);
|
|
void compile_unary(const UnaryExpr &expr);
|
|
void compile_literal(const LiteralExpr &expr);
|
|
void compile_variable(const VariableExpr &expr);
|
|
void compile_assign(const AssignExpr &expr);
|
|
void compile_call(const CallExpr &expr);
|
|
void compile_get(const GetExpr &expr);
|
|
void compile_set(const SetExpr &expr);
|
|
void compile_index(const IndexExpr &expr);
|
|
void compile_index_set(const IndexSetExpr &expr);
|
|
void compile_list(const ListExpr &expr);
|
|
void compile_map(const MapExpr &expr);
|
|
|
|
// Compilation methods for statements
|
|
void compile_stmt(const Stmt &stmt);
|
|
void compile_expr_stmt(const ExprStmt &stmt);
|
|
void compile_var_decl(const VarDecl &stmt);
|
|
void compile_block(const BlockStmt &stmt);
|
|
void compile_if(const IfStmt &stmt);
|
|
void compile_while(const WhileStmt &stmt);
|
|
void compile_for(const ForStmt &stmt);
|
|
void compile_return(const ReturnStmt &stmt);
|
|
void compile_break(const BreakStmt &stmt);
|
|
void compile_continue(const ContinueStmt &stmt);
|
|
void compile_function_decl(const FunctionDecl &stmt);
|
|
void compile_class_decl(const ClassDecl &stmt);
|
|
|
|
// Helper methods
|
|
void emit_byte(uint8_t byte);
|
|
void emit_opcode(OpCode op);
|
|
void emit_bytes(uint8_t byte1, uint8_t byte2);
|
|
void emit_constant(ValuePtr value);
|
|
size_t emit_jump(OpCode op);
|
|
void patch_jump(size_t offset);
|
|
void emit_loop(size_t loop_start);
|
|
|
|
// Variable management
|
|
void begin_scope();
|
|
void end_scope();
|
|
void add_local(const std::string &name);
|
|
int resolve_local(const std::string &name);
|
|
|
|
// Constant pool
|
|
uint8_t make_constant(ValuePtr value);
|
|
uint8_t identifier_constant(const std::string &name);
|
|
|
|
// Error handling
|
|
void report_error(const std::string &message);
|
|
};
|
|
|
|
} // namespace camellya
|
|
|
|
#endif // CAMELLYA_COMPILER_H
|