Bsatool: extract and extractall modes

apps/bsatool/CMakeLists.txt

@@ -1,7 +1,5 @@
 set(BSATOOL
 	bsatool.cpp
-	bsatool_cmd.c
-	bsatool_cmd.h
 )
 source_group(apps\\bsatool FILES ${BSATOOL})
 
@@ -15,11 +13,6 @@ target_link_libraries(bsatool
   components
 )
 
-#if (APPLE)
-#    find_library(CARBON_FRAMEWORK Carbon)
-#    target_link_libraries(openmw ${CARBON_FRAMEWORK})
-#endif (APPLE)
-
 if (BUILD_WITH_CODE_COVERAGE)
   add_definitions (--coverage)
   target_link_libraries(bsatool gcov)

apps/bsatool/bsatool.cpp

@@ -1,76 +1,192 @@
+#include <iostream>
+#include <vector>
+#include <exception>
+
+#include <boost/program_options.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+
 #include <components/bsa/bsa_file.hpp>
 
-#include "bsatool_cmd.h"
+#define BSATOOL_VERSION 1.1
 
-#include <iostream>
-#include <iomanip>
-#include <fstream>
-#include <exception>
+// Create local aliases for brevity
+namespace bpo = boost::program_options;
+namespace bfs = boost::filesystem;
 
-int main(int argc, char** argv)
+struct Arguments
 {
-    gengetopt_args_info info;
+    std::string mode;
+    std::string filename;
+    std::string extractfile;
+    std::string outdir;
 
-    if(cmdline_parser(argc, argv, &info) != 0)
-        return 1;
+    bool longformat;
+    bool fullpath;
+};
 
-    if(info.inputs_num != 1)
+void replaceAll(std::string& str, const std::string& needle, const std::string& substitute)
+{
+    int pos = str.find(needle);
+    while(pos != -1)
     {
-        if(info.inputs_num == 0)
-            std::cout << "ERROR: missing BSA file\n\n";
-        else
-            std::cout << "ERROR: more than one BSA file specified\n\n";
-        cmdline_parser_print_help();
-        return 1;
+        str.replace(pos, needle.size(), substitute);
+        pos = str.find(needle);
     }
+}
 
-    // Open file
-    Bsa::BSAFile bsa;
-    char *arcname = info.inputs[0];
-    try { bsa.open(arcname); }
+bool parseOptions (int argc, char** argv, Arguments &info)
+{
+    bpo::options_description desc("Inspect and extract files from Bethesda BSA archives\n\n"
+            "Usages:\n"
+            "  bsatool list [-l] archivefile\n"
+            "      List the files presents in the input archive.\n\n"
+            "  bsatool extract [-f] archivefile [file_to_extract] [output_directory]\n"
+            "      Extract a file from the input archive.\n\n"
+            "  bsatool extractall archivefile [output_directory]\n"
+            "      Extract all files from the input archive.\n\n"
+            "Allowed options");
+
+    desc.add_options()
+        ("help,h", "print help message.")
+        ("version,v", "print version information and quit.")
+        ("long,l", "Include extra information in archive listing.")
+        ("full-path,f", "Create diretory hierarchy on file extraction "
+         "(always true for extractall).")
+        ;
+
+    // input-file is hidden and used as a positional argument
+    bpo::options_description hidden("Hidden Options");
+
+    hidden.add_options()
+        ( "mode,m", bpo::value<std::string>(), "bsatool mode")
+        ( "input-file,i", bpo::value< std::vector<std::string> >(), "input file")
+        ;
+
+    bpo::positional_options_description p;
+    p.add("mode", 1).add("input-file", 3);
+
+    // there might be a better way to do this
+    bpo::options_description all;
+    all.add(desc).add(hidden);
+
+    bpo::variables_map variables;
+    try
+    {
+        bpo::parsed_options valid_opts = bpo::command_line_parser(argc, argv)
+            .options(all).positional(p).run();
+        bpo::store(valid_opts, variables);
+    }
     catch(std::exception &e)
     {
-        std::cout << "ERROR reading BSA archive '" << arcname
-            << "'\nDetails:\n" << e.what() << std::endl;
-        return 2;
+        std::cout << "ERROR parsing arguments: " << e.what() << "\n\n"
+            << desc << std::endl;
+        return false;
     }
 
-    if(info.extract_given)
+    bpo::notify(variables);
+
+    if (variables.count ("help"))
+    {
+        std::cout << desc << std::endl;
+        return false;
+    }
+    if (variables.count ("version"))
+    {
+        std::cout << "BSATool version " << BSATOOL_VERSION << std::endl;
+        return false;
+    }
+    if (!variables.count("mode"))
+    {
+        std::cout << "ERROR: no mode specified!\n\n"
+            << desc << std::endl;
+        return false;
+    }
+
+    info.mode = variables["mode"].as<std::string>();
+    if (!(info.mode == "list" || info.mode == "extract" || info.mode == "extractall"))
+    {
+        std::cout << std::endl << "ERROR: invalid mode \"" << info.mode << "\"\n\n"
+            << desc << std::endl;
+        return false;
+    }
+
+    if (!variables.count("input-file"))
     {
-        char *file = info.extract_arg;
+        std::cout << "\nERROR: missing BSA archive\n\n"
+            << desc << std::endl;
+        return false;
+    }
+    info.filename = variables["input-file"].as< std::vector<std::string> >()[0];
 
-        if(!bsa.exists(file))
+    // Default output to the working directory
+    info.outdir = ".";
+
+    if (info.mode == "extract")
+    {
+        if (variables["input-file"].as< std::vector<std::string> >().size() < 2)
         {
-            std::cout << "ERROR: file '" << file << "' not found\n";
-            std::cout << "In archive: " << arcname << std::endl;
-            return 3;
+            std::cout << "\nERROR: file to extract unspecified\n\n"
+                << desc << std::endl;
+            return false;
         }
+        if (variables["input-file"].as< std::vector<std::string> >().size() > 1)
+            info.extractfile = variables["input-file"].as< std::vector<std::string> >()[1];
+        if (variables["input-file"].as< std::vector<std::string> >().size() > 2)
+            info.outdir = variables["input-file"].as< std::vector<std::string> >()[2];
+    }
+    else if (variables["input-file"].as< std::vector<std::string> >().size() > 1)
+        info.outdir = variables["input-file"].as< std::vector<std::string> >()[1];
 
-        // Find the base name of the file
-        int pos = strlen(file);
-        while(pos > 0 && file[pos] != '\\') pos--;
-        char *base = file+pos+1;
+    info.longformat = variables.count("long");
+    info.fullpath = variables.count("full-path");
 
-        // TODO: We might add full directory name extraction later. We
-        // could also allow automatic conversion from / to \ in
-        // parameter file names.
+    return true;
+}
 
-        // Load the file into a memory buffer
-        Ogre::DataStreamPtr data = bsa.getFile(file);
+int list(Bsa::BSAFile& bsa, Arguments& info);
+int extract(Bsa::BSAFile& bsa, Arguments& info);
+int extractAll(Bsa::BSAFile& bsa, Arguments& info);
 
-        // Write the file to disk
-        std::ofstream out(base, std::ios::binary);
-        out.write(data->getAsString().c_str(), data->size());
-        out.close();
+int main(int argc, char** argv)
+{
+    Arguments info;
+    if(!parseOptions (argc, argv, info))
+        return 1;
+
+    // Open file
+    Bsa::BSAFile bsa;
+    try
+    {
+        bsa.open(info.filename);
+    }
+    catch(std::exception &e)
+    {
+        std::cout << "ERROR reading BSA archive '" << info.filename
+            << "'\nDetails:\n" << e.what() << std::endl;
+        return 2;
+    }
 
-        return 0;
+    if (info.mode == "list")
+        return list(bsa, info);
+    else if (info.mode == "extract")
+        return extract(bsa, info);
+    else if (info.mode == "extractall")
+        return extractAll(bsa, info);
+    else
+    {
+        std::cout << "Unsupported mode. That is not supposed to happen." << std::endl;
+        return 1;
     }
+}
 
+int list(Bsa::BSAFile& bsa, Arguments& info)
+{
     // List all files
     const Bsa::BSAFile::FileList &files = bsa.getList();
     for(int i=0; i<files.size(); i++)
     {
-        if(info.long_given)
+        if(info.longformat)
         {
             // Long format
             std::cout << std::setw(50) << std::left << files[i].name;
@@ -81,6 +197,92 @@ int main(int argc, char** argv)
             std::cout << files[i].name << std::endl;
     }
 
-    // Done!
+    return 0;
+}
+
+int extract(Bsa::BSAFile& bsa, Arguments& info)
+{
+    std::string archivePath = info.extractfile;
+    replaceAll(archivePath, "/", "\\");
+
+    std::string extractPath = info.extractfile;
+    replaceAll(extractPath, "\\", "/");
+
+    if (!bsa.exists(archivePath.c_str()))
+    {
+        std::cout << "ERROR: file '" << archivePath << "' not found\n";
+        std::cout << "In archive: " << info.filename << std::endl;
+        return 3;
+    }
+
+    // Get the target path (the path the file will be extracted to)
+    bfs::path relPath (extractPath);
+    bfs::path outdir (info.outdir);
+
+    bfs::path target;
+    if (info.fullpath)
+        target = outdir / relPath;
+    else
+        target = outdir / relPath.filename();
+
+    // Create the directory hierarchy
+    bfs::create_directories(target.parent_path());
+
+    bfs::file_status s = bfs::status(target.parent_path());
+    if (!bfs::is_directory(s))
+    {
+        std::cout << "ERROR: " << target.parent_path() << " is not a directory." << std::endl;
+        return 3;
+    }
+
+    // Get a stream for the file to extract
+    Ogre::DataStreamPtr data = bsa.getFile(archivePath.c_str());
+    bfs::ofstream out(target, std::ios::binary);
+
+    // Write the file to disk
+    std::cout << "Extracting " << info.extractfile << " to " << target << std::endl;
+    out.write(data->getAsString().c_str(), data->size());
+    out.close();
+
+    return 0;
+}
+
+int extractAll(Bsa::BSAFile& bsa, Arguments& info)
+{
+    // Get the list of files present in the archive
+    Bsa::BSAFile::FileList list = bsa.getList();
+
+    // Iter on the list
+    for(Bsa::BSAFile::FileList::iterator it = list.begin(); it != list.end(); ++it) {
+        const char* archivePath = it->name;
+
+        std::string extractPath (archivePath);
+        replaceAll(extractPath, "\\", "/");
+
+        // Get the target path (the path the file will be extracted to)
+        bfs::path target (info.outdir);
+        target /= extractPath;
+
+        // Create the directory hierarchy
+        bfs::create_directories(target.parent_path());
+
+        bfs::file_status s = bfs::status(target.parent_path());
+        if (!bfs::is_directory(s))
+        {
+            std::cout << "ERROR: " << target.parent_path() << " is not a directory." << std::endl;
+            return 3;
+        }
+
+        // Get a stream for the file to extract
+        // (inefficient because getFile iter on the list again)
+        Ogre::DataStreamPtr data = bsa.getFile(archivePath);
+        bfs::ofstream out(target, std::ios::binary);
+
+        // Write the file to disk
+        std::cout << "Extracting " << target << std::endl;
+        out.write(data->getAsString().c_str(), data->size());
+        out.close();
+    }
+
     return 0;
 }

apps/bsatool/bsatool.ggo

@@ -1,11 +0,0 @@
-package "bsatool"
-version "1.0"
-purpose "Inspect and extract files from Bethesda BSA archives"
-#usage "<usage>"
-#description "<description>"
-args "--unamed-opts=BSA-FILE -F bsatool_cmd -G"
-
-option "extract" x "Extract file from archive" string optional
-option "long" l "Include extra information in archive listing" optional
-
-text "\nIf no option is given, the default action is to list all files in the archive."

apps/bsatool/bsatool_cmd.h

@@ -1,179 +0,0 @@
-/** @file bsatool_cmd.h
- *  @brief The header file for the command line option parser
- *  generated by GNU Gengetopt version 2.22.2
- *  http://www.gnu.org/software/gengetopt.
- *  DO NOT modify this file, since it can be overwritten
- *  @author GNU Gengetopt by Lorenzo Bettini */
-
-#ifndef BSATOOL_CMD_H
-#define BSATOOL_CMD_H
-
-/* If we use autoconf.  */
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <stdio.h> /* for FILE */
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-#ifndef CMDLINE_PARSER_PACKAGE
-/** @brief the program name (used for printing errors) */
-#define CMDLINE_PARSER_PACKAGE "bsatool"
-#endif
-
-#ifndef CMDLINE_PARSER_PACKAGE_NAME
-/** @brief the complete program name (used for help and version) */
-#define CMDLINE_PARSER_PACKAGE_NAME "bsatool"
-#endif
-
-#ifndef CMDLINE_PARSER_VERSION
-/** @brief the program version */
-#define CMDLINE_PARSER_VERSION "1.0"
-#endif
-
-/** @brief Where the command line options are stored */
-struct gengetopt_args_info
-{
-  const char *help_help; /**< @brief Print help and exit help description.  */
-  const char *version_help; /**< @brief Print version and exit help description.  */
-  char * extract_arg;   /**< @brief Extract file from archive.  */
-  char * extract_orig;  /**< @brief Extract file from archive original value given at command line.  */
-  const char *extract_help; /**< @brief Extract file from archive help description.  */
-  const char *long_help; /**< @brief Include extra information in archive listing help description.  */
-
-  unsigned int help_given ; /**< @brief Whether help was given.  */
-  unsigned int version_given ;  /**< @brief Whether version was given.  */
-  unsigned int extract_given ;  /**< @brief Whether extract was given.  */
-  unsigned int long_given ; /**< @brief Whether long was given.  */
-
-  char **inputs ; /**< @brief unamed options (options without names) */
-  unsigned inputs_num ; /**< @brief unamed options number */
-} ;
-
-/** @brief The additional parameters to pass to parser functions */
-struct cmdline_parser_params
-{
-  int override; /**< @brief whether to override possibly already present options (default 0) */
-  int initialize; /**< @brief whether to initialize the option structure gengetopt_args_info (default 1) */
-  int check_required; /**< @brief whether to check that all required options were provided (default 1) */
-  int check_ambiguity; /**< @brief whether to check for options already specified in the option structure gengetopt_args_info (default 0) */
-  int print_errors; /**< @brief whether getopt_long should print an error message for a bad option (default 1) */
-} ;
-
-/** @brief the purpose string of the program */
-extern const char *gengetopt_args_info_purpose;
-/** @brief the usage string of the program */
-extern const char *gengetopt_args_info_usage;
-/** @brief all the lines making the help output */
-extern const char *gengetopt_args_info_help[];
-
-/**
- * The command line parser
- * @param argc the number of command line options
- * @param argv the command line options
- * @param args_info the structure where option information will be stored
- * @return 0 if everything went fine, NON 0 if an error took place
- */
-int cmdline_parser (int argc, char * const *argv,
-  struct gengetopt_args_info *args_info);
-
-/**
- * The command line parser (version with additional parameters - deprecated)
- * @param argc the number of command line options
- * @param argv the command line options
- * @param args_info the structure where option information will be stored
- * @param override whether to override possibly already present options
- * @param initialize whether to initialize the option structure my_args_info
- * @param check_required whether to check that all required options were provided
- * @return 0 if everything went fine, NON 0 if an error took place
- * @deprecated use cmdline_parser_ext() instead
- */
-int cmdline_parser2 (int argc, char * const *argv,
-  struct gengetopt_args_info *args_info,
-  int override, int initialize, int check_required);
-
-/**
- * The command line parser (version with additional parameters)
- * @param argc the number of command line options
- * @param argv the command line options
- * @param args_info the structure where option information will be stored
- * @param params additional parameters for the parser
- * @return 0 if everything went fine, NON 0 if an error took place
- */
-int cmdline_parser_ext (int argc, char * const *argv,
-  struct gengetopt_args_info *args_info,
-  struct cmdline_parser_params *params);
-
-/**
- * Save the contents of the option struct into an already open FILE stream.
- * @param outfile the stream where to dump options
- * @param args_info the option struct to dump
- * @return 0 if everything went fine, NON 0 if an error took place
- */
-int cmdline_parser_dump(FILE *outfile,
-  struct gengetopt_args_info *args_info);
-
-/**
- * Save the contents of the option struct into a (text) file.
- * This file can be read by the config file parser (if generated by gengetopt)
- * @param filename the file where to save
- * @param args_info the option struct to save
- * @return 0 if everything went fine, NON 0 if an error took place
- */
-int cmdline_parser_file_save(const char *filename,
-  struct gengetopt_args_info *args_info);
-
-/**
- * Print the help
- */
-void cmdline_parser_print_help(void);
-/**
- * Print the version
- */
-void cmdline_parser_print_version(void);
-
-/**
- * Initializes all the fields a cmdline_parser_params structure
- * to their default values
- * @param params the structure to initialize
- */
-void cmdline_parser_params_init(struct cmdline_parser_params *params);
-
-/**
- * Allocates dynamically a cmdline_parser_params structure and initializes
- * all its fields to their default values
- * @return the created and initialized cmdline_parser_params structure
- */
-struct cmdline_parser_params *cmdline_parser_params_create(void);
-
-/**
- * Initializes the passed gengetopt_args_info structure's fields
- * (also set default values for options that have a default)
- * @param args_info the structure to initialize
- */
-void cmdline_parser_init (struct gengetopt_args_info *args_info);
-/**
- * Deallocates the string fields of the gengetopt_args_info structure
- * (but does not deallocate the structure itself)
- * @param args_info the structure to deallocate
- */
-void cmdline_parser_free (struct gengetopt_args_info *args_info);
-
-/**
- * Checks that all the required options were specified
- * @param args_info the structure to check
- * @param prog_name the name of the program that will be used to print
- *   possible errors
- * @return
- */
-int cmdline_parser_required (struct gengetopt_args_info *args_info,
-  const char *prog_name);
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* BSATOOL_CMD_H */