nova/RustIJVM
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'stack-type-safety'

Browse Source 
* stack-type-safety:
  Fix tests
  Initial stack typing
This commit is contained in:
Jur van den Berg
2019-05-29 15:41:13 +02:00
parent 9740c0fc57 23cc193333
commit a79d5b8aac
9 changed files with 135 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/frame.rs
View File

@@ -1,11 +1,12 @@
use stack::Stack;
use Result;
use value::Value;
#[derive(Debug)]
pub struct Frame {
pub base: usize,
pub stack: Stack,
pub locals: Vec<i32>,
pub locals: Vec<Value>,
pub can_extend_locals: bool,
}
@@ -17,7 +18,7 @@ impl Frame {
Frame {
base,
stack: Stack::new(),
locals: vec![0; num_locals],
locals: vec![Value::Int(0); num_locals],
can_extend_locals: false,
}
}
@@ -42,21 +43,21 @@ impl Frame {
self.locals.is_empty()
}
pub fn get(&mut self, offset: usize) -> Result<i32> {
pub fn get(&mut self, offset: usize) -> Result<&Value> {
if offset >= self.locals.len() {
if self.can_extend_locals {
self.locals.resize(offset + 1, 0);
self.locals.resize(offset + 1, Value::Int(0));
} else {
return Err("Local variable out of range");
}
}
Ok(self.locals[offset])
Ok(&self.locals[offset])
}
pub fn set(&mut self, offset: usize, val: i32) -> Result<()> {
pub fn set(&mut self, offset: usize, val: Value) -> Result<()> {
if offset >= self.locals.len() {
if self.can_extend_locals {
self.locals.resize(offset + 1, 0);
self.locals.resize(offset + 1, Value::Int(0));
} else {
return Err("Local variable out of range");
}

1
src/lib.rs
View File

@@ -6,6 +6,7 @@ extern crate lazy_static;
pub mod ijvmreader;
pub mod binread;
pub mod block;
pub mod value;
pub mod ops;
pub mod stack;
pub mod pool;

3
src/machine.rs
View File

@@ -14,6 +14,7 @@ use Result;
use heap::Heap;
#[cfg(feature = "bonus:network")]
use netstack::NetStack;
use std::convert::TryInto;
pub const MAGIC_HEADER: u32 = 0x1DEA_DFAD;
@@ -118,7 +119,7 @@ impl Machine {
}
pub fn get_tos(&mut self) -> Result<i32> {
self.cur_stack().top()
self.cur_stack().top()?.try_into()
}
pub fn cur_frame(&mut self) -> &mut Frame {

100
src/ops.rs
View File

@@ -4,6 +4,8 @@ use machine::Machine;
use std::io::Read;
use std::num::Wrapping;
use Result;
use value::Value;
use std::convert::TryInto;
pub type OpFunc = fn(&mut Machine) -> Result<()>;
@@ -91,23 +93,24 @@ fn bipush(machine: &mut Machine) -> Result<()> {
Ok(a) => i32::from(a),
Err(_) => return Err("Expected argument"),
};
machine.cur_stack().push(val);
machine.cur_stack().push(Value::Int(val));
Ok(())
}
fn dup(machine: &mut Machine) -> Result<()> {
let val = machine.cur_stack().top()?;
let val = machine.cur_stack().top()?.clone();
machine.cur_stack().push(val);
Ok(())
}
fn out(machine: &mut Machine) -> Result<()> {
let val = machine.cur_stack().pop()?;
let val: i32 = machine.cur_stack().pop()?.try_into()?;
let buffer = [val as u8];
let mut out = machine.stream_out.lock().unwrap();
out.write_all(&buffer).unwrap();
out.flush().unwrap();
Ok(())
return Ok(());
}
fn pop(machine: &mut Machine) -> Result<()> {
@@ -116,16 +119,17 @@ fn pop(machine: &mut Machine) -> Result<()> {
}
fn iadd(machine: &mut Machine) -> Result<()> {
let a = Wrapping(machine.cur_stack().pop()?);
let b = Wrapping(machine.cur_stack().pop()?);
machine.cur_stack().push((a + b).0);
let a: i32 = machine.cur_stack().pop()?.try_into()?;
let b: i32 = machine.cur_stack().pop()?.try_into()?;
let res = Wrapping(a) + Wrapping(b);
machine.cur_stack().push(Value::Int(res.0));
Ok(())
}
fn isub(machine: &mut Machine) -> Result<()> {
let a = Wrapping(machine.cur_stack().pop()?);
let b = Wrapping(machine.cur_stack().pop()?);
machine.cur_stack().push((b - a).0);
let a: Wrapping<i32> = Wrapping(machine.cur_stack().pop()?.try_into()?);
let b: Wrapping<i32> = Wrapping(machine.cur_stack().pop()?.try_into()?);
machine.cur_stack().push(Value::Int((b - a).0));
Ok(())
}
@@ -135,7 +139,7 @@ fn _in(machine: &mut Machine) -> Result<()> {
Err(_) => 0i32,
Ok(_) => i32::from(buffer[0]),
};
machine.cur_stack().push(val);
machine.cur_stack().push(Value::Int(val));
Ok(())
}
@@ -157,7 +161,8 @@ fn halt(machine: &mut Machine) -> Result<()> {
fn ifeq(machine: &mut Machine) -> Result<()> {
let offset = i32::from(machine.block.read_i16()?) - JUMP_OFFSET;
if machine.cur_stack().pop()? == 0 {
let compare: i32 = machine.cur_stack().pop()?.try_into()?;
if compare == 0 {
return machine.block.jump(offset);
}
Ok(())
@@ -165,7 +170,8 @@ fn ifeq(machine: &mut Machine) -> Result<()> {
fn iflt(machine: &mut Machine) -> Result<()> {
let offset = i32::from(machine.block.read_i16()?) - JUMP_OFFSET;
if machine.cur_stack().pop()? < 0 {
let compare: i32 = machine.cur_stack().pop()?.try_into()?;
if compare < 0 {
return machine.block.jump(offset);
}
Ok(())
@@ -180,23 +186,23 @@ fn if_icmpeq(machine: &mut Machine) -> Result<()> {
}
fn iand(machine: &mut Machine) -> Result<()> {
let a = machine.cur_stack().pop()?;
let b = machine.cur_stack().pop()?;
machine.cur_stack().push(a & b);
let a: i32 = machine.cur_stack().pop()?.try_into()?;
let b: i32 = machine.cur_stack().pop()?.try_into()?;
machine.cur_stack().push(Value::Int(a & b));
Ok(())
}
fn ior(machine: &mut Machine) -> Result<()> {
let a = machine.cur_stack().pop()?;
let b = machine.cur_stack().pop()?;
machine.cur_stack().push(a | b);
let a: i32 = machine.cur_stack().pop()?.try_into()?;
let b: i32 = machine.cur_stack().pop()?.try_into()?;
machine.cur_stack().push(Value::Int(a | b));
Ok(())
}
fn ldc_w(machine: &mut Machine) -> Result<()> {
let offset = machine.block.read_i16()? as usize;
let val = machine.pool.get(offset)?;
machine.cur_stack().push(val);
machine.cur_stack().push(Value::Int(val));
Ok(())
}
@@ -215,7 +221,7 @@ fn wide(machine: &mut Machine) -> Result<()> {
fn iload(machine: &mut Machine) -> Result<()> {
let a = machine.read_index()?;
let val = machine.cur_frame().get(a)?;
let val = machine.cur_frame().get(a)?.clone();
machine.cur_stack().push(val);
Ok(())
}
@@ -229,8 +235,8 @@ fn istore(machine: &mut Machine) -> Result<()> {
fn iinc(machine: &mut Machine) -> Result<()> {
let a = machine.read_index()?;
let b = i32::from(machine.block.read_i8()?);
let val = machine.cur_frame().get(a)?;
machine.cur_frame().set(a, val + b)
let val: i32 = machine.cur_frame().get(a)?.try_into()?;
machine.cur_frame().set(a, Value::Int(val + b))
}
fn invokevirtual(machine: &mut Machine) -> Result<()> {
@@ -253,7 +259,7 @@ fn invokevirtual(machine: &mut Machine) -> Result<()> {
cur_stack.pop()?; // Nuke the OBJREF
}
newframe.set(0, return_addr as i32)?;
newframe.set(0, Value::Int(return_addr as i32))?;
machine.frame.push(newframe);
Ok(())
@@ -265,7 +271,7 @@ fn ireturn(machine: &mut Machine) -> Result<()> {
None => return Err("Got no frame... somehow..."),
};
let result = prev_frame.stack.pop()?;
let return_addr = prev_frame.get(0)?;
let return_addr: i32 = prev_frame.get(0)?.try_into()?;
machine.cur_stack().push(result);
machine.block.seek(return_addr as usize)
}
@@ -285,28 +291,28 @@ fn slp(machine: &mut Machine) -> Result<()> {
#[cfg(feature = "bonus:network")]
fn netbind(machine: &mut Machine) -> Result<()> {
let port = machine.cur_stack().pop()? as u16;
machine.net.bind(port)
let port: i32 = machine.cur_stack().pop()?.try_into()?;
machine.net.bind(port as u16)
}
#[cfg(feature = "bonus:network")]
fn netconnect(machine: &mut Machine) -> Result<()> {
let port = machine.cur_stack().pop()? as u16;
let host = machine.cur_stack().pop()? as u32;
machine.net.connect(host, port)
let port: i32 = machine.cur_stack().pop()?.try_into()?;
let host: i32 = machine.cur_stack().pop()?.try_into()?;
machine.net.connect(host as u32, port as u16)
}
#[cfg(feature = "bonus:network")]
fn netin(machine: &mut Machine) -> Result<()> {
let byte = i32::from(machine.net.read_byte()?);
machine.cur_stack().push(byte);
machine.cur_stack().push(Value::Int(byte));
Ok(())
}
#[cfg(feature = "bonus:network")]
fn netout(machine: &mut Machine) -> Result<()> {
let val = machine.cur_stack().pop()? as u8;
machine.net.write_byte(val)
let val: i32 = machine.cur_stack().pop()?.try_into()?;
machine.net.write_byte(val as u8)
}
#[cfg(feature = "bonus:network")]
@@ -316,35 +322,41 @@ fn netclose(machine: &mut Machine) -> Result<()> {
#[cfg(feature = "bonus:heap")]
fn newarray(machine: &mut Machine) -> Result<()> {
let size = machine.cur_stack().pop()? as usize;
let heapref = machine.heap.alloc(size);
machine.cur_stack().push(heapref as i32);
let size: i32 = machine.cur_stack().pop()?.try_into()?;
let heapref = machine.heap.alloc(size as usize);
machine.cur_stack().push(Value::HeapRef(heapref));
Ok(())
}
#[cfg(feature = "bonus:heap")]
fn iastore(machine: &mut Machine) -> Result<()> {
let heapref = machine.cur_stack().pop()? as usize;
let index = machine.cur_stack().pop()? as usize;
let value = machine.cur_stack().pop()?;
let heapref = match machine.cur_stack().pop()? {
Value::HeapRef(a) => a,
_ => return Err("Cannot use int as heapref"),
};
let index: i32 = machine.cur_stack().pop()?.try_into()?;
let value: i32 = machine.cur_stack().pop()?.try_into()?;
let heap = machine.heap.get(heapref);
heap[index] = value;
heap[index as usize] = value;
Ok(())
}
#[cfg(feature = "bonus:heap")]
fn iaload(machine: &mut Machine) -> Result<()> {
let heapref = machine.cur_stack().pop()? as usize;
let index = machine.cur_stack().pop()? as usize;
let heapref = match machine.cur_stack().pop()? {
Value::HeapRef(a) => a,
_ => return Err("Cannot use int as heapref"),
};
let index: i32 = machine.cur_stack().pop()?.try_into()?;
let value: i32;
{
let heap = machine.heap.get(heapref);
value = heap[index];
value = heap[index as usize];
}
machine.cur_stack().push(value);
machine.cur_stack().push(Value::Int(value));
Ok(())
}

20
src/stack.rs
View File

@@ -1,8 +1,10 @@
use Result;
use value::Value;
#[derive(Debug, Default)]
pub struct Stack {
pub data: Vec<i32>
pub data: Vec<Value>
}
impl Stack {
@@ -20,25 +22,25 @@ impl Stack {
self.len() == 0
}
pub fn get(&self, i: usize) -> i32 {
self.data[i]
pub fn get(&self, i: usize) -> &Value {
&self.data[i]
}
pub fn top(&self) -> Result<i32> {
Ok(match self.data.last() {
Some(a) => *a,
pub fn top(&self) -> Result<&Value> {
Ok(match self.data.last() {
Some(a) => a,
None => return Err("Stack empty"),
})
}
pub fn pop(&mut self) -> Result<i32> {
pub fn pop(&mut self) -> Result<Value> {
Ok(match self.data.pop() {
Some(a) => a,
None => return Err("Stack empty"),
})
}
pub fn push(&mut self, val: i32) {
pub fn push(&mut self, val: Value) {
self.data.push(val);
}
}
}

30
src/value.rs Normal file
View File

@@ -0,0 +1,30 @@
use Result;
use std::convert::TryInto;
#[derive(Debug, Copy, Clone, PartialEq)]
pub enum Value {
Int(i32),
HeapRef(usize),
}
impl TryInto<i32> for Value {
type Error = &'static str;
fn try_into(self) -> Result<i32> {
match self {
Value::Int(a) => Ok(a),
Value::HeapRef(_) => Err("Cannot use HeapRef as i32"),
}
}
}
impl TryInto<i32> for &Value {
type Error = &'static str;
fn try_into(self) -> Result<i32> {
match self {
&Value::Int(a) => Ok(a),
&Value::HeapRef(_) => Err("Cannot use HeapRef as i32"),
}
}
}

12
tests/advanced3.rs
View File

@@ -8,12 +8,13 @@ fn steps(machine: &mut rustijvm::Machine, num: usize) {
#[test]
fn advanced3_wide1() {
let mut machine = rustijvm::Machine::new_from_file("files/advanced/test-wide1.ijvm").unwrap();
use rustijvm::value::Value::Int;
let mut machine = rustijvm::Machine::new_from_file("files/advanced/test-wide1.ijvm").unwrap();
steps(&mut machine, 6);
assert_eq!(machine.cur_frame().get(1), Ok(0x1));
assert_eq!(machine.cur_frame().get(1), Ok(&Int(0x1)));
steps(&mut machine, 2);
assert_eq!(machine.cur_frame().get(257), Ok(0x2));
assert_eq!(machine.cur_frame().get(257), Ok(&Int(0x2)));
steps(&mut machine, 1);
assert_eq!(machine.get_tos(), Ok(0x1));
@@ -23,12 +24,13 @@ fn advanced3_wide1() {
#[test]
fn advanced3_wide2() {
use rustijvm::value::Value::Int;
let mut machine = rustijvm::Machine::new_from_file("files/advanced/test-wide2.ijvm").unwrap();
steps(&mut machine, 6);
assert_eq!(machine.cur_frame().get(1), Ok(0x1));
assert_eq!(machine.cur_frame().get(1), Ok(&Int(0x1)));
steps(&mut machine, 2);
assert_eq!(machine.cur_frame().get(32768), Ok(0x2));
assert_eq!(machine.cur_frame().get(32768), Ok(&Int(0x2)));
steps(&mut machine, 1);
assert_eq!(machine.get_tos(), Ok(0x1));

14
tests/advancedstack.rs
View File

@@ -1,5 +1,7 @@
extern crate rustijvm;
use std::convert::TryInto;
fn steps(machine: &mut rustijvm::Machine, num: usize) {
for _ in 0..num {
machine.step().unwrap();
@@ -44,7 +46,9 @@ fn advancedstack_contents() {
let size = stack.len();
assert!(size >= 100);
let markers = (0..size).filter(|i| { stack.get(*i) == 0x2 }).count();
let markers = (0..size).filter(|i| {
stack.get(*i).try_into().unwrap_or(0) == 0x2
}).count();
assert!(markers >= 99);
}
@@ -55,7 +59,9 @@ fn advancedstack_method() {
steps(&mut machine, 8);
{
let stack = machine.cur_stack();
let markers = (0..stack.len()).filter(|i| { stack.get(*i) == 0x2 }).count();
let markers = (0..stack.len()).filter(|i| {
stack.get(*i).try_into().unwrap_or(0) == 0x2
}).count();
assert_eq!(markers, 4);
}
@@ -63,7 +69,9 @@ fn advancedstack_method() {
steps(&mut machine, 2 * 5000);
{
let stack = machine.cur_stack();
let markers = (0..stack.len()).filter(|i| { stack.get(*i) == 0x2 }).count();
let markers = (0..stack.len()).filter(|i| {
stack.get(*i).try_into().unwrap_or(0) == 0x2
}).count();
assert!(markers > 4000);
}
}

17
tests/task4.rs
View File

@@ -100,23 +100,24 @@ fn task4_iteration_load() {
#[test]
fn task4_iinc() {
use rustijvm::value::Value::Int;
let mut machine = rustijvm::Machine::new_from_file("files/task4/IINCTest.ijvm").unwrap();
steps(&mut machine, 4);
assert_eq!(machine.cur_frame().get(0), Ok(0));
assert_eq!(machine.cur_frame().get(1), Ok(0));
assert_eq!(machine.cur_frame().get(0), Ok(&Int(0)));
assert_eq!(machine.cur_frame().get(1), Ok(&Int(0)));
steps(&mut machine, 1);
assert_eq!(machine.cur_frame().get(0), Ok(0));
assert_eq!(machine.cur_frame().get(0), Ok(&Int(0)));
steps(&mut machine, 1);
assert_eq!(machine.cur_frame().get(0), Ok(1));
assert_eq!(machine.cur_frame().get(0), Ok(&Int(1)));
steps(&mut machine, 1);
assert_eq!(machine.cur_frame().get(0), Ok(4));
assert_eq!(machine.cur_frame().get(0), Ok(&Int(4)));
steps(&mut machine, 1);
assert_eq!(machine.cur_frame().get(1), Ok(0));
assert_eq!(machine.cur_frame().get(1), Ok(&Int(0)));
steps(&mut machine, 1);
assert_eq!(machine.cur_frame().get(1), Ok(-1));
assert_eq!(machine.cur_frame().get(1), Ok(&Int(-1)));
steps(&mut machine, 1);
assert_eq!(machine.cur_frame().get(1), Ok(-4));
assert_eq!(machine.cur_frame().get(1), Ok(&Int(-4)));
}