trapexit · trapexit · Sep 6, 2022 · Sep 6, 2022
diff --git a/src/main.cpp b/src/main.cpp
@@ -50,6 +50,12 @@ generate_list_argparser(CLI::App      &app_,
     ->required();
   subcmd->add_option("prefix-filter",options_.prefix_filter)
     ->description("filter out paths with shared starting path");
+  subcmd->add_option("-f,--format",options_.format)
+    ->description("output format")
+    ->type_name("TEXT")
+    ->default_val("default")
+    ->take_last()
+    ->check(CLI::IsMember({"default","file-offsets","block-offsets"}));
 
   subcmd->callback(std::bind(Subcommand::list,std::cref(options_)));
 }

diff --git a/src/options.hpp b/src/options.hpp
@@ -33,6 +33,7 @@ struct Options
   {
     Path filepath;
     Path prefix_filter;
+    std::string format;
   };
 
   struct Info

diff --git a/src/subcommand_list.cpp b/src/subcommand_list.cpp
@@ -25,6 +25,8 @@
 #include <fstream>
 
 namespace fs = std::filesystem;
+typedef std::function<void(const fs::path&,const TDO::DirectoryRecord&,const uint32_t,TDO::DevStream&)> Printer;
+
 
 static
 bool
@@ -48,55 +50,159 @@ starts_with(const fs::path &base_,
   return (biter == biter_end);
 }
 
+static
+void
+default_header()
+{
+    fmt::print("Flags      Size         ID Type Filename\n");
+}
+
+static
+void
+default_printer(const fs::path             &filepath_,
+                const TDO::DirectoryRecord &record_,
+                const uint32_t              record_pos_,
+                TDO::DevStream             &stream_)
+{
+  char dir_char;
+  char readonly_char;
+  char for_fs_char;
+
+  dir_char      = (record_.is_directory() ? 'd' : '-');
+  readonly_char = (record_.is_readonly() ? 'r' : '-');
+  for_fs_char   = (record_.is_for_fs() ? 'f' : '-');
+  fmt::print("{}{}{} {:11L} {:#010x} {:4s} {}\n",
+             dir_char,
+             readonly_char,
+             for_fs_char,
+             record_.byte_count,
+             record_.unique_identifier,
+             record_.type_str(),
+             filepath_);
+}
+
+static
+void
+offset_header()
+{
+    fmt::print("Flags      Size         ID Type  RecOffset     Avatar Filename\n");
+}
+
+static
+void
+file_offset_printer(const fs::path             &filepath_,
+                    const TDO::DirectoryRecord &record_,
+                    const uint32_t              record_pos_,
+                    TDO::DevStream             &stream_)
+{
+  char dir_char;
+  char readonly_char;
+  char for_fs_char;
+  std::uint32_t avatar;
+
+  dir_char      = (record_.is_directory() ? 'd' : '-');
+  readonly_char = (record_.is_readonly() ? 'r' : '-');
+  for_fs_char   = (record_.is_for_fs() ? 'f' : '-');
+  avatar = (stream_.data_offset() + (record_.avatar_list[0] * stream_.device_block_size()));
+  fmt::print("{}{}{} {:11L} {:#010x} {:4s} {:#010x} {:#010x} {}\n",
+             dir_char,
+             readonly_char,
+             for_fs_char,
+             record_.byte_count,
+             record_.unique_identifier,
+             record_.type_str(),
+             record_pos_,
+             avatar,
+             filepath_);
+}
+
+static
+void
+block_offset_printer(const fs::path             &filepath_,
+                     const TDO::DirectoryRecord &record_,
+                     const uint32_t              record_pos_,
+                     TDO::DevStream             &stream_)
+{
+  char dir_char;
+  char readonly_char;
+  char for_fs_char;
+
+  dir_char      = (record_.is_directory() ? 'd' : '-');
+  readonly_char = (record_.is_readonly() ? 'r' : '-');
+  for_fs_char   = (record_.is_for_fs() ? 'f' : '-');
+  fmt::print("{}{}{} {:11L} {:#010x} {:4s} {:#010x} {:#010x} {}\n",
+             dir_char,
+             readonly_char,
+             for_fs_char,
+             record_.byte_count,
+             record_.unique_identifier,
+             record_.type_str(),
+             record_pos_ / stream_.device_block_size(),
+             record_.avatar_list[0],
+             filepath_);
+}
+
 class ListCallbacks final : public TDO::FSWalker::Callbacks
 {
+public:
+  ListCallbacks(const Options::List &opts_)
+    : base_filter(opts_.prefix_filter)
+  {
+    _header  = ::default_header;
+    _printer = ::default_printer;
+
+    if(opts_.format == "file-offsets")
+      {
+        _header  = ::offset_header;
+        _printer = ::file_offset_printer;
+      }
+    else if(opts_.format == "block-offsets")
+      {
+        _header  = ::offset_header;
+        _printer = ::block_offset_printer;
+      }
+  }
+
+public:
+  void
+  begin()
+  {
+    _header();
+  }
+
 public:
   void
   operator()(const std::filesystem::path &filepath_,
              const TDO::DirectoryRecord  &record_,
+             const uint32_t               record_pos_,
              TDO::DevStream              &stream_)
   {
-    char dir_char;
-    char readonly_char;
-    char for_fs_char;
-
     if(!starts_with(base_filter,filepath_))
       return;
 
-    dir_char      = (record_.is_directory() ? 'd' : '-');
-    readonly_char = (record_.is_readonly() ? 'r' : '-');
-    for_fs_char   = (record_.is_for_fs() ? 'f' : '-');
-    fmt::print("{}{}{} {:11L} {:#010x} {:#010x} ({:4s}) {}\n",
-               dir_char,
-               readonly_char,
-               for_fs_char,
-               record_.byte_count,
-               record_.unique_identifier,
-               record_.type,
-               record_.type_str(),
-               filepath_);
+    _printer(filepath_,record_,record_pos_,stream_);
   }
 
 public:
   fs::path base_filter;
+  Printer _printer;
+  std::function<void()> _header;
 };
 
 
 namespace Subcommand
 {
   void
-  list(const Options::List &options_)
+  list(const Options::List &opts_)
   {
     Error err;
     std::ifstream ifs;
-    ListCallbacks callbacks;
+    ListCallbacks callbacks(opts_);
     TDO::FSWalker walker(ifs,callbacks);
 
-    callbacks.base_filter = options_.prefix_filter;
-
-    ifs.open(options_.filepath,std::ios::binary);
+    ifs.open(opts_.filepath,std::ios::binary);
     if(!ifs.good())
-      return  Log::error_stream_open(options_.filepath);
+      return  Log::error_stream_open(opts_.filepath);
 
     err = walker.walk();
     if(err)

diff --git a/src/tdo_dev_stream.cpp b/src/tdo_dev_stream.cpp
@@ -148,6 +148,12 @@ TDO::DevStream::is_romfs() const
           (_device_block_footer    == 0));
 }
 
+std::uint32_t
+TDO::DevStream::data_offset() const
+{
+  return _data_offset;
+}
+
 std::uint32_t
 TDO::DevStream::device_block_header() const
 {
@@ -190,15 +196,15 @@ TDO::DevStream::file_tell() const
 }
 
 std::int64_t
-TDO::DevStream::data_byte_tell() const
+TDO::DevStream::data_byte_tell(const std::int64_t pos_) const
 {
   assert(_initialized == true);
 
   std::int64_t pos;
   std::int64_t block;
   std::int64_t extra;
 
-  pos   = file_tell();
+  pos   = pos_;
   block = (pos / device_block_size());
   extra = (pos % device_block_size());
 
@@ -209,6 +215,16 @@ TDO::DevStream::data_byte_tell() const
   return pos;
 }
 
+std::int64_t
+TDO::DevStream::data_byte_tell() const
+{
+  std::int64_t pos;
+
+  pos = file_tell();
+
+  return data_byte_tell(pos);
+}
+
 void
 TDO::DevStream::file_seek(const std::int64_t pos_)
 {

diff --git a/src/tdo_dev_stream.hpp b/src/tdo_dev_stream.hpp
@@ -45,7 +45,7 @@ namespace TDO
     std::istream &istream() { return _is; }
 
   public:
-    void data_offset(const std::uint32_t);
+    std::uint32_t data_offset() const;
     std::uint32_t device_block_size() const;
     std::uint32_t device_block_header() const;
     std::uint32_t device_block_footer() const;
@@ -62,7 +62,10 @@ namespace TDO
 
   public:
     std::int64_t file_tell() const;
+    std::int64_t data_byte_tell(std::int64_t) const;
     std::int64_t data_byte_tell() const;
+    std::int64_t data_block_tell(std::int64_t) const;
+    std::int64_t data_block_tell() const;
 
   public:
     void read(char *buf, uint32_t size);