nom-mpq 2.0.8

A nom parser for the MoPaQ archive format
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use clap::{Parser, Subcommand};
use nom_mpq::*;
use std::io::Write;

#[derive(Subcommand)]
enum Commands {
    /// List Files
    List,
    /// Extract a file from the archive
    ExtractFile {
        /// lists test values
        #[arg(short, long)]
        name: String,
    },
    /// Extract a header from the archive
    ExtractHeader {
        /// Extract a specific named header
        #[arg(short, long)]
        name: String,
    },
}

#[derive(Parser)]
#[command(author, version, about, long_about = None)]
struct Cli {
    /// Sets a custom config file
    #[arg(short, long, value_name = "FILE")]
    source: String,

    /// Turn debugging information on
    #[arg(short, long, action = clap::ArgAction::Count)]
    debug: u8,

    #[command(subcommand)]
    command: Commands,
}

fn main() {
    tracing_subscriber::fmt::init();
    let cli = Cli::parse();
    let file_contents = parser::read_file(&cli.source);
    let (_input, mpq) = parser::parse(&file_contents).unwrap();
    match &cli.command {
        Commands::List => match mpq.get_files(&file_contents) {
            Err(e) => eprintln!("Error: {}", e),
            Ok(mpq_listfiles_res) => {
                for (filename, size) in mpq_listfiles_res {
                    println!("{} {1:>8} bytes", filename, size);
                }
            }
        },
        Commands::ExtractFile { name } => {
            let (_tail, file_data) = mpq
                .read_mpq_file_sector(name, false, &file_contents)
                .unwrap();
            for word in file_data {
                let bytes = word.to_le_bytes();
                let _ = std::io::stdout().write_all(&bytes);
            }
            let _ = std::io::stdout().flush();
        }
        Commands::ExtractHeader { name } => match name.as_ref() {
            "user_data.content" => {
                let user_data = mpq
                    .user_data
                    .as_ref()
                    .expect("Unable to get user data, not provided in MPQ Archive");
                for word in &user_data.content {
                    let bytes = word.to_le_bytes();
                    let _ = std::io::stdout().write_all(&bytes);
                }
                let _ = std::io::stdout().flush();
            }
            _ => eprintln!("Unknown header"),
        },
    }
}