nyar_assembler/program/

types.rs

use gaia_types::{GaiaError, QualifiedName};
use serde::{Deserialize, Serialize};

/// 异常处理器
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct NyarHandler {
    pub start: u32,
    pub end: u32,
    pub target: u32,
    pub error_type: u16,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct NyarChunk {
    pub code: Vec<u8>,
    pub locals: u16,
    pub upvalues: u16,
    pub max_stack: u16,
    pub handlers: Vec<NyarHandler>,
    pub lines: Vec<(u32, u32)>,
}

impl Clone for NyarChunk {
    fn clone(&self) -> Self {
        Self {
            code: self.code.clone(),
            locals: self.locals,
            upvalues: self.upvalues,
            max_stack: self.max_stack,
            handlers: self.handlers.clone(),
            lines: self.lines.clone(),
        }
    }
}

impl Default for NyarChunk {
    fn default() -> Self {
        Self {
            code: Vec::new(),
            locals: 0,
            upvalues: 0,
            max_stack: 0,
            handlers: Vec::new(),
            lines: Vec::new(),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NyarModule {
    pub name: QualifiedName,
    pub version: u16,
    pub flags: u32,
    pub timestamp: u64,
    pub constants: Vec<NyarConstant>,
    pub effects: Vec<QualifiedName>,
    pub chunks: Vec<NyarChunk>,
    pub classes: Vec<NyarClassInfo>,
    pub traits: Vec<NyarTraitInfo>,
    pub impls: Vec<NyarImplInfo>,
    pub imports: Vec<NyarImportInfo>,
    pub exports: Vec<NyarExportInfo>,
}

impl Default for NyarModule {
    fn default() -> Self {
        Self {
            name: QualifiedName::new(vec![], "main".to_string()),
            version: 1,
            flags: 0,
            timestamp: 0,
            constants: Vec::new(),
            effects: Vec::new(),
            chunks: Vec::new(),
            classes: Vec::new(),
            traits: Vec::new(),
            impls: Vec::new(),
            imports: Vec::new(),
            exports: Vec::new(),
        }
    }
}

/// Nyar 常量池项
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
#[serde(tag = "kind", content = "value")]
pub enum NyarConstant {
    /// 空常量
    None,
    /// 整数常量
    Int(i64),
    /// 浮点数常量
    Float(u64), // Use u64 bits for Eq/Hash
    /// 字符串常量
    String(String),
    /// 限定名称常量
    QualifiedName(QualifiedName),
}

impl NyarConstant {
    pub fn float(f: f64) -> Self {
        Self::Float(f.to_bits())
    }
    pub fn get_float(&self) -> Option<f64> {
        if let Self::Float(v) = self {
            Some(f64::from_bits(*v))
        } else {
            None
        }
    }
}

/// 类型信息
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NyarClassInfo {
    pub name: QualifiedName,
    pub fields: Vec<String>,
}

/// 特征信息
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NyarTraitInfo {
    pub name: QualifiedName,
    pub methods: Vec<String>,
}

/// 实现信息
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NyarImplInfo {
    pub class_idx: u16,
    pub trait_idx: u16,
    pub methods: Vec<u16>,
}

/// 导入信息
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NyarImportInfo {
    pub provider: String,
    pub symbol: QualifiedName,
}

/// 导出信息
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NyarExportInfo {
    pub symbol: QualifiedName,
    pub chunk_idx: u16,
}

/// 上值引用
#[repr(C)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct NyarUpvalueRef {
    /// 是否为局部变量
    pub is_local: bool,
    /// 索引
    pub index: u8,
}

/// Nyar 操作码枚举
#[repr(u8)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum NyarOpcode {
    /// 无操作
    Nop = 0x00,
    /// 入栈
    Push = 0x01,
    /// 出栈
    Pop = 0x02,
    /// 复制栈顶
    Dup = 0x03,
    /// 交换栈顶
    Swap = 0x04,
    /// 加载局部变量
    LoadLocal = 0x05,
    /// 存储局部变量
    StoreLocal = 0x06,
    /// 加载全局变量
    LoadGlobal = 0x07,
    /// 存储全局变量
    StoreGlobal = 0x08,
    /// 加载上值 (Upvalue)
    LoadUpvalue = 0x09,
    /// 存储上值 (Upvalue)
    StoreUpvalue = 0x0A,
    /// 关闭上值
    CloseUpvalues = 0x0B,
    /// 无条件跳转
    Jump = 0x0C,
    /// 为假时跳转
    JumpIfFalse = 0x0D,
    /// 为真时跳转
    JumpIfTrue = 0x0E,
    /// 为空时跳转
    JumpIfNull = 0x0F,
    /// 入栈空值
    PushNone = 0x10,
    /// 返回
    Return = 0x13,
    /// 创建闭包
    MakeClosure = 0x15,

    /// 函数调用
    Call = 0x20,
    /// 虚函数调用
    CallVirtual = 0x21,
    /// 动态调用
    CallDynamic = 0x22,
    /// 闭包调用
    CallClosure = 0x23,
    /// 方法调用
    InvokeMethod = 0x24,
    /// 符号调用
    CallSymbol = 0x25,
    /// FFI 调用
    FFICall = 0xF0,
    /// 尾调用
    TailCall = 0x14,
    /// 闭包尾调用
    TailCallClosure = 0x16,

    /// 获取字段
    GetField = 0x30,
    /// 设置字段
    SetField = 0x31,
    /// 创建对象
    NewObject = 0x32,
    /// 创建数组
    NewArray = 0x33,
    /// 获取元素
    GetElement = 0x34,
    /// 设置元素
    SetElement = 0x35,
    /// 创建元组
    MakeTuple = 0x36,
    /// 是否存在键
    HasKey = 0x37,
    /// 匹配变体
    MatchVariant = 0x38,
    /// 获取大小
    SizeOf = 0x39,
    /// 创建动态对象
    NewDynObject = 0x3A,
    /// 移除键
    RemoveKey = 0x3B,
    /// 创建列表
    NewList = 0x3C,
    /// 左侧入队
    PushElementLeft = 0x3D,
    /// 左侧出队
    PopElementLeft = 0x3E,
    /// 元素入队右侧
    PushElementRight = 0x3F,
    /// 元素出队右侧
    PopElementRight = 0x40,
    /// 获取类型
    TypeOf = 0x41,
    /// 类型实例判断
    InstanceOf = 0x42,
    /// 检查转换
    CheckCast = 0x43,
    /// 类型转换
    Cast = 0x44,
    /// 初始化
    Initiate = 0x45,
    /// 终止
    Finalize = 0x46,
    /// 执行副作用 (Effect)
    Perform = 0x50,
    /// 注册副作用处理器
    WithHandler = 0x51,
    /// 继续副作用执行
    ResumeWith = 0x52,
    /// 捕获延续 (Continuation)
    CaptureCont = 0x53,
    /// 等待 (Await)
    Await = 0x54,
    /// 阻塞等待 (BlockOn)
    BlockOn = 0x55,
    /// 匹配副作用
    MatchEffect = 0x56,
    /// 获取虚表
    GetWitnessTable = 0x60,
    /// 虚表方法调用
    WitnessMethod = 0x61,
    /// 打开存在类型
    OpenExistential = 0x62,
    /// 关闭存在类型
    CloseExistential = 0x63,
    /// 引用 (Quote)
    Quote = 0x70,
    /// 拼接 (Splice)
    Splice = 0x71,
    /// 求值 (Eval)
    Eval = 0x72,
    /// 宏展开
    ExpandMacro = 0x73,

    /// 新建通道
    NewChannel = 0x57,
    /// 发送通道消息
    SendChannel = 0x58,
    /// 接收通道消息
    RecvChannel = 0x59,
    /// 选择通道
    SelectChannel = 0x5A,
    /// 新建查询
    NewQuery = 0x5B,
    /// 执行查询
    QueryExec = 0x5C,
    /// 新建时钟
    NewClock = 0x5D,
    /// 时钟等待
    ClockWait = 0x5E,

    /// I32 扩展指令
    I32Ext = 0xC1,
    /// I64 扩展指令
    I64Ext = 0xC2,
    /// F32 扩展指令
    F32Ext = 0xC3,
    /// F64 扩展指令
    F64Ext = 0xC4,
    /// 大整数扩展指令
    BigIntExt = 0xC5,
    /// 字符串扩展指令
    StringExt = 0xC6,

    /// 停机
    Halt = 0xFF,
}

/// Nyar 指令枚举
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum NyarInstruction {
    /// 无操作
    Nop,
    /// 入栈常量，参数为常量池索引
    Push(u16),
    /// 入栈空值
    PushNone,
    /// 栈顶出栈
    Pop,
    /// 复制栈顶元素，参数为相对于栈顶的深度
    Dup(u8),
    /// 交换栈顶两个元素，参数为相对于栈顶的深度
    Swap(u8),
    /// 加载局部变量，参数为局部变量索引
    LoadLocal(u8),
    /// 存储局部变量，参数为局部变量索引
    StoreLocal(u8),
    /// 加载全局变量，参数为全局变量名索引
    LoadGlobal(u16),
    /// 存储全局变量，参数为全局变量名索引
    StoreGlobal(u16),
    /// 加载上值，参数为上值索引
    LoadUpvalue(u8),
    /// 存储上值，参数为上值索引
    StoreUpvalue(u8),
    /// 关闭所有开启的上值
    CloseUpvalues,
    /// 无条件跳转，参数为相对偏移量
    Jump(i16),
    /// 如果栈顶为假则跳转
    JumpIfFalse(i16),
    /// 如果栈顶为真则跳转
    JumpIfTrue(i16),
    /// 如果栈顶为空则跳转
    JumpIfNull(i16),
    /// 函数返回
    Return,
    /// 创建闭包，参数为函数体索引和上值引用列表
    MakeClosure(u16, Vec<NyarUpvalueRef>),
    /// 尾递归调用，参数为函数名索引和参数数量
    TailCall(u16, u8),
    /// 闭包尾递归调用，参数为参数数量
    TailCallClosure(u8),
    /// 函数调用，参数为函数名索引和参数数量
    Call(u16, u8),
    /// 虚函数调用，参数为函数名索引和参数数量
    CallVirtual(u16, u8),
    /// 动态调用，参数为函数名索引和参数数量
    CallDynamic(u16, u8),
    /// 闭包调用，参数为参数数量
    CallClosure(u8),
    /// 方法调用，参数为函数名索引和参数数量
    InvokeMethod(u16, u8),
    /// 符号调用，参数为符号名索引和参数数量
    CallSymbol(u16, u8),
    /// 获取对象字段，参数为字段名索引
    GetField(u16),
    /// 设置对象字段，参数为字段名索引
    SetField(u16),
    /// 创建新对象，参数为类型名索引
    NewObject(u16),
    /// 创建新数组，参数为长度
    NewArray(u16),
    /// 获取容器元素
    GetElement,
    /// 设置容器元素
    SetElement,
    /// 创建动态对象
    NewDynObject,
    /// 移除容器中的键
    RemoveKey,
    /// 初始化对象
    Initiate(u8),
    /// 终止对象生命周期
    Finalize,
    /// 创建新列表
    NewList(u16),
    /// 元素入队左侧
    PushElementLeft,
    /// 元素出队左侧
    PopElementLeft,
    /// 元素入队右侧
    PushElementRight,
    /// 元素出队右侧
    PopElementRight,
    /// 创建元组，参数为元素数量
    MakeTuple(u8),
    /// 判断是否存在键
    HasKey,
    /// 匹配枚举变体，参数为变体索引
    MatchVariant(u16),
    /// 获取容器大小
    SizeOf,
    /// 获取元素类型
    TypeOf,
    /// 判断是否为类型实例
    InstanceOf(u16),
    /// 检查类型转换
    CheckCast(u16),
    /// 强制类型转换
    Cast(u16),
    /// 执行副作用，参数为副作用名称索引和参数数量
    Perform(u16, u8),
    /// 注册副作用处理器，参数为处理器函数索引
    WithHandler(u16),
    /// 恢复延续执行
    ResumeWith,
    /// 捕获延续
    CaptureCont,
    /// 等待异步操作
    Await,
    /// 阻塞等待异步操作
    BlockOn,
    /// 匹配副作用处理结果
    MatchEffect(u16),
    /// 获取虚表索引
    GetWitnessTable(u16, u16),
    /// 调用虚表方法，参数为方法索引
    WitnessMethod(u16),
    /// 打开存在类型
    OpenExistential,
    /// 关闭存在类型
    CloseExistential,
    /// 引用 LIR 代码块
    Quote(u32),
    /// 拼接 LIR 表达式
    Splice,
    /// 对 LIR 表达式求值
    Eval(u8),
    /// 宏展开，参数为宏名称索引
    ExpandMacro(u16, u8),
    /// FFI 调用
    FFICall(u16, u8),
    /// 停机
    Halt,

    // --- Arithmetic and Logic Extensions ---
    
    /// I32 常量
    I32Const(i32),
    /// I32 加法
    I32Add,
    /// I32 减法
    I32Sub,
    /// I32 乘法
    I32Mul,
    /// I32 有符号除法
    I32DivS,
    /// I32 无符号除法
    I32DivU,
    /// I32 有符号取模
    I32RemS,
    /// I32 无符号取模
    I32RemU,
    /// I32 按位与
    I32And,
    /// I32 按位或
    I32Or,
    /// I32 按位异或
    I32Xor,
    /// I32 左移
    I32Shl,
    /// I32 有符号右移
    I32ShrS,
    /// I32 无符号右移
    I32ShrU,
    /// I32 按位取反
    I32Not,
    /// I32 取负
    I32Neg,
    /// I32 等于
    I32Eq,
    /// I32 不等于
    I32Ne,
    /// I32 有符号小于
    I32LtS,
    /// I32 无符号小于
    I32LtU,
    /// I32 有符号小于等于
    I32LeS,
    /// I32 无符号小于等于
    I32LeU,
    /// I32 有符号大于
    I32GtS,
    /// I32 无符号大于
    I32GtU,
    /// I32 有符号大于等于
    I32GeS,
    /// I32 无符号大于等于
    I32GeU,
    /// I32 转 F32 (有符号)
    I32ToF32S,
    /// I32 转 F32 (无符号)
    I32ToF32U,
    /// I32 转 F64 (有符号)
    I32ToF64S,
    /// I32 转 F64 (无符号)
    I32ToF64U,
    /// I32 加法 (饱和有符号)
    I32AddSatS,
    /// I32 加法 (饱和无符号)
    I32AddSatU,
    /// I32 减法 (饱和有符号)
    I32SubSatS,
    /// I32 减法 (饱和无符号)
    I32SubSatU,
    /// I32 符号扩展为 I64
    I32Extend64S,
    /// I32 零扩展为 I64
    I32Extend64U,
    /// I32 截断 I64 (低位)
    I32Trunc64SLow,
    /// I32 截断 I64 (有符号)
    I32Trunc64S,
    /// I32 截断 I64 (无符号)
    I32Trunc64U,

    /// I64 常量
    I64Const(i64),
    /// I64 加法
    I64Add,
    /// I64 减法
    I64Sub,
    /// I64 乘法
    I64Mul,
    /// I64 有符号除法
    I64DivS,
    /// I64 无符号除法
    I64DivU,
    /// I64 有符号取模
    I64RemS,
    /// I64 无符号取模
    I64RemU,
    /// I64 按位与
    I64And,
    /// I64 按位或
    I64Or,
    /// I64 按位异或
    I64Xor,
    /// I64 左移
    I64Shl,
    /// I64 有符号右移
    I64ShrS,
    /// I64 无符号右移
    I64ShrU,
    /// I64 按位取反
    I64Not,
    /// I64 取负
    I64Neg,
    /// I64 等于
    I64Eq,
    /// I64 不等于
    I64Ne,
    /// I64 有符号小于
    I64LtS,
    /// I64 无符号小于
    I64LtU,
    /// I64 有符号小于等于
    I64LeS,
    /// I64 无符号小于等于
    I64LeU,
    /// I64 有符号大于
    I64GtS,
    /// I64 无符号大于
    I64GtU,
    /// I64 有符号大于等于
    I64GeS,
    /// I64 无符号大于等于
    I64GeU,
    /// I64 转 F32 (有符号)
    I64ToF32S,
    /// I64 转 F32 (无符号)
    I64ToF32U,
    /// I64 转 F64 (有符号)
    I64ToF64S,
    /// I64 转 F64 (无符号)
    I64ToF64U,
    /// I64 加法 (饱和有符号)
    I64AddSatS,
    /// I64 加法 (饱和无符号)
    I64AddSatU,

    /// F32 常量
    F32Const(f32),
    /// F32 加法
    F32Add,
    /// F32 减法
    F32Sub,
    /// F32 乘法
    F32Mul,
    /// F32 除法
    F32Div,
    /// F32 取负
    F32Neg,
    /// F32 等于
    F32Eq,
    /// F32 不等于
    F32Ne,
    /// F32 小于
    F32Lt,
    /// F32 小于等于
    F32Le,
    /// F32 大于
    F32Gt,
    /// F32 大于等于
    F32Ge,
    /// F32 转 I32 (有符号)
    F32ToI32S,
    /// F32 转 I32 (无符号)
    F32ToI32U,
    /// F32 转 I64 (有符号)
    F32ToI64S,
    /// F32 转 I64 (无符号)
    F32ToI64U,
    /// F32 转 F64
    F32ToF64,

    /// F64 常量
    F64Const(f64),
    /// F64 加法
    F64Add,
    /// F64 减法
    F64Sub,
    /// F64 乘法
    F64Mul,
    /// F64 除法
    F64Div,
    /// F64 取负
    F64Neg,
    /// F64 等于
    F64Eq,
    /// F64 不等于
    F64Ne,
    /// F64 小于
    F64Lt,
    /// F64 小于等于
    F64Le,
    /// F64 大于
    F64Gt,
    /// F64 大于等于
    F64Ge,
    /// F64 转 I32 (有符号)
    F64ToI32S,
    /// F64 转 I32 (无符号)
    F64ToI32U,
    /// F64 转 I64 (有符号)
    F64ToI64S,
    /// F64 转 I64 (无符号)
    F64ToI64U,
    /// F64 转 F32
    F64ToF32,

    /// 大整数常量
    BigIntConst {
        /// 符号 (0: 正, 1: 负)
        sign: u8,
        /// 原始字节数据
        bytes: Vec<u8>,
    },
    /// 大整数加法
    BigIntAdd,
    /// 大整数减法
    BigIntSub,
    /// 大整数乘法
    BigIntMul,
    /// 大整数除法
    BigIntDiv,
    /// 大整数取模
    BigIntMod,
    /// 大整数取负
    BigIntNeg,
    /// 大整数等于
    BigIntEq,
    /// 大整数不等于
    BigIntNe,
    /// 大整数小于
    BigIntLt,
    /// 大整数小于等于
    BigIntLe,
    /// 大整数大于
    BigIntGt,
    /// 大整数大于等于
    BigIntGe,
    /// 大整数转 I64
    BigIntToI64,
    /// I64 转 大整数
    BigIntFromI64,
    /// 大整数转字符串
    BigIntToString,

    /// 字符串常量
    StringConst(String),
    /// 字符串拼接
    StringConcat,
    /// 字符串长度 (字节)
    StringLenBytes,
    /// 字符串长度 (字符)
    StringLenChars,
    /// 字符串等于
    StringEq,
    /// 字符串不等于
    StringNe,
    /// 字符串小于
    StringLt,
    /// 字符串小于等于
    StringLe,
    /// 字符串大于
    StringGt,
    /// 字符串大于等于
    StringGe,
    /// 字符串截取
    StringSubstr,

    /// 新建通道
    NewChannel(u16),
    /// 发送通道消息
    SendChannel,
    /// 接收通道消息
    RecvChannel,
    /// 选择通道
    SelectChannel(u8),
    /// 新建查询
    NewQuery(u16),
    /// 执行查询
    QueryExec,
    /// 新建时钟
    NewClock,
    /// 时钟等待
    ClockWait,
}