Added API scanner tool

New tool for issue #171 which links to libxenia to dump the API usage
from packaged content

src/xenia/kernel/fs/devices/stfs_container_device.cc

@@ -39,7 +39,7 @@ int STFSContainerDevice::Init() {
     return 1;
   }
 
-  stfs_->Dump();
+  //stfs_->Dump();
 
   return 0;
 }

src/xenia/kernel/xam_module.cc

@@ -19,26 +19,36 @@ namespace kernel {
 
 XamModule::XamModule(Emulator* emulator, KernelState* kernel_state)
     : XKernelModule(kernel_state, "xe:\\xam.xex") {
-// Build the export table used for resolution.
+  RegisterExportTable(export_resolver_);
+
+  // Register all exported functions.
+  xam::RegisterContentExports(export_resolver_, kernel_state_);
+  xam::RegisterInfoExports(export_resolver_, kernel_state_);
+  xam::RegisterInputExports(export_resolver_, kernel_state_);
+  xam::RegisterMsgExports(export_resolver_, kernel_state_);
+  xam::RegisterNetExports(export_resolver_, kernel_state_);
+  xam::RegisterNotifyExports(export_resolver_, kernel_state_);
+  xam::RegisterUIExports(export_resolver_, kernel_state_);
+  xam::RegisterUserExports(export_resolver_, kernel_state_);
+  xam::RegisterVideoExports(export_resolver_, kernel_state_);
+  xam::RegisterVoiceExports(export_resolver_, kernel_state_);
+}
+
+void XamModule::RegisterExportTable(ExportResolver* export_resolver) {
+  assert_not_null(export_resolver);
+
+  if (!export_resolver) {
+    return;
+  }
+
+  // Build the export table used for resolution.
 #include "xenia/kernel/util/export_table_pre.inc"
   static KernelExport xam_export_table[] = {
 #include "xenia/kernel/xam_table.inc"
   };
 #include "xenia/kernel/util/export_table_post.inc"
-  export_resolver_->RegisterTable("xam.xex", xam_export_table,
-                                  poly::countof(xam_export_table));
-
-  // Register all exported functions.
-  xam::RegisterContentExports(export_resolver_, kernel_state);
-  xam::RegisterInfoExports(export_resolver_, kernel_state);
-  xam::RegisterInputExports(export_resolver_, kernel_state);
-  xam::RegisterMsgExports(export_resolver_, kernel_state);
-  xam::RegisterNetExports(export_resolver_, kernel_state);
-  xam::RegisterNotifyExports(export_resolver_, kernel_state);
-  xam::RegisterUIExports(export_resolver_, kernel_state);
-  xam::RegisterUserExports(export_resolver_, kernel_state);
-  xam::RegisterVideoExports(export_resolver_, kernel_state);
-  xam::RegisterVoiceExports(export_resolver_, kernel_state);
+  export_resolver->RegisterTable("xam.xex", xam_export_table,
+    poly::countof(xam_export_table));
 }
 
 XamModule::~XamModule() {}

src/xenia/kernel/xam_module.h

@@ -23,6 +23,7 @@ class XamModule : public XKernelModule {
   XamModule(Emulator* emulator, KernelState* kernel_state);
   virtual ~XamModule();
 
+  static void RegisterExportTable(ExportResolver* export_resolver);
  private:
 };
 

src/xenia/kernel/xboxkrnl_module.cc

@@ -26,30 +26,23 @@ namespace kernel {
 XboxkrnlModule::XboxkrnlModule(Emulator* emulator, KernelState* kernel_state)
     : XKernelModule(kernel_state, "xe:\\xboxkrnl.exe"),
       timestamp_timer_(nullptr) {
-// Build the export table used for resolution.
-#include "xenia/kernel/util/export_table_pre.inc"
-  static KernelExport xboxkrnl_export_table[] = {
-#include "xenia/kernel/xboxkrnl_table.inc"
-  };
-#include "xenia/kernel/util/export_table_post.inc"
-  export_resolver_->RegisterTable("xboxkrnl.exe", xboxkrnl_export_table,
-                                  poly::countof(xboxkrnl_export_table));
+  RegisterExportTable(export_resolver_);
 
   // Register all exported functions.
-  xboxkrnl::RegisterAudioExports(export_resolver_, kernel_state);
-  xboxkrnl::RegisterAudioXmaExports(export_resolver_, kernel_state);
-  xboxkrnl::RegisterDebugExports(export_resolver_, kernel_state);
-  xboxkrnl::RegisterHalExports(export_resolver_, kernel_state);
-  xboxkrnl::RegisterIoExports(export_resolver_, kernel_state);
-  xboxkrnl::RegisterMemoryExports(export_resolver_, kernel_state);
-  xboxkrnl::RegisterMiscExports(export_resolver_, kernel_state);
-  xboxkrnl::RegisterModuleExports(export_resolver_, kernel_state);
-  xboxkrnl::RegisterObExports(export_resolver_, kernel_state);
+  xboxkrnl::RegisterAudioExports(export_resolver_, kernel_state_);
+  xboxkrnl::RegisterAudioXmaExports(export_resolver_, kernel_state_);
+  xboxkrnl::RegisterDebugExports(export_resolver_, kernel_state_);
+  xboxkrnl::RegisterHalExports(export_resolver_, kernel_state_);
+  xboxkrnl::RegisterIoExports(export_resolver_, kernel_state_);
+  xboxkrnl::RegisterMemoryExports(export_resolver_, kernel_state_);
+  xboxkrnl::RegisterMiscExports(export_resolver_, kernel_state_);
+  xboxkrnl::RegisterModuleExports(export_resolver_, kernel_state_);
+  xboxkrnl::RegisterObExports(export_resolver_, kernel_state_);
   xboxkrnl::RegisterRtlExports(export_resolver_, kernel_state_);
   xboxkrnl::RegisterStringExports(export_resolver_, kernel_state_);
-  xboxkrnl::RegisterThreadingExports(export_resolver_, kernel_state);
-  xboxkrnl::RegisterUsbcamExports(export_resolver_, kernel_state);
-  xboxkrnl::RegisterVideoExports(export_resolver_, kernel_state);
+  xboxkrnl::RegisterThreadingExports(export_resolver_, kernel_state_);
+  xboxkrnl::RegisterUsbcamExports(export_resolver_, kernel_state_);
+  xboxkrnl::RegisterVideoExports(export_resolver_, kernel_state_);
 
   uint8_t* mem = memory_->membase();
 
@@ -149,6 +142,23 @@ XboxkrnlModule::XboxkrnlModule(Emulator* emulator, KernelState* kernel_state)
                         WT_EXECUTEINTIMERTHREAD);
 }
 
+void XboxkrnlModule::RegisterExportTable(ExportResolver* export_resolver) {
+  assert_not_null(export_resolver);
+
+  if (!export_resolver) {
+    return;
+  }
+
+  // Build the export table used for resolution.
+#include "xenia/kernel/util/export_table_pre.inc"
+  static KernelExport xboxkrnl_export_table[] = {
+#include "xenia/kernel/xboxkrnl_table.inc"
+  };
+#include "xenia/kernel/util/export_table_post.inc"
+  export_resolver->RegisterTable("xboxkrnl.exe", xboxkrnl_export_table,
+    poly::countof(xboxkrnl_export_table));
+}
+
 XboxkrnlModule::~XboxkrnlModule() {
   DeleteTimerQueueTimer(nullptr, timestamp_timer_, nullptr);
 }

src/xenia/kernel/xboxkrnl_module.h

@@ -28,6 +28,8 @@ class XboxkrnlModule : public XKernelModule {
   XboxkrnlModule(Emulator* emulator, KernelState* kernel_state);
   virtual ~XboxkrnlModule();
 
+  static void RegisterExportTable(ExportResolver* export_resolver);
+
   int LaunchModule(const char* path);
 
  private:

src/xenia/kernel/xobject.cc

@@ -23,7 +23,11 @@ XObject::XObject(KernelState* kernel_state, Type type)
       pointer_ref_count_(1),
       type_(type),
       handle_(X_INVALID_HANDLE_VALUE) {
-  kernel_state->object_table()->AddHandle(this, &handle_);
+
+  // Added pointer check to support usage without a kernel_state
+  if (kernel_state != nullptr){
+    kernel_state->object_table()->AddHandle(this, &handle_);
+  }
 }
 
 XObject::~XObject() {
@@ -56,10 +60,15 @@ void XObject::Release() {
 }
 
 X_STATUS XObject::Delete() {
-  if (!name_.empty()) {
-    kernel_state_->object_table()->RemoveNameMapping(name_);
+  if (kernel_state_ == nullptr) {
+    // Fake return value for api-scanner
+    return X_STATUS_SUCCESS;
+  } else {
+    if (!name_.empty()) {
+      kernel_state_->object_table()->RemoveNameMapping(name_);
+    }
+    return kernel_state_->object_table()->RemoveHandle(handle_);
   }
-  return kernel_state_->object_table()->RemoveHandle(handle_);
 }
 
 void XObject::SetAttributes(const uint8_t* obj_attrs_ptr) {