zaphar/ucg
1
0
Fork 0
mirror of https://github.com/zaphar/ucg.git synced 2025-07-23 18:29:50 -04:00
Code Issues Packages Projects Releases Wiki Activity

MAINT: Cleanup warnings and unnecessary qualifiers.

Browse Source
This commit is contained in:
Jeremy Wall 2019-06-30 23:43:33 -05:00
parent 53c7dfb1ce
commit 7242a68ff9
1 changed files with 39 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
src/build/opcode/mod.rs
View File

@ -26,7 +26,7 @@ pub enum Primitive {
Empty, Empty,
} }
use Primitive::{Bool, Empty, Float, Int, Str}; use Primitive::{Bool, Float, Int, Str};
#[derive(Debug, PartialEq, Clone)] #[derive(Debug, PartialEq, Clone)]
pub enum Composite { pub enum Composite {
@ -118,8 +118,8 @@ impl VM {
while self.ops.next().is_some() { while self.ops.next().is_some() {
let idx = self.ops.ptr.unwrap(); let idx = self.ops.ptr.unwrap();
match self.ops.op().unwrap() { match self.ops.op().unwrap() {
Op::Val(p) => self.primitive_push(p.clone())?, Op::Val(p) => self.push(P(p.clone()))?,
Op::Sym(s) => self.push(Value::S(s.clone()))?, Op::Sym(s) => self.push(S(s.clone()))?,
Op::Add => self.op_add()?, Op::Add => self.op_add()?,
Op::Sub => self.op_sub()?, Op::Sub => self.op_sub()?,
Op::Mul => self.op_mul()?, Op::Mul => self.op_mul()?,
@ -131,16 +131,15 @@ impl VM {
Op::GtEq => self.op_gteq()?, Op::GtEq => self.op_gteq()?,
Op::LtEq => self.op_lteq()?, Op::LtEq => self.op_lteq()?,
// Add a Composite list value to the stack // Add a Composite list value to the stack
Op::InitList => self.composite_push(List(Vec::new()))?, Op::InitList => self.push(C(List(Vec::new())))?,
// Add a composite tuple value to the stack // Add a composite tuple value to the stack
Op::InitTuple => self.composite_push(Tuple(Vec::new()))?, Op::InitTuple => self.push(C(Tuple(Vec::new())))?,
Op::Field => self.op_field()?, Op::Field => self.op_field()?,
Op::Element => self.op_element()?, Op::Element => self.op_element()?,
Op::Cp => self.op_copy()?, Op::Cp => self.op_copy()?,
Op::Bang => return Err(Error {}), Op::Bang => return Err(Error {}),
Op::InitThunk(jp) => self.op_thunk(idx, *jp)?, Op::InitThunk(jp) => self.op_thunk(idx, *jp)?,
Op::Noop => { Op::Noop => {
self.stack.last();
// Do nothing // Do nothing
} }
Op::Return => { Op::Return => {
@ -155,6 +154,7 @@ impl VM {
} }
Ok(()) Ok(())
} }
fn op_jump(&mut self, jp: usize) -> Result<(), Error> { fn op_jump(&mut self, jp: usize) -> Result<(), Error> {
self.ops.jump(self.ops.ptr.map(|v| v + jp).unwrap_or(jp))?; self.ops.jump(self.ops.ptr.map(|v| v + jp).unwrap_or(jp))?;
Ok(()) Ok(())
@ -170,14 +170,14 @@ impl VM {
} }
fn op_thunk(&mut self, idx: usize, jp: usize) -> Result<(), Error> { fn op_thunk(&mut self, idx: usize, jp: usize) -> Result<(), Error> {
self.push(Value::T(idx))?; self.push(T(idx))?;
self.op_jump(jp) self.op_jump(jp)
} }
fn op_equal(&mut self) -> Result<(), Error> { fn op_equal(&mut self) -> Result<(), Error> {
let left = self.pop()?; let left = self.pop()?;
let right = self.pop()?; let right = self.pop()?;
self.push(Value::P(Bool(left == right)))?; self.push(P(Bool(left == right)))?;
Ok(()) Ok(())
} }
@ -186,10 +186,10 @@ impl VM {
let right = self.pop()?; let right = self.pop()?;
match (left, right) { match (left, right) {
(P(Int(i)), P(Int(ii))) => { (P(Int(i)), P(Int(ii))) => {
self.push(Value::P(Bool(i > ii)))?; self.push(P(Bool(i > ii)))?;
} }
(P(Float(f)), P(Float(ff))) => { (P(Float(f)), P(Float(ff))) => {
self.push(Value::P(Bool(f > ff)))?; self.push(P(Bool(f > ff)))?;
} }
_ => return Err(Error {}), _ => return Err(Error {}),
} }
@ -201,10 +201,10 @@ impl VM {
let right = self.pop()?; let right = self.pop()?;
match (left, right) { match (left, right) {
(P(Int(i)), P(Int(ii))) => { (P(Int(i)), P(Int(ii))) => {
self.push(Value::P(Bool(i < ii)))?; self.push(P(Bool(i < ii)))?;
} }
(P(Float(f)), P(Float(ff))) => { (P(Float(f)), P(Float(ff))) => {
self.push(Value::P(Bool(f < ff)))?; self.push(P(Bool(f < ff)))?;
} }
_ => return Err(Error {}), _ => return Err(Error {}),
} }
@ -216,10 +216,10 @@ impl VM {
let right = self.pop()?; let right = self.pop()?;
match (left, right) { match (left, right) {
(P(Int(i)), P(Int(ii))) => { (P(Int(i)), P(Int(ii))) => {
self.push(Value::P(Bool(i <= ii)))?; self.push(P(Bool(i <= ii)))?;
} }
(P(Float(f)), P(Float(ff))) => { (P(Float(f)), P(Float(ff))) => {
self.push(Value::P(Bool(f <= ff)))?; self.push(P(Bool(f <= ff)))?;
} }
_ => return Err(Error {}), _ => return Err(Error {}),
} }
@ -231,10 +231,10 @@ impl VM {
let right = self.pop()?; let right = self.pop()?;
match (left, right) { match (left, right) {
(P(Int(i)), P(Int(ii))) => { (P(Int(i)), P(Int(ii))) => {
self.push(Value::P(Bool(i >= ii)))?; self.push(P(Bool(i >= ii)))?;
} }
(P(Float(f)), P(Float(ff))) => { (P(Float(f)), P(Float(ff))) => {
self.push(Value::P(Bool(f >= ff)))?; self.push(P(Bool(f >= ff)))?;
} }
_ => return Err(Error {}), _ => return Err(Error {}),
} }
@ -246,7 +246,7 @@ impl VM {
let left = self.pop()?; let left = self.pop()?;
let right = self.pop()?; let right = self.pop()?;
// Then pushes the result onto the stack. // Then pushes the result onto the stack.
self.primitive_push(self.add(left, right)?)?; self.push(P(self.add(left, right)?))?;
Ok(()) Ok(())
} }
@ -255,7 +255,7 @@ impl VM {
let left = self.pop()?; let left = self.pop()?;
let right = self.pop()?; let right = self.pop()?;
// Then pushes the result onto the stack. // Then pushes the result onto the stack.
self.primitive_push(self.sub(left, right)?)?; self.push(P(self.sub(left, right)?))?;
Ok(()) Ok(())
} }
@ -264,7 +264,7 @@ impl VM {
let left = self.pop()?; let left = self.pop()?;
let right = self.pop()?; let right = self.pop()?;
// Then pushes the result onto the stack. // Then pushes the result onto the stack.
self.primitive_push(self.mul(left, right)?)?; self.push(P(self.mul(left, right)?))?;
Ok(()) Ok(())
} }
@ -273,19 +273,16 @@ impl VM {
let left = self.pop()?; let left = self.pop()?;
let right = self.pop()?; let right = self.pop()?;
// Then pushes the result onto the stack. // Then pushes the result onto the stack.
self.primitive_push(self.div(left, right)?)?; self.push(P(self.div(left, right)?))?;
Ok(()) Ok(())
} }
fn op_bind(&mut self) -> Result<(), Error> { fn op_bind(&mut self) -> Result<(), Error> {
// TODO(jwall): Okay this should actually
// point to a location in the library op code
// instead of storing in the heap.
// pop val off stack. // pop val off stack.
let val = self.pop()?; let val = self.pop()?;
// pop name off stack. // pop name off stack.
let name = self.pop()?; let name = self.pop()?;
if let Value::S(name) = name { if let S(name) = name {
self.binding_push(name, val)?; self.binding_push(name, val)?;
} else { } else {
return Err(Error {}); return Err(Error {});
@ -298,18 +295,18 @@ impl VM {
// get value from stack // get value from stack
let val = self.pop()?; let val = self.pop()?;
// get name from stack. // get name from stack.
let name = if let Value::S(s) | Value::P(Primitive::Str(s)) = self.pop()? { let name = if let S(s) | P(Str(s)) = self.pop()? {
s s
} else { } else {
return Err(Error {}); return Err(Error {});
}; };
// get composite tuple from stack // get composite tuple from stack
let tpl = self.pop()?; let tpl = self.pop()?;
if let Value::C(Tuple(mut flds)) = tpl { if let C(Tuple(mut flds)) = tpl {
// add name and value to tuple // add name and value to tuple
self.merge_field_into_tuple(&mut flds, name, val)?; self.merge_field_into_tuple(&mut flds, name, val)?;
// place composite tuple back on stack // place composite tuple back on stack
self.composite_push(Tuple(flds))?; self.push(C(Tuple(flds)))?;
} else { } else {
return Err(Error {}); return Err(Error {});
}; };
@ -321,11 +318,11 @@ impl VM {
let val = self.pop()?; let val = self.pop()?;
// get next value. It should be a Composite list. // get next value. It should be a Composite list.
let tpl = self.pop()?; let tpl = self.pop()?;
if let Value::C(List(mut elems)) = tpl { if let C(List(mut elems)) = tpl {
// add value to list // add value to list
elems.push(val); elems.push(val);
// Add that value to the list and put list back on stack. // Add that value to the list and put list back on stack.
self.composite_push(List(elems))?; self.push(C(List(elems)))?;
} else { } else {
return Err(Error {}); return Err(Error {});
}; };
@ -335,13 +332,13 @@ impl VM {
fn op_copy(&mut self) -> Result<(), Error> { fn op_copy(&mut self) -> Result<(), Error> {
// TODO Use Cow pointers for this? // TODO Use Cow pointers for this?
// get next value. It should be a Composite Tuple. // get next value. It should be a Composite Tuple.
if let Value::C(Tuple(flds)) = self.pop()? { if let C(Tuple(flds)) = self.pop()? {
// Make a copy of the original // Make a copy of the original
let original = Tuple(flds.clone()); let original = Tuple(flds.clone());
let copy = Tuple(flds); let copy = Tuple(flds);
// Put the original on the Stack as well as the copy // Put the original on the Stack as well as the copy
self.composite_push(original)?; self.push(C(original))?;
self.composite_push(copy)?; self.push(C(copy))?;
} else { } else {
return Err(Error {}); return Err(Error {});
}; };
@ -369,16 +366,6 @@ impl VM {
Ok(()) Ok(())
} }
fn primitive_push(&mut self, p: Primitive) -> Result<(), Error> {
self.stack.push(Value::P(p));
Ok(())
}
fn composite_push(&mut self, c: Composite) -> Result<(), Error> {
self.stack.push(Value::C(c));
Ok(())
}
fn binding_push(&mut self, name: String, val: Value) -> Result<(), Error> { fn binding_push(&mut self, name: String, val: Value) -> Result<(), Error> {
// FIXME(jwall): Error if the symbol already exists. // FIXME(jwall): Error if the symbol already exists.
self.symbols.insert(name, val); self.symbols.insert(name, val);
@ -401,45 +388,37 @@ impl VM {
fn mul(&self, left: Value, right: Value) -> Result<Primitive, Error> { fn mul(&self, left: Value, right: Value) -> Result<Primitive, Error> {
Ok(match (left, right) { Ok(match (left, right) {
(Value::P(Primitive::Int(i)), Value::P(Primitive::Int(ii))) => Primitive::Int(i * ii), (P(Int(i)), P(Int(ii))) => Int(i * ii),
(Value::P(Primitive::Float(f)), Value::P(Primitive::Float(ff))) => { (P(Float(f)), P(Float(ff))) => Float(f * ff),
Primitive::Float(f * ff)
}
_ => return Err(Error {}), _ => return Err(Error {}),
}) })
} }
fn div(&self, left: Value, right: Value) -> Result<Primitive, Error> { fn div(&self, left: Value, right: Value) -> Result<Primitive, Error> {
Ok(match (left, right) { Ok(match (left, right) {
(Value::P(Primitive::Int(i)), Value::P(Primitive::Int(ii))) => Primitive::Int(i / ii), (P(Int(i)), P(Int(ii))) => Int(i / ii),
(Value::P(Primitive::Float(f)), Value::P(Primitive::Float(ff))) => { (P(Float(f)), P(Float(ff))) => Float(f / ff),
Primitive::Float(f / ff)
}
_ => return Err(Error {}), _ => return Err(Error {}),
}) })
} }
fn sub(&self, left: Value, right: Value) -> Result<Primitive, Error> { fn sub(&self, left: Value, right: Value) -> Result<Primitive, Error> {
Ok(match (left, right) { Ok(match (left, right) {
(Value::P(Primitive::Int(i)), Value::P(Primitive::Int(ii))) => Primitive::Int(i - ii), (P(Int(i)), Value::P(Int(ii))) => Int(i - ii),
(Value::P(Primitive::Float(f)), Value::P(Primitive::Float(ff))) => { (P(Float(f)), Value::P(Float(ff))) => Float(f - ff),
Primitive::Float(f - ff)
}
_ => return Err(Error {}), _ => return Err(Error {}),
}) })
} }
fn add(&self, left: Value, right: Value) -> Result<Primitive, Error> { fn add(&self, left: Value, right: Value) -> Result<Primitive, Error> {
Ok(match (left, right) { Ok(match (left, right) {
(Value::P(Primitive::Int(i)), Value::P(Primitive::Int(ii))) => Primitive::Int(i + ii), (P(Int(i)), Value::P(Int(ii))) => Int(i + ii),
(Value::P(Primitive::Float(f)), Value::P(Primitive::Float(ff))) => { (P(Float(f)), Value::P(Float(ff))) => Float(f + ff),
Primitive::Float(f + ff) (P(Str(s)), Value::P(Str(ss))) => {
}
(Value::P(Primitive::Str(s)), Value::P(Primitive::Str(ss))) => {
let mut ns = String::new(); let mut ns = String::new();
ns.push_str(&s); ns.push_str(&s);
ns.push_str(&ss); ns.push_str(&ss);
Primitive::Str(ns) Str(ns)
} }
_ => return Err(Error {}), _ => return Err(Error {}),
}) })