Some fs/ cleanup.

src/xenia/kernel/fs/gdfx.cc

@@ -13,21 +13,14 @@
 
 #include <poly/math.h>
 
-using namespace xe;
-using namespace xe::kernel;
-using namespace xe::kernel::fs;
+namespace xe {
+namespace kernel {
+namespace fs {
 
+const size_t kXESectorSize = 2048;
 
-namespace {
-
-#define kXESectorSize   2048
-
-}
-
-
-GDFXEntry::GDFXEntry() :
-    attributes(X_FILE_ATTRIBUTE_NONE), offset(0), size(0) {
-}
+GDFXEntry::GDFXEntry()
+    : attributes(X_FILE_ATTRIBUTE_NONE), offset(0), size(0) {}
 
 GDFXEntry::~GDFXEntry() {
   for (std::vector<GDFXEntry*>::iterator it = children.begin();
@@ -57,7 +50,6 @@ void GDFXEntry::Dump(int indent) {
   }
 }
 
-
 GDFX::GDFX(xe_mmap_ref mmap) {
   mmap_ = xe_mmap_retain(mmap);
 
@@ -70,28 +62,26 @@ GDFX::~GDFX() {
   xe_mmap_release(mmap_);
 }
 
-GDFXEntry* GDFX::root_entry() {
-  return root_entry_;
-}
+GDFXEntry* GDFX::root_entry() { return root_entry_; }
 
 GDFX::Error GDFX::Load() {
-  Error result = kErrorOutOfMemory;
-
   ParseState state;
   xe_zero_struct(&state, sizeof(state));
 
-  state.ptr   = (uint8_t*)xe_mmap_get_addr(mmap_);
-  state.size  = xe_mmap_get_length(mmap_);
+  state.ptr = (uint8_t*)xe_mmap_get_addr(mmap_);
+  state.size = xe_mmap_get_length(mmap_);
 
-  result = Verify(state);
-  XEEXPECTZERO(result);
+  auto result = Verify(state);
+  if (result != kSuccess) {
+    return result;
+  }
 
   result = ReadAllEntries(state, state.ptr + state.root_offset);
-  XEEXPECTZERO(result);
+  if (result != kSuccess) {
+    return result;
+  }
 
-  result = kSuccess;
-XECLEANUP:
-  return result;
+  return kSuccess;
 }
 
 void GDFX::Dump() {
@@ -103,7 +93,7 @@ void GDFX::Dump() {
 GDFX::Error GDFX::Verify(ParseState& state) {
   // Find sector 32 of the game partition - try at a few points.
   const static size_t likely_offsets[] = {
-    0x00000000, 0x0000FB20, 0x00020600, 0x0FD90000,
+      0x00000000, 0x0000FB20, 0x00020600, 0x0FD90000,
   };
   bool magic_found = false;
   for (size_t n = 0; n < poly::countof(likely_offsets); n++) {
@@ -124,10 +114,9 @@ GDFX::Error GDFX::Verify(ParseState& state) {
   }
   uint8_t* fs_ptr = state.ptr + state.game_offset + (32 * kXESectorSize);
   state.root_sector = poly::load<uint32_t>(fs_ptr + 20);
-  state.root_size   = poly::load<uint32_t>(fs_ptr + 24);
+  state.root_size = poly::load<uint32_t>(fs_ptr + 24);
   state.root_offset = state.game_offset + (state.root_sector * kXESectorSize);
-  if (state.root_size < 13 ||
-      state.root_size > 32 * 1024 * 1024) {
+  if (state.root_size < 13 || state.root_size > 32 * 1024 * 1024) {
     return kErrorDamagedFile;
   }
 
@@ -143,8 +132,8 @@ GDFX::Error GDFX::ReadAllEntries(ParseState& state,
                                  const uint8_t* root_buffer) {
   root_entry_ = new GDFXEntry();
   root_entry_->offset = 0;
-  root_entry_->size   = 0;
-  root_entry_->name   = "";
+  root_entry_->size = 0;
+  root_entry_->name = "";
   root_entry_->attributes = X_FILE_ATTRIBUTE_DIRECTORY;
 
   if (!ReadEntry(state, root_buffer, 0, root_entry_)) {
@@ -158,13 +147,13 @@ bool GDFX::ReadEntry(ParseState& state, const uint8_t* buffer,
                      uint16_t entry_ordinal, GDFXEntry* parent) {
   const uint8_t* p = buffer + (entry_ordinal * 4);
 
-  uint16_t  node_l      = poly::load<uint16_t>(p + 0);
-  uint16_t  node_r      = poly::load<uint16_t>(p + 2);
-  size_t    sector      = poly::load<uint32_t>(p + 4);
-  size_t    length      = poly::load<uint32_t>(p + 8);
-  uint8_t   attributes  = poly::load<uint8_t>(p + 12);
-  uint8_t   name_length = poly::load<uint8_t>(p + 13);
-  char*     name        = (char*)(p + 14);
+  uint16_t node_l = poly::load<uint16_t>(p + 0);
+  uint16_t node_r = poly::load<uint16_t>(p + 2);
+  size_t sector = poly::load<uint32_t>(p + 4);
+  size_t length = poly::load<uint32_t>(p + 8);
+  uint8_t attributes = poly::load<uint8_t>(p + 12);
+  uint8_t name_length = poly::load<uint8_t>(p + 13);
+  char* name = (char*)(p + 14);
 
   if (node_l && !ReadEntry(state, buffer, node_l, parent)) {
     return false;
@@ -181,7 +170,7 @@ bool GDFX::ReadEntry(ParseState& state, const uint8_t* buffer,
   if (attributes & X_FILE_ATTRIBUTE_DIRECTORY) {
     // Folder.
     entry->offset = 0;
-    entry->size   = 0;
+    entry->size = 0;
     if (length) {
       // Not a leaf - read in children.
       if (state.size < state.game_offset + (sector * kXESectorSize)) {
@@ -198,7 +187,7 @@ bool GDFX::ReadEntry(ParseState& state, const uint8_t* buffer,
   } else {
     // File.
     entry->offset = state.game_offset + (sector * kXESectorSize);
-    entry->size   = length;
+    entry->size = length;
   }
 
   // Read next file in the list.
@@ -208,3 +197,7 @@ bool GDFX::ReadEntry(ParseState& state, const uint8_t* buffer,
 
   return true;
 }
+
+}  // namespace fs
+}  // namespace kernel
+}  // namespace xe