ShuriZma
/
mgba
mirror of https://github.com/mgba-emu/mgba.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

All: Fix several memory leaks

This commit is contained in:
Vicki Pfau 2019-04-22 13:59:39 -07:00
parent 04f8597942
commit a32cb5cc5e
13 changed files with 74 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGES
View File

@ -28,6 +28,7 @@ Other fixes:
- Qt: Fix crash in sprite viewer magnification (fixes mgba.io/i/1362) - Qt: Fix crash in sprite viewer magnification (fixes mgba.io/i/1362)
- 3DS: Ensure core 2 can be used for threaded renderer (fixes mgba.io/i/1371) - 3DS: Ensure core 2 can be used for threaded renderer (fixes mgba.io/i/1371)
- GB Core: Fix toggling WIN and OBJ being swapped - GB Core: Fix toggling WIN and OBJ being swapped
- All: Fix several memory leaks
Misc: Misc:
- GBA Savedata: EEPROM performance fixes - GBA Savedata: EEPROM performance fixes
- GBA Savedata: Automatically map 1Mbit Flash files as 1Mbit Flash - GBA Savedata: Automatically map 1Mbit Flash files as 1Mbit Flash

1
src/core/cheats.c
View File

@ -90,6 +90,7 @@ void mCheatSetDeinit(struct mCheatSet* set) {
if (set->name) { if (set->name) {
free(set->name); free(set->name);
} }
StringListDeinit(&set->lines);
set->deinit(set); set->deinit(set);
free(set); free(set);
} }

28
src/debugger/test/parser.c
View File

@ -21,16 +21,16 @@ struct LPTest {
struct ParseTree* tree = &lp->tree; \ struct ParseTree* tree = &lp->tree; \
parseLexedExpression(tree, &lp->lv) parseLexedExpression(tree, &lp->lv)
M_TEST_SUITE_SETUP(Parser) { static int parseSetup(void** state) {
struct LPTest* lp = malloc(sizeof(struct LPTest)); struct LPTest* lp = malloc(sizeof(struct LPTest));
LexVectorInit(&lp->lv, 0); LexVectorInit(&lp->lv, 0);
*state = lp; *state = lp;
return 0; return 0;
} }
M_TEST_SUITE_TEARDOWN(Parser) { static int parseTeardown(void** state) {
struct LPTest* lp = *state; struct LPTest* lp = *state;
parseFree(&lp->tree); \ parseFree(&lp->tree);
lexFree(&lp->lv); lexFree(&lp->lv);
LexVectorDeinit(&lp->lv); LexVectorDeinit(&lp->lv);
free(lp); free(lp);
@ -135,14 +135,14 @@ M_TEST_DEFINE(parseUnaryChainedOperator) {
assert_int_equal(tree->rhs->rhs->token.uintValue, 2); assert_int_equal(tree->rhs->rhs->token.uintValue, 2);
} }
M_TEST_SUITE_DEFINE_SETUP_TEARDOWN(Parser, M_TEST_SUITE_DEFINE(Parser,
cmocka_unit_test(parseEmpty), cmocka_unit_test_setup_teardown(parseEmpty, parseSetup, parseTeardown),
cmocka_unit_test(parseInt), cmocka_unit_test_setup_teardown(parseInt, parseSetup, parseTeardown),
cmocka_unit_test(parseLexError), cmocka_unit_test_setup_teardown(parseLexError, parseSetup, parseTeardown),
cmocka_unit_test(parseError), cmocka_unit_test_setup_teardown(parseError, parseSetup, parseTeardown),
cmocka_unit_test(parseSimpleExpression), cmocka_unit_test_setup_teardown(parseSimpleExpression, parseSetup, parseTeardown),
cmocka_unit_test(parseAddMultplyExpression), cmocka_unit_test_setup_teardown(parseAddMultplyExpression, parseSetup, parseTeardown),
cmocka_unit_test(parseParentheticalExpression), cmocka_unit_test_setup_teardown(parseParentheticalExpression, parseSetup, parseTeardown),
cmocka_unit_test(parseParentheticalAddMultplyExpression), cmocka_unit_test_setup_teardown(parseParentheticalAddMultplyExpression, parseSetup, parseTeardown),
cmocka_unit_test(parseIsolatedOperator), cmocka_unit_test_setup_teardown(parseIsolatedOperator, parseSetup, parseTeardown),
cmocka_unit_test(parseUnaryChainedOperator)) cmocka_unit_test_setup_teardown(parseUnaryChainedOperator, parseSetup, parseTeardown))

2
src/feature/gui/gui-runner.c
View File

@ -362,6 +362,7 @@ void mGUIRun(struct mGUIRunner* runner, const char* path) {
found = mCoreLoadFile(runner->core, path); found = mCoreLoadFile(runner->core, path);
if (!found) { if (!found) {
mLOG(GUI_RUNNER, WARN, "Failed to load %s!", path); mLOG(GUI_RUNNER, WARN, "Failed to load %s!", path);
mCoreConfigDeinit(&runner->core->config);
runner->core->deinit(runner->core); runner->core->deinit(runner->core);
} }
} }
@ -606,6 +607,7 @@ void mGUIRun(struct mGUIRunner* runner, const char* path) {
} }
mInputMapDeinit(&runner->core->inputMap); mInputMapDeinit(&runner->core->inputMap);
mLOG(GUI_RUNNER, DEBUG, "Deinitializing core..."); mLOG(GUI_RUNNER, DEBUG, "Deinitializing core...");
mCoreConfigDeinit(&runner->core->config);
runner->core->deinit(runner->core); runner->core->deinit(runner->core);
runner->core = NULL; runner->core = NULL;

4
src/gb/test/core.c
View File

@ -31,6 +31,7 @@ M_TEST_DEFINE(reset) {
assert_true(core->init(core)); assert_true(core->init(core));
mCoreInitConfig(core, NULL); mCoreInitConfig(core, NULL);
core->reset(core); core->reset(core);
mCoreConfigDeinit(&core->config);
core->deinit(core); core->deinit(core);
} }
@ -41,6 +42,7 @@ M_TEST_DEFINE(loadNullROM) {
mCoreInitConfig(core, NULL); mCoreInitConfig(core, NULL);
assert_false(core->loadROM(core, NULL)); assert_false(core->loadROM(core, NULL));
core->reset(core); core->reset(core);
mCoreConfigDeinit(&core->config);
core->deinit(core); core->deinit(core);
} }
@ -51,7 +53,9 @@ M_TEST_DEFINE(isROM) {
struct mCore* core = mCoreFindVF(vf); struct mCore* core = mCoreFindVF(vf);
assert_non_null(core); assert_non_null(core);
assert_int_equal(core->platform(core), PLATFORM_GB); assert_int_equal(core->platform(core), PLATFORM_GB);
vf->close(vf);
assert_true(core->init(core)); assert_true(core->init(core));
core->deinit(core); core->deinit(core);
} }

1
src/gb/test/mbc.c
View File

@ -27,6 +27,7 @@ M_TEST_SUITE_TEARDOWN(GBMBC) {
return 0; return 0;
} }
struct mCore* core = *state; struct mCore* core = *state;
mCoreConfigDeinit(&core->config);
core->deinit(core); core->deinit(core);
return 0; return 0;
} }

1
src/gb/test/memory.c
View File

@ -27,6 +27,7 @@ M_TEST_SUITE_TEARDOWN(GBMemory) {
return 0; return 0;
} }
struct mCore* core = *state; struct mCore* core = *state;
mCoreConfigDeinit(&core->config);
core->deinit(core); core->deinit(core);
return 0; return 0;
} }

1
src/gb/test/rtc.c
View File

@ -69,6 +69,7 @@ M_TEST_SUITE_TEARDOWN(GBRTC) {
return 0; return 0;
} }
struct GBRTCTest* test = *state; struct GBRTCTest* test = *state;
mCoreConfigDeinit(&test->core->config);
test->core->deinit(test->core); test->core->deinit(test->core);
free(test); free(test);
return 0; return 0;

90
src/gba/test/cheats.c
View File

@ -13,7 +13,7 @@
#include "gba/cheats/parv3.h" #include "gba/cheats/parv3.h"
#include "gba/cheats/gameshark.h" #include "gba/cheats/gameshark.h"
M_TEST_SUITE_SETUP(GBACheats) { static int cheatsSetup(void** state) {
struct mCore* core = GBACoreCreate(); struct mCore* core = GBACoreCreate();
core->init(core); core->init(core);
core->cheatDevice(core); core->cheatDevice(core);
@ -21,7 +21,7 @@ M_TEST_SUITE_SETUP(GBACheats) {
return 0; return 0;
} }
M_TEST_SUITE_TEARDOWN(GBACheats) { static int cheatsTeardown(void** state) {
if (!*state) { if (!*state) {
return 0; return 0;
} }
@ -36,7 +36,7 @@ M_TEST_DEFINE(createSet) {
assert_non_null(device); assert_non_null(device);
struct mCheatSet* set = device->createSet(device, NULL); struct mCheatSet* set = device->createSet(device, NULL);
assert_non_null(set); assert_non_null(set);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(addRawPARv3) { M_TEST_DEFINE(addRawPARv3) {
@ -48,7 +48,7 @@ M_TEST_DEFINE(addRawPARv3) {
GBACheatSetGameSharkVersion((struct GBACheatSet*) set, GBA_GS_PARV3_RAW); GBACheatSetGameSharkVersion((struct GBACheatSet*) set, GBA_GS_PARV3_RAW);
assert_true(set->addLine(set, "80000000 00000000", GBA_CHEAT_PRO_ACTION_REPLAY)); assert_true(set->addLine(set, "80000000 00000000", GBA_CHEAT_PRO_ACTION_REPLAY));
assert_false(set->addLine(set, "43000000 00000000", GBA_CHEAT_PRO_ACTION_REPLAY)); assert_false(set->addLine(set, "43000000 00000000", GBA_CHEAT_PRO_ACTION_REPLAY));
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3Assign) { M_TEST_DEFINE(doPARv3Assign) {
@ -72,7 +72,7 @@ M_TEST_DEFINE(doPARv3Assign) {
assert_int_equal(core->rawRead16(core, 0x03000002, -1), 0x5678); assert_int_equal(core->rawRead16(core, 0x03000002, -1), 0x5678);
assert_int_equal(core->rawRead32(core, 0x03000004, -1), 0x12345678); assert_int_equal(core->rawRead32(core, 0x03000004, -1), 0x12345678);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3Slide1) { M_TEST_DEFINE(doPARv3Slide1) {
@ -101,7 +101,7 @@ M_TEST_DEFINE(doPARv3Slide1) {
assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0); assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0);
assert_int_equal(core->rawRead8(core, 0x03000005, -1), 0); assert_int_equal(core->rawRead8(core, 0x03000005, -1), 0);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3Slide2) { M_TEST_DEFINE(doPARv3Slide2) {
@ -130,7 +130,7 @@ M_TEST_DEFINE(doPARv3Slide2) {
assert_int_equal(core->rawRead16(core, 0x03000008, -1), 0); assert_int_equal(core->rawRead16(core, 0x03000008, -1), 0);
assert_int_equal(core->rawRead16(core, 0x0300000A, -1), 0); assert_int_equal(core->rawRead16(core, 0x0300000A, -1), 0);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3Slide4) { M_TEST_DEFINE(doPARv3Slide4) {
@ -159,7 +159,7 @@ M_TEST_DEFINE(doPARv3Slide4) {
assert_int_equal(core->rawRead16(core, 0x03000010, -1), 0); assert_int_equal(core->rawRead16(core, 0x03000010, -1), 0);
assert_int_equal(core->rawRead16(core, 0x03000014, -1), 0); assert_int_equal(core->rawRead16(core, 0x03000014, -1), 0);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3If1) { M_TEST_DEFINE(doPARv3If1) {
@ -188,7 +188,7 @@ M_TEST_DEFINE(doPARv3If1) {
assert_int_equal(core->rawRead8(core, 0x03000000, -1), 0x1); assert_int_equal(core->rawRead8(core, 0x03000000, -1), 0x1);
assert_int_equal(core->rawRead8(core, 0x03000001, -1), 0x11); assert_int_equal(core->rawRead8(core, 0x03000001, -1), 0x11);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3If1x1) { M_TEST_DEFINE(doPARv3If1x1) {
@ -243,7 +243,7 @@ M_TEST_DEFINE(doPARv3If1x1) {
assert_int_equal(core->rawRead8(core, 0x03000002, -1), 0x21); assert_int_equal(core->rawRead8(core, 0x03000002, -1), 0x21);
assert_int_equal(core->rawRead8(core, 0x03000003, -1), 0x31); assert_int_equal(core->rawRead8(core, 0x03000003, -1), 0x31);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3If2) { M_TEST_DEFINE(doPARv3If2) {
@ -277,7 +277,7 @@ M_TEST_DEFINE(doPARv3If2) {
assert_int_equal(core->rawRead8(core, 0x03000001, -1), 0x11); assert_int_equal(core->rawRead8(core, 0x03000001, -1), 0x11);
assert_int_equal(core->rawRead8(core, 0x03000002, -1), 0x21); assert_int_equal(core->rawRead8(core, 0x03000002, -1), 0x21);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3If2x2) { M_TEST_DEFINE(doPARv3If2x2) {
@ -345,7 +345,7 @@ M_TEST_DEFINE(doPARv3If2x2) {
assert_int_equal(core->rawRead8(core, 0x03000003, -1), 0x31); assert_int_equal(core->rawRead8(core, 0x03000003, -1), 0x31);
assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0x41); assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0x41);
assert_int_equal(core->rawRead8(core, 0x03000005, -1), 0x51); assert_int_equal(core->rawRead8(core, 0x03000005, -1), 0x51);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3If2Contain1) { M_TEST_DEFINE(doPARv3If2Contain1) {
@ -392,7 +392,7 @@ M_TEST_DEFINE(doPARv3If2Contain1) {
assert_int_equal(core->rawRead8(core, 0x03000000, -1), 0x1); assert_int_equal(core->rawRead8(core, 0x03000000, -1), 0x1);
assert_int_equal(core->rawRead8(core, 0x03000001, -1), 0x1); assert_int_equal(core->rawRead8(core, 0x03000001, -1), 0x1);
assert_int_equal(core->rawRead8(core, 0x03000002, -1), 0x21); assert_int_equal(core->rawRead8(core, 0x03000002, -1), 0x21);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3IfX) { M_TEST_DEFINE(doPARv3IfX) {
@ -421,7 +421,7 @@ M_TEST_DEFINE(doPARv3IfX) {
mCheatRefresh(device, set); mCheatRefresh(device, set);
assert_int_equal(core->rawRead8(core, 0x03000000, -1), 0x1); assert_int_equal(core->rawRead8(core, 0x03000000, -1), 0x1);
assert_int_equal(core->rawRead8(core, 0x03000001, -1), 0x11); assert_int_equal(core->rawRead8(core, 0x03000001, -1), 0x11);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3IfXxX) { M_TEST_DEFINE(doPARv3IfXxX) {
@ -484,7 +484,7 @@ M_TEST_DEFINE(doPARv3IfXxX) {
assert_int_equal(core->rawRead8(core, 0x03000002, -1), 0x21); assert_int_equal(core->rawRead8(core, 0x03000002, -1), 0x21);
assert_int_equal(core->rawRead8(core, 0x03000003, -1), 0x32); assert_int_equal(core->rawRead8(core, 0x03000003, -1), 0x32);
assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0x41); assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0x41);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3IfXElse) { M_TEST_DEFINE(doPARv3IfXElse) {
@ -519,7 +519,7 @@ M_TEST_DEFINE(doPARv3IfXElse) {
assert_int_equal(core->rawRead8(core, 0x03000000, -1), 0x1); assert_int_equal(core->rawRead8(core, 0x03000000, -1), 0x1);
assert_int_equal(core->rawRead8(core, 0x03000001, -1), 0x11); assert_int_equal(core->rawRead8(core, 0x03000001, -1), 0x11);
assert_int_equal(core->rawRead8(core, 0x03000002, -1), 0x22); assert_int_equal(core->rawRead8(core, 0x03000002, -1), 0x22);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3IfXElsexX) { M_TEST_DEFINE(doPARv3IfXElsexX) {
@ -590,7 +590,7 @@ M_TEST_DEFINE(doPARv3IfXElsexX) {
assert_int_equal(core->rawRead8(core, 0x03000003, -1), 0x32); assert_int_equal(core->rawRead8(core, 0x03000003, -1), 0x32);
assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0x42); assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0x42);
assert_int_equal(core->rawRead8(core, 0x03000005, -1), 0x51); assert_int_equal(core->rawRead8(core, 0x03000005, -1), 0x51);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3IfXElsexXElse) { M_TEST_DEFINE(doPARv3IfXElsexXElse) {
@ -668,7 +668,7 @@ M_TEST_DEFINE(doPARv3IfXElsexXElse) {
assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0x42); assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0x42);
assert_int_equal(core->rawRead8(core, 0x03000005, -1), 0x51); assert_int_equal(core->rawRead8(core, 0x03000005, -1), 0x51);
assert_int_equal(core->rawRead8(core, 0x03000006, -1), 0x62); assert_int_equal(core->rawRead8(core, 0x03000006, -1), 0x62);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3IfXContain1) { M_TEST_DEFINE(doPARv3IfXContain1) {
@ -730,7 +730,7 @@ M_TEST_DEFINE(doPARv3IfXContain1) {
assert_int_equal(core->rawRead8(core, 0x03000002, -1), 0x21); assert_int_equal(core->rawRead8(core, 0x03000002, -1), 0x21);
assert_int_equal(core->rawRead8(core, 0x03000003, -1), 0x31); assert_int_equal(core->rawRead8(core, 0x03000003, -1), 0x31);
assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0x41); assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0x41);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3IfXContain1Else) { M_TEST_DEFINE(doPARv3IfXContain1Else) {
@ -800,7 +800,7 @@ M_TEST_DEFINE(doPARv3IfXContain1Else) {
assert_int_equal(core->rawRead8(core, 0x03000003, -1), 0x31); assert_int_equal(core->rawRead8(core, 0x03000003, -1), 0x31);
assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0x41); assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0x41);
assert_int_equal(core->rawRead8(core, 0x03000005, -1), 0x52); assert_int_equal(core->rawRead8(core, 0x03000005, -1), 0x52);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3IfXElseContain1) { M_TEST_DEFINE(doPARv3IfXElseContain1) {
@ -870,7 +870,7 @@ M_TEST_DEFINE(doPARv3IfXElseContain1) {
assert_int_equal(core->rawRead8(core, 0x03000003, -1), 0x32); assert_int_equal(core->rawRead8(core, 0x03000003, -1), 0x32);
assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0x41); assert_int_equal(core->rawRead8(core, 0x03000004, -1), 0x41);
assert_int_equal(core->rawRead8(core, 0x03000005, -1), 0x52); assert_int_equal(core->rawRead8(core, 0x03000005, -1), 0x52);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3IfXContain1ElseContain1) { M_TEST_DEFINE(doPARv3IfXContain1ElseContain1) {
@ -1016,7 +1016,7 @@ M_TEST_DEFINE(doPARv3IfXContain1ElseContain1) {
assert_int_equal(core->rawRead8(core, 0x03000006, -1), 0x62); assert_int_equal(core->rawRead8(core, 0x03000006, -1), 0x62);
assert_int_equal(core->rawRead8(core, 0x03000007, -1), 0x71); assert_int_equal(core->rawRead8(core, 0x03000007, -1), 0x71);
assert_int_equal(core->rawRead8(core, 0x03000008, -1), 0x82); assert_int_equal(core->rawRead8(core, 0x03000008, -1), 0x82);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_DEFINE(doPARv3IfButton) { M_TEST_DEFINE(doPARv3IfButton) {
@ -1046,28 +1046,28 @@ M_TEST_DEFINE(doPARv3IfButton) {
core->rawWrite8(core, 0x03000000, -1, 0); core->rawWrite8(core, 0x03000000, -1, 0);
mCheatRefresh(device, set); mCheatRefresh(device, set);
assert_int_equal(core->rawRead8(core, 0x03000000, -1), 0); assert_int_equal(core->rawRead8(core, 0x03000000, -1), 0);
set->deinit(set); mCheatSetDeinit(set);
} }
M_TEST_SUITE_DEFINE_SETUP_TEARDOWN(GBACheats, M_TEST_SUITE_DEFINE(GBACheats,
cmocka_unit_test(createSet), cmocka_unit_test_setup_teardown(createSet, cheatsSetup, cheatsTeardown),
cmocka_unit_test(addRawPARv3), cmocka_unit_test_setup_teardown(addRawPARv3, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3Assign), cmocka_unit_test_setup_teardown(doPARv3Assign, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3Slide1), cmocka_unit_test_setup_teardown(doPARv3Slide1, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3Slide2), cmocka_unit_test_setup_teardown(doPARv3Slide2, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3Slide4), cmocka_unit_test_setup_teardown(doPARv3Slide4, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3If1), cmocka_unit_test_setup_teardown(doPARv3If1, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3If1x1), cmocka_unit_test_setup_teardown(doPARv3If1x1, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3If2), cmocka_unit_test_setup_teardown(doPARv3If2, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3If2x2), cmocka_unit_test_setup_teardown(doPARv3If2x2, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3If2Contain1), cmocka_unit_test_setup_teardown(doPARv3If2Contain1, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3IfX), cmocka_unit_test_setup_teardown(doPARv3IfX, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3IfXxX), cmocka_unit_test_setup_teardown(doPARv3IfXxX, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3IfXElse), cmocka_unit_test_setup_teardown(doPARv3IfXElse, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3IfXElsexX), cmocka_unit_test_setup_teardown(doPARv3IfXElsexX, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3IfXElsexXElse), cmocka_unit_test_setup_teardown(doPARv3IfXElsexXElse, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3IfXContain1), cmocka_unit_test_setup_teardown(doPARv3IfXContain1, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3IfXContain1Else), cmocka_unit_test_setup_teardown(doPARv3IfXContain1Else, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3IfXElseContain1), cmocka_unit_test_setup_teardown(doPARv3IfXElseContain1, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3IfXContain1ElseContain1), cmocka_unit_test_setup_teardown(doPARv3IfXContain1ElseContain1, cheatsSetup, cheatsTeardown),
cmocka_unit_test(doPARv3IfButton)) cmocka_unit_test_setup_teardown(doPARv3IfButton, cheatsSetup, cheatsTeardown))

1
src/platform/libretro/libretro.c
View File

@ -562,6 +562,7 @@ void retro_unload_game(void) {
if (!core) { if (!core) {
return; return;
} }
mCoreConfigDeinit(&core->config);
core->deinit(core); core->deinit(core);
mappedMemoryFree(data, dataSize); mappedMemoryFree(data, dataSize);
data = 0; data = 0;

1
src/platform/openemu/mGBAGameCore.m
View File

@ -76,6 +76,7 @@
- (void)dealloc - (void)dealloc
{ {
mCoreConfigDeinit(&core->config);
core->deinit(core); core->deinit(core);
[cheatSets release]; [cheatSets release];
free(outputBuffer); free(outputBuffer);

1
src/platform/sdl/main.c
View File

@ -143,6 +143,7 @@ int main(int argc, char** argv) {
if (!mSDLInit(&renderer)) { if (!mSDLInit(&renderer)) {
freeArguments(&args); freeArguments(&args);
mCoreConfigDeinit(&renderer.core->config);
renderer.core->deinit(renderer.core); renderer.core->deinit(renderer.core);
return 1; return 1;
} }

1
src/platform/test/fuzz-main.c
View File

@ -165,6 +165,7 @@ loadError:
if (outputBuffer) { if (outputBuffer) {
free(outputBuffer); free(outputBuffer);
} }
mCoreConfigDeinit(&core->config);
core->deinit(core); core->deinit(core);
return !cleanExit; return !cleanExit;