diff --git a/src/avm1/read.rs b/src/avm1/read.rs index cec9f4dd2..9b0a5ce56 100644 --- a/src/avm1/read.rs +++ b/src/avm1/read.rs @@ -24,7 +24,7 @@ impl Reader { pub fn read_action_list(&mut self) -> Result> { let mut actions = Vec::new(); - while let Some(action) = try!(self.read_action()) { + while let Some(action) = self.read_action()? { actions.push(action); } Ok(actions) @@ -33,7 +33,7 @@ impl Reader { pub fn read_action(&mut self) -> Result> { use num_traits::FromPrimitive; - let (opcode, length) = try!(self.read_opcode_and_length()); + let (opcode, length) = self.read_opcode_and_length()?; let mut action_reader = Reader::new(self.inner.by_ref().take(length as u64), self.version); @@ -82,11 +82,11 @@ impl Reader { OpCode::GetProperty => Action::GetProperty, OpCode::GetTime => Action::GetTime, OpCode::GetUrl => Action::GetUrl { - url: try!(action_reader.read_c_string()), - target: try!(action_reader.read_c_string()), + url: action_reader.read_c_string()?, + target: action_reader.read_c_string()?, }, OpCode::GetUrl2 => { - let flags = try!(action_reader.read_u8()); + let flags = action_reader.read_u8()?; Action::GetUrl2 { is_target_sprite: flags & 0b10 != 0, is_load_vars: flags & 0b1 != 0, @@ -105,29 +105,29 @@ impl Reader { } OpCode::GetVariable => Action::GetVariable, OpCode::GotoFrame => { - let frame = try!(action_reader.read_u16()); + let frame = action_reader.read_u16()?; Action::GotoFrame(frame) } OpCode::GotoFrame2 => { - let flags = try!(action_reader.read_u8()); + let flags = action_reader.read_u8()?; Action::GotoFrame2 { set_playing: flags & 0b1 != 0, scene_offset: if flags & 0b10 != 0 { - try!(action_reader.read_u16()) + action_reader.read_u16()? } else { 0 }, } } - OpCode::GotoLabel => Action::GotoLabel(try!(action_reader.read_c_string())), + OpCode::GotoLabel => Action::GotoLabel(action_reader.read_c_string()?), OpCode::Greater => Action::Greater, - OpCode::If => Action::If { offset: try!(action_reader.read_i16()) }, + OpCode::If => Action::If { offset: action_reader.read_i16()? }, OpCode::ImplementsOp => Action::ImplementsOp, OpCode::Increment => Action::Increment, OpCode::InitArray => Action::InitArray, OpCode::InitObject => Action::InitObject, OpCode::InstanceOf => Action::InstanceOf, - OpCode::Jump => Action::Jump { offset: try!(action_reader.read_i16()) }, + OpCode::Jump => Action::Jump { offset: action_reader.read_i16()? }, OpCode::Less => Action::Less, OpCode::Less2 => Action::Less2, OpCode::MBAsciiToChar => Action::MBAsciiToChar, @@ -184,8 +184,8 @@ impl Reader { OpCode::Try => action_reader.read_try()?, OpCode::TypeOf => Action::TypeOf, OpCode::WaitForFrame => Action::WaitForFrame { - frame: try!(action_reader.read_u16()), - num_actions_to_skip: try!(action_reader.read_u8()), + frame: action_reader.read_u16()?, + num_actions_to_skip: action_reader.read_u8()?, }, OpCode::With => { let code_length = action_reader.read_u16()?; @@ -196,7 +196,7 @@ impl Reader { Action::With { actions: with_reader.read_action_list()? } } OpCode::WaitForFrame2 => Action::WaitForFrame2 { - num_actions_to_skip: try!(action_reader.read_u8()), + num_actions_to_skip: action_reader.read_u8()?, }, } } else { @@ -207,9 +207,9 @@ impl Reader { } pub fn read_opcode_and_length(&mut self) -> Result<(u8, usize)> { - let opcode = try!(self.read_u8()); + let opcode = self.read_u8()?; let length = if opcode >= 0x80 { - try!(self.read_u16()) as usize + self.read_u16()? as usize } else { 0 }; @@ -226,17 +226,17 @@ impl Reader { } fn read_push_value(&mut self) -> Result { - let value = match try!(self.read_u8()) { - 0 => Value::Str(try!(self.read_c_string())), - 1 => Value::Float(try!(self.read_f32())), + let value = match self.read_u8()? { + 0 => Value::Str(self.read_c_string()?), + 1 => Value::Float(self.read_f32()?), 2 => Value::Null, 3 => Value::Undefined, - 4 => Value::Register(try!(self.read_u8())), - 5 => Value::Bool(try!(self.read_u8()) != 0), - 6 => Value::Double(try!(self.read_f64())), - 7 => Value::Int(try!(self.read_u32())), - 8 => Value::ConstantPool(try!(self.read_u8()) as u16), - 9 => Value::ConstantPool(try!(self.read_u16())), + 4 => Value::Register(self.read_u8()?), + 5 => Value::Bool(self.read_u8()? != 0), + 6 => Value::Double(self.read_f64()?), + 7 => Value::Int(self.read_u32()?), + 8 => Value::ConstantPool(self.read_u8()? as u16), + 9 => Value::ConstantPool(self.read_u16()?), _ => { return Err(Error::new( ErrorKind::InvalidData, @@ -332,7 +332,7 @@ impl Reader { fn_reader.read_action_list()? }; Ok(Action::Try(TryBlock { - try: try_actions, + try_actions, catch: if flags & 0b1 != 0 { Some((catch_var, catch_actions)) } else { diff --git a/src/avm1/types.rs b/src/avm1/types.rs index 3a2191a2d..97d8abf7d 100644 --- a/src/avm1/types.rs +++ b/src/avm1/types.rs @@ -157,7 +157,7 @@ pub struct FunctionParam { #[derive(Clone, Debug, PartialEq)] pub struct TryBlock { - pub try: Vec, + pub try_actions: Vec, pub catch: Option<(CatchVar, Vec)>, pub finally: Option>, } diff --git a/src/avm1/write.rs b/src/avm1/write.rs index 6fb052897..529948d6d 100644 --- a/src/avm1/write.rs +++ b/src/avm1/write.rs @@ -24,9 +24,9 @@ impl Writer { pub fn write_action_list(&mut self, actions: &[Action]) -> Result<()> { for action in actions { - try!(self.write_action(action)); + self.write_action(action)?; } - try!(self.write_u8(0)); // End + self.write_u8(0)?; // End Ok(()) } @@ -287,7 +287,7 @@ impl Writer { let mut action_buf = vec![]; { let mut fn_writer = Writer::new(&mut action_buf, self.version); - fn_writer.write_action_list(&try_block.try)?; + fn_writer.write_action_list(&try_block.try_actions)?; try_length = fn_writer.inner.len(); if let Some((_, ref catch)) = try_block.catch { fn_writer.write_action_list(catch)?; @@ -359,13 +359,13 @@ impl Writer { } pub fn write_opcode_and_length(&mut self, opcode: u8, length: usize) -> Result<()> { - try!(self.write_u8(opcode)); + self.write_u8(opcode)?; assert!( opcode >= 0x80 || length == 0, "Opcodes less than 0x80 must have length 0" ); if opcode >= 0x80 { - try!(self.write_u16(length as u16)); + self.write_u16(length as u16)?; } Ok(()) } @@ -373,42 +373,42 @@ impl Writer { fn write_push_value(&mut self, value: &Value) -> Result<()> { match *value { Value::Str(ref string) => { - try!(self.write_u8(0)); - try!(self.write_c_string(string)); + self.write_u8(0)?; + self.write_c_string(string)?; } Value::Float(v) => { - try!(self.write_u8(1)); - try!(self.write_f32(v)); + self.write_u8(1)?; + self.write_f32(v)?; } Value::Null => { - try!(self.write_u8(2)); + self.write_u8(2)?; } Value::Undefined => { - try!(self.write_u8(3)); + self.write_u8(3)?; } Value::Register(v) => { - try!(self.write_u8(4)); - try!(self.write_u8(v)); + self.write_u8(4)?; + self.write_u8(v)?; } Value::Bool(v) => { - try!(self.write_u8(5)); - try!(self.write_u8(v as u8)); + self.write_u8(5)?; + self.write_u8(v as u8)?; } Value::Double(v) => { - try!(self.write_u8(6)); - try!(self.write_f64(v)); + self.write_u8(6)?; + self.write_f64(v)?; } Value::Int(v) => { - try!(self.write_u8(7)); - try!(self.write_u32(v)); + self.write_u8(7)?; + self.write_u32(v)?; } Value::ConstantPool(v) => { if v < 256 { - try!(self.write_u8(8)); - try!(self.write_u8(v as u8)); + self.write_u8(8)?; + self.write_u8(v as u8)?; } else { - try!(self.write_u8(9)); - try!(self.write_u16(v)); + self.write_u8(9)?; + self.write_u16(v)?; } } };