Mercurial > touhou

changeset 774:d08eb4c9fce3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
formats: Upgrade nom to version 8
author Link Mauve <linkmauve@linkmauve.fr>
date Mon, 29 Sep 2025 11:10:15 +0000
parents 317e93b7d586
children 28d8b892fd06
files formats/Cargo.toml formats/src/th06/anm0.rs formats/src/th06/ecl.rs formats/src/th06/std.rs
diffstat 4 files changed, 34 insertions(+), 34 deletions(-) [+]
line wrap: on
line diff
--- a/formats/Cargo.toml
+++ b/formats/Cargo.toml
@@ -10,7 +10,7 @@
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-nom = { version = "7", default-features = false, features = ["alloc"] }
+nom = { version = "8", default-features = false, features = ["alloc"] }
 encoding_rs = "0.8"
 bitflags = "1"
 touhou-utils = "*"
--- a/formats/src/th06/anm0.rs
+++ b/formats/src/th06/anm0.rs
@@ -2,9 +2,9 @@
 
 use nom::{
     IResult,
+    Parser,
     bytes::complete::{tag, take_while_m_n},
     number::complete::{le_u8, le_u16, le_u32, le_i32, le_f32},
-    sequence::tuple,
     multi::{many_m_n, many0},
 };
 use std::collections::BTreeMap;
@@ -77,7 +77,7 @@
 impl Anm0 {
     /// Parse a slice of bytes into an `Anm0` struct.
     pub fn from_slice(data: &[u8]) -> IResult<&[u8], Vec<Anm0>> {
-        many0(parse_anm0)(data)
+        many0(parse_anm0).parse(data)
     }
 
     /// TODO
@@ -98,7 +98,7 @@
 }
 
 fn parse_sprite(i: &[u8]) -> IResult<&[u8], Sprite> {
-    let (i, (index, x, y, width, height)) = tuple((le_u32, le_f32, le_f32, le_f32, le_f32))(i)?;
+    let (i, (index, x, y, width, height)) = (le_u32, le_f32, le_f32, le_f32, le_f32).parse(i)?;
     Ok((i, Sprite {
         index,
         x,
@@ -175,17 +175,17 @@
     let (i, (num_sprites, num_scripts, _, width, height, format, color_key,
              first_name_offset, _, second_name_offset, version, _,
              _texture_offset, has_data, _next_offset, _)) =
-        tuple((le_u32, le_u32, tag(b"\0\0\0\0"), le_u32, le_u32, le_u32, le_u32, le_u32,
-               tag(b"\0\0\0\0"), le_u32, le_u32, tag(b"\0\0\0\0"), le_u32, le_u32, le_u32,
-               tag(b"\0\0\0\0")))(input)?;
+        (le_u32, le_u32, tag(&b"\0\0\0\0"[..]), le_u32, le_u32, le_u32, le_u32, le_u32,
+               tag(&b"\0\0\0\0"[..]), le_u32, le_u32, tag(&b"\0\0\0\0"[..]), le_u32, le_u32, le_u32,
+               tag(&b"\0\0\0\0"[..])).parse(input)?;
 
     assert_eq!(version, 0);
     assert_eq!(has_data, 0);
     let num_sprites = num_sprites as usize;
     let num_scripts = num_scripts as usize;
 
-    let (i, sprite_offsets) = many_m_n(num_sprites, num_sprites, le_u32)(i)?;
-    let (_, script_offsets) = many_m_n(num_scripts, num_scripts, tuple((le_u32, le_u32)))(i)?;
+    let (i, sprite_offsets) = many_m_n(num_sprites, num_sprites, le_u32).parse(i)?;
+    let (_, script_offsets) = many_m_n(num_scripts, num_scripts, (le_u32, le_u32)).parse(i)?;
 
     let png_filename = if first_name_offset > 0 {
         if input.len() < first_name_offset as usize {
@@ -233,7 +233,7 @@
             let tell = input.len() - i.len();
             instruction_offsets.push(tell - offset);
             // TODO: maybe check against the size of parsed data?
-            let (i2, (time, opcode, _size)) = tuple((le_u16, le_u8, le_u8))(i)?;
+            let (i2, (time, opcode, _size)) = (le_u16, le_u8, le_u8).parse(i)?;
             let (i2, instr) = parse_instruction_args(i2, opcode)?;
             instructions.push(Call { time, instr });
             i = i2;
--- a/formats/src/th06/ecl.rs
+++ b/formats/src/th06/ecl.rs
@@ -2,8 +2,8 @@
 
 use nom::{
     IResult,
+    Parser,
     number::complete::{le_u8, le_u16, le_u32, le_i16, le_i32, le_f32},
-    sequence::tuple,
     multi::{count, many0},
     error::ErrorKind,
     Err,
@@ -329,12 +329,12 @@
 
 fn parse_sub_instruction(input: &[u8]) -> IResult<&[u8], CallSub> {
     let i = &input[..];
-    let (i, (time, opcode)) = tuple((le_i32, le_u16))(i)?;
+    let (i, (time, opcode)) = (le_i32, le_u16).parse(i)?;
     if time == -1 || opcode == 0xffff {
         return Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof)));
     }
 
-    let (i, (size, rank_mask, param_mask)) = tuple((le_u16, le_u16, le_u16))(i)?;
+    let (i, (size, rank_mask, param_mask)) = (le_u16, le_u16, le_u16).parse(i)?;
     let rank_mask = Rank::from_bits(rank_mask).unwrap();
     let (i, instr) = parse_sub_instruction_args(i, opcode)?;
     assert_eq!(input.len() - i.len(), size as usize);
@@ -343,19 +343,19 @@
 }
 
 fn parse_sub(i: &[u8]) -> IResult<&[u8], Sub> {
-    let (i, instructions) = many0(parse_sub_instruction)(i)?;
+    let (i, instructions) = many0(parse_sub_instruction).parse(i)?;
     let sub = Sub { instructions };
     Ok((i, sub))
 }
 
 fn parse_main_instruction(input: &[u8]) -> IResult<&[u8], CallMain> {
     let i = &input[..];
-    let (i, (time, sub)) = tuple((le_u16, le_u16))(i)?;
+    let (i, (time, sub)) = (le_u16, le_u16).parse(i)?;
     if time == 0xffff && sub == 4 {
         return Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof)));
     }
 
-    let (i, (opcode, size)) = tuple((le_u16, le_u16))(i)?;
+    let (i, (opcode, size)) = (le_u16, le_u16).parse(i)?;
     let size = size as usize;
     let (i, instr) = parse_main_instruction_args(i, opcode)?;
     assert_eq!(input.len() - i.len(), size as usize);
@@ -364,7 +364,7 @@
 }
 
 fn parse_main(i: &[u8]) -> IResult<&[u8], Main> {
-    let (i, instructions) = many0(parse_main_instruction)(i)?;
+    let (i, instructions) = many0(parse_main_instruction).parse(i)?;
     let main = Main { instructions };
     Ok((i, main))
 }
@@ -372,7 +372,7 @@
 fn parse_ecl(input: &[u8]) -> IResult<&[u8], Ecl> {
     let i = input;
 
-    let (i, (sub_count, main_count)) = tuple((le_u16, le_u16))(i)?;
+    let (i, (sub_count, main_count)) = (le_u16, le_u16).parse(i)?;
     let sub_count = sub_count as usize;
 
     if main_count != 0 {
@@ -380,10 +380,10 @@
         return Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof)));
     }
 
-    let (_, (main_offsets, sub_offsets)) = tuple((
+    let (_, (main_offsets, sub_offsets)) = (
         count(le_u32, 3),
         count(le_u32, sub_count),
-    ))(i)?;
+    ).parse(i)?;
 
     // Read all subs.
     let mut subs = Vec::new();
--- a/formats/src/th06/std.rs
+++ b/formats/src/th06/std.rs
@@ -2,9 +2,9 @@
 
 use nom::{
     IResult,
+    Parser,
     bytes::complete::tag,
     number::complete::{le_u8, le_u16, le_u32, le_i32, le_f32},
-    sequence::tuple,
     combinator::map,
     multi::{many0, count},
     error::ErrorKind,
@@ -164,13 +164,13 @@
 }
 
 fn parse_quad(i: &[u8]) -> IResult<&[u8], Quad> {
-    let (i, (unk1, size)) = tuple((le_u16, le_u16))(i)?;
+    let (i, (unk1, size)) = (le_u16, le_u16).parse(i)?;
     if unk1 == 0xffff {
         return Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof)));
     }
     // TODO: replace this assert with a custom error.
     assert_eq!(size, 0x1c);
-    let (i, (anm_script, _, x, y, z, width, height)) = tuple((le_u16, tag(b"\0\0"), le_f32, le_f32, le_f32, le_f32, le_f32))(i)?;
+    let (i, (anm_script, _, x, y, z, width, height)) = (le_u16, tag(&b"\0\0"[..]), le_f32, le_f32, le_f32, le_f32, le_f32).parse(i)?;
     let quad = Quad {
         anm_script,
         pos: Position { x, y, z },
@@ -180,7 +180,7 @@
 }
 
 fn parse_model(i: &[u8]) -> IResult<&[u8], Model> {
-    let (i, (_id, unknown, x, y, z, width, height, depth, quads)) = tuple((le_u16, le_u16, le_f32, le_f32, le_f32, le_f32, le_f32, le_f32, many0(parse_quad)))(i)?;
+    let (i, (_id, unknown, x, y, z, width, height, depth, quads)) = (le_u16, le_u16, le_f32, le_f32, le_f32, le_f32, le_f32, le_f32, many0(parse_quad)).parse(i)?;
     let bounding_box = [x, y, z, width, height, depth];
     let model = Model {
         unknown,
@@ -191,7 +191,7 @@
 }
 
 fn parse_instance(i: &[u8]) -> IResult<&[u8], Instance> {
-    let (i, (id, unknown, x, y, z)) = tuple((le_u16, le_u16, le_f32, le_f32, le_f32))(i)?;
+    let (i, (id, unknown, x, y, z)) = (le_u16, le_u16, le_f32, le_f32, le_f32).parse(i)?;
     if id == 0xffff && unknown == 0xffff {
         return Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof)));
     }
@@ -205,7 +205,7 @@
 }
 
 fn parse_instruction(i: &[u8]) -> IResult<&[u8], Call> {
-    let (i, (time, opcode, size)) = tuple((le_u32, le_u16, le_u16))(i)?;
+    let (i, (time, opcode, size)) = (le_u32, le_u16, le_u16).parse(i)?;
     if time == 0xffffffff && opcode == 0xffff && size == 0xffff {
         return Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof)));
     }
@@ -220,15 +220,15 @@
 fn parse_stage(input: &[u8]) -> IResult<&[u8], Stage> {
     let i = &input[..];
 
-    let (i, (num_models, _num_faces, object_instances_offset, script_offset, _, name, music_names, music_paths)) = tuple((
-        le_u16, le_u16, le_u32, le_u32, tag(b"\0\0\0\0"),
+    let (i, (num_models, _num_faces, object_instances_offset, script_offset, _, name, music_names, music_paths)) = (
+        le_u16, le_u16, le_u32, le_u32, tag(&b"\0\0\0\0"[..]),
         le_String,
-        map(tuple((le_String, le_String, le_String, le_String)), |(a, b, c, d)| [a, b, c, d]),
-        map(tuple((le_String, le_String, le_String, le_String)), |(a, b, c, d)| [a, b, c, d])
-    ))(i)?;
+        map((le_String, le_String, le_String, le_String), |(a, b, c, d)| [a, b, c, d]),
+        map((le_String, le_String, le_String, le_String), |(a, b, c, d)| [a, b, c, d])
+    ).parse(i)?;
     let musics = music_names.iter().zip(&music_paths).map(|(name, path)| if name == " " { None } else { Some((name.clone(), path.clone())) }).collect();
 
-    let (_, offsets) = count(le_u32, num_models as usize)(i)?;
+    let (_, offsets) = count(le_u32, num_models as usize).parse(i)?;
 
     let mut models = vec![];
     for offset in offsets {
@@ -236,8 +236,8 @@
         models.push(model);
     }
 
-    let (_, instances) = many0(parse_instance)(&input[object_instances_offset as usize..])?;
-    let (_, script) = many0(parse_instruction)(&input[script_offset as usize..])?;
+    let (_, instances) = many0(parse_instance).parse(&input[object_instances_offset as usize..])?;
+    let (_, script) = many0(parse_instruction).parse(&input[script_offset as usize..])?;
 
     let stage = Stage {
         name,