avm2: Implement Dxns and DxnsLate opcodes

jarca0123 · jarca0123 · commit ca506625fb4a · 2025-07-16T18:53:23.000+02:00
diff --git a/core/src/avm2.rs b/core/src/avm2.rs
@@ -119,6 +119,10 @@ pub struct Avm2<'gc> {
     /// Scopes currently present of the scope stack.
     scope_stack: Vec<Scope<'gc>>,
 
+    /// Default XML namespace stack for E4X operations.
+    /// The last element is the current default namespace.
+    default_xml_namespace_stack: Vec<AvmString<'gc>>,
+
     /// The current call stack of the player.
     call_stack: GcRefLock<'gc, CallStack<'gc>>,
 
@@ -214,6 +218,7 @@ impl<'gc> Avm2<'gc> {
             player_runtime,
             stack: Vec::with_capacity(PREALLOCATED_STACK_SIZE),
             scope_stack: Vec::new(),
+            default_xml_namespace_stack: Vec::new(),
             call_stack: GcRefLock::new(mc, CallStack::new().into()),
             playerglobals_domain,
             stage_domain,
@@ -818,6 +823,25 @@ impl<'gc> Avm2<'gc> {
         self.scope_stack.pop();
     }
 
+    /// Push a default XML namespace onto the default XML namespace stack.
+    pub fn push_default_xml_namespace(&mut self, namespace: AvmString<'gc>) {
+        self.default_xml_namespace_stack.push(namespace);
+    }
+
+    /// Pop a default XML namespace from the default XML namespace stack.
+    pub fn pop_default_xml_namespace(&mut self) {
+        self.default_xml_namespace_stack.pop();
+    }
+
+    /// Get the current default XML namespace.
+    /// Returns an empty string if no default XML namespace is set.
+    pub fn current_default_xml_namespace(&self, strings: &StringContext<'gc>) -> AvmString<'gc> {
+        self.default_xml_namespace_stack
+            .last()
+            .copied()
+            .unwrap_or_else(|| AvmString::new_ascii_static(strings.gc(), b""))
+    }
+
     #[cfg(feature = "avm_debug")]
     #[inline]
     pub fn show_debug_output(&self) -> bool {
diff --git a/core/src/avm2/activation.rs b/core/src/avm2/activation.rs
@@ -77,6 +77,10 @@ pub struct Activation<'a, 'gc: 'a> {
     /// The index where the scope frame starts.
     scope_depth: usize,
 
+    /// The index where the default XML namespace frame starts.
+    /// Used to implement proper function-level scoping for default XML namespace.
+    default_xml_namespace_depth: usize,
+
     /// In avmplus, some behavior differs slightly depending on whether the JIT
     /// or the interpreter is used. Most methods are executed in "JIT mode", but
     /// in some cases "interpreter mode" is used instead: for example, script
@@ -125,6 +129,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             bound_class: None,
             stack_depth: context.avm2.stack.len(),
             scope_depth: context.avm2.scope_stack.len(),
+            default_xml_namespace_depth: context.avm2.default_xml_namespace_stack.len(),
             is_interpreter: false,
             context,
         }
@@ -149,6 +154,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             bound_class: None,
             stack_depth: context.avm2.stack.len(),
             scope_depth: context.avm2.scope_stack.len(),
+            default_xml_namespace_depth: context.avm2.default_xml_namespace_stack.len(),
             is_interpreter: false,
             context,
         }
@@ -177,6 +183,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             bound_class: Some(script.global_class()),
             stack_depth: context.avm2.stack.len(),
             scope_depth: context.avm2.scope_stack.len(),
+            default_xml_namespace_depth: 0, // Scripts inherit global default XML namespace
             is_interpreter: true, // Script initializers are always in interpreter mode
             context,
         };
@@ -377,6 +384,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         self.bound_class = bound_class;
         self.stack_depth = self.context.avm2.stack.len();
         self.scope_depth = self.context.avm2.scope_stack.len();
+        self.default_xml_namespace_depth = self.context.avm2.default_xml_namespace_stack.len();
         self.is_interpreter = false;
 
         // Resolve parameters and return type
@@ -483,6 +491,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             bound_class,
             stack_depth: context.avm2.stack.len(),
             scope_depth: context.avm2.scope_stack.len(),
+            default_xml_namespace_depth: context.avm2.default_xml_namespace_stack.len(), // Builtin functions start with isolated scope
             is_interpreter: false,
             context,
         }
@@ -626,6 +635,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
     pub fn cleanup(&mut self) {
         self.clear_stack_and_locals();
         self.clear_scope();
+        self.clear_default_xml_namespace();
     }
 
     /// Clears the operand stack used by this activation.
@@ -650,6 +660,13 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         self.avm2().scope_stack.truncate(scope_depth);
     }
 
+    /// Clears the default XML namespace stack used by this activation.
+    #[inline]
+    fn clear_default_xml_namespace(&mut self) {
+        let default_xml_namespace_depth = self.default_xml_namespace_depth;
+        self.avm2().default_xml_namespace_stack.truncate(default_xml_namespace_depth);
+    }
+
     /// Get the superclass of the class that defined the currently-executing
     /// method, if it exists.
     ///
@@ -664,6 +681,12 @@ impl<'a, 'gc> Activation<'a, 'gc> {
         self.bound_class
     }
 
+    /// Get the current default XML namespace.
+    /// Returns an empty string if no default XML namespace is set.
+    pub fn default_xml_namespace(&self) -> AvmString<'gc> {
+        self.context.avm2.current_default_xml_namespace(self.strings_ref())
+    }
+
     /// Retrieve a method entry from the current ABC file's method table.
     fn table_method(
         &mut self,
@@ -845,7 +868,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(),
@@ -2627,14 +2650,21 @@ 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>> {
+        let namespace_uri: AvmString<'gc> = string.into();
+        self.avm2().push_default_xml_namespace(namespace_uri);
+        
+        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();
+        let namespace_uri = namespace_value.coerce_to_string(self)?;
+
+        self.avm2().push_default_xml_namespace(namespace_uri);
+        
+        Ok(())
     }
 
     /// Implements `Op::EscXAttr`
diff --git a/core/src/avm2/e4x.rs b/core/src/avm2/e4x.rs
@@ -1,6 +1,6 @@
 use crate::avm2::error::{make_error_1010, make_error_1085, make_error_1118, type_error};
 use crate::avm2::object::{E4XOrXml, FunctionObject, NamespaceObject};
-use crate::avm2::{Activation, Error, Multiname, TObject, Value};
+use crate::avm2::{Activation, Error, Multiname, Namespace, TObject, Value};
 use crate::string::{AvmString, StringContext, WStr, WString};
 use crate::xml::custom_unescape;
 
@@ -1084,7 +1084,18 @@ impl<'gc> E4XNode<'gc> {
             ResolveResult::Unknown(ns) => {
                 return Err(make_unknown_ns_error(activation, ns, name));
             }
-            ResolveResult::Unbound => None,
+            ResolveResult::Unbound => {
+                // Use default XML namespace if available
+                let default_ns_uri = activation.default_xml_namespace();
+                if default_ns_uri.is_empty() {
+                    None
+                } else {
+                    Some(E4XNamespace {
+                        prefix: None,
+                        uri: default_ns_uri,
+                    })
+                }
+            }
         };
 
         let result = E4XNode(Gc::new(
@@ -1673,7 +1684,17 @@ pub fn string_to_multiname<'gc>(
     } else if &*name == b"*" {
         Multiname::any()
     } else {
-        Multiname::new(activation.avm2().namespaces.public_all(), name)
+        let default_ns_uri = activation.default_xml_namespace();
+        if default_ns_uri.is_empty() {
+            Multiname::new(activation.avm2().namespaces.public_all(), name)
+        } else {
+            let namespace = Namespace::package(
+                default_ns_uri, 
+                activation.avm2().root_api_version, 
+                activation.strings()
+            );
+            Multiname::new(namespace, name)
+        }
     }
 }
 
diff --git a/core/src/avm2/globals/q_name.rs b/core/src/avm2/globals/q_name.rs
@@ -92,7 +92,18 @@ pub fn q_name_constructor<'gc>(
 
         if &*local != b"*" {
             this.set_local_name(activation.gc(), local);
-            Some(activation.avm2().find_public_namespace())
+            
+            // Use default XML namespace if set, otherwise use public namespace
+            let default_ns_uri = activation.default_xml_namespace();
+            if default_ns_uri.is_empty() {
+                Some(activation.avm2().find_public_namespace())
+            } else {
+                Some(Namespace::package(
+                    default_ns_uri,
+                    activation.avm2().root_api_version,
+                    activation.strings(),
+                ))
+            }
         } else {
             None
         }
diff --git a/core/src/avm2/object/xml_object.rs b/core/src/avm2/object/xml_object.rs
@@ -715,15 +715,18 @@ fn handle_input_multiname<'gc>(
             .local_name()
             .map(|name| string_to_multiname(activation, name))
         {
-            // Copy the namespaces from the previous name,
-            // but make sure to definitely include the public namespace.
-            if !new_name.is_any_namespace() {
-                let mut ns = Vec::new();
-                ns.extend(name.namespace_set());
-                if !name.contains_public_namespace() {
-                    ns.push(activation.avm2().namespaces.public_all());
+            let default_ns_uri = activation.default_xml_namespace();
+            if default_ns_uri.is_empty() || new_name.contains_public_namespace() {
+                // Copy the namespaces from the previous name,
+                // but make sure to definitely include the public namespace.
+                if !new_name.is_any_namespace() {
+                    let mut ns = Vec::new();
+                    ns.extend(name.namespace_set());
+                    if !name.contains_public_namespace() {
+                        ns.push(activation.avm2().namespaces.public_all());
+                    }
+                    new_name.set_ns(NamespaceSet::new(ns, activation.gc()));
                 }
-                new_name.set_ns(NamespaceSet::new(ns, activation.gc()));
             }
 
             return new_name;
diff --git a/tests/tests/swfs/from_avmplus/e4x/Statements/e12_1/test.toml b/tests/tests/swfs/from_avmplus/e4x/Statements/e12_1/test.toml
@@ -1,2 +1 @@
 num_ticks = 1
-known_failure = true # https://github.com/ruffle-rs/ruffle/issues/12355
diff --git a/tests/tests/swfs/from_avmplus/e4x/Types/e9_1_1_9/test.toml b/tests/tests/swfs/from_avmplus/e4x/Types/e9_1_1_9/test.toml
@@ -1,2 +1 @@
 num_ticks = 1
-known_failure = true

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1 @@`
`1`	`1`	`num_ticks = 1`
`2`		`-known_failure = true # https://github.com/ruffle-rs/ruffle/issues/12355`
Original file line number	Diff line number	Diff line change
`@@ -1,2 +1 @@`
`1`	`1`	`num_ticks = 1`
`2`		`-known_failure = true`