634 lines
20 KiB
Rust
634 lines
20 KiB
Rust
// Charter Codegen - NVM 2.0字节码生成器
|
||
// 将AST转换为NVM 2.0字节码
|
||
|
||
use crate::parser::ast::*;
|
||
use std::collections::HashMap;
|
||
use thiserror::Error;
|
||
|
||
#[derive(Error, Debug)]
|
||
#[allow(dead_code)]
|
||
pub enum CodegenError {
|
||
#[error("不支持的操作: {0}")]
|
||
UnsupportedOperation(String),
|
||
|
||
#[error("未定义的变量: {0}")]
|
||
UndefinedVariable(String),
|
||
|
||
#[error("未定义的函数: {0}")]
|
||
UndefinedFunction(String),
|
||
}
|
||
|
||
/// NVM 2.0操作码（从NAC UDM导入）
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
#[repr(u8)]
|
||
#[allow(non_camel_case_types)]
|
||
#[allow(dead_code)]
|
||
pub enum OpCode {
|
||
// 基础操作码
|
||
STOP = 0x00,
|
||
ADD = 0x01,
|
||
MUL = 0x02,
|
||
SUB = 0x03,
|
||
DIV = 0x04,
|
||
MOD = 0x06,
|
||
LT = 0x10,
|
||
GT = 0x11,
|
||
EQ = 0x14,
|
||
IS_ZERO = 0x15,
|
||
AND = 0x16,
|
||
OR = 0x17,
|
||
NOT = 0x19,
|
||
|
||
// 栈操作
|
||
POP = 0x50,
|
||
MLOAD = 0x51,
|
||
MSTORE = 0x52,
|
||
SLOAD = 0x54,
|
||
SSTORE = 0x55,
|
||
JUMP = 0x56,
|
||
JUMPI = 0x57,
|
||
PC = 0x58,
|
||
JUMPDEST = 0x5B,
|
||
|
||
// PUSH操作
|
||
PUSH1 = 0x60,
|
||
PUSH2 = 0x61,
|
||
PUSH4 = 0x63,
|
||
PUSH8 = 0x67,
|
||
PUSH32 = 0x7F,
|
||
|
||
// DUP操作
|
||
DUP1 = 0x80,
|
||
DUP2 = 0x81,
|
||
|
||
// SWAP操作
|
||
SWAP1 = 0x90,
|
||
|
||
// 系统操作
|
||
CALL = 0xF1,
|
||
RETURN = 0xF3,
|
||
REVERT = 0xFD,
|
||
|
||
// RWA专属操作码
|
||
CR_CREATE = 0xE1,
|
||
CR_VERIFY = 0xE2,
|
||
CR_GET = 0xE3,
|
||
GNACS_ENCODE = 0xE6,
|
||
GNACS_DECODE = 0xE7,
|
||
GNACS_VALIDATE = 0xE8,
|
||
// ACC 基础代币操作码
|
||
ACC20_TRANSFER = 0xEB,
|
||
ACC20_BALANCE = 0xEF,
|
||
ACC20_MINT = 0xA0,
|
||
ACC20_BURN = 0xA1,
|
||
ACC721_MINT = 0xA2,
|
||
ACC721_TRANSFER = 0xA3,
|
||
ACC1155_MINT = 0xA4,
|
||
ACC1155_TRANSFER = 0xA5,
|
||
// RWA 专用操作码
|
||
RWA_REGISTER = 0xD0,
|
||
RWA_TRANSFER = 0xD1,
|
||
RWA_FREEZE = 0xD2,
|
||
RWA_UPDATE_VALUATION = 0xD3,
|
||
COMPLIANCE_CHECK = 0xD4,
|
||
COMPLIANCE_SEVEN_LAYER = 0xD5,
|
||
VALUATION_REQUEST = 0xD6,
|
||
VALUATION_GET = 0xD7,
|
||
CUSTODY_CREATE = 0xD8,
|
||
CUSTODY_TRANSFER = 0xD9,
|
||
COLLATERAL_CREATE = 0xDA,
|
||
COLLATERAL_LIQUIDATE = 0xDB,
|
||
REDEMPTION_REQUEST = 0xDC,
|
||
REDEMPTION_COMPLETE = 0xDD,
|
||
INSURANCE_ISSUE = 0xDE,
|
||
INSURANCE_CLAIM = 0xDF,
|
||
GOVERNANCE_PROPOSE = 0xC0,
|
||
GOVERNANCE_VOTE = 0xC1,
|
||
GOVERNANCE_FINALIZE = 0xC2,
|
||
// 稳定币与储备操作码
|
||
XTZH_MINT = 0xC3,
|
||
XTZH_BURN = 0xC4,
|
||
XTZH_TRANSFER = 0xC5,
|
||
XTZH_UPDATE_RATE = 0xC6,
|
||
RESERVE_DEPOSIT = 0xC7,
|
||
RESERVE_WITHDRAW = 0xC8,
|
||
RESERVE_AUDIT = 0xC9,
|
||
// 证券代币操作码
|
||
ACC1410_PARTITION = 0xB0,
|
||
ACC1410_TRANSFER_BY_PARTITION = 0xB1,
|
||
ACC1400_ISSUE = 0xB2,
|
||
ACC1400_REDEEM = 0xB3,
|
||
ACC1594_DISTRIBUTE = 0xB4,
|
||
ACC1643_ADD_DOCUMENT = 0xB5,
|
||
ACC1644_FREEZE = 0xB6,
|
||
ACC1644_FORCE_TRANSFER = 0xB7,
|
||
}
|
||
|
||
pub struct CodeGenerator {
|
||
bytecode: Vec<u8>,
|
||
variables: HashMap<String, usize>, // 变量名 -> 存储位置
|
||
next_storage_slot: usize,
|
||
jump_labels: HashMap<String, usize>,
|
||
next_label_id: usize,
|
||
/// 待回填的跳转位置 (字节码位置 -> 标签名)
|
||
pending_jumps: Vec<(usize, String)>,
|
||
}
|
||
|
||
impl CodeGenerator {
|
||
pub fn new() -> Self {
|
||
Self {
|
||
bytecode: Vec::new(),
|
||
variables: HashMap::new(),
|
||
next_storage_slot: 0,
|
||
jump_labels: HashMap::new(),
|
||
next_label_id: 0,
|
||
pending_jumps: Vec::new(),
|
||
}
|
||
}
|
||
|
||
pub fn generate(&mut self, program: &Program) -> Result<Vec<u8>, CodegenError> {
|
||
for item in &program.items {
|
||
match item {
|
||
TopLevelItem::Asset(asset) => {
|
||
self.generate_asset(asset)?;
|
||
}
|
||
TopLevelItem::Contract(contract) => {
|
||
self.generate_contract(contract)?;
|
||
}
|
||
TopLevelItem::Function(function) => {
|
||
self.generate_function(function)?;
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
Ok(self.bytecode.clone())
|
||
}
|
||
|
||
fn generate_asset(&mut self, asset: &AssetDefinition) -> Result<(), CodegenError> {
|
||
// 生成GNACS验证代码
|
||
self.emit_comment(&format!("Asset: {}", asset.name));
|
||
self.emit_comment(&format!("GNACS: {}", asset.gnacs_code));
|
||
|
||
// 验证GNACS编码
|
||
self.emit_push_bytes(asset.gnacs_code.as_bytes());
|
||
self.emit(OpCode::GNACS_VALIDATE);
|
||
|
||
// 如果验证失败，回滚
|
||
self.emit(OpCode::IS_ZERO);
|
||
let revert_label = self.create_label();
|
||
self.emit_jumpi(&revert_label);
|
||
|
||
// 生成资产方法
|
||
for method in &asset.methods {
|
||
self.generate_method(method)?;
|
||
}
|
||
|
||
// Revert标签
|
||
self.place_label(&revert_label);
|
||
self.emit(OpCode::REVERT);
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn generate_contract(&mut self, contract: &ContractDefinition) -> Result<(), CodegenError> {
|
||
self.emit_comment(&format!("Contract: {}", contract.name));
|
||
|
||
// 生成合约方法
|
||
for method in &contract.methods {
|
||
self.generate_method(method)?;
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn generate_function(&mut self, function: &FunctionDeclaration) -> Result<(), CodegenError> {
|
||
self.emit_comment(&format!("Function: {}", function.name));
|
||
|
||
// 添加参数到变量映射
|
||
for (i, param) in function.parameters.iter().enumerate() {
|
||
self.variables.insert(param.name.clone(), i);
|
||
}
|
||
|
||
// 生成函数体
|
||
self.generate_block(&function.body)?;
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn generate_method(&mut self, method: &MethodDeclaration) -> Result<(), CodegenError> {
|
||
self.emit_comment(&format!("Method: {}", method.name));
|
||
|
||
// 生成requires子句（前置条件）
|
||
for expr in &method.requires {
|
||
self.generate_expression(expr)?;
|
||
|
||
// 如果条件为false，回滚
|
||
self.emit(OpCode::IS_ZERO);
|
||
let revert_label = self.create_label();
|
||
self.emit_jumpi(&revert_label);
|
||
}
|
||
|
||
// 生成方法体
|
||
self.generate_block(&method.body)?;
|
||
|
||
// 生成ensures子句（后置条件）
|
||
for expr in &method.ensures {
|
||
self.generate_expression(expr)?;
|
||
|
||
// 如果条件为false，回滚
|
||
self.emit(OpCode::IS_ZERO);
|
||
let revert_label = self.create_label();
|
||
self.emit_jumpi(&revert_label);
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn generate_block(&mut self, block: &Block) -> Result<(), CodegenError> {
|
||
for statement in &block.statements {
|
||
self.generate_statement(statement)?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn generate_statement(&mut self, statement: &Statement) -> Result<(), CodegenError> {
|
||
match statement {
|
||
Statement::Let(let_stmt) => {
|
||
// 生成表达式
|
||
self.generate_expression(&let_stmt.value)?;
|
||
|
||
// 分配存储位置
|
||
let storage_slot = self.next_storage_slot;
|
||
self.next_storage_slot += 1;
|
||
self.variables.insert(let_stmt.name.clone(), storage_slot);
|
||
|
||
// 存储到存储槽
|
||
self.emit_push_u256(storage_slot as u64);
|
||
self.emit(OpCode::SSTORE);
|
||
|
||
Ok(())
|
||
}
|
||
Statement::Assign(assign_stmt) => {
|
||
// 生成表达式
|
||
self.generate_expression(&assign_stmt.value)?;
|
||
|
||
// 获取变量存储位置
|
||
let storage_slot = self.variables.get(&assign_stmt.target)
|
||
.ok_or_else(|| CodegenError::UndefinedVariable(assign_stmt.target.clone()))?;
|
||
|
||
// 存储到存储槽
|
||
self.emit_push_u256(*storage_slot as u64);
|
||
self.emit(OpCode::SSTORE);
|
||
|
||
Ok(())
|
||
}
|
||
Statement::If(if_stmt) => {
|
||
// 生成条件表达式
|
||
self.generate_expression(&if_stmt.condition)?;
|
||
|
||
let else_label = self.create_label();
|
||
let end_label = self.create_label();
|
||
|
||
// 如果条件为false，跳转到else
|
||
self.emit(OpCode::IS_ZERO);
|
||
self.emit_jumpi(&else_label);
|
||
|
||
// 生成then块
|
||
self.generate_block(&if_stmt.then_block)?;
|
||
self.emit_jump(&end_label);
|
||
|
||
// 生成else块
|
||
self.place_label(&else_label);
|
||
if let Some(else_block) = &if_stmt.else_block {
|
||
self.generate_block(else_block)?;
|
||
}
|
||
|
||
self.place_label(&end_label);
|
||
Ok(())
|
||
}
|
||
Statement::While(while_stmt) => {
|
||
let start_label = self.create_label();
|
||
let end_label = self.create_label();
|
||
|
||
self.place_label(&start_label);
|
||
|
||
// 生成条件表达式
|
||
self.generate_expression(&while_stmt.condition)?;
|
||
|
||
// 如果条件为false，跳出循环
|
||
self.emit(OpCode::IS_ZERO);
|
||
self.emit_jumpi(&end_label);
|
||
|
||
// 生成循环体
|
||
self.generate_block(&while_stmt.body)?;
|
||
|
||
// 跳回循环开始
|
||
self.emit_jump(&start_label);
|
||
|
||
self.place_label(&end_label);
|
||
Ok(())
|
||
}
|
||
Statement::Return(return_stmt) => {
|
||
if let Some(value) = &return_stmt.value {
|
||
// 生成返回值表达式，结果将在栈顶
|
||
self.generate_expression(value)?;
|
||
// 设置返回值：从栈顶弹出并存储到返回值寄存器
|
||
// 实际应该根据返回值类型选择合适的指令
|
||
// 这里简化处理：RETURN指令会自动处理栈顶的值
|
||
} else {
|
||
// 无返回值，返回unit类型
|
||
}
|
||
|
||
self.emit(OpCode::RETURN);
|
||
Ok(())
|
||
}
|
||
Statement::RequireCR(expr) => {
|
||
// 生成宪法收据验证代码
|
||
self.emit_comment("RequireCR");
|
||
self.generate_expression(expr)?;
|
||
self.emit(OpCode::CR_VERIFY);
|
||
|
||
// 如果验证失败，回滚
|
||
self.emit(OpCode::IS_ZERO);
|
||
let revert_label = self.create_label();
|
||
self.emit_jumpi(&revert_label);
|
||
|
||
Ok(())
|
||
}
|
||
Statement::VerifyCR(expr) => {
|
||
// 生成宪法收据验证代码
|
||
self.emit_comment("VerifyCR");
|
||
self.generate_expression(expr)?;
|
||
self.emit(OpCode::CR_VERIFY);
|
||
|
||
Ok(())
|
||
}
|
||
Statement::Expression(expr) => {
|
||
self.generate_expression(expr)?;
|
||
self.emit(OpCode::POP); // 丢弃表达式结果
|
||
Ok(())
|
||
}
|
||
_ => Err(CodegenError::UnsupportedOperation(format!("{:?}", statement))),
|
||
}
|
||
}
|
||
|
||
fn generate_expression(&mut self, expr: &Expression) -> Result<(), CodegenError> {
|
||
match expr {
|
||
Expression::Integer(n) => {
|
||
self.emit_push_u256(*n);
|
||
Ok(())
|
||
}
|
||
Expression::Boolean(b) => {
|
||
self.emit_push_u256(if *b { 1 } else { 0 });
|
||
Ok(())
|
||
}
|
||
Expression::String(s) => {
|
||
self.emit_push_bytes(s.as_bytes());
|
||
Ok(())
|
||
}
|
||
Expression::GNACSCode(code) => {
|
||
self.emit_push_bytes(code.as_bytes());
|
||
self.emit(OpCode::GNACS_ENCODE);
|
||
Ok(())
|
||
}
|
||
Expression::Identifier(name) => {
|
||
// 从存储加载变量
|
||
let storage_slot = self.variables.get(name)
|
||
.ok_or_else(|| CodegenError::UndefinedVariable(name.clone()))?;
|
||
|
||
self.emit_push_u256(*storage_slot as u64);
|
||
self.emit(OpCode::SLOAD);
|
||
Ok(())
|
||
}
|
||
Expression::Binary(op, left, right) => {
|
||
// 生成左右操作数
|
||
self.generate_expression(left)?;
|
||
self.generate_expression(right)?;
|
||
|
||
// 生成操作符
|
||
match op {
|
||
BinaryOp::Add => self.emit(OpCode::ADD),
|
||
BinaryOp::Sub => self.emit(OpCode::SUB),
|
||
BinaryOp::Mul => self.emit(OpCode::MUL),
|
||
BinaryOp::Div => self.emit(OpCode::DIV),
|
||
BinaryOp::Mod => self.emit(OpCode::MOD),
|
||
BinaryOp::Equal => self.emit(OpCode::EQ),
|
||
BinaryOp::NotEqual => {
|
||
self.emit(OpCode::EQ);
|
||
self.emit(OpCode::IS_ZERO);
|
||
}
|
||
BinaryOp::Less => self.emit(OpCode::LT),
|
||
BinaryOp::LessEqual => {
|
||
// a <= b 等价于 !(a > b)
|
||
self.emit(OpCode::GT);
|
||
self.emit(OpCode::IS_ZERO);
|
||
}
|
||
BinaryOp::Greater => self.emit(OpCode::GT),
|
||
BinaryOp::GreaterEqual => {
|
||
// a >= b 等价于 !(a < b)
|
||
self.emit(OpCode::LT);
|
||
self.emit(OpCode::IS_ZERO);
|
||
}
|
||
BinaryOp::And => self.emit(OpCode::AND),
|
||
BinaryOp::Or => self.emit(OpCode::OR),
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
Expression::Cast(expr, _target_type) => {
|
||
// 生成表达式（类型转换在NVM层面是透明的）
|
||
self.generate_expression(expr)?;
|
||
Ok(())
|
||
}
|
||
Expression::If(condition, then_expr, else_expr) => {
|
||
// 生成条件
|
||
self.generate_expression(condition)?;
|
||
|
||
// 如果条件为false，跳转到else分支
|
||
let else_label = self.create_label();
|
||
let end_label = self.create_label();
|
||
|
||
self.emit(OpCode::IS_ZERO);
|
||
self.emit_jumpi(&else_label);
|
||
|
||
// then分支
|
||
self.generate_expression(then_expr)?;
|
||
self.emit_jump(&end_label);
|
||
|
||
// else分支
|
||
self.place_label(&else_label);
|
||
self.generate_expression(else_expr)?;
|
||
|
||
// 结束
|
||
self.place_label(&end_label);
|
||
|
||
Ok(())
|
||
}
|
||
Expression::Unary(op, expr) => {
|
||
self.generate_expression(expr)?;
|
||
|
||
match op {
|
||
UnaryOp::Not => self.emit(OpCode::NOT),
|
||
UnaryOp::Neg => {
|
||
// 取反：0 - expr
|
||
self.emit_push_u256(0);
|
||
self.emit(OpCode::SWAP1);
|
||
self.emit(OpCode::SUB);
|
||
}
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
Expression::FunctionCall(name, args) => {
|
||
// 生成参数
|
||
for arg in args {
|
||
self.generate_expression(arg)?;
|
||
}
|
||
|
||
// 函数调用：参数已在栈上，发出CALL指令
|
||
self.emit_comment(&format!("Call: {}", name));
|
||
// 推送函数名哈希作为函数选择器
|
||
let function_selector = self.compute_function_selector(name);
|
||
self.emit_push_u256(function_selector as u64);
|
||
// 推送参数数量
|
||
self.emit_push_u256(args.len() as u64);
|
||
self.emit(OpCode::CALL);
|
||
|
||
Ok(())
|
||
}
|
||
_ => Err(CodegenError::UnsupportedOperation(format!("{:?}", expr))),
|
||
}
|
||
}
|
||
|
||
// 辅助方法
|
||
|
||
fn emit(&mut self, opcode: OpCode) {
|
||
self.bytecode.push(opcode as u8);
|
||
}
|
||
|
||
fn emit_push_u256(&mut self, value: u64) {
|
||
if value == 0 {
|
||
self.emit(OpCode::PUSH1);
|
||
self.bytecode.push(0);
|
||
} else if value <= 0xFF {
|
||
self.emit(OpCode::PUSH1);
|
||
self.bytecode.push(value as u8);
|
||
} else if value <= 0xFFFF {
|
||
self.emit(OpCode::PUSH2);
|
||
self.bytecode.extend_from_slice(&(value as u16).to_be_bytes());
|
||
} else if value <= 0xFFFFFFFF {
|
||
self.emit(OpCode::PUSH4);
|
||
self.bytecode.extend_from_slice(&(value as u32).to_be_bytes());
|
||
} else {
|
||
self.emit(OpCode::PUSH8);
|
||
self.bytecode.extend_from_slice(&value.to_be_bytes());
|
||
}
|
||
}
|
||
|
||
fn emit_push_bytes(&mut self, bytes: &[u8]) {
|
||
if bytes.len() <= 32 {
|
||
self.emit(OpCode::PUSH32);
|
||
let mut padded = [0u8; 32];
|
||
padded[..bytes.len()].copy_from_slice(bytes);
|
||
self.bytecode.extend_from_slice(&padded);
|
||
} else {
|
||
// 对于超过32字节的数据，需要分块处理
|
||
for chunk in bytes.chunks(32) {
|
||
self.emit_push_bytes(chunk);
|
||
}
|
||
}
|
||
}
|
||
|
||
fn emit_jump(&mut self, label: &str) {
|
||
// 记录需要回填的跳转地址
|
||
let jump_pos = self.bytecode.len();
|
||
self.emit_push_u256(0); // 占位符，将在place_label时回填
|
||
self.emit(OpCode::JUMP);
|
||
|
||
// 实际应该：
|
||
// self.pending_jumps.entry(label.to_string())
|
||
// .or_insert_with(Vec::new)
|
||
// .push(jump_pos);
|
||
let _ = (label, jump_pos); // 避免未使用警告
|
||
}
|
||
|
||
fn emit_jumpi(&mut self, label: &str) {
|
||
// 记录需要回填的条件跳转地址
|
||
let jump_pos = self.bytecode.len();
|
||
self.emit_push_u256(0); // 占位符，将在place_label时回填
|
||
self.emit(OpCode::JUMPI);
|
||
|
||
// 实际应该：
|
||
// self.pending_jumps.entry(label.to_string())
|
||
// .or_insert_with(Vec::new)
|
||
// .push(jump_pos);
|
||
let _ = (label, jump_pos); // 避免未使用警告
|
||
}
|
||
|
||
fn create_label(&mut self) -> String {
|
||
let label = format!("label_{}", self.next_label_id);
|
||
self.next_label_id += 1;
|
||
label
|
||
}
|
||
|
||
fn place_label(&mut self, label: &str) {
|
||
self.jump_labels.insert(label.to_string(), self.bytecode.len());
|
||
self.emit(OpCode::JUMPDEST);
|
||
}
|
||
|
||
fn emit_comment(&mut self, _comment: &str) {
|
||
// 注释不生成字节码，仅用于调试
|
||
}
|
||
|
||
/// 计算函数选择器（使用简单的哈希）
|
||
fn compute_function_selector(&self, name: &str) -> u32 {
|
||
use std::collections::hash_map::DefaultHasher;
|
||
use std::hash::{Hash, Hasher};
|
||
|
||
let mut hasher = DefaultHasher::new();
|
||
name.hash(&mut hasher);
|
||
(hasher.finish() & 0xFFFFFFFF) as u32
|
||
}
|
||
}
|
||
|
||
/// 生成NVM 2.0字节码
|
||
pub fn generate(program: &Program) -> anyhow::Result<Vec<u8>> {
|
||
let mut generator = CodeGenerator::new();
|
||
Ok(generator.generate(program)?)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use crate::lexer::tokenize;
|
||
use crate::parser::parse;
|
||
|
||
#[test]
|
||
fn test_generate_empty() {
|
||
let program = Program { items: vec![] };
|
||
let bytecode = generate(&program).expect("FIX-006: unexpected None/Err");
|
||
assert_eq!(bytecode.len(), 0);
|
||
}
|
||
|
||
#[test]
|
||
fn test_generate_simple() {
|
||
let source = r#"
|
||
contract Test {
|
||
total: uint256;
|
||
|
||
public fn get() -> uint256 {
|
||
let x = 100;
|
||
return x;
|
||
}
|
||
}
|
||
"#;
|
||
|
||
let tokens = tokenize(source).expect("FIX-006: unexpected None/Err");
|
||
let program = parse(&tokens).expect("FIX-006: unexpected None/Err");
|
||
let bytecode = generate(&program).expect("FIX-006: unexpected None/Err");
|
||
|
||
assert!(bytecode.len() > 0);
|
||
}
|
||
}
|