bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Simplify handling of Result in eval_assignment.

Browse source
This commit is contained in:
Scott Olson 2016-03-20 23:09:27 -06:00
parent f7d0e0423b
commit 49e8d3ef5e
1 changed files with 22 additions and 27 deletions
Download patch file Download diff file Expand all files Collapse all files

37
src/interpreter.rs
View file

@ -495,7 +495,7 @@ impl<'a, 'tcx: 'a, 'arena> Interpreter<'a, 'tcx, 'arena> {
match *rvalue {
Use(ref operand) => {
let src = try!(self.eval_operand(operand));
self.memory.copy(src, dest, dest_repr.size())
try!(self.memory.copy(src, dest, dest_repr.size()));
}
BinaryOp(bin_op, ref left, ref right) => {
@ -508,26 +508,26 @@ impl<'a, 'tcx: 'a, 'arena> Interpreter<'a, 'tcx, 'arena> {
let right_val = try!(self.read_primval(right_ptr, right_ty));
let val = try!(primval::binary_op(bin_op, left_val, right_val));
self.memory.write_primval(dest, val)
try!(self.memory.write_primval(dest, val));
}
UnaryOp(un_op, ref operand) => {
let ptr = try!(self.eval_operand(operand));
let ty = self.operand_ty(operand);
let val = try!(self.read_primval(ptr, ty));
self.memory.write_primval(dest, primval::unary_op(un_op, val))
try!(self.memory.write_primval(dest, primval::unary_op(un_op, val)));
}
Aggregate(ref kind, ref operands) => {
use rustc::mir::repr::AggregateKind::*;
match *kind {
Tuple => self.assign_to_aggregate(dest, &dest_repr, 0, operands),
Tuple | Closure(..) =>
try!(self.assign_to_aggregate(dest, &dest_repr, 0, operands)),
Adt(_, variant_idx, _) =>
self.assign_to_aggregate(dest, &dest_repr, variant_idx, operands),
try!(self.assign_to_aggregate(dest, &dest_repr, variant_idx, operands)),
Vec => match *dest_repr {
Repr::Array { elem_size, length } => {
Vec => if let Repr::Array { elem_size, length } = *dest_repr {
assert_eq!(length, operands.len());
for (i, operand) in operands.iter().enumerate() {
let src = try!(self.eval_operand(operand));
@ -535,12 +535,9 @@ impl<'a, 'tcx: 'a, 'arena> Interpreter<'a, 'tcx, 'arena> {
let elem_dest = dest.offset(offset as isize);
try!(self.memory.copy(src, elem_dest, elem_size));
}
Ok(())
}
_ => panic!("expected Repr::Array target"),
} else {
panic!("expected Repr::Array target");
},
Closure(..) => self.assign_to_aggregate(dest, &dest_repr, 0, operands),
}
}
@ -557,7 +554,7 @@ impl<'a, 'tcx: 'a, 'arena> Interpreter<'a, 'tcx, 'arena> {
_ => panic!("Rvalue::Len expected array or slice, got {:?}", ty),
};
let psize = self.memory.pointer_size;
self.memory.write_uint(dest, len, psize)
try!(self.memory.write_uint(dest, len, psize));
}
Ref(_, _, ref lvalue) => {
@ -571,13 +568,12 @@ impl<'a, 'tcx: 'a, 'arena> Interpreter<'a, 'tcx, 'arena> {
try!(self.memory.write_uint(len_ptr, len, psize));
}
}
Ok(())
}
Box(ty) => {
let size = self.ty_size(ty);
let ptr = self.memory.allocate(size);
self.memory.write_ptr(dest, ptr)
try!(self.memory.write_ptr(dest, ptr));
}
Cast(kind, ref operand, dest_ty) => {
@ -594,11 +590,8 @@ impl<'a, 'tcx: 'a, 'arena> Interpreter<'a, 'tcx, 'arena> {
match (&src_pointee_ty.sty, &dest_pointee_ty.sty) {
(&ty::TyArray(_, length), &ty::TySlice(_)) => {
let size = self.memory.pointer_size;
self.memory.write_uint(
dest.offset(size as isize),
length as u64,
size,
)
let len_ptr = dest.offset(size as isize);
try!(self.memory.write_uint(len_ptr, length as u64, size));
}
_ => panic!("can't handle cast: {:?}", rvalue),
@ -608,7 +601,7 @@ impl<'a, 'tcx: 'a, 'arena> Interpreter<'a, 'tcx, 'arena> {
Misc => {
// FIXME(tsion): Wrong for almost everything.
let size = dest_repr.size();
self.memory.copy(src, dest, size)
try!(self.memory.copy(src, dest, size));
}
_ => panic!("can't handle cast: {:?}", rvalue),
@ -617,6 +610,8 @@ impl<'a, 'tcx: 'a, 'arena> Interpreter<'a, 'tcx, 'arena> {
ref r => panic!("can't handle rvalue: {:?}", r),
}
Ok(())
}
fn operand_ty(&self, operand: &mir::Operand<'tcx>) -> ty::Ty<'tcx> {