2020-02-06 04:15:03 +00:00
|
|
|
//! Activation frames
|
|
|
|
|
2020-02-12 23:52:00 +00:00
|
|
|
use crate::avm2::function::{Avm2Function, Avm2MethodEntry};
|
2020-02-06 04:15:03 +00:00
|
|
|
use crate::avm2::object::Object;
|
2020-02-10 19:54:55 +00:00
|
|
|
use crate::avm2::scope::Scope;
|
|
|
|
use crate::avm2::script_object::ScriptObject;
|
2020-02-07 19:54:14 +00:00
|
|
|
use crate::avm2::value::Value;
|
2020-02-12 19:58:33 +00:00
|
|
|
use crate::avm2::{Avm2, Error};
|
2020-02-07 19:54:14 +00:00
|
|
|
use crate::context::UpdateContext;
|
|
|
|
use gc_arena::{Collect, Gc, GcCell, MutationContext};
|
|
|
|
use smallvec::SmallVec;
|
2020-02-12 23:52:00 +00:00
|
|
|
use std::rc::Rc;
|
|
|
|
use swf::avm2::types::AbcFile;
|
2020-02-07 19:54:14 +00:00
|
|
|
|
|
|
|
/// Represents a particular register set.
|
|
|
|
///
|
|
|
|
/// This type exists primarily because SmallVec isn't garbage-collectable.
|
|
|
|
#[derive(Clone)]
|
|
|
|
pub struct RegisterSet<'gc>(SmallVec<[Value<'gc>; 8]>);
|
|
|
|
|
|
|
|
unsafe impl<'gc> gc_arena::Collect for RegisterSet<'gc> {
|
|
|
|
#[inline]
|
|
|
|
fn trace(&self, cc: gc_arena::CollectionContext) {
|
|
|
|
for register in &self.0 {
|
|
|
|
register.trace(cc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'gc> RegisterSet<'gc> {
|
|
|
|
/// Create a new register set with a given number of specified registers.
|
|
|
|
///
|
|
|
|
/// The given registers will be set to `undefined`.
|
|
|
|
pub fn new(num: u32) -> Self {
|
|
|
|
Self(smallvec![Value::Undefined; num as usize])
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return a reference to a given register, if it exists.
|
|
|
|
pub fn get(&self, num: u32) -> Option<&Value<'gc>> {
|
|
|
|
self.0.get(num as usize)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return a mutable reference to a given register, if it exists.
|
|
|
|
pub fn get_mut(&mut self, num: u32) -> Option<&mut Value<'gc>> {
|
|
|
|
self.0.get_mut(num as usize)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn len(&self) -> u32 {
|
|
|
|
self.0.len() as u32
|
|
|
|
}
|
|
|
|
}
|
2020-02-06 04:15:03 +00:00
|
|
|
|
|
|
|
/// Represents a single activation of a given AVM2 function or keyframe.
|
|
|
|
#[derive(Clone, Collect)]
|
|
|
|
#[collect(no_drop)]
|
|
|
|
pub struct Activation<'gc> {
|
2020-02-12 23:52:00 +00:00
|
|
|
/// The AVM method entry we're executing code out of.
|
|
|
|
method: Avm2MethodEntry,
|
2020-02-06 04:15:03 +00:00
|
|
|
|
|
|
|
/// The current location of the instruction stream being executed.
|
|
|
|
pc: usize,
|
|
|
|
|
|
|
|
/// The immutable value of `this`.
|
|
|
|
this: Object<'gc>,
|
|
|
|
|
|
|
|
/// The arguments this function was called by.
|
|
|
|
arguments: Option<Object<'gc>>,
|
|
|
|
|
|
|
|
/// Flags that the current activation frame is being executed and has a
|
|
|
|
/// reader object copied from it. Taking out two readers on the same
|
|
|
|
/// activation frame is a programming error.
|
|
|
|
is_executing: bool,
|
2020-02-07 19:54:14 +00:00
|
|
|
|
|
|
|
/// Local registers.
|
|
|
|
///
|
|
|
|
/// All activations have local registers, but it is possible for multiple
|
|
|
|
/// activations (such as a rescope) to execute from the same register set.
|
|
|
|
local_registers: GcCell<'gc, RegisterSet<'gc>>,
|
2020-02-08 21:59:59 +00:00
|
|
|
|
|
|
|
/// What was returned from the function.
|
|
|
|
///
|
|
|
|
/// A return value of `None` indicates that the called function is still
|
|
|
|
/// executing. Functions that do not return instead return `Undefined`.
|
|
|
|
return_value: Option<Value<'gc>>,
|
2020-02-10 19:54:55 +00:00
|
|
|
|
|
|
|
/// The current local scope, implemented as a bare object.
|
|
|
|
local_scope: Object<'gc>,
|
|
|
|
|
|
|
|
/// The current scope stack.
|
|
|
|
///
|
|
|
|
/// A `scope` of `None` indicates that the scope stack is empty.
|
|
|
|
scope: Option<GcCell<'gc, Scope<'gc>>>,
|
2020-02-06 04:15:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl<'gc> Activation<'gc> {
|
|
|
|
pub fn from_action(
|
2020-02-07 19:54:14 +00:00
|
|
|
context: &mut UpdateContext<'_, 'gc, '_>,
|
2020-02-12 23:52:00 +00:00
|
|
|
action: &Avm2Function<'gc>,
|
2020-02-06 04:15:03 +00:00
|
|
|
this: Object<'gc>,
|
|
|
|
arguments: Option<Object<'gc>>,
|
2020-02-07 19:54:14 +00:00
|
|
|
) -> Result<Self, Error> {
|
2020-02-12 23:52:00 +00:00
|
|
|
let method = action.method.clone();
|
|
|
|
let scope = action.scope;
|
|
|
|
let num_locals = method.body().num_locals;
|
2020-02-07 19:54:14 +00:00
|
|
|
|
|
|
|
Ok(Self {
|
2020-02-12 23:52:00 +00:00
|
|
|
method,
|
2020-02-06 04:15:03 +00:00
|
|
|
pc: 0,
|
|
|
|
this,
|
|
|
|
arguments,
|
|
|
|
is_executing: false,
|
2020-02-12 23:52:00 +00:00
|
|
|
local_registers: GcCell::allocate(context.gc_context, RegisterSet::new(num_locals)),
|
2020-02-08 21:59:59 +00:00
|
|
|
return_value: None,
|
2020-02-10 19:54:55 +00:00
|
|
|
local_scope: ScriptObject::bare_object(context.gc_context),
|
2020-02-12 23:52:00 +00:00
|
|
|
scope: scope,
|
2020-02-07 19:54:14 +00:00
|
|
|
})
|
2020-02-06 04:15:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Attempts to lock the activation frame for execution.
|
|
|
|
///
|
|
|
|
/// If this frame is already executing, that is an error condition.
|
|
|
|
pub fn lock(&mut self) -> Result<(), Error> {
|
|
|
|
if self.is_executing {
|
|
|
|
return Err("Attempted to execute the same frame twice".into());
|
|
|
|
}
|
|
|
|
|
|
|
|
self.is_executing = true;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Unlock the activation object. This allows future execution to run on it
|
|
|
|
/// again.
|
|
|
|
pub fn unlock_execution(&mut self) {
|
|
|
|
self.is_executing = false;
|
|
|
|
}
|
|
|
|
|
2020-02-12 23:52:00 +00:00
|
|
|
/// Obtain a reference to the method being executed.
|
|
|
|
pub fn method(&self) -> &Avm2MethodEntry {
|
|
|
|
&self.method
|
2020-02-06 04:15:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Get the PC value.
|
|
|
|
pub fn pc(&self) -> usize {
|
|
|
|
self.pc
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Set the PC value.
|
|
|
|
pub fn set_pc(&mut self, new_pc: usize) {
|
|
|
|
self.pc = new_pc;
|
|
|
|
}
|
2020-02-07 19:54:14 +00:00
|
|
|
|
|
|
|
/// Retrieve a local register.
|
|
|
|
pub fn local_register(&self, id: u32) -> Option<Value<'gc>> {
|
|
|
|
self.local_registers.read().get(id).cloned()
|
|
|
|
}
|
|
|
|
|
2020-02-11 19:46:47 +00:00
|
|
|
/// Get the current scope stack.
|
2020-02-11 04:58:15 +00:00
|
|
|
pub fn scope(&self) -> Option<GcCell<'gc, Scope<'gc>>> {
|
|
|
|
self.scope
|
|
|
|
}
|
|
|
|
|
2020-02-11 19:46:47 +00:00
|
|
|
/// Set a new scope stack.
|
|
|
|
pub fn set_scope(&mut self, new_scope: Option<GcCell<'gc, Scope<'gc>>>) {
|
|
|
|
self.scope = new_scope;
|
|
|
|
}
|
|
|
|
|
2020-02-07 19:54:14 +00:00
|
|
|
/// Set a local register.
|
|
|
|
///
|
|
|
|
/// Returns `true` if the set was successful; `false` otherwise
|
|
|
|
pub fn set_local_register(
|
|
|
|
&mut self,
|
|
|
|
id: u32,
|
|
|
|
value: impl Into<Value<'gc>>,
|
|
|
|
mc: MutationContext<'gc, '_>,
|
|
|
|
) -> bool {
|
|
|
|
if let Some(r) = self.local_registers.write(mc).get_mut(id) {
|
|
|
|
*r = value.into();
|
|
|
|
|
|
|
|
true
|
|
|
|
} else {
|
|
|
|
false
|
|
|
|
}
|
|
|
|
}
|
2020-02-08 21:59:59 +00:00
|
|
|
|
|
|
|
/// Retrieve the return value from a completed activation, if the function
|
|
|
|
/// has already returned.
|
|
|
|
pub fn return_value(&self) -> Option<Value<'gc>> {
|
|
|
|
self.return_value.clone()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Set the return value.
|
|
|
|
pub fn set_return_value(&mut self, value: Value<'gc>) {
|
|
|
|
self.return_value = Some(value);
|
|
|
|
}
|
2020-02-06 04:15:03 +00:00
|
|
|
}
|