avm2: Implement Dxns and DxnsLate opcodes

Author: jarca0123

Cargo.lock

@@ -29,7 +29,7 @@ bitflags = { workspace = true }
 smallvec = { workspace = true }
 num-traits = { workspace = true }
 num-derive = { workspace = true }
-quick-xml = "0.37.5"
+quick-xml = { git = "https://github.com/jarca0123/quick-xml.git", branch = "ruffle" }
 url = { workspace = true }
 weak-table = "0.3.2"
 percent-encoding = { workspace = true }

core/Cargo.toml

@@ -652,6 +652,17 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         self.bound_class
     }
 
+    /// Get the default XML namespace for this activation.
+    pub fn default_xml_namespace(&mut self) -> Option<Namespace<'gc>> {
+        // Get the default XML namespace by walking up the call stack
+        // This matches avmplus's MethodFrame::findDxns behavior
+        self.context
+            .avm2
+            .call_stack()
+            .borrow()
+            .find_default_xml_namespace(self)
+    }
+
     pub fn run_actions(&mut self, method: Method<'gc>) -> Result<Value<'gc>, Error<'gc>> {
         // The method must be verified at this point
 
@@ -819,7 +830,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
                 Op::BkptLine { line_num } => self.op_bkpt_line(*line_num),
                 Op::Timestamp => self.op_timestamp(),
                 Op::TypeOf => self.op_type_of(),
-                Op::Dxns { .. } => self.op_dxns(),
+                Op::Dxns { string } => self.op_dxns(*string),
                 Op::DxnsLate => self.op_dxns_late(),
                 Op::EscXAttr => self.op_esc_xattr(),
                 Op::EscXElem => self.op_esc_elem(),
@@ -2580,14 +2591,57 @@ impl<'a, 'gc> Activation<'a, 'gc> {
     }
 
     /// Implements `Op::Dxns`
-    fn op_dxns(&mut self) -> Result<(), Error<'gc>> {
-        Err("Unimplemented opcode Dxns.".into())
+    fn op_dxns(&mut self, string: AvmAtom<'gc>) -> Result<(), Error<'gc>> {
+        // Convert the AvmAtom to an AvmString
+        let uri = AvmString::from(string);
+
+        // Create a namespace from the URI string
+        let namespace = Namespace::package(uri, self.avm2().root_api_version, self.strings());
+
+        // Set the default XML namespace for the current method frame
+        self.context
+            .avm2
+            .call_stack()
+            .borrow_mut(self.gc())
+            .set_default_xml_namespace(namespace);
+
+        Ok(())
     }
 
     /// Implements `Op::DxnsLate`
     fn op_dxns_late(&mut self) -> Result<(), Error<'gc>> {
-        let _ = self.pop_stack();
-        Err("Unimplemented opcode DxnsLate.".into())
+        let namespace_value = self.pop_stack();
+
+        // Convert the value to a namespace
+        let namespace = match namespace_value {
+            Value::Object(Object::NamespaceObject(ns)) => ns.namespace(),
+            Value::String(uri) => {
+                // Create a namespace from the URI string
+                Namespace::package(uri, self.avm2().root_api_version, self.strings())
+            }
+            Value::Undefined | Value::Null => {
+                // Empty namespace
+                Namespace::package(
+                    AvmString::new_utf8(self.gc(), ""),
+                    self.avm2().root_api_version,
+                    self.strings(),
+                )
+            }
+            _ => {
+                // Try to coerce to string and create namespace
+                let uri = namespace_value.coerce_to_string(self)?;
+                Namespace::package(uri, self.avm2().root_api_version, self.strings())
+            }
+        };
+
+        // Set the default XML namespace for the current method frame
+        self.context
+            .avm2
+            .call_stack()
+            .borrow_mut(self.gc())
+            .set_default_xml_namespace(namespace);
+
+        Ok(())
     }
 
     /// Implements `Op::EscXAttr`

core/src/avm2/activation.rs

@@ -1,6 +1,9 @@
+use crate::avm2::activation::Activation;
 use crate::avm2::class::Class;
 use crate::avm2::function::display_function;
 use crate::avm2::method::Method;
+use crate::avm2::AvmString;
+use crate::avm2::Namespace;
 use crate::string::WString;
 use gc_arena::Collect;
 
@@ -9,6 +12,8 @@ use gc_arena::Collect;
 pub struct CallNode<'gc> {
     method: Method<'gc>,
     class: Option<Class<'gc>>,
+    /// The default XML namespace for this method frame, if set.
+    default_xml_namespace: Option<Namespace<'gc>>,
 }
 
 #[derive(Collect, Clone)]
@@ -23,7 +28,11 @@ impl<'gc> CallStack<'gc> {
     }
 
     pub fn push(&mut self, method: Method<'gc>, class: Option<Class<'gc>>) {
-        self.stack.push(CallNode { method, class })
+        self.stack.push(CallNode {
+            method,
+            class,
+            default_xml_namespace: None,
+        });
     }
 
     pub fn pop(&mut self) -> Option<CallNode<'gc>> {
@@ -62,6 +71,41 @@ impl<'gc> CallStack<'gc> {
     pub fn is_empty(&self) -> bool {
         self.stack.is_empty()
     }
+
+    /// Set the default XML namespace for the current method frame.
+    /// This is called by the DxnsLate opcode.
+    pub fn set_default_xml_namespace(&mut self, namespace: Namespace<'gc>) {
+        if let Some(call_node) = self.stack.last_mut() {
+            call_node.default_xml_namespace = Some(namespace);
+        }
+    }
+
+    /// Get the default XML namespace by walking up the call stack.
+    /// This matches avmplus's MethodFrame::findDxns behavior.
+    pub fn find_default_xml_namespace(
+        &self,
+        activation: &mut Activation<'_, 'gc>,
+    ) -> Option<Namespace<'gc>> {
+        // Walk backwards through the call stack (most recent first)
+        for call_node in self.stack.iter().rev() {
+            // If this frame has an explicit DXNS declaration, return it
+            if let Some(ns) = call_node.default_xml_namespace {
+                return Some(ns);
+            }
+
+            // If this method has the SET_DXNS flag, it means it has a local
+            // default xml namespace declaration, so the default should be the
+            // unnamed namespace (empty string) rather than inheriting from global scope
+            if call_node.method.sets_dxns() {
+                return Some(Namespace::package(
+                    AvmString::new_utf8(activation.gc(), ""),
+                    activation.avm2().root_api_version,
+                    activation.strings(),
+                ));
+            }
+        }
+        None
+    }
 }
 
 impl Default for CallStack<'_> {