Support RGBDS 0.8.0 object version 10 (#2)

Author: Rangi42

Cargo.lock

@@ -1,5 +1,5 @@
 //! This crate allows working with [RGBDS] object files.
-//! Currently, only version 9 revisions 6–9 are supported, but more should be added in the
+//! Currently, only version 9 revisions 6–10 are supported, but more should be added in the
 //! future.
 //!
 //! # Object file revision table
@@ -11,7 +11,10 @@
 //!
 //! RGBDS release                                          | Object file format
 //! -------------------------------------------------------|-------------------
-//! [v0.6.0](https://rgbds.gbdev.io/docs/v0.?.?/rgbds.5)   | v9 r9
+//! [v0.8.0](https://rgbds.gbdev.io/docs/v0.8.0/rgbds.5)   | v9 r10
+//! [v0.7.0](https://rgbds.gbdev.io/docs/v0.7.0/rgbds.5)   | v9 r9 (reported), v9 r10 (actual)
+//! [v0.6.1](https://rgbds.gbdev.io/docs/v0.6.1/rgbds.5)   | v9 r9
+//! [v0.6.0](https://rgbds.gbdev.io/docs/v0.6.0/rgbds.5)   | v9 r9
 //! [v0.5.1](https://rgbds.gbdev.io/docs/v0.5.1/rgbds.5)   | v9 r8
 //! [v0.5.0](https://rgbds.gbdev.io/docs/v0.5.0/rgbds.5)   | v9 r7
 //! [v0.4.2](https://rgbds.gbdev.io/docs/v0.4.2/rgbds.5)   | v9 r6
@@ -48,6 +51,7 @@ use util::*;
 /// A RGBDS object file.
 #[derive(Debug)]
 pub struct Object {
+    version: u8,
     revision: u32,
     fstack_nodes: Vec<Node>,
     symbols: Vec<Symbol>,
@@ -78,23 +82,25 @@ impl Object {
                 "This does not appear to be a valid RGBDS object",
             ));
         }
-        if magic[3] != b'9' {
+
+        let version = magic[3];
+        if version != b'9' {
             return Err(io::Error::new(
                 io::ErrorKind::InvalidData,
                 format!(
-                    "Object file version {} is not supported (only 9 is)",
-                    magic[3]
+                    "Object file version {} is not supported (must be 9)",
+                    version
                 ),
             ));
         }
 
         let revision = read_u32le(&mut input)?;
-        if !(6..=9).contains(&revision) {
+        if !(6..=10).contains(&revision) {
             return Err(io::Error::new(
                 io::ErrorKind::InvalidData,
                 format!(
-                    "Object file v9 revision {} is not supported (must be between 6 and 9)",
-                    revision
+                    "Object file {} revision {} is not supported (must be between 6 and 10)",
+                    version, revision
                 ),
             ));
         }
@@ -104,6 +110,7 @@ impl Object {
         let nb_fstack_nodes = read_u32le(&mut input)?.try_into().unwrap();
 
         let mut obj = Self {
+            version,
             revision,
             fstack_nodes: Vec::with_capacity(nb_fstack_nodes),
             symbols: Vec::with_capacity(nb_symbols),
@@ -132,7 +139,7 @@ impl Object {
 
     /// The object's version.
     pub fn version(&self) -> u8 {
-        9
+        self.version
     }
 
     /// The object's revision.

src/lib.rs

@@ -17,6 +17,36 @@ use std::iter;
 #[derive(Debug)]
 pub struct RpnExpr(Vec<u8>);
 
+/// A section memory type.
+#[derive(Debug, PartialEq)]
+pub enum SectType {
+    Wram0,
+    Vram,
+    Romx,
+    Rom0,
+    Hram,
+    Wramx,
+    Sram,
+    Oam,
+}
+impl SectType {
+    /// The section type's name.
+    pub fn name(&self) -> &'static str {
+        use SectType::*;
+
+        match self {
+            Wram0 => "WRAM0",
+            Vram => "VRAM",
+            Romx => "ROMX",
+            Rom0 => "ROM0",
+            Hram => "HRAM",
+            Wramx => "WRAMX",
+            Sram => "SRAM",
+            Oam => "OAM",
+        }
+    }
+}
+
 impl RpnExpr {
     /// Constructs a RPN expression from its byte serialization.
     /// This does not check the expression's correctness.
@@ -65,6 +95,24 @@ impl<'a> Iter<'a> {
             }
         }
     }
+
+    fn read_sect_type(&mut self) -> Option<SectType> {
+        use SectType::*;
+
+        let val = match self.0.bytes().get(self.1) {
+            Some(0) => Some(Wram0),
+            Some(1) => Some(Vram),
+            Some(2) => Some(Romx),
+            Some(3) => Some(Rom0),
+            Some(4) => Some(Hram),
+            Some(5) => Some(Wramx),
+            Some(6) => Some(Sram),
+            Some(7) => Some(Oam),
+            _ => None,
+        };
+        self.1 += 1;
+        val
+    }
 }
 impl<'a> Iterator for Iter<'a> {
     type Item = Result<RpnOp<'a>, RpnIterError>;
@@ -112,6 +160,12 @@ impl<'a> Iterator for Iter<'a> {
             0x54 => self
                 .read_string()
                 .map_or(err, |string| Ok(RpnOp::StartofSect(string))),
+            0x55 => self
+                .read_sect_type()
+                .map_or(err, |sect_type| Ok(RpnOp::SizeofSectType(sect_type))),
+            0x56 => self
+                .read_sect_type()
+                .map_or(err, |sect_type| Ok(RpnOp::StartofSectType(sect_type))),
             0x60 => Ok(RpnOp::HramCheck),
             0x61 => Ok(RpnOp::RstCheck),
             0x80 => self.read_u32().map_or(err, |id| Ok(RpnOp::Int(id))),
@@ -284,6 +338,10 @@ pub enum RpnOp<'a> {
     SizeofSect(&'a [u8]),
     /// `STARTOF("section")`
     StartofSect(&'a [u8]),
+    /// `SIZEOF(SectionType)`
+    SizeofSectType(SectType),
+    /// `STARTOF(SectionType)`
+    StartofSectType(SectType),
     /// HRAM check (check if the value is in HRAM range, then `& 0xFF`).
     HramCheck,
     /// `rst` check (check if the value is a `rst` target, then `| 0xC7`).
@@ -336,6 +394,8 @@ impl RpnOp<'_> {
             BankSelf => Literal,
             SizeofSect(..) => Literal,
             StartofSect(..) => Literal,
+            SizeofSectType(..) => Literal,
+            StartofSectType(..) => Literal,
             HramCheck => Unary,
             RstCheck => Unary,
             Int(..) => Literal,
@@ -363,7 +423,8 @@ impl RpnOp<'_> {
 
             // There is no precedence for non-binary operators...
             Neg | Cpl | Not | BankSym(..) | BankSect(..) | BankSelf | SizeofSect(..)
-            | StartofSect(..) | HramCheck | RstCheck | Int(..) | Sym(..) => unreachable!(),
+            | StartofSect(..) | SizeofSectType(..) | StartofSectType(..) | HramCheck | RstCheck
+            | Int(..) | Sym(..) => unreachable!(),
         }
     }
 
@@ -381,7 +442,8 @@ impl RpnOp<'_> {
 
             // There is no associativity for non-binary operators...
             Neg | Cpl | Not | BankSym(..) | BankSect(..) | BankSelf | SizeofSect(..)
-            | StartofSect(..) | HramCheck | RstCheck | Int(..) | Sym(..) => unreachable!(),
+            | StartofSect(..) | SizeofSectType(..) | StartofSectType(..) | HramCheck | RstCheck
+            | Int(..) | Sym(..) => unreachable!(),
         }
     }
 
@@ -444,6 +506,8 @@ impl Display for RpnOp<'_> {
             BankSelf => write!(fmt, "BANK(@)"),
             SizeofSect(name) => write!(fmt, "SIZEOF(\"{}\")", String::from_utf8_lossy(&name)),
             StartofSect(name) => write!(fmt, "STARTOF(\"{}\")", String::from_utf8_lossy(&name)),
+            SizeofSectType(sect_type) => write!(fmt, "SIZEOF({})", sect_type.name()),
+            StartofSectType(sect_type) => write!(fmt, "STARTOF({})", sect_type.name()),
             HramCheck => write!(fmt, "HRAM?"),
             RstCheck => write!(fmt, "RST?"),
             Int(val) => write!(fmt, "${:04x}", val),