Switch to the AMF0 type marker names

Author: evilpie

flash-lso/src/amf0/read.rs

@@ -82,7 +82,7 @@ impl AMF0Decoder {
         Ok((i, Rc::new(Value::Reference(Reference(reference_index)))))
     }
 
-    fn parse_element_mixed_array<'a>(&mut self, i: &'a [u8]) -> AMFResult<'a, Rc<Value>> {
+    fn parse_element_ecma_array<'a>(&mut self, i: &'a [u8]) -> AMFResult<'a, Rc<Value>> {
         let (i, array_length) = be_u32(i)?;
         map(
             |i| self.parse_array_element(i),
@@ -120,11 +120,11 @@ impl AMF0Decoder {
     #[cfg(fuzzing)]
     /// For fuzzing
     pub fn fuzz_parse_element_array<'a>(&mut self, i: &'a [u8]) -> AMFResult<'a, Rc<Value>> {
-        self.parse_element_array(i)
+        self.parse_element_strict_array(i)
     }
 
     /// Parse an array of elements
-    fn parse_element_array<'a>(&mut self, i: &'a [u8]) -> AMFResult<'a, Rc<Value>> {
+    fn parse_element_strict_array<'a>(&mut self, i: &'a [u8]) -> AMFResult<'a, Rc<Value>> {
         let (i, length) = be_u32(i)?;
 
         let length_usize = length
@@ -199,13 +199,13 @@ impl AMF0Decoder {
                 let (i, v) = self.parse_element_reference(i)?;
                 Ok((i, v))
             }
-            TypeMarker::MixedArrayStart => {
-                let (i, v) = self.parse_element_mixed_array(i)?;
+            TypeMarker::ECMAArray => {
+                let (i, v) = self.parse_element_ecma_array(i)?;
                 self.cache[cache_idx] = Rc::clone(&v);
                 Ok((i, v))
             }
-            TypeMarker::Array => {
-                let (i, v) = self.parse_element_array(i)?;
+            TypeMarker::StrictArray => {
+                let (i, v) = self.parse_element_strict_array(i)?;
                 self.cache[cache_idx] = Rc::clone(&v);
                 Ok((i, v))
             }

flash-lso/src/amf0/type_marker.rs

@@ -4,58 +4,58 @@
 #[repr(u8)]
 pub(crate) enum TypeMarker {
     /// Number
-    Number = 0,
+    Number = 0x00,
 
     /// Boolean
-    Boolean = 1,
+    Boolean = 0x01,
 
     /// String
-    String = 2,
+    String = 0x02,
 
     /// Object start
-    Object = 3,
+    Object = 0x03,
 
     /// MovieClip (unused)
-    MovieClip = 4,
+    MovieClip = 0x04,
 
     /// Null
-    Null = 5,
+    Null = 0x05,
 
     /// Undefined
-    Undefined = 6,
+    Undefined = 0x06,
 
-    /// Reference (unused)
-    Reference = 7,
+    /// Reference
+    Reference = 0x07,
 
-    /// Start of a mixed array
-    MixedArrayStart = 8,
+    /// Start of an ECMA array
+    ECMAArray = 0x08,
 
     /// Object end
-    ObjectEnd = 9,
+    ObjectEnd = 0x09,
 
-    /// Array start
-    Array = 10,
+    /// Strict array start
+    StrictArray = 0x0A,
 
     /// Date with timezone
-    Date = 11,
+    Date = 0x0B,
 
     /// Long string (length > 65535)
-    LongString = 12,
+    LongString = 0x0C,
 
     /// Unsupported
-    Unsupported = 13,
+    Unsupported = 0x0D,
 
-    /// Recordset
-    RecordSet = 14,
+    /// Recordset (unused)
+    RecordSet = 0x0E,
 
     /// XML
-    Xml = 15,
+    Xml = 0x0F,
 
     /// Typed object start
-    TypedObject = 16,
+    TypedObject = 0x10,
 
     /// Embedded AMF3 element
-    AMF3 = 17,
+    AMF3 = 0x11,
 }
 
 impl TryFrom<u8> for TypeMarker {
@@ -71,9 +71,9 @@ impl TryFrom<u8> for TypeMarker {
             5 => Ok(Self::Null),
             6 => Ok(Self::Undefined),
             7 => Ok(Self::Reference),
-            8 => Ok(Self::MixedArrayStart),
+            8 => Ok(Self::ECMAArray),
             9 => Ok(Self::ObjectEnd),
-            10 => Ok(Self::Array),
+            10 => Ok(Self::StrictArray),
             11 => Ok(Self::Date),
             12 => Ok(Self::LongString),
             13 => Ok(Self::Unsupported),

flash-lso/src/amf0/write.rs

@@ -75,7 +75,7 @@ fn write_strict_array_element<'a, 'b: 'a, W: Write + 'a>(
     writer: &mut W,
     elements: &'b [Rc<Value>],
 ) -> Result<()> {
-    write_type_marker(writer, TypeMarker::Array)?;
+    write_type_marker(writer, TypeMarker::StrictArray)?;
     writer.write_u32(elements.len() as u32)?;
     for element in elements {
         write_value(writer, element)?;
@@ -133,7 +133,7 @@ fn write_dense_element<'a, 'b: 'a, W: Write + 'a>(
     Ok(())
 }
 
-fn write_mixed_array<'a, 'b: 'a, W: Write + 'a>(
+fn write_ecma_array<'a, 'b: 'a, W: Write + 'a>(
     writer: &mut W,
     dense: &'b [Rc<Value>],
     elements: &'b [Element],
@@ -142,7 +142,7 @@ fn write_mixed_array<'a, 'b: 'a, W: Write + 'a>(
     //TODO: what is the u16 padding
     //TODO: sometimes array length is ignored (u32) sometimes its: elements.len() as u32
 
-    write_type_marker(writer, TypeMarker::MixedArrayStart)?;
+    write_type_marker(writer, TypeMarker::ECMAArray)?;
     writer.write_u32(length)?;
     for (idx, value) in dense.iter().enumerate() {
         write_dense_element(writer, idx, value)?
@@ -183,7 +183,7 @@ pub(crate) fn write_value<'a, 'b: 'a, W: Write + 'a>(
         Value::Unsupported => write_unsupported_element(writer),
         Value::XML(x, _string) => write_xml_element(writer, x),
         Value::ECMAArray(_id, dense, elems, elems_length) => {
-            write_mixed_array(writer, dense, elems, *elems_length)
+            write_ecma_array(writer, dense, elems, *elems_length)
         }
         #[cfg(feature = "amf3")]
         Value::AMF3(e) => {