imxyy1soope1/nixjit
1
0
Fork 0
Code Issues Pull Requests Actions Projects 1 Releases Activity

refactor: type

Browse Source
This commit is contained in:
imxyy_soope_
2025-05-03 20:33:59 +08:00
parent 3f0cb2c2fa
commit 4a310ff317
23 changed files with 475 additions and 309 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/vm/env.rs
View File

@@ -1,6 +1,7 @@
use rpds::HashTrieMapSync;
use super::value::{Symbol, Value};
use crate::ty::common::Symbol;
use crate::ty::internal::Value;
pub struct Env {
last: Option<Box<Env>>,

4
src/vm/mod.rs
View File

@@ -1,6 +1,5 @@
mod env;
mod stack;
mod value;
mod vm;
mod vmthunk;
@@ -8,5 +7,4 @@ mod vmthunk;
mod test;
pub use env::Env;
pub use value::Symbol;
pub use value::*;
pub use vm::VM;

2
src/vm/stack.rs
View File

@@ -3,7 +3,7 @@ use std::ops::Deref;
use anyhow::{Result, anyhow};
use super::value::Value;
use crate::ty::internal::Value;
pub const STACK_SIZE: usize = 8 * 1024 / size_of::<Value>();

8
src/vm/test.rs
View File

@@ -2,7 +2,8 @@ use ecow::EcoString;
use rpds::{ht_map_sync, vector_sync};
use crate::compile::compile;
use crate::value::*;
use crate::ty::public::*;
use crate::ty::common::Symbol;
use super::vm::run;
@@ -166,3 +167,8 @@ fn test_let() {
attrs! { symbol!("a") => attrs!{ symbol!("ac") => int!(2) } },
);
}
#[test]
fn test_func() {
test_expr("(x: x) 1", int!(1));
}

64
src/vm/value/attrset.rs
View File

@@ -1,64 +0,0 @@
use derive_more::Constructor;
use rpds::HashTrieMapSync;
use crate::value::{self, Value as Value_};
use super::super::vm::VM;
use super::{Symbol, ToValue, Value};
#[derive(Debug, Constructor, Clone, PartialEq)]
pub struct AttrSet {
data: HashTrieMapSync<Symbol, Value>,
}
impl AttrSet {
pub fn empty() -> AttrSet {
AttrSet { data: HashTrieMapSync::new_sync() }
}
pub fn push_attr_force(&mut self, sym: Symbol, val: Value) {
self.data.insert_mut(sym, val);
}
pub fn push_attr(&mut self, sym: Symbol, val: Value) {
if self.data.get(&sym).is_some() {
todo!()
}
self.data.insert_mut(sym, val);
}
pub fn select(&self, sym: Symbol) -> Option<Value> {
self.data.get(&sym).cloned()
}
pub fn has_attr(&self, sym: Symbol) -> bool {
self.data.get(&sym).is_some()
}
pub fn update(mut self, other: AttrSet) -> AttrSet {
for (k, v) in other.data.iter() {
self.push_attr_force(k.clone(), v.clone())
}
self
}
pub fn to_data(self) -> HashTrieMapSync<Symbol, Value> {
self.data
}
}
impl ToValue for AttrSet {
fn to_value(self, vm: &VM) -> Value_ {
Value_::AttrSet(value::AttrSet::new(
self.data
.iter()
.map(|(sym, value)| {
(
value::Symbol::new(sym.0.clone()),
value.clone().to_value(vm),
)
})
.collect(),
))
}
}

42
src/vm/value/list.rs
View File

@@ -1,42 +0,0 @@
use derive_more::Constructor;
use rpds::VectorSync;
use crate::value::{self, Value as Value_};
use super::super::vm::VM;
use super::{ToValue, Value};
#[derive(Debug, Constructor, Clone, PartialEq)]
pub struct List {
data: VectorSync<Value>,
}
impl List {
pub fn empty() -> List {
List {
data: VectorSync::new_sync()
}
}
pub fn push(&mut self, elem: Value) {
self.data.push_back_mut(elem);
}
pub fn concat(mut self, other: List) -> List {
for elem in other.data.iter() {
self.data.push_back_mut(elem.clone());
}
self
}
}
impl ToValue for List {
fn to_value(self, vm: &VM) -> Value_ {
Value_::List(value::List::new(
self.data
.iter()
.map(|value| value.clone().to_value(vm))
.collect(),
))
}
}

254
src/vm/value/mod.rs
View File

@@ -1,254 +0,0 @@
use anyhow::Result;
use derive_more::{Constructor, IsVariant, Unwrap};
use ecow::EcoString;
use crate::value::{Value as Value_, Const, Catchable};
use super::env::Env;
use super::vm::VM;
mod attrset;
mod list;
mod string;
pub use attrset::AttrSet;
pub use list::List;
pub use string::ContextfulString;
pub trait ToValue {
fn to_value(self, vm: &VM) -> Value_;
}
#[derive(Debug, PartialEq, Eq, Hash, Clone, Constructor)]
pub struct Symbol(EcoString);
impl<T: Into<EcoString>> From<T> for Symbol {
fn from(value: T) -> Self {
Symbol(value.into())
}
}
#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy, Constructor)]
pub struct Thunk(usize);
#[derive(Debug, IsVariant, Unwrap, Clone, PartialEq)]
pub enum Value {
Const(Const),
Thunk(Thunk),
AttrSet(AttrSet),
List(List),
Catchable(crate::value::Catchable),
PrimOp(crate::builtins::PrimOp),
PartialPrimOp(crate::builtins::PartialPrimOp),
}
use Value::Const as VmConst;
impl Value {
pub fn call(self, args: Vec<Value>) -> Value {
match self {
Value::PrimOp(func) => func.call(args),
Value::PartialPrimOp(func) => func.call(args),
_ => todo!(),
}
}
pub fn not(self) -> Value {
use Const::*;
match self {
VmConst(Bool(bool)) => VmConst(Bool(!bool)),
_ => todo!(),
}
}
pub fn and(self, other: Value) -> Value {
use Const::*;
match (self, other) {
(VmConst(Bool(a)), VmConst(Bool(b))) => VmConst(Bool(a && b)),
_ => todo!(),
}
}
pub fn or(self, other: Value) -> Value {
use Const::*;
match (self, other) {
(VmConst(Bool(a)), VmConst(Bool(b))) => VmConst(Bool(a || b)),
_ => todo!(),
}
}
pub fn eq(self, other: Value) -> Value {
use Const::Bool;
VmConst(Bool(self == other))
}
pub fn lt(self, other: Value) -> Value {
use Const::*;
VmConst(Bool(match (self, other) {
(VmConst(Int(a)), VmConst(Int(b))) => a < b,
(VmConst(Int(a)), VmConst(Float(b))) => (a as f64) < b,
(VmConst(Float(a)), VmConst(Int(b))) => a < b as f64,
(VmConst(Float(a)), VmConst(Float(b))) => a < b,
(VmConst(String(a)), VmConst(String(b))) => a < b,
_ => todo!(),
}))
}
pub fn neg(self) -> Value {
use Const::*;
match self {
VmConst(Int(int)) => VmConst(Int(-int)),
VmConst(Float(float)) => VmConst(Float(-float)),
_ => todo!(),
}
}
pub fn add(self, other: Value) -> Value {
use Const::*;
match (self, other) {
(VmConst(Int(a)), VmConst(Int(b))) => VmConst(Int(a + b)),
(VmConst(Int(a)), VmConst(Float(b))) => VmConst(Float(a as f64 + b)),
(VmConst(Float(a)), VmConst(Int(b))) => VmConst(Float(a + b as f64)),
(VmConst(Float(a)), VmConst(Float(b))) => VmConst(Float(a + b)),
(VmConst(String(a)), VmConst(String(b))) => {
let mut string = a.clone();
string.push_str(b.as_str());
VmConst(String(string))
}
_ => todo!(),
}
}
pub fn mul(self, other: Value) -> Value {
use Const::*;
match (self, other) {
(VmConst(Int(a)), VmConst(Int(b))) => VmConst(Int(a * b)),
(VmConst(Int(a)), VmConst(Float(b))) => VmConst(Float(a as f64 * b)),
(VmConst(Float(a)), VmConst(Int(b))) => VmConst(Float(a * b as f64)),
(VmConst(Float(a)), VmConst(Float(b))) => VmConst(Float(a * b)),
_ => todo!(),
}
}
pub fn div(self, other: Value) -> Value {
use Const::*;
match (self, other) {
(_, VmConst(Int(0))) => todo!(),
(_, VmConst(Float(0.))) => todo!(),
(VmConst(Int(a)), VmConst(Int(b))) => VmConst(Int(a / b)),
(VmConst(Int(a)), VmConst(Float(b))) => VmConst(Float(a as f64 / b)),
(VmConst(Float(a)), VmConst(Int(b))) => VmConst(Float(a / b as f64)),
(VmConst(Float(a)), VmConst(Float(b))) => VmConst(Float(a / b)),
_ => todo!(),
}
}
pub fn concat_string(&mut self, mut other: Value) -> &mut Self {
if let (VmConst(Const::String(a)), VmConst(Const::String(b))) =
(self.coerce_to_string(), other.coerce_to_string())
{
a.push_str(b.as_str());
} else {
todo!()
}
self
}
pub fn push(&mut self, elem: Value) -> &mut Self {
if let Value::List(list) = self {
list.push(elem);
} else {
todo!()
}
self
}
pub fn concat(self, other: Value) -> Value {
if let (Value::List(a), Value::List(b)) = (self, other) {
Value::List(a.concat(b))
} else {
todo!()
}
}
pub fn push_attr(&mut self, sym: Symbol, val: Value) -> &mut Self {
if let Value::AttrSet(attrs) = self {
attrs.push_attr(sym, val)
} else {
todo!()
}
self
}
pub fn update(self, other: Value) -> Value {
if let (Value::AttrSet(a), Value::AttrSet(b)) = (self, other) {
Value::AttrSet(a.update(b))
} else {
todo!()
}
}
pub fn select(&mut self, sym: Symbol) -> &mut Self {
if let Value::AttrSet(attrs) = self {
let val = attrs
.select(sym.clone())
.unwrap_or(Value::Catchable(Catchable::new(Some(format!(
"{sym:?} not found"
)))));
*self = val;
} else {
todo!()
}
self
}
pub fn select_with_default(&mut self, sym: Symbol, default: Value) -> &mut Self {
if let Value::AttrSet(attrs) = self {
let val = attrs.select(sym).unwrap_or(default);
*self = val;
} else {
todo!()
}
self
}
pub fn has_attr(&mut self, sym: Symbol) -> &mut Self {
if let Value::AttrSet(attrs) = self {
let val = VmConst(Const::Bool(attrs.has_attr(sym)));
*self = val;
} else {
*self = VmConst(Const::Bool(false));
}
self
}
pub fn coerce_to_string(&mut self) -> &mut Self {
if let VmConst(Const::String(_)) = self {
()
} else {
todo!()
}
self
}
pub fn force(&mut self, vm: &VM, env: &mut Env) -> Result<&mut Self> {
if let Value::Thunk(thunk) = self {
let value = vm.get_thunk_value(thunk.0, env)?;
*self = value
}
Ok(self)
}
}
impl ToValue for Value {
fn to_value(self, vm: &VM) -> Value_ {
match self {
Value::AttrSet(attrs) => attrs.to_value(vm),
Value::List(list) => list.to_value(vm),
Value::Catchable(catchable) => Value_::Catchable(catchable),
Value::Const(cnst) => Value_::Const(cnst),
Value::Thunk(_) => Value_::Thunk,
Value::PrimOp(_) => Value_::PrimOp,
Value::PartialPrimOp(_) => Value_::PartialPrimOp,
}
}
}

30
src/vm/value/string.rs
View File

@@ -1,30 +0,0 @@
// TODO: Contextful String
use ecow::EcoString;
use rpds::List;
pub struct StringContext {
context: List<()>,
}
impl StringContext {
pub fn new() -> StringContext {
StringContext {
context: List::new(),
}
}
}
pub struct ContextfulString {
string: EcoString,
context: StringContext,
}
impl ContextfulString {
pub fn new(string: EcoString) -> ContextfulString {
ContextfulString {
string,
context: StringContext::new(),
}
}
}

36
src/vm/vm.rs
View File

@@ -1,17 +1,18 @@
use anyhow::Result;
use crate::builtins::env;
use crate::bytecode::{self, *};
use crate::value::{Const, Value as Value_};
use crate::bytecode::{self, Program, OpCode, OpCodes, Thunks, UnOp, BinOp};
use crate::ty::internal::*;
use crate::ty::common::Symbol;
use crate::ty::public as p;
use super::env::Env;
use super::stack::{STACK_SIZE, Stack};
use super::value::{self as vmValue, *};
use super::vmthunk::*;
pub fn run(prog: Program) -> Result<Value_> {
pub fn run(prog: Program) -> Result<p::Value> {
let vm = VM::new(prog.thunks);
Ok(vm.eval(prog.top_level, &mut env())?.to_value(&vm))
Ok(vm.eval(prog.top_level, &mut env())?.to_public(&vm))
}
pub struct VM {
@@ -54,7 +55,7 @@ impl VM {
match opcode {
OpCode::NoOp => (),
OpCode::Const { value } => stack.push(Value::Const(value))?,
OpCode::LoadThunk { idx } => stack.push(Value::Thunk(vmValue::Thunk::new(idx)))?,
OpCode::LoadThunk { idx } => stack.push(Value::Thunk(Thunk::new(idx)))?,
OpCode::LoadValue { idx } => {
stack.push(self.get_thunk_value(idx, env)?)?;
}
@@ -128,17 +129,11 @@ impl VM {
OpCode::Select { sym } => {
stack.tos_mut()?.select(Symbol::new(sym)).force(self, env)?;
}
OpCode::SelectWithDefault { sym } => {
OpCode::SelectOrDefault { sym } => {
let default = stack.pop()?;
stack
.tos_mut()?
.select_with_default(Symbol::new(sym), default.clone());
}
OpCode::SelectOrEmpty { sym } => {
stack.tos_mut()?.select_with_default(
Symbol::new(sym),
Value::AttrSet(AttrSet::empty()),
);
.select_with_default(Symbol::new(sym), default);
}
OpCode::SelectDynamic => {
let mut val = stack.pop().unwrap();
@@ -146,21 +141,12 @@ impl VM {
let sym = val.unwrap_const().unwrap_string().into();
stack.tos_mut()?.select(sym);
}
OpCode::SelectDynamicWithDefault => {
let mut val = stack.pop().unwrap();
val.coerce_to_string();
let sym = val.unwrap_const().unwrap_string().into();
OpCode::SelectDynamicOrDefault => {
let default = stack.pop()?;
stack.tos_mut()?.select_with_default(sym, default.clone());
}
OpCode::SelectDynamicOrEmpty => {
let mut val = stack.pop().unwrap();
val.coerce_to_string();
let sym = val.unwrap_const().unwrap_string().into();
stack.tos_mut()?.select_with_default(
sym,
Value::AttrSet(AttrSet::empty()),
);
stack.tos_mut()?.select_with_default(sym, default);
}
OpCode::HasAttr { sym } => {
stack.tos_mut()?.has_attr(Symbol::new(sym));

2
src/vm/vmthunk.rs
View File

@@ -7,7 +7,7 @@ use derive_more::{IsVariant, Unwrap};
use crate::bytecode::OpCodes;
use super::env::Env;
use super::value::Value;
use crate::ty::internal::Value;
use super::vm::VM;
pub struct VmThunk {