Mercurial > touhou

comparison formats/src/th06/ecl.rs @ 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 21b186be2590
children 94033091458b
comparison
equal deleted inserted replaced
773:317e93b7d586 774:d08eb4c9fce3
1 //! ECL enemy script format support. 1 //! ECL enemy script format support.
2 2
3 use nom::{ 3 use nom::{
4 IResult, 4 IResult,
5 Parser,
5 number::complete::{le_u8, le_u16, le_u32, le_i16, le_i32, le_f32}, 6 number::complete::{le_u8, le_u16, le_u32, le_i16, le_i32, le_f32},
6 sequence::tuple,
7 multi::{count, many0}, 7 multi::{count, many0},
8 error::ErrorKind, 8 error::ErrorKind,
9 Err, 9 Err,
10 }; 10 };
11 use encoding_rs::SHIFT_JIS; 11 use encoding_rs::SHIFT_JIS;
327 135 => fn EnableSpellcardBonus(UNK1: i32), 327 135 => fn EnableSpellcardBonus(UNK1: i32),
328 } 328 }
329 329
330 fn parse_sub_instruction(input: &[u8]) -> IResult<&[u8], CallSub> { 330 fn parse_sub_instruction(input: &[u8]) -> IResult<&[u8], CallSub> {
331 let i = &input[..]; 331 let i = &input[..];
332 let (i, (time, opcode)) = tuple((le_i32, le_u16))(i)?; 332 let (i, (time, opcode)) = (le_i32, le_u16).parse(i)?;
333 if time == -1 || opcode == 0xffff { 333 if time == -1 || opcode == 0xffff {
334 return Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof))); 334 return Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof)));
335 } 335 }
336 336
337 let (i, (size, rank_mask, param_mask)) = tuple((le_u16, le_u16, le_u16))(i)?; 337 let (i, (size, rank_mask, param_mask)) = (le_u16, le_u16, le_u16).parse(i)?;
338 let rank_mask = Rank::from_bits(rank_mask).unwrap(); 338 let rank_mask = Rank::from_bits(rank_mask).unwrap();
339 let (i, instr) = parse_sub_instruction_args(i, opcode)?; 339 let (i, instr) = parse_sub_instruction_args(i, opcode)?;
340 assert_eq!(input.len() - i.len(), size as usize); 340 assert_eq!(input.len() - i.len(), size as usize);
341 let call = CallSub { time, rank_mask, param_mask, instr }; 341 let call = CallSub { time, rank_mask, param_mask, instr };
342 Ok((i, call)) 342 Ok((i, call))
343 } 343 }
344 344
345 fn parse_sub(i: &[u8]) -> IResult<&[u8], Sub> { 345 fn parse_sub(i: &[u8]) -> IResult<&[u8], Sub> {
346 let (i, instructions) = many0(parse_sub_instruction)(i)?; 346 let (i, instructions) = many0(parse_sub_instruction).parse(i)?;
347 let sub = Sub { instructions }; 347 let sub = Sub { instructions };
348 Ok((i, sub)) 348 Ok((i, sub))
349 } 349 }
350 350
351 fn parse_main_instruction(input: &[u8]) -> IResult<&[u8], CallMain> { 351 fn parse_main_instruction(input: &[u8]) -> IResult<&[u8], CallMain> {
352 let i = &input[..]; 352 let i = &input[..];
353 let (i, (time, sub)) = tuple((le_u16, le_u16))(i)?; 353 let (i, (time, sub)) = (le_u16, le_u16).parse(i)?;
354 if time == 0xffff && sub == 4 { 354 if time == 0xffff && sub == 4 {
355 return Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof))); 355 return Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof)));
356 } 356 }
357 357
358 let (i, (opcode, size)) = tuple((le_u16, le_u16))(i)?; 358 let (i, (opcode, size)) = (le_u16, le_u16).parse(i)?;
359 let size = size as usize; 359 let size = size as usize;
360 let (i, instr) = parse_main_instruction_args(i, opcode)?; 360 let (i, instr) = parse_main_instruction_args(i, opcode)?;
361 assert_eq!(input.len() - i.len(), size as usize); 361 assert_eq!(input.len() - i.len(), size as usize);
362 let call = CallMain { time, sub, instr }; 362 let call = CallMain { time, sub, instr };
363 Ok((i, call)) 363 Ok((i, call))
364 } 364 }
365 365
366 fn parse_main(i: &[u8]) -> IResult<&[u8], Main> { 366 fn parse_main(i: &[u8]) -> IResult<&[u8], Main> {
367 let (i, instructions) = many0(parse_main_instruction)(i)?; 367 let (i, instructions) = many0(parse_main_instruction).parse(i)?;
368 let main = Main { instructions }; 368 let main = Main { instructions };
369 Ok((i, main)) 369 Ok((i, main))
370 } 370 }
371 371
372 fn parse_ecl(input: &[u8]) -> IResult<&[u8], Ecl> { 372 fn parse_ecl(input: &[u8]) -> IResult<&[u8], Ecl> {
373 let i = input; 373 let i = input;
374 374
375 let (i, (sub_count, main_count)) = tuple((le_u16, le_u16))(i)?; 375 let (i, (sub_count, main_count)) = (le_u16, le_u16).parse(i)?;
376 let sub_count = sub_count as usize; 376 let sub_count = sub_count as usize;
377 377
378 if main_count != 0 { 378 if main_count != 0 {
379 // TODO: use a better error. 379 // TODO: use a better error.
380 return Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof))); 380 return Err(Err::Error(nom::error::Error::new(i, ErrorKind::Eof)));
381 } 381 }
382 382
383 let (_, (main_offsets, sub_offsets)) = tuple(( 383 let (_, (main_offsets, sub_offsets)) = (
384 count(le_u32, 3), 384 count(le_u32, 3),
385 count(le_u32, sub_count), 385 count(le_u32, sub_count),
386 ))(i)?; 386 ).parse(i)?;
387 387
388 // Read all subs. 388 // Read all subs.
389 let mut subs = Vec::new(); 389 let mut subs = Vec::new();
390 for offset in sub_offsets.into_iter().map(|offset| offset as usize) { 390 for offset in sub_offsets.into_iter().map(|offset| offset as usize) {
391 let (_, sub) = parse_sub(&input[offset..])?; 391 let (_, sub) = parse_sub(&input[offset..])?;