Split the cart parsing and loading steps (#1707)

* Split ROMList into a .cpp file

- Its definition in ROMList.h was causing multiple-definition linker errors
- Introduce ROMListSize, since you can't take a sizeof() of an extern declaration
- Mark ROMList and ROMListSize as const

* Update ReadROMParams to accommodate ROMList changes

* Split parsing and loading of NDS ROMs

- Introduce an NDSCartData class for parsing a ROM file
- Introduce InsertROM for loading a NDS cart
- Refactor LoadROM to use NDSCartData and InsertROM under the hood

* Reset cart state and initialize save memory in the NDSCartData constructor

- Otherwise there's no way to know about SRAM-specific attributes before inserting the game

* Add a comment to NDSCartData

* First crack at splitting parsing and loading for GBACart

* Add some logging calls for encrypting the secure area

* Log the XXH64 hash of the inserted NDS ROM

* Log the XXH64 hash of the secure area after decryption

* Add some logging to Key1_LoadKeyBuf

* Re-encrypt the secure area when inserting the cart, not when parsing it

- This way, constructing a NDSCart doesn't imply a read from the filesystem (as is done in Key1_KeyBuf)

* Load Key1_KeyBuf from memory, not from the file system

- Now that the cart's secure area isn't re-encrypted until insertion, we can expect that the BIOS will be ready at this point

* Add some helper query methods to NDSHeader

* Query the DSi region directly from the header instead of checking the ROM again

* Introduce a CartType enum

- So CartCommon::Type doesn't have to return magic numbers

* Reset the cart in NDSCart::InsertROM instead of the NDSCartData constructor

- That way the constructor doesn't rely on the config or on file I/O when loading homebrew
- This keeps the use of global state closer to one place

* Add non-const getters for the carts

* Add InsertROM overloads that accept unique_ptrs

* Fix a comment

* Rename member functions on NDSCartData and GBACartData to adhere to the convention

* Rename members on NDSCartData and GBACartData to adhere to the convention

* Fix build errors on some platforms

* Add NDSHeader::IsDSiWare

* Add a ROMListEntry parameter to the cart constructors

- To allow for looking up details of SRAM or expected ROM size

* Add some new getters to CartCommon

* Use the Header/Banner members instead of globals

* Make CartCommon abstract

- It's not supposed to be instantiated anyway

* Change the signature of CartCommon::Checksum

- It's neither overridden nor mutating

* Add some clarifying comments to NDSHeader

* Delete CartCommon::ROM in its destructor

- ParseROM copies its input and gives that copy to the cart object, so it's okay

* Add some getters to CartCommon

* Refactor NDSCart

- Get rid of NDSCartData
- Get rid of cart-specific global state within NDSCart (so registers are untouched)
- Refactor uses of removed global variables to use the Cart pointer instead
- Refactor ROMInfoDialog's icon functions to accept const arguments

* Return the cart pointer

- So *that's* why it was crashing. Whoops
- Why is this even allowed?

* Refactor GBACart

- Delete CartGame::ROM in the destructor
- Get rid of GBACartData
- Remove some global state

* Mark NDSCart::CartCommon::Type as const

* Slightly refactor GBACart::CartCommon

- Mark Type as const
- Use enum constants
- Make CartCommon itself abstract

* Mark CRC32's data parameter as const

* Mark GBACart::CartCommon::Checksum as const

* Use assert.h instead of cassert

- As demanded by the style guide

* Fix some includes to adhere to the style guide

* Get the ARM9 entry address directly from the header object

* Use more Header fields directly

* Rename some parameters to match the style guide

* Remove some unused includes

* Slightly change NDS_Header::IsHomebrew for clarity

src/GBACart.h

@@ -19,12 +19,21 @@
 #ifndef GBACART_H
 #define GBACART_H
 
+#include <memory>
 #include "types.h"
 #include "Savestate.h"
 
 namespace GBACart
 {
 
+enum CartType
+{
+    Default = 0x001,
+    Game = 0x101,
+    GameSolarSensor = 0x102,
+    RAMExpansion = 0x201,
+};
+
 // CartCommon -- base code shared by all cart types
 class CartCommon
 {
@@ -32,8 +41,8 @@ public:
     CartCommon();
     virtual ~CartCommon();
 
-    virtual u32 Type() { return 0x001; }
-    virtual u32 Checksum() { return 0; }
+    virtual u32 Type() const = 0;
+    virtual u32 Checksum() const { return 0; }
 
     virtual void Reset();
 
@@ -50,6 +59,9 @@ public:
     virtual u8 SRAMRead(u32 addr);
     virtual void SRAMWrite(u32 addr, u8 val);
 
+    [[nodiscard]] virtual const u8* GetROM() const { return nullptr; }
+    [[nodiscard]] virtual u32 GetROMLength() const { return 0; }
+
     virtual u8* GetSaveMemory() const;
     virtual u32 GetSaveMemoryLength() const;
 };
@@ -61,8 +73,8 @@ public:
     CartGame(u8* rom, u32 len);
     virtual ~CartGame() override;
 
-    virtual u32 Type() override { return 0x101; }
-    virtual u32 Checksum() override;
+    virtual u32 Type() const override { return CartType::Game; }
+    virtual u32 Checksum() const override;
 
     virtual void Reset() override;
 
@@ -77,6 +89,9 @@ public:
     virtual u8 SRAMRead(u32 addr) override;
     virtual void SRAMWrite(u32 addr, u8 val) override;
 
+    [[nodiscard]] const u8* GetROM() const override { return ROM; }
+    [[nodiscard]] u32 GetROMLength() const override { return ROMLength; }
+
     virtual u8* GetSaveMemory() const override;
     virtual u32 GetSaveMemoryLength() const override;
 protected:
@@ -133,7 +148,7 @@ public:
     CartGameSolarSensor(u8* rom, u32 len);
     virtual ~CartGameSolarSensor() override;
 
-    virtual u32 Type() override { return 0x102; }
+    virtual u32 Type() const override { return CartType::GameSolarSensor; }
 
     virtual void Reset() override;
 
@@ -159,7 +174,7 @@ public:
     CartRAMExpansion();
     ~CartRAMExpansion() override;
 
-    virtual u32 Type() override { return 0x201; }
+    virtual u32 Type() const override { return CartType::RAMExpansion; }
 
     void Reset() override;
 
@@ -180,9 +195,7 @@ enum
     Input_SolarSensorUp,
 };
 
-extern bool CartInserted;
-extern u8* CartROM;
-extern u32 CartROMSize;
+extern std::unique_ptr<CartCommon> Cart;
 
 bool Init();
 void DeInit();
@@ -190,6 +203,20 @@ void Reset();
 
 void DoSavestate(Savestate* file);
 
+/// Parses the given ROM data and constructs a \c GBACart::CartCommon subclass
+/// that can be inserted into the emulator or used to extract information about the cart beforehand.
+/// @param romdata The ROM data to parse.
+/// The returned cartridge will contain a copy of this data,
+/// so the caller may deallocate \c romdata after this function returns.
+/// @param romlen The length of the ROM data in bytes.
+/// @returns A \c GBACart::CartCommon object representing the parsed ROM,
+/// or \c nullptr if the ROM data couldn't be parsed.
+std::unique_ptr<CartCommon> ParseROM(const u8* romdata, u32 romlen);
+
+/// Applies the GBACartData to the emulator state and unloads an existing ROM if any.
+/// Upon successful insertion, \c cart will be nullptr and the global GBACart state
+/// (\c CartROM, CartInserted, etc.) will be updated.
+bool InsertROM(std::unique_ptr<CartCommon>&& cart);
 bool LoadROM(const u8* romdata, u32 romlen);
 void LoadSave(const u8* savedata, u32 savelen);