mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-01-10 08:09:26 +01:00
Merge pull request #579 from degasus/statics
Mark unexported global variables and functions as statics.
This commit is contained in:
Pierre Bourdon
commit
84bf097fb7
@ -197,6 +197,8 @@ if(NOT MSVC)
|
||||
check_and_add_flag(LOGICAL_OP -Wlogical-op)
|
||||
check_and_add_flag(SHADOW -Wshadow)
|
||||
check_and_add_flag(INIT_SELF -Winit-self)
|
||||
check_and_add_flag(MISSING_DECLARATIONS -Wmissing-declarations)
|
||||
check_and_add_flag(MISSING_VARIABLE_DECLARATIONS -Wmissing-variable-declarations)
|
||||
endif(NOT MSVC)
|
||||
|
||||
# gcc uses some optimizations which might break stuff without this flag
|
||||
|
||||
@ -23,18 +23,18 @@
|
||||
#define M_SQRT1_2 0.70710678118654752440
|
||||
#endif
|
||||
|
||||
int olddelay = -1;
|
||||
unsigned int oldfreq = 0;
|
||||
unsigned int dlbuflen;
|
||||
int cyc_pos;
|
||||
float l_fwr, r_fwr, lpr_fwr, lmr_fwr;
|
||||
std::vector<float> fwrbuf_l, fwrbuf_r;
|
||||
float adapt_l_gain, adapt_r_gain, adapt_lpr_gain, adapt_lmr_gain;
|
||||
std::vector<float> lf, rf, lr, rr, cf, cr;
|
||||
float LFE_buf[256];
|
||||
unsigned int lfe_pos;
|
||||
float *filter_coefs_lfe;
|
||||
unsigned int len125;
|
||||
static int olddelay = -1;
|
||||
static unsigned int oldfreq = 0;
|
||||
static unsigned int dlbuflen;
|
||||
static int cyc_pos;
|
||||
static float l_fwr, r_fwr, lpr_fwr, lmr_fwr;
|
||||
static std::vector<float> fwrbuf_l, fwrbuf_r;
|
||||
static float adapt_l_gain, adapt_r_gain, adapt_lpr_gain, adapt_lmr_gain;
|
||||
static std::vector<float> lf, rf, lr, rr, cf, cr;
|
||||
static float LFE_buf[256];
|
||||
static unsigned int lfe_pos;
|
||||
static float *filter_coefs_lfe;
|
||||
static unsigned int len125;
|
||||
|
||||
template<class T,class _ftype_t> static _ftype_t dotproduct(int count,const T *buf,const _ftype_t *coefficients)
|
||||
{
|
||||
@ -83,7 +83,7 @@ template<class T> static T firfilter(const T *buf, int pos, int len, int count,
|
||||
// n window length
|
||||
// w buffer for the window parameters
|
||||
*/
|
||||
void hamming(int n, float* w)
|
||||
static void hamming(int n, float* w)
|
||||
{
|
||||
int i;
|
||||
float k = float(2*M_PI/((float)(n-1))); // 2*pi/(N-1)
|
||||
@ -110,7 +110,7 @@ opt beta constant used only when designing using kaiser windows
|
||||
|
||||
returns 0 if OK, -1 if fail
|
||||
*/
|
||||
float* design_fir(unsigned int *n, float* fc, float opt)
|
||||
static float* design_fir(unsigned int *n, float* fc, float opt)
|
||||
{
|
||||
unsigned int o = *n & 1; // Indicator for odd filter length
|
||||
unsigned int end = ((*n + 1) >> 1) - o; // Loop end
|
||||
@ -165,7 +165,7 @@ float* design_fir(unsigned int *n, float* fc, float opt)
|
||||
return w;
|
||||
}
|
||||
|
||||
void onSeek(void)
|
||||
static void onSeek(void)
|
||||
{
|
||||
l_fwr = r_fwr = lpr_fwr = lmr_fwr = 0;
|
||||
std::fill(fwrbuf_l.begin(), fwrbuf_l.end(), 0.0f);
|
||||
@ -181,7 +181,7 @@ void onSeek(void)
|
||||
memset(LFE_buf, 0, sizeof(LFE_buf));
|
||||
}
|
||||
|
||||
void done(void)
|
||||
static void done(void)
|
||||
{
|
||||
onSeek();
|
||||
if (filter_coefs_lfe)
|
||||
@ -191,7 +191,7 @@ void done(void)
|
||||
filter_coefs_lfe = nullptr;
|
||||
}
|
||||
|
||||
float* calc_coefficients_125Hz_lowpass(int rate)
|
||||
static float* calc_coefficients_125Hz_lowpass(int rate)
|
||||
{
|
||||
len125 = 256;
|
||||
float f = 125.0f / (rate / 2);
|
||||
@ -204,7 +204,7 @@ float* calc_coefficients_125Hz_lowpass(int rate)
|
||||
return coeffs;
|
||||
}
|
||||
|
||||
float passive_lock(float x)
|
||||
static float passive_lock(float x)
|
||||
{
|
||||
static const float MATAGCLOCK = 0.2f; /* AGC range (around 1) where the matrix behaves passively */
|
||||
const float x1 = x - 1;
|
||||
@ -212,7 +212,7 @@ float passive_lock(float x)
|
||||
return x1 - x1 / (1 + ax1s * ax1s) + 1;
|
||||
}
|
||||
|
||||
void matrix_decode(const float *in, const int k, const int il,
|
||||
static void matrix_decode(const float *in, const int k, const int il,
|
||||
const int ir, bool decode_rear,
|
||||
const int _dlbuflen,
|
||||
float _l_fwr, float _r_fwr,
|
||||
|
||||
@ -916,7 +916,7 @@ u32 EncodeVm(ARMReg Vm)
|
||||
}
|
||||
|
||||
// Double/single, Neon
|
||||
extern const VFPEnc VFPOps[16][2] = {
|
||||
static const VFPEnc VFPOps[16][2] = {
|
||||
{{0xE0, 0xA0}, { -1, -1}}, // 0: VMLA
|
||||
{{0xE1, 0xA4}, { -1, -1}}, // 1: VNMLA
|
||||
{{0xE0, 0xA4}, { -1, -1}}, // 2: VMLS
|
||||
@ -934,7 +934,7 @@ extern const VFPEnc VFPOps[16][2] = {
|
||||
{{ -1, -1}, {0x3B, 0x30}}, // 14: VABSi
|
||||
};
|
||||
|
||||
const char *VFPOpNames[16] = {
|
||||
static const char *VFPOpNames[16] = {
|
||||
"VMLA",
|
||||
"VNMLA",
|
||||
"VMLS",
|
||||
|
||||
@ -720,7 +720,4 @@ struct VFPEnc {
|
||||
s16 opc1;
|
||||
s16 opc2;
|
||||
};
|
||||
extern const VFPEnc VFPOps[16][2];
|
||||
extern const char *VFPOpNames[16];
|
||||
|
||||
} // namespace
|
||||
|
||||
@ -155,7 +155,7 @@ static struct
|
||||
};
|
||||
|
||||
// Returns true if a device is a block or char device and not a symbolic link
|
||||
bool is_device(const std::string& source_name)
|
||||
static bool is_device(const std::string& source_name)
|
||||
{
|
||||
struct stat buf;
|
||||
if (0 != lstat(source_name.c_str(), &buf))
|
||||
|
||||
@ -16,7 +16,7 @@ const int lut4to8[] = { 0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,
|
||||
0x88,0x99,0xAA,0xBB,0xCC,0xDD,0xEE,0xFF };
|
||||
const int lut3to8[] = { 0x00,0x24,0x48,0x6D,0x91,0xB6,0xDA,0xFF };
|
||||
|
||||
u32 Decode5A3(u16 val)
|
||||
static u32 Decode5A3(u16 val)
|
||||
{
|
||||
const u32 bg_color = 0x00000000;
|
||||
|
||||
|
||||
@ -6,6 +6,7 @@
|
||||
#include <string.h>
|
||||
|
||||
#include "Common/Common.h"
|
||||
#include "Common/Crypto/bn.h"
|
||||
|
||||
static void bn_zero(u8 *d, u32 n)
|
||||
{
|
||||
|
||||
@ -411,8 +411,8 @@ void StackTrace(HANDLE hThread, const char* lpszMessage, FILE *file, DWORD eip,
|
||||
if (hThread != GetCurrentThread())
|
||||
ResumeThread(hThread);
|
||||
}
|
||||
|
||||
char g_uefbuf[2048];
|
||||
#define UEFBUFSIZE 2048
|
||||
static char g_uefbuf[UEFBUFSIZE];
|
||||
|
||||
void etfprintf(FILE *file, const char *format, ...)
|
||||
{
|
||||
|
||||
@ -36,8 +36,6 @@ void StackTrace(HANDLE, char const* msg, FILE *file, DWORD eip, DWORD esp, DWORD
|
||||
// functions by Masken
|
||||
void etfprintf(FILE *file, const char *format, ...);
|
||||
void etfprint(FILE *file, const std::string &text);
|
||||
#define UEFBUFSIZE 2048
|
||||
extern char g_uefbuf[UEFBUFSIZE];
|
||||
|
||||
#else // not WIN32
|
||||
|
||||
|
||||
@ -7,6 +7,7 @@
|
||||
#include <string>
|
||||
|
||||
#include "Common/Common.h"
|
||||
#include "Common/MemoryUtil.h"
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
|
||||
@ -22,7 +22,7 @@ typedef std::string (*StringTranslator)(const char* text);
|
||||
void RegisterMsgAlertHandler(MsgAlertHandler handler);
|
||||
void RegisterStringTranslator(StringTranslator translator);
|
||||
|
||||
extern bool MsgAlert(bool yes_no, int Style, const char* format, ...)
|
||||
bool MsgAlert(bool yes_no, int Style, const char* format, ...)
|
||||
#ifdef __GNUC__
|
||||
__attribute__((format(printf, 3, 4)))
|
||||
#endif
|
||||
|
||||
@ -154,7 +154,7 @@ bool SysConf::LoadFromFileInternal(FILE *fh)
|
||||
}
|
||||
|
||||
// Returns the size of the item in file
|
||||
unsigned int create_item(SSysConfEntry &item, SysconfType type, const std::string &name,
|
||||
static unsigned int create_item(SSysConfEntry &item, SysconfType type, const std::string &name,
|
||||
const int data_length, unsigned int offset)
|
||||
{
|
||||
item.offset = offset;
|
||||
|
||||
@ -18,9 +18,9 @@ namespace ActionReplay
|
||||
{
|
||||
|
||||
// Alphanumeric filter for text<->bin conversion
|
||||
const char *filter = "0123456789ABCDEFGHJKMNPQRTUVWXYZILOS";
|
||||
static const char *filter = "0123456789ABCDEFGHJKMNPQRTUVWXYZILOS";
|
||||
|
||||
u32 genseeds[0x20];
|
||||
static u32 genseeds[0x20];
|
||||
|
||||
const u8 gentable0[0x38] = {
|
||||
0x39, 0x31, 0x29, 0x21, 0x19, 0x11, 0x09, 0x01,
|
||||
@ -143,7 +143,7 @@ const u32 table7[0x40] = {
|
||||
};
|
||||
|
||||
|
||||
void generateseeds(u32 *seeds, const u8 *seedtable, u8 doreverse)
|
||||
static void generateseeds(u32 *seeds, const u8 *seedtable, u8 doreverse)
|
||||
{
|
||||
u32 tmp3;
|
||||
u8 array0[0x38],array1[0x38],array2[0x08];
|
||||
@ -208,24 +208,24 @@ void generateseeds(u32 *seeds, const u8 *seedtable, u8 doreverse)
|
||||
}
|
||||
}
|
||||
|
||||
void buildseeds()
|
||||
static void buildseeds()
|
||||
{
|
||||
generateseeds(genseeds,gensubtable,0);
|
||||
}
|
||||
|
||||
void getcode(u32 *src, u32 *addr, u32 *val)
|
||||
static void getcode(u32 *src, u32 *addr, u32 *val)
|
||||
{
|
||||
*addr = Common::swap32(src[0]);
|
||||
*val = Common::swap32(src[1]);
|
||||
}
|
||||
|
||||
void setcode(u32 *dst, u32 addr, u32 val)
|
||||
static void setcode(u32 *dst, u32 addr, u32 val)
|
||||
{
|
||||
dst[0] = Common::swap32(addr);
|
||||
dst[1] = Common::swap32(val);
|
||||
}
|
||||
|
||||
u16 gencrc16(u32 *codes, u16 size)
|
||||
static u16 gencrc16(u32 *codes, u16 size)
|
||||
{
|
||||
u16 ret = 0;
|
||||
|
||||
@ -243,13 +243,13 @@ u16 gencrc16(u32 *codes, u16 size)
|
||||
return ret;
|
||||
}
|
||||
|
||||
u8 verifycode(u32 *codes, u16 size)
|
||||
static u8 verifycode(u32 *codes, u16 size)
|
||||
{
|
||||
u16 tmp = gencrc16(codes,size);
|
||||
return (((tmp>>12)^(tmp>>8)^(tmp>>4)^tmp)&0x0F);
|
||||
}
|
||||
|
||||
void unscramble1(u32 *addr, u32 *val)
|
||||
static void unscramble1(u32 *addr, u32 *val)
|
||||
{
|
||||
u32 tmp;
|
||||
|
||||
@ -276,7 +276,7 @@ void unscramble1(u32 *addr, u32 *val)
|
||||
*val ^= tmp;
|
||||
}
|
||||
|
||||
void unscramble2(u32 *addr, u32 *val)
|
||||
static void unscramble2(u32 *addr, u32 *val)
|
||||
{
|
||||
u32 tmp;
|
||||
|
||||
@ -303,7 +303,7 @@ void unscramble2(u32 *addr, u32 *val)
|
||||
*addr = _rotr((*addr^tmp),4);
|
||||
}
|
||||
|
||||
void decryptcode(u32 *seeds, u32 *code)
|
||||
static void decryptcode(u32 *seeds, u32 *code)
|
||||
{
|
||||
u32 addr,val;
|
||||
u32 tmp,tmp2;
|
||||
@ -325,7 +325,7 @@ void decryptcode(u32 *seeds, u32 *code)
|
||||
setcode(code,val,addr);
|
||||
}
|
||||
|
||||
bool getbitstring(u32 *ctrl, u32 *out, u8 len)
|
||||
static bool getbitstring(u32 *ctrl, u32 *out, u8 len)
|
||||
{
|
||||
u32 tmp=(ctrl[0]+(ctrl[1]<<2));
|
||||
|
||||
@ -348,7 +348,7 @@ bool getbitstring(u32 *ctrl, u32 *out, u8 len)
|
||||
return true;
|
||||
}
|
||||
|
||||
bool batchdecrypt(u32 *codes, u16 size)
|
||||
static bool batchdecrypt(u32 *codes, u16 size)
|
||||
{
|
||||
u32 tmp,*ptr=codes;
|
||||
u32 tmparray[4] = { 0 },tmparray2[8] = { 0 };
|
||||
@ -391,7 +391,7 @@ bool batchdecrypt(u32 *codes, u16 size)
|
||||
// Unfinished (so says Parasyte :p )
|
||||
}
|
||||
|
||||
int GetVal(const char *flt, char chr)
|
||||
static int GetVal(const char *flt, char chr)
|
||||
{
|
||||
int ret = (int)(strchr(flt,chr) - flt);
|
||||
switch (ret)
|
||||
@ -410,7 +410,7 @@ int GetVal(const char *flt, char chr)
|
||||
return ret;
|
||||
}
|
||||
|
||||
int alphatobin(u32 *dst, std::vector<std::string> alpha, int size)
|
||||
static int alphatobin(u32 *dst, std::vector<std::string> alpha, int size)
|
||||
{
|
||||
int j = 0;
|
||||
int ret = 0;
|
||||
|
||||
@ -11,8 +11,8 @@
|
||||
#include "Core/HW/Memmap.h"
|
||||
#include "Core/PowerPC/PPCSymbolDB.h"
|
||||
|
||||
void bswap(Elf32_Word &w) {w = Common::swap32(w);}
|
||||
void bswap(Elf32_Half &w) {w = Common::swap16(w);}
|
||||
static void bswap(Elf32_Word &w) {w = Common::swap32(w);}
|
||||
static void bswap(Elf32_Half &w) {w = Common::swap16(w);}
|
||||
|
||||
static void byteswapHeader(Elf32_Ehdr &ELF_H)
|
||||
{
|
||||
|
||||
@ -148,7 +148,6 @@ set(SRCS ActionReplay.cpp
|
||||
IPC_HLE/WII_IPC_HLE_Device_usb_kbd.cpp
|
||||
IPC_HLE/WII_IPC_HLE_WiiMote.cpp
|
||||
IPC_HLE/WiiMote_HID_Attr.cpp
|
||||
PowerPC/LUT_frsqrtex.cpp
|
||||
PowerPC/PowerPC.cpp
|
||||
PowerPC/PPCAnalyst.cpp
|
||||
PowerPC/PPCCache.cpp
|
||||
|
||||
@ -66,9 +66,9 @@ namespace Core
|
||||
{
|
||||
|
||||
// Declarations and definitions
|
||||
Common::Timer Timer;
|
||||
volatile u32 DrawnFrame = 0;
|
||||
u32 DrawnVideo = 0;
|
||||
static Common::Timer Timer;
|
||||
static volatile u32 DrawnFrame = 0;
|
||||
static u32 DrawnVideo = 0;
|
||||
|
||||
// Function forwarding
|
||||
const char *Callback_ISOName(void);
|
||||
@ -77,12 +77,12 @@ void Callback_WiimoteInterruptChannel(int _number, u16 _channelID, const void* _
|
||||
// Function declarations
|
||||
void EmuThread();
|
||||
|
||||
bool g_bStopping = false;
|
||||
bool g_bHwInit = false;
|
||||
bool g_bStarted = false;
|
||||
void *g_pWindowHandle = nullptr;
|
||||
std::string g_stateFileName;
|
||||
std::thread g_EmuThread;
|
||||
static bool g_bStopping = false;
|
||||
static bool g_bHwInit = false;
|
||||
static bool g_bStarted = false;
|
||||
static void *g_pWindowHandle = nullptr;
|
||||
static std::string g_stateFileName;
|
||||
static std::thread g_EmuThread;
|
||||
static StoppedCallbackFunc s_onStoppedCb = nullptr;
|
||||
|
||||
static std::thread g_cpu_thread;
|
||||
@ -139,7 +139,7 @@ void DisplayMessage(const std::string& message, int time_in_ms)
|
||||
}
|
||||
}
|
||||
|
||||
void Callback_DebuggerBreak()
|
||||
static void Callback_DebuggerBreak()
|
||||
{
|
||||
CCPU::Break();
|
||||
}
|
||||
@ -264,7 +264,7 @@ void Stop() // - Hammertime!
|
||||
}
|
||||
|
||||
// Create the CPU thread, which is a CPU + Video thread in Single Core mode.
|
||||
void CpuThread()
|
||||
static void CpuThread()
|
||||
{
|
||||
const SCoreStartupParameter& _CoreParameter =
|
||||
SConfig::GetInstance().m_LocalCoreStartupParameter;
|
||||
@ -310,7 +310,7 @@ void CpuThread()
|
||||
return;
|
||||
}
|
||||
|
||||
void FifoPlayerThread()
|
||||
static void FifoPlayerThread()
|
||||
{
|
||||
const SCoreStartupParameter& _CoreParameter = SConfig::GetInstance().m_LocalCoreStartupParameter;
|
||||
|
||||
|
||||
@ -17,6 +17,9 @@
|
||||
#include "Common/CommonTypes.h"
|
||||
#include "Core/CoreParameter.h"
|
||||
|
||||
// TODO: ugly, remove
|
||||
extern bool g_aspect_wide;
|
||||
|
||||
namespace Core
|
||||
{
|
||||
|
||||
|
||||
@ -223,7 +223,6 @@
|
||||
<ClCompile Include="PowerPC\JitCommon\JitCache.cpp" />
|
||||
<ClCompile Include="PowerPC\JitCommon\Jit_Util.cpp" />
|
||||
<ClCompile Include="PowerPC\JitInterface.cpp" />
|
||||
<ClCompile Include="PowerPC\LUT_frsqrtex.cpp" />
|
||||
<ClCompile Include="PowerPC\PowerPC.cpp" />
|
||||
<ClCompile Include="PowerPC\PPCAnalyst.cpp" />
|
||||
<ClCompile Include="PowerPC\PPCCache.cpp" />
|
||||
@ -409,7 +408,6 @@
|
||||
<ClInclude Include="PowerPC\JitCommon\JitCache.h" />
|
||||
<ClInclude Include="PowerPC\JitCommon\Jit_Util.h" />
|
||||
<ClInclude Include="PowerPC\JitInterface.h" />
|
||||
<ClInclude Include="PowerPC\LUT_frsqrtex.h" />
|
||||
<ClInclude Include="PowerPC\PowerPC.h" />
|
||||
<ClInclude Include="PowerPC\PPCAnalyst.h" />
|
||||
<ClInclude Include="PowerPC\PPCCache.h" />
|
||||
|
||||
@ -602,9 +602,6 @@
|
||||
<ClCompile Include="PowerPC\JitInterface.cpp">
|
||||
<Filter>PowerPC</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="PowerPC\LUT_frsqrtex.cpp">
|
||||
<Filter>PowerPC</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="PowerPC\PowerPC.cpp">
|
||||
<Filter>PowerPC</Filter>
|
||||
</ClCompile>
|
||||
@ -1161,9 +1158,6 @@
|
||||
<ClInclude Include="PowerPC\JitInterface.h">
|
||||
<Filter>PowerPC</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="PowerPC\LUT_frsqrtex.h">
|
||||
<Filter>PowerPC</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="PowerPC\PowerPC.h">
|
||||
<Filter>PowerPC</Filter>
|
||||
</ClInclude>
|
||||
|
||||
@ -27,7 +27,7 @@ struct EventType
|
||||
std::string name;
|
||||
};
|
||||
|
||||
std::vector<EventType> event_types;
|
||||
static std::vector<EventType> event_types;
|
||||
|
||||
struct BaseEvent
|
||||
{
|
||||
@ -41,28 +41,28 @@ typedef LinkedListItem<BaseEvent> Event;
|
||||
// STATE_TO_SAVE
|
||||
static Event *first;
|
||||
static std::mutex tsWriteLock;
|
||||
Common::FifoQueue<BaseEvent, false> tsQueue;
|
||||
static Common::FifoQueue<BaseEvent, false> tsQueue;
|
||||
|
||||
// event pools
|
||||
Event *eventPool = nullptr;
|
||||
static Event *eventPool = nullptr;
|
||||
|
||||
int slicelength;
|
||||
int maxSliceLength = MAX_SLICE_LENGTH;
|
||||
static int maxSliceLength = MAX_SLICE_LENGTH;
|
||||
|
||||
s64 globalTimer;
|
||||
s64 idledCycles;
|
||||
static s64 globalTimer;
|
||||
static s64 idledCycles;
|
||||
|
||||
u32 fakeDecStartValue;
|
||||
u64 fakeDecStartTicks;
|
||||
u64 fakeTBStartValue;
|
||||
u64 fakeTBStartTicks;
|
||||
static u32 fakeDecStartValue;
|
||||
static u64 fakeDecStartTicks;
|
||||
static u64 fakeTBStartValue;
|
||||
static u64 fakeTBStartTicks;
|
||||
|
||||
int ev_lost;
|
||||
static int ev_lost;
|
||||
|
||||
|
||||
void (*advanceCallback)(int cyclesExecuted) = nullptr;
|
||||
static void (*advanceCallback)(int cyclesExecuted) = nullptr;
|
||||
|
||||
Event* GetNewEvent()
|
||||
static Event* GetNewEvent()
|
||||
{
|
||||
if (!eventPool)
|
||||
return new Event;
|
||||
@ -72,7 +72,7 @@ Event* GetNewEvent()
|
||||
return ev;
|
||||
}
|
||||
|
||||
void FreeEvent(Event* ev)
|
||||
static void FreeEvent(Event* ev)
|
||||
{
|
||||
ev->next = eventPool;
|
||||
eventPool = ev;
|
||||
@ -136,7 +136,7 @@ void Shutdown()
|
||||
}
|
||||
}
|
||||
|
||||
void EventDoState(PointerWrap &p, BaseEvent* ev)
|
||||
static void EventDoState(PointerWrap &p, BaseEvent* ev)
|
||||
{
|
||||
p.Do(ev->time);
|
||||
|
||||
@ -234,7 +234,7 @@ void ClearPendingEvents()
|
||||
}
|
||||
}
|
||||
|
||||
void AddEventToQueue(Event* ne)
|
||||
static void AddEventToQueue(Event* ne)
|
||||
{
|
||||
Event* prev = nullptr;
|
||||
Event** pNext = &first;
|
||||
|
||||
@ -5,11 +5,11 @@
|
||||
#include "Common/Common.h"
|
||||
#include "Common/MathUtil.h"
|
||||
|
||||
#include "Core/DSP/DSPAccelerator.h"
|
||||
#include "Core/DSP/DSPCore.h"
|
||||
#include "Core/DSP/DSPHost.h"
|
||||
#include "Core/DSP/DSPHWInterface.h"
|
||||
#include "Core/DSP/DSPInterpreter.h"
|
||||
|
||||
// The hardware adpcm decoder :)
|
||||
static s16 ADPCM_Step(u32& _rSamplePos)
|
||||
{
|
||||
|
||||
@ -60,12 +60,12 @@ const u16 idle_skip_sigs[NUM_IDLE_SIGS][MAX_IDLE_SIG_SIZE + 1] =
|
||||
0, 0 }
|
||||
};
|
||||
|
||||
void Reset()
|
||||
static void Reset()
|
||||
{
|
||||
memset(code_flags, 0, sizeof(code_flags));
|
||||
}
|
||||
|
||||
void AnalyzeRange(int start_addr, int end_addr)
|
||||
static void AnalyzeRange(int start_addr, int end_addr)
|
||||
{
|
||||
// First we run an extremely simplified version of a disassembler to find
|
||||
// where all instructions start.
|
||||
|
||||
@ -160,14 +160,14 @@ void DSPAssembler::ShowError(err_t err_code, const char *extra_info)
|
||||
last_error = err_code;
|
||||
}
|
||||
|
||||
char *skip_spaces(char *ptr)
|
||||
static char *skip_spaces(char *ptr)
|
||||
{
|
||||
while (*ptr == ' ')
|
||||
ptr++;
|
||||
return ptr;
|
||||
}
|
||||
|
||||
const char *skip_spaces(const char *ptr)
|
||||
static const char *skip_spaces(const char *ptr)
|
||||
{
|
||||
while (*ptr == ' ')
|
||||
ptr++;
|
||||
@ -510,7 +510,7 @@ const opc_t *DSPAssembler::FindOpcode(const char *opcode, u32 par_count, const o
|
||||
}
|
||||
|
||||
// weird...
|
||||
u16 get_mask_shifted_down(u16 mask)
|
||||
static u16 get_mask_shifted_down(u16 mask)
|
||||
{
|
||||
while (!(mask & 1))
|
||||
mask >>= 1;
|
||||
|
||||
@ -38,12 +38,12 @@
|
||||
|
||||
SDSP g_dsp;
|
||||
DSPBreakpoints dsp_breakpoints;
|
||||
DSPCoreState core_state = DSPCORE_STOP;
|
||||
static DSPCoreState core_state = DSPCORE_STOP;
|
||||
u16 cyclesLeft = 0;
|
||||
bool init_hax = false;
|
||||
DSPEmitter *dspjit = nullptr;
|
||||
std::unique_ptr<DSPCaptureLogger> g_dsp_cap;
|
||||
Common::Event step_event;
|
||||
static Common::Event step_event;
|
||||
|
||||
// Returns false if the hash fails and the user hits "Yes"
|
||||
static bool VerifyRoms()
|
||||
|
||||
@ -35,8 +35,6 @@
|
||||
#include "Core/DSP/DSPDisassembler.h"
|
||||
#include "Core/DSP/DSPTables.h"
|
||||
|
||||
extern void nop(const UDSPInstruction opc);
|
||||
|
||||
DSPDisassembler::DSPDisassembler(const AssemblerSettings &settings)
|
||||
: settings_(settings)
|
||||
{
|
||||
|
||||
@ -31,7 +31,7 @@
|
||||
|
||||
namespace DSPInterpreter {
|
||||
|
||||
volatile u32 gdsp_running;
|
||||
static volatile u32 gdsp_running;
|
||||
|
||||
// NOTE: These have nothing to do with g_dsp.r.cr !
|
||||
|
||||
|
||||
@ -54,6 +54,8 @@ enum partype_t
|
||||
#define OPTABLE_SIZE 0xffff + 1
|
||||
#define EXT_OPTABLE_SIZE 0xff + 1
|
||||
|
||||
void nop(const UDSPInstruction opc);
|
||||
|
||||
typedef void (*dspIntFunc)(const UDSPInstruction);
|
||||
typedef void (DSPEmitter::*dspJitFunc)(const UDSPInstruction);
|
||||
|
||||
|
||||
@ -117,7 +117,7 @@ static void WriteBlockLink(DSPEmitter& emitter, u16 dest)
|
||||
}
|
||||
}
|
||||
|
||||
void r_jcc(const UDSPInstruction opc, DSPEmitter& emitter)
|
||||
static void r_jcc(const UDSPInstruction opc, DSPEmitter& emitter)
|
||||
{
|
||||
u16 dest = dsp_imem_read(emitter.compilePC + 1);
|
||||
const DSPOPCTemplate *opcode = GetOpTemplate(opc);
|
||||
@ -141,7 +141,7 @@ void DSPEmitter::jcc(const UDSPInstruction opc)
|
||||
ReJitConditional<r_jcc>(opc, *this);
|
||||
}
|
||||
|
||||
void r_jmprcc(const UDSPInstruction opc, DSPEmitter& emitter)
|
||||
static void r_jmprcc(const UDSPInstruction opc, DSPEmitter& emitter)
|
||||
{
|
||||
u8 reg = (opc >> 5) & 0x7;
|
||||
//reg can only be DSP_REG_ARx and DSP_REG_IXx now,
|
||||
@ -161,7 +161,7 @@ void DSPEmitter::jmprcc(const UDSPInstruction opc)
|
||||
ReJitConditional<r_jmprcc>(opc, *this);
|
||||
}
|
||||
|
||||
void r_call(const UDSPInstruction opc, DSPEmitter& emitter)
|
||||
static void r_call(const UDSPInstruction opc, DSPEmitter& emitter)
|
||||
{
|
||||
emitter.MOV(16, R(DX), Imm16(emitter.compilePC + 2));
|
||||
emitter.dsp_reg_store_stack(DSP_STACK_C);
|
||||
@ -188,7 +188,7 @@ void DSPEmitter::call(const UDSPInstruction opc)
|
||||
ReJitConditional<r_call>(opc, *this);
|
||||
}
|
||||
|
||||
void r_callr(const UDSPInstruction opc, DSPEmitter& emitter)
|
||||
static void r_callr(const UDSPInstruction opc, DSPEmitter& emitter)
|
||||
{
|
||||
u8 reg = (opc >> 5) & 0x7;
|
||||
emitter.MOV(16, R(DX), Imm16(emitter.compilePC + 1));
|
||||
@ -210,7 +210,7 @@ void DSPEmitter::callr(const UDSPInstruction opc)
|
||||
ReJitConditional<r_callr>(opc, *this);
|
||||
}
|
||||
|
||||
void r_ifcc(const UDSPInstruction opc, DSPEmitter& emitter)
|
||||
static void r_ifcc(const UDSPInstruction opc, DSPEmitter& emitter)
|
||||
{
|
||||
emitter.MOV(16, M(&g_dsp.pc), Imm16(emitter.compilePC + 1));
|
||||
}
|
||||
@ -226,7 +226,7 @@ void DSPEmitter::ifcc(const UDSPInstruction opc)
|
||||
WriteBranchExit(*this);
|
||||
}
|
||||
|
||||
void r_ret(const UDSPInstruction opc, DSPEmitter& emitter)
|
||||
static void r_ret(const UDSPInstruction opc, DSPEmitter& emitter)
|
||||
{
|
||||
emitter.dsp_reg_load_stack(DSP_STACK_C);
|
||||
emitter.MOV(16, M(&g_dsp.pc), R(DX));
|
||||
|
||||
@ -37,12 +37,12 @@ void AddAutoBreakpoints()
|
||||
}
|
||||
|
||||
// Returns true if the address is not a valid RAM address or NULL.
|
||||
bool IsStackBottom(u32 addr)
|
||||
static bool IsStackBottom(u32 addr)
|
||||
{
|
||||
return !addr || !Memory::IsRAMAddress(addr);
|
||||
}
|
||||
|
||||
void WalkTheStack(const std::function<void(u32)>& stack_step)
|
||||
static void WalkTheStack(const std::function<void(u32)>& stack_step)
|
||||
{
|
||||
if (!IsStackBottom(PowerPC::ppcState.gpr[1]))
|
||||
{
|
||||
|
||||
@ -45,7 +45,7 @@ bool GeckoCode::Compare(GeckoCode compare) const
|
||||
|
||||
static bool code_handler_installed = false;
|
||||
// the currently active codes
|
||||
std::vector<GeckoCode> active_codes;
|
||||
static std::vector<GeckoCode> active_codes;
|
||||
static std::mutex active_codes_lock;
|
||||
|
||||
void SetActiveCodes(const std::vector<GeckoCode>& gcodes)
|
||||
@ -68,7 +68,7 @@ void SetActiveCodes(const std::vector<GeckoCode>& gcodes)
|
||||
code_handler_installed = false;
|
||||
}
|
||||
|
||||
bool InstallCodeHandler()
|
||||
static bool InstallCodeHandler()
|
||||
{
|
||||
u32 codelist_location = 0x800028B8; // Debugger on location (0x800022A8 = Debugger off, using codehandleronly.bin)
|
||||
std::string data;
|
||||
|
||||
@ -97,7 +97,7 @@ void LoadCodes(const IniFile& globalIni, const IniFile& localIni, std::vector<Ge
|
||||
}
|
||||
|
||||
// used by the SaveGeckoCodes function
|
||||
void SaveGeckoCode(std::vector<std::string>& lines, std::vector<std::string>& enabledLines, const GeckoCode& gcode)
|
||||
static void SaveGeckoCode(std::vector<std::string>& lines, std::vector<std::string>& enabledLines, const GeckoCode& gcode)
|
||||
{
|
||||
if (gcode.enabled)
|
||||
enabledLines.push_back("$" + gcode.name);
|
||||
|
||||
@ -11,6 +11,7 @@
|
||||
#include "Core/Host.h"
|
||||
#include "Core/Boot/Boot_DOL.h"
|
||||
#include "Core/HLE/HLE.h"
|
||||
#include "Core/HLE/HLE_Misc.h"
|
||||
#include "Core/HLE/HLE_OS.h"
|
||||
#include "Core/HW/Memmap.h"
|
||||
#include "Core/IPC_HLE/WII_IPC_HLE_Device_DI.h"
|
||||
@ -29,8 +30,7 @@
|
||||
namespace HLE_Misc
|
||||
{
|
||||
|
||||
std::string args;
|
||||
u32 argsPtr;
|
||||
static std::string args;
|
||||
|
||||
// If you just want to kill a function, one of the three following are usually appropriate.
|
||||
// According to the PPC ABI, the return value is always in r3.
|
||||
|
||||
@ -46,7 +46,7 @@ void HLE_GeneralDebugPrint()
|
||||
NOTICE_LOG(OSREPORT, "%08x->%08x| %s", LR, PC, ReportMessage.c_str());
|
||||
}
|
||||
|
||||
void HLE_VPrintf()
|
||||
static void HLE_VPrintf()
|
||||
{
|
||||
std::string ReportMessage;
|
||||
u32 r4 = GPR(4);
|
||||
@ -66,7 +66,7 @@ void HLE_VPrintf()
|
||||
NOTICE_LOG(OSREPORT, "%08x->%08x| %s", LR, PC, ReportMessage.c_str());
|
||||
}
|
||||
// Generalized func for just printing string pointed to by r3.
|
||||
void HLE_GeneralDebugPrintWithInt()
|
||||
static void HLE_GeneralDebugPrintWithInt()
|
||||
{
|
||||
std::string ReportMessage;
|
||||
GetStringVA(ReportMessage, 5);
|
||||
|
||||
@ -147,7 +147,7 @@ static void GenerateAudioInterrupt();
|
||||
static void UpdateInterrupts();
|
||||
static void IncreaseSampleCount(const u32 _uAmount);
|
||||
static u64 GetAIPeriod();
|
||||
int et_AI;
|
||||
static int et_AI;
|
||||
|
||||
void Init()
|
||||
{
|
||||
|
||||
@ -106,7 +106,7 @@ bool CEXIETHERNET::SendFrame(u8* frame, u32 size)
|
||||
#endif
|
||||
}
|
||||
|
||||
void ReadThreadHandler(CEXIETHERNET* self)
|
||||
static void ReadThreadHandler(CEXIETHERNET* self)
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
|
||||
@ -175,7 +175,7 @@ static ARAM_Info g_ARAM_Info;
|
||||
static u16 g_AR_MODE;
|
||||
static u16 g_AR_REFRESH;
|
||||
|
||||
DSPEmulator *dsp_emulator;
|
||||
static DSPEmulator *dsp_emulator;
|
||||
|
||||
static int dsp_slice = 0;
|
||||
static bool dsp_is_lle = false;
|
||||
@ -205,9 +205,9 @@ void WriteARAM(u8 _iValue, u32 _iAddress);
|
||||
bool Update_DSP_ReadRegister();
|
||||
void Update_DSP_WriteRegister();
|
||||
|
||||
int et_GenerateDSPInterrupt;
|
||||
static int et_GenerateDSPInterrupt;
|
||||
|
||||
void GenerateDSPInterrupt_Wrapper(u64 userdata, int cyclesLate)
|
||||
static void GenerateDSPInterrupt_Wrapper(u64 userdata, int cyclesLate)
|
||||
{
|
||||
GenerateDSPInterrupt((DSPInterruptType)(userdata&0xFFFF), (bool)((userdata>>16) & 1));
|
||||
}
|
||||
|
||||
@ -136,4 +136,4 @@ private:
|
||||
bool m_needs_resume_mail;
|
||||
};
|
||||
|
||||
extern UCodeInterface* UCodeFactory(u32 crc, DSPHLE *dsphle, bool wii);
|
||||
UCodeInterface* UCodeFactory(u32 crc, DSPHLE *dsphle, bool wii);
|
||||
|
||||
@ -91,7 +91,7 @@ void ZeldaUCode::Resample(ZeldaVoicePB &PB, int size, s16 *in, s32 *out, bool do
|
||||
PB.CurSampleFrac = position & 0xFFFF;
|
||||
}
|
||||
|
||||
void UpdateSampleCounters10(ZeldaVoicePB &PB)
|
||||
static void UpdateSampleCounters10(ZeldaVoicePB &PB)
|
||||
{
|
||||
PB.RemLength = PB.Length - PB.RestartPos;
|
||||
PB.CurAddr = PB.StartAddr + (PB.RestartPos << 1);
|
||||
@ -149,7 +149,7 @@ clear_buffer:
|
||||
PB.CurAddr += rem_samples << 1;
|
||||
}
|
||||
|
||||
void UpdateSampleCounters8(ZeldaVoicePB &PB)
|
||||
static void UpdateSampleCounters8(ZeldaVoicePB &PB)
|
||||
{
|
||||
PB.RemLength = PB.Length - PB.RestartPos;
|
||||
PB.CurAddr = PB.StartAddr + PB.RestartPos;
|
||||
|
||||
@ -37,8 +37,8 @@ DSPLLE::DSPLLE()
|
||||
m_cycle_count = 0;
|
||||
}
|
||||
|
||||
Common::Event dspEvent;
|
||||
Common::Event ppcEvent;
|
||||
static Common::Event dspEvent;
|
||||
static Common::Event ppcEvent;
|
||||
|
||||
void DSPLLE::DoState(PointerWrap &p)
|
||||
{
|
||||
|
||||
@ -20,11 +20,11 @@ namespace DSPSymbols
|
||||
|
||||
DSPSymbolDB g_dsp_symbol_db;
|
||||
|
||||
std::map<u16, int> addr_to_line;
|
||||
std::map<int, u16> line_to_addr;
|
||||
std::map<int, const char *> line_to_symbol;
|
||||
std::vector<std::string> lines;
|
||||
int line_counter = 0;
|
||||
static std::map<u16, int> addr_to_line;
|
||||
static std::map<int, u16> line_to_addr;
|
||||
static std::map<int, const char *> line_to_symbol;
|
||||
static std::vector<std::string> lines;
|
||||
static int line_counter = 0;
|
||||
|
||||
int Addr2Line(u16 address) // -1 for not found
|
||||
{
|
||||
@ -75,7 +75,7 @@ Symbol *DSPSymbolDB::GetSymbolFromAddr(u32 addr)
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void DisassembleRange(u16 start, u16 end)
|
||||
static void DisassembleRange(u16 start, u16 end)
|
||||
{
|
||||
// TODO: ?
|
||||
}
|
||||
|
||||
@ -206,11 +206,11 @@ static u32 CurrentStart;
|
||||
static u32 LoopLength;
|
||||
static u32 CurrentLength;
|
||||
|
||||
u32 g_ErrorCode = 0;
|
||||
bool g_bDiscInside = false;
|
||||
static u32 g_ErrorCode = 0;
|
||||
static bool g_bDiscInside = false;
|
||||
bool g_bStream = false;
|
||||
int tc = 0;
|
||||
int dtk = 0;
|
||||
static int tc = 0;
|
||||
static int dtk = 0;
|
||||
|
||||
static u64 g_last_read_offset;
|
||||
static u64 g_last_read_time;
|
||||
@ -255,7 +255,7 @@ void DoState(PointerWrap &p)
|
||||
p.Do(g_last_read_time);
|
||||
}
|
||||
|
||||
void TransferComplete(u64 userdata, int cyclesLate)
|
||||
static void TransferComplete(u64 userdata, int cyclesLate)
|
||||
{
|
||||
if (m_DICR.TSTART)
|
||||
FinishExecuteRead();
|
||||
@ -297,7 +297,7 @@ static u32 ProcessDTKSamples(short *tempPCM, u32 num_samples)
|
||||
return samples_processed;
|
||||
}
|
||||
|
||||
void DTKStreamingCallback(u64 userdata, int cyclesLate)
|
||||
static void DTKStreamingCallback(u64 userdata, int cyclesLate)
|
||||
{
|
||||
// Send audio to the mixer.
|
||||
static const int NUM_SAMPLES = 48000 / 2000 * 7; // 3.5ms of 48kHz samples
|
||||
|
||||
@ -21,7 +21,7 @@ namespace ExpansionInterface
|
||||
|
||||
static int changeDevice;
|
||||
|
||||
CEXIChannel *g_Channels[MAX_EXI_CHANNELS];
|
||||
static CEXIChannel *g_Channels[MAX_EXI_CHANNELS];
|
||||
void Init()
|
||||
{
|
||||
initSRAM();
|
||||
|
||||
@ -53,4 +53,4 @@ public:
|
||||
TEXIDevices m_deviceType;
|
||||
};
|
||||
|
||||
extern IEXIDevice* EXIDevice_Create(const TEXIDevices device_type, const int channel_num);
|
||||
IEXIDevice* EXIDevice_Create(const TEXIDevices device_type, const int channel_num);
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
#include "DiscIO/Volume.h"
|
||||
|
||||
const int NO_INDEX = -1;
|
||||
const char *MC_HDR = "MC_SYSTEM_AREA";
|
||||
static const char *MC_HDR = "MC_SYSTEM_AREA";
|
||||
int GCMemcardDirectory::LoadGCI(std::string fileName, int region)
|
||||
{
|
||||
File::IOFile gcifile(fileName, "rb");
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
#define SIZE_TO_Mb (1024 * 8 * 16)
|
||||
#define MC_HDR_SIZE 0xA000
|
||||
|
||||
void innerFlush(FlushData *data)
|
||||
static void innerFlush(FlushData *data)
|
||||
{
|
||||
File::IOFile pFile(data->filename, "r+b");
|
||||
if (!pFile)
|
||||
|
||||
@ -5,8 +5,8 @@
|
||||
#include "Common/Common.h"
|
||||
|
||||
#include "Core/ConfigManager.h"
|
||||
#include "Core/HW/GCPad.h"
|
||||
#include "Core/HW/GCPadEmu.h"
|
||||
|
||||
#include "InputCommon/GCPadStatus.h"
|
||||
#include "InputCommon/InputConfig.h"
|
||||
#include "InputCommon/ControllerInterface/ControllerInterface.h"
|
||||
|
||||
@ -155,7 +155,7 @@ void FastWrite64(const u64 _iValue)
|
||||
m_gatherPipeCount += 8;
|
||||
}
|
||||
|
||||
void FastWriteEnd()
|
||||
static void FastWriteEnd()
|
||||
{
|
||||
CheckGatherPipe();
|
||||
}
|
||||
|
||||
@ -46,7 +46,7 @@ namespace Memory
|
||||
/* Enable the Translation Lookaside Buffer functions. TLBHack = 1 in Dolphin.ini or a
|
||||
<GameID>.ini file will set this to true */
|
||||
bool bFakeVMEM = false;
|
||||
bool bMMU = false;
|
||||
static bool bMMU = false;
|
||||
// ==============
|
||||
|
||||
|
||||
@ -57,11 +57,11 @@ bool bMMU = false;
|
||||
u8* base = nullptr;
|
||||
|
||||
// The MemArena class
|
||||
MemArena g_arena;
|
||||
static MemArena g_arena;
|
||||
// ==============
|
||||
|
||||
// STATE_TO_SAVE
|
||||
bool m_IsInitialized = false; // Save the Init(), Shutdown() state
|
||||
static bool m_IsInitialized = false; // Save the Init(), Shutdown() state
|
||||
// END STATE_TO_SAVE
|
||||
|
||||
// 64-bit: Pointers to low-mem (sub-0x10000000) mirror
|
||||
@ -74,20 +74,20 @@ u8 *m_pFakeVMEM;
|
||||
|
||||
// 64-bit: Pointers to high-mem mirrors
|
||||
// 32-bit: Same as above
|
||||
u8 *m_pPhysicalRAM;
|
||||
u8 *m_pVirtualCachedRAM;
|
||||
u8 *m_pVirtualUncachedRAM;
|
||||
u8 *m_pPhysicalEXRAM; // wii only
|
||||
u8 *m_pVirtualCachedEXRAM; // wii only
|
||||
u8 *m_pVirtualUncachedEXRAM; // wii only
|
||||
static u8 *m_pPhysicalRAM;
|
||||
static u8 *m_pVirtualCachedRAM;
|
||||
static u8 *m_pVirtualUncachedRAM;
|
||||
static u8 *m_pPhysicalEXRAM; // wii only
|
||||
static u8 *m_pVirtualCachedEXRAM; // wii only
|
||||
static u8 *m_pVirtualUncachedEXRAM; // wii only
|
||||
//u8 *m_pVirtualEFB;
|
||||
u8 *m_pVirtualL1Cache;
|
||||
static u8 *m_pVirtualL1Cache;
|
||||
u8 *m_pVirtualFakeVMEM;
|
||||
|
||||
// MMIO mapping object.
|
||||
MMIO::Mapping* mmio_mapping;
|
||||
|
||||
void InitMMIO(MMIO::Mapping* mmio)
|
||||
static void InitMMIO(MMIO::Mapping* mmio)
|
||||
{
|
||||
g_video_backend->RegisterCPMMIO(mmio, 0xCC000000);
|
||||
PixelEngine::RegisterMMIO(mmio, 0xCC001000);
|
||||
@ -101,7 +101,7 @@ void InitMMIO(MMIO::Mapping* mmio)
|
||||
AudioInterface::RegisterMMIO(mmio, 0xCC006C00);
|
||||
}
|
||||
|
||||
void InitMMIOWii(MMIO::Mapping* mmio)
|
||||
static void InitMMIOWii(MMIO::Mapping* mmio)
|
||||
{
|
||||
InitMMIO(mmio);
|
||||
|
||||
|
||||
@ -46,6 +46,8 @@ extern u8 *m_pRAM;
|
||||
extern u8 *m_pEXRAM;
|
||||
extern u8 *m_pL1Cache;
|
||||
extern u8 *m_pVirtualFakeVMEM;
|
||||
extern u8 *m_pFakeVMEM;
|
||||
extern bool bFakeVMEM;
|
||||
|
||||
enum
|
||||
{
|
||||
|
||||
@ -53,15 +53,6 @@ GXPeekZ
|
||||
// From Memmap.cpp
|
||||
// ----------------
|
||||
|
||||
// Pointers to low memory
|
||||
extern u8 *m_pFakeVMEM;
|
||||
extern u8 *m_pEXRAM; // Wii
|
||||
extern u8 *m_pEFB;
|
||||
|
||||
// Init
|
||||
extern bool m_IsInitialized;
|
||||
extern bool bFakeVMEM;
|
||||
|
||||
// Overloaded byteswap functions, for use within the templated functions below.
|
||||
inline u8 bswap(u8 val) {return val;}
|
||||
inline u16 bswap(u16 val) {return Common::swap16(val);}
|
||||
@ -630,7 +621,7 @@ typedef struct tlb_entry
|
||||
static tlb_entry tlb[NUM_TLBS][TLB_SIZE/TLB_WAYS][TLB_WAYS];
|
||||
#endif
|
||||
|
||||
u32 LookupTLBPageAddress(const XCheckTLBFlag _Flag, const u32 vpa, u32 *paddr)
|
||||
static u32 LookupTLBPageAddress(const XCheckTLBFlag _Flag, const u32 vpa, u32 *paddr)
|
||||
{
|
||||
#ifdef FAST_TLB_CACHE
|
||||
tlb_entry *tlbe = tlb[_Flag == FLAG_OPCODE][(vpa>>HW_PAGE_INDEX_SHIFT)&HW_PAGE_INDEX_MASK];
|
||||
@ -679,7 +670,7 @@ u32 LookupTLBPageAddress(const XCheckTLBFlag _Flag, const u32 vpa, u32 *paddr)
|
||||
#endif
|
||||
}
|
||||
|
||||
void UpdateTLBEntry(const XCheckTLBFlag _Flag, UPTE2 PTE2, const u32 vpa)
|
||||
static void UpdateTLBEntry(const XCheckTLBFlag _Flag, UPTE2 PTE2, const u32 vpa)
|
||||
{
|
||||
#ifdef FAST_TLB_CACHE
|
||||
tlb_entry *tlbe = tlb[_Flag == FLAG_OPCODE][(vpa>>HW_PAGE_INDEX_SHIFT)&HW_PAGE_INDEX_MASK];
|
||||
@ -757,7 +748,7 @@ void InvalidateTLBEntry(u32 vpa)
|
||||
}
|
||||
|
||||
// Page Address Translation
|
||||
u32 TranslatePageAddress(const u32 _Address, const XCheckTLBFlag _Flag)
|
||||
static u32 TranslatePageAddress(const u32 _Address, const XCheckTLBFlag _Flag)
|
||||
{
|
||||
// TLB cache
|
||||
u32 translatedAddress = 0;
|
||||
@ -851,7 +842,7 @@ u32 TranslatePageAddress(const u32 _Address, const XCheckTLBFlag _Flag)
|
||||
#define BAT_EA_4(v) ((v)&0xf0000000)
|
||||
|
||||
// Block Address Translation
|
||||
u32 TranslateBlockAddress(const u32 addr, const XCheckTLBFlag _Flag)
|
||||
static u32 TranslateBlockAddress(const u32 addr, const XCheckTLBFlag _Flag)
|
||||
{
|
||||
u32 result = 0;
|
||||
UReg_MSR& m_MSR = ((UReg_MSR&)PowerPC::ppcState.msr);
|
||||
|
||||
@ -43,10 +43,10 @@ u32 Fifo_CPUBase;
|
||||
u32 Fifo_CPUEnd;
|
||||
u32 Fifo_CPUWritePointer;
|
||||
|
||||
u32 m_Fifo_Reset;
|
||||
u32 m_ResetCode;
|
||||
u32 m_FlipperRev;
|
||||
u32 m_Unknown;
|
||||
static u32 m_Fifo_Reset;
|
||||
static u32 m_ResetCode;
|
||||
static u32 m_FlipperRev;
|
||||
static u32 m_Unknown;
|
||||
|
||||
|
||||
// ID and callback for scheduling reset button presses/releases
|
||||
@ -211,7 +211,7 @@ void SetInterrupt(u32 _causemask, bool _bSet)
|
||||
UpdateException();
|
||||
}
|
||||
|
||||
void SetResetButton(bool _bSet)
|
||||
static void SetResetButton(bool _bSet)
|
||||
{
|
||||
if (_bSet)
|
||||
Common::AtomicAnd(m_InterruptCause, ~INT_CAUSE_RST_BUTTON);
|
||||
|
||||
@ -458,7 +458,7 @@ void AddDevice(const SIDevices _device, int _iDeviceNumber)
|
||||
AddDevice(pDevice);
|
||||
}
|
||||
|
||||
void SetNoResponse(u32 channel)
|
||||
static void SetNoResponse(u32 channel)
|
||||
{
|
||||
// raise the NO RESPONSE error
|
||||
switch (channel)
|
||||
|
||||
@ -95,4 +95,4 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
extern ISIDevice* SIDevice_Create(const SIDevices device, const int port_number);
|
||||
ISIDevice* SIDevice_Create(const SIDevices device, const int port_number);
|
||||
|
||||
@ -17,7 +17,7 @@ namespace { volatile bool server_running; }
|
||||
|
||||
// --- GameBoy Advance "Link Cable" ---
|
||||
|
||||
void GBAConnectionWaiter()
|
||||
static void GBAConnectionWaiter()
|
||||
{
|
||||
server_running = true;
|
||||
|
||||
@ -51,7 +51,7 @@ void GBAConnectionWaiter_Shutdown()
|
||||
connectionThread.join();
|
||||
}
|
||||
|
||||
bool GetAvailableSock(sf::SocketTCP& sock_to_fill)
|
||||
static bool GetAvailableSock(sf::SocketTCP& sock_to_fill)
|
||||
{
|
||||
bool sock_filled = false;
|
||||
|
||||
|
||||
@ -13,7 +13,7 @@ static s32 histl2;
|
||||
static s32 histr1;
|
||||
static s32 histr2;
|
||||
|
||||
s16 ADPDecodeSample(s32 bits, s32 q, s32& hist1, s32& hist2)
|
||||
static s16 ADPDecodeSample(s32 bits, s32 q, s32& hist1, s32& hist2)
|
||||
{
|
||||
s32 hist = 0;
|
||||
switch (q >> 4)
|
||||
|
||||
@ -82,7 +82,7 @@ IPC_HLE_PERIOD: For the Wiimote this is the call schedule:
|
||||
namespace SystemTimers
|
||||
{
|
||||
|
||||
u32 CPU_CORE_CLOCK = 486000000u; // 486 mhz (its not 485, stop bugging me!)
|
||||
static u32 CPU_CORE_CLOCK = 486000000u; // 486 mhz (its not 485, stop bugging me!)
|
||||
|
||||
/*
|
||||
GameCube MHz
|
||||
@ -109,19 +109,19 @@ enum
|
||||
TIMER_RATIO = 12
|
||||
};
|
||||
|
||||
int et_Dec;
|
||||
int et_VI;
|
||||
int et_SI;
|
||||
int et_CP;
|
||||
int et_AudioDMA;
|
||||
int et_DSP;
|
||||
int et_IPC_HLE;
|
||||
int et_PatchEngine; // PatchEngine updates every 1/60th of a second by default
|
||||
int et_Throttle;
|
||||
static int et_Dec;
|
||||
static int et_VI;
|
||||
static int et_SI;
|
||||
static int et_CP;
|
||||
static int et_AudioDMA;
|
||||
static int et_DSP;
|
||||
static int et_IPC_HLE;
|
||||
static int et_PatchEngine; // PatchEngine updates every 1/60th of a second by default
|
||||
static int et_Throttle;
|
||||
|
||||
// These are badly educated guesses
|
||||
// Feel free to experiment. Set these in Init below.
|
||||
int
|
||||
static int
|
||||
// This is a fixed value, don't change it
|
||||
AUDIO_DMA_PERIOD,
|
||||
|
||||
@ -139,13 +139,13 @@ u32 GetTicksPerSecond()
|
||||
return CPU_CORE_CLOCK;
|
||||
}
|
||||
|
||||
u32 ConvertMillisecondsToTicks(u32 _Milliseconds)
|
||||
static u32 ConvertMillisecondsToTicks(u32 _Milliseconds)
|
||||
{
|
||||
return GetTicksPerSecond() / 1000 * _Milliseconds;
|
||||
}
|
||||
|
||||
// DSP/CPU timeslicing.
|
||||
void DSPCallback(u64 userdata, int cyclesLate)
|
||||
static void DSPCallback(u64 userdata, int cyclesLate)
|
||||
{
|
||||
//splits up the cycle budget in case lle is used
|
||||
//for hle, just gives all of the slice to hle
|
||||
@ -153,7 +153,7 @@ void DSPCallback(u64 userdata, int cyclesLate)
|
||||
CoreTiming::ScheduleEvent(DSP::GetDSPEmulator()->DSP_UpdateRate() - cyclesLate, et_DSP);
|
||||
}
|
||||
|
||||
void AudioDMACallback(u64 userdata, int cyclesLate)
|
||||
static void AudioDMACallback(u64 userdata, int cyclesLate)
|
||||
{
|
||||
int fields = VideoInterface::GetNumFields();
|
||||
int period = CPU_CORE_CLOCK / (AudioInterface::GetAIDSampleRate() * 4 / 32 * fields);
|
||||
@ -161,7 +161,7 @@ void AudioDMACallback(u64 userdata, int cyclesLate)
|
||||
CoreTiming::ScheduleEvent(period - cyclesLate, et_AudioDMA);
|
||||
}
|
||||
|
||||
void IPC_HLE_UpdateCallback(u64 userdata, int cyclesLate)
|
||||
static void IPC_HLE_UpdateCallback(u64 userdata, int cyclesLate)
|
||||
{
|
||||
if (SConfig::GetInstance().m_LocalCoreStartupParameter.bWii)
|
||||
{
|
||||
@ -170,25 +170,25 @@ void IPC_HLE_UpdateCallback(u64 userdata, int cyclesLate)
|
||||
}
|
||||
}
|
||||
|
||||
void VICallback(u64 userdata, int cyclesLate)
|
||||
static void VICallback(u64 userdata, int cyclesLate)
|
||||
{
|
||||
VideoInterface::Update();
|
||||
CoreTiming::ScheduleEvent(VideoInterface::GetTicksPerLine() - cyclesLate, et_VI);
|
||||
}
|
||||
|
||||
void SICallback(u64 userdata, int cyclesLate)
|
||||
static void SICallback(u64 userdata, int cyclesLate)
|
||||
{
|
||||
SerialInterface::UpdateDevices();
|
||||
CoreTiming::ScheduleEvent(SerialInterface::GetTicksToNextSIPoll() - cyclesLate, et_SI);
|
||||
}
|
||||
|
||||
void CPCallback(u64 userdata, int cyclesLate)
|
||||
static void CPCallback(u64 userdata, int cyclesLate)
|
||||
{
|
||||
CommandProcessor::Update();
|
||||
CoreTiming::ScheduleEvent(CP_PERIOD - cyclesLate, et_CP);
|
||||
}
|
||||
|
||||
void DecrementerCallback(u64 userdata, int cyclesLate)
|
||||
static void DecrementerCallback(u64 userdata, int cyclesLate)
|
||||
{
|
||||
PowerPC::ppcState.spr[SPR_DEC] = 0xFFFFFFFF;
|
||||
Common::AtomicOr(PowerPC::ppcState.Exceptions, EXCEPTION_DECREMENTER);
|
||||
@ -224,7 +224,7 @@ u64 GetFakeTimeBase()
|
||||
return CoreTiming::GetFakeTBStartValue() + ((CoreTiming::GetTicks() - CoreTiming::GetFakeTBStartTicks()) / TIMER_RATIO);
|
||||
}
|
||||
|
||||
void PatchEngineCallback(u64 userdata, int cyclesLate)
|
||||
static void PatchEngineCallback(u64 userdata, int cyclesLate)
|
||||
{
|
||||
// Patch mem and run the Action Replay
|
||||
PatchEngine::ApplyFramePatches();
|
||||
@ -232,7 +232,7 @@ void PatchEngineCallback(u64 userdata, int cyclesLate)
|
||||
CoreTiming::ScheduleEvent(VideoInterface::GetTicksPerFrame() - cyclesLate, et_PatchEngine);
|
||||
}
|
||||
|
||||
void ThrottleCallback(u64 last_time, int cyclesLate)
|
||||
static void ThrottleCallback(u64 last_time, int cyclesLate)
|
||||
{
|
||||
u32 time = Common::Timer::GetTimeMs();
|
||||
|
||||
|
||||
@ -101,7 +101,7 @@ static u32 arm_irq_masks;
|
||||
|
||||
static u32 sensorbar_power; // do we need to care about this?
|
||||
|
||||
int updateInterrupts;
|
||||
static int updateInterrupts;
|
||||
|
||||
void DoState(PointerWrap &p)
|
||||
{
|
||||
|
||||
@ -192,7 +192,7 @@ static inline u8 ror8(const u8 a, const u8 b)
|
||||
}
|
||||
|
||||
|
||||
void genkey(const u8* const rand, const u8 idx, u8* const key)
|
||||
static void genkey(const u8* const rand, const u8 idx, u8* const key)
|
||||
{
|
||||
const u8* const ans = ans_tbl[idx];
|
||||
u8 t0[10];
|
||||
@ -209,7 +209,7 @@ void genkey(const u8* const rand, const u8 idx, u8* const key)
|
||||
}
|
||||
|
||||
|
||||
void gentabs(const u8* const rand, const u8* const key, const u8 idx, u8* const ft, u8* const sb)
|
||||
static void gentabs(const u8* const rand, const u8* const key, const u8 idx, u8* const ft, u8* const sb)
|
||||
{
|
||||
ft[0] = sboxes[idx][key[4]] ^ sboxes[(idx+1)%8][rand[3]];
|
||||
ft[1] = sboxes[idx][key[2]] ^ sboxes[(idx+1)%8][rand[5]];
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
|
||||
namespace UDPTLayer
|
||||
{
|
||||
void GetButtons(UDPWrapper * m , wm_core * butt)
|
||||
static void GetButtons(UDPWrapper * m , wm_core * butt)
|
||||
{
|
||||
if (!(m->inst)) return;
|
||||
if (!(m->updButt)) return;
|
||||
@ -29,7 +29,7 @@ namespace UDPTLayer
|
||||
*butt |= (mask & UDPWM_BR) ? WiimoteEmu::Wiimote::PAD_RIGHT : 0;
|
||||
}
|
||||
|
||||
void GetAcceleration(UDPWrapper * m , WiimoteEmu::AccelData * const data)
|
||||
static void GetAcceleration(UDPWrapper * m , WiimoteEmu::AccelData * const data)
|
||||
{
|
||||
if (!(m->inst)) return;
|
||||
if (!(m->updAccel)) return;
|
||||
@ -40,7 +40,7 @@ namespace UDPTLayer
|
||||
data->z = z;
|
||||
}
|
||||
|
||||
void GetIR( UDPWrapper * m, float * x, float * y, float * z)
|
||||
static void GetIR( UDPWrapper * m, float * x, float * y, float * z)
|
||||
{
|
||||
if (!(m->inst)) return;
|
||||
if (!(m->updIR)) return;
|
||||
|
||||
@ -54,7 +54,7 @@ static const u8 eeprom_data_16D0[] = {
|
||||
0x77, 0x88, 0x00, 0x00, 0x2B, 0x01, 0xE8, 0x13
|
||||
};
|
||||
|
||||
const ReportFeatures reporting_mode_features[] =
|
||||
static const ReportFeatures reporting_mode_features[] =
|
||||
{
|
||||
//0x30: Core Buttons
|
||||
{ 2, 0, 0, 0, 4 },
|
||||
|
||||
@ -68,8 +68,6 @@ struct ExtensionReg
|
||||
u8 constant_id[6];
|
||||
};
|
||||
|
||||
extern const ReportFeatures reporting_mode_features[];
|
||||
|
||||
void FillRawAccelFromGForceData(wm_accel& raw_accel,
|
||||
const accel_cal& calib,
|
||||
const WiimoteEmu::AccelData& accel);
|
||||
|
||||
@ -29,7 +29,7 @@ void TryToConnectWiimote(Wiimote*);
|
||||
void HandleWiimoteDisconnect(int index);
|
||||
void DoneWithWiimote(int index);
|
||||
|
||||
bool g_real_wiimotes_initialized = false;
|
||||
static bool g_real_wiimotes_initialized = false;
|
||||
|
||||
std::recursive_mutex g_refresh_lock;
|
||||
|
||||
@ -254,7 +254,7 @@ bool Wiimote::Write()
|
||||
return false;
|
||||
}
|
||||
|
||||
bool IsDataReport(const Report& rpt)
|
||||
static bool IsDataReport(const Report& rpt)
|
||||
{
|
||||
return rpt.size() >= 2 && rpt[1] >= WM_REPORT_CORE;
|
||||
}
|
||||
@ -373,7 +373,7 @@ void Wiimote::EmuPause()
|
||||
NOTICE_LOG(WIIMOTE, "Pausing Wiimote data reporting.");
|
||||
}
|
||||
|
||||
unsigned int CalculateConnectedWiimotes()
|
||||
static unsigned int CalculateConnectedWiimotes()
|
||||
{
|
||||
unsigned int connected_wiimotes = 0;
|
||||
for (unsigned int i = 0; i < MAX_WIIMOTES; ++i)
|
||||
@ -383,7 +383,7 @@ unsigned int CalculateConnectedWiimotes()
|
||||
return connected_wiimotes;
|
||||
}
|
||||
|
||||
unsigned int CalculateWantedWiimotes()
|
||||
static unsigned int CalculateWantedWiimotes()
|
||||
{
|
||||
// Figure out how many real Wiimotes are required
|
||||
unsigned int wanted_wiimotes = 0;
|
||||
@ -394,7 +394,7 @@ unsigned int CalculateWantedWiimotes()
|
||||
return wanted_wiimotes;
|
||||
}
|
||||
|
||||
unsigned int CalculateWantedBB()
|
||||
static unsigned int CalculateWantedBB()
|
||||
{
|
||||
unsigned int wanted_bb = 0;
|
||||
if (WIIMOTE_SRC_REAL & g_wiimote_sources[WIIMOTE_BALANCE_BOARD] && !g_wiimotes[WIIMOTE_BALANCE_BOARD])
|
||||
@ -431,7 +431,7 @@ void WiimoteScanner::StopScanning()
|
||||
}
|
||||
}
|
||||
|
||||
void CheckForDisconnectedWiimotes()
|
||||
static void CheckForDisconnectedWiimotes()
|
||||
{
|
||||
std::lock_guard<std::recursive_mutex> lk(g_refresh_lock);
|
||||
|
||||
|
||||
@ -61,16 +61,16 @@ namespace WII_IPC_HLE_Interface
|
||||
{
|
||||
|
||||
typedef std::map<u32, IWII_IPC_HLE_Device*> TDeviceMap;
|
||||
TDeviceMap g_DeviceMap;
|
||||
static TDeviceMap g_DeviceMap;
|
||||
|
||||
// STATE_TO_SAVE
|
||||
typedef std::map<u32, std::string> TFileNameMap;
|
||||
|
||||
#define IPC_MAX_FDS 0x18
|
||||
#define ES_MAX_COUNT 2
|
||||
IWII_IPC_HLE_Device* g_FdMap[IPC_MAX_FDS];
|
||||
bool es_inuse[ES_MAX_COUNT];
|
||||
IWII_IPC_HLE_Device* es_handles[ES_MAX_COUNT];
|
||||
static IWII_IPC_HLE_Device* g_FdMap[IPC_MAX_FDS];
|
||||
static bool es_inuse[ES_MAX_COUNT];
|
||||
static IWII_IPC_HLE_Device* es_handles[ES_MAX_COUNT];
|
||||
|
||||
|
||||
typedef std::deque<u32> ipc_msg_queue;
|
||||
|
||||
@ -50,8 +50,6 @@ typedef struct pollfd pollfd_t;
|
||||
#include <errno.h>
|
||||
#endif
|
||||
|
||||
extern std::queue<std::pair<u32,std::string> > g_ReplyQueueLater;
|
||||
|
||||
// **********************************************************************************
|
||||
// Handle /dev/net/kd/request requests
|
||||
CWII_IPC_HLE_Device_net_kd_request::CWII_IPC_HLE_Device_net_kd_request(u32 _DeviceID, const std::string& _rDeviceName)
|
||||
@ -308,13 +306,13 @@ s32 CWII_IPC_HLE_Device_net_kd_request::NWC24MakeUserID(u64* nwc24_id, u32 holly
|
||||
return WC24_OK;
|
||||
}
|
||||
|
||||
void SaveMacAddress(u8* mac)
|
||||
static void SaveMacAddress(u8* mac)
|
||||
{
|
||||
SConfig::GetInstance().m_WirelessMac = MacAddressToString(mac);
|
||||
SConfig::GetInstance().SaveSettings();
|
||||
}
|
||||
|
||||
void GetMacAddress(u8* mac)
|
||||
static void GetMacAddress(u8* mac)
|
||||
{
|
||||
// Parse MAC address from config, and generate a new one if it doesn't
|
||||
// exist or can't be parsed.
|
||||
|
||||
@ -700,7 +700,7 @@ static u32 ParseCont(u8* pCont)
|
||||
}
|
||||
|
||||
|
||||
int ParseAttribList(u8* pAttribIDList, u16& _startID, u16& _endID)
|
||||
static int ParseAttribList(u8* pAttribIDList, u16& _startID, u16& _endID)
|
||||
{
|
||||
u32 attribOffset = 0;
|
||||
CBigEndianBuffer attribList(pAttribIDList);
|
||||
|
||||
@ -34,7 +34,7 @@ char* WiiSockMan::DecodeError(s32 ErrorCode)
|
||||
#endif
|
||||
}
|
||||
|
||||
s32 TranslateErrorCode(s32 native_error, bool isRW)
|
||||
static s32 TranslateErrorCode(s32 native_error, bool isRW)
|
||||
{
|
||||
switch (native_error)
|
||||
{
|
||||
|
||||
@ -35,54 +35,56 @@
|
||||
// The chunk to allocate movie data in multiples of.
|
||||
#define DTM_BASE_LENGTH (1024)
|
||||
|
||||
std::mutex cs_frameSkip;
|
||||
static std::mutex cs_frameSkip;
|
||||
|
||||
namespace Movie {
|
||||
|
||||
bool g_bFrameStep = false;
|
||||
bool g_bFrameStop = false;
|
||||
bool g_bReadOnly = true;
|
||||
u32 g_rerecords = 0;
|
||||
PlayMode g_playMode = MODE_NONE;
|
||||
static bool g_bFrameStep = false;
|
||||
static bool g_bFrameStop = false;
|
||||
static bool g_bReadOnly = true;
|
||||
static u32 g_rerecords = 0;
|
||||
static PlayMode g_playMode = MODE_NONE;
|
||||
|
||||
u32 g_framesToSkip = 0, g_frameSkipCounter = 0;
|
||||
static u32 g_framesToSkip = 0, g_frameSkipCounter = 0;
|
||||
|
||||
u8 g_numPads = 0;
|
||||
ControllerState g_padState;
|
||||
DTMHeader tmpHeader;
|
||||
u8* tmpInput = nullptr;
|
||||
size_t tmpInputAllocated = 0;
|
||||
u64 g_currentByte = 0, g_totalBytes = 0;
|
||||
static u8 g_numPads = 0;
|
||||
static ControllerState g_padState;
|
||||
static DTMHeader tmpHeader;
|
||||
static u8* tmpInput = nullptr;
|
||||
static size_t tmpInputAllocated = 0;
|
||||
static u64 g_currentByte = 0, g_totalBytes = 0;
|
||||
u64 g_currentFrame = 0, g_totalFrames = 0; // VI
|
||||
u64 g_currentLagCount = 0, g_totalLagCount = 0; // just stats
|
||||
u64 g_currentLagCount = 0;
|
||||
static u64 g_totalLagCount = 0; // just stats
|
||||
u64 g_currentInputCount = 0, g_totalInputCount = 0; // just stats
|
||||
u64 g_totalTickCount = 0, g_tickCountAtLastInput = 0; // just stats
|
||||
u64 g_recordingStartTime; // seconds since 1970 that recording started
|
||||
bool bSaveConfig = false, bSkipIdle = false, bDualCore = false, bProgressive = false, bDSPHLE = false, bFastDiscSpeed = false;
|
||||
bool g_bClearSave = false, bSyncGPU = false, bNetPlay = false;
|
||||
std::string videoBackend = "unknown";
|
||||
int iCPUCore = 1;
|
||||
static u64 g_totalTickCount = 0, g_tickCountAtLastInput = 0; // just stats
|
||||
static u64 g_recordingStartTime; // seconds since 1970 that recording started
|
||||
static bool bSaveConfig = false, bSkipIdle = false, bDualCore = false, bProgressive = false, bDSPHLE = false, bFastDiscSpeed = false;
|
||||
bool g_bClearSave = false;
|
||||
static bool bSyncGPU = false, bNetPlay = false;
|
||||
static std::string videoBackend = "unknown";
|
||||
static int iCPUCore = 1;
|
||||
bool g_bDiscChange = false;
|
||||
std::string g_discChange = "";
|
||||
std::string author = "";
|
||||
static std::string author = "";
|
||||
u64 g_titleID = 0;
|
||||
unsigned char MD5[16];
|
||||
u8 bongos, memcards;
|
||||
u8 revision[20];
|
||||
u32 DSPiromHash = 0;
|
||||
u32 DSPcoefHash = 0;
|
||||
static unsigned char MD5[16];
|
||||
static u8 bongos, memcards;
|
||||
static u8 revision[20];
|
||||
static u32 DSPiromHash = 0;
|
||||
static u32 DSPcoefHash = 0;
|
||||
|
||||
bool g_bRecordingFromSaveState = false;
|
||||
bool g_bPolled = false;
|
||||
int g_currentSaveVersion = 0;
|
||||
static bool g_bRecordingFromSaveState = false;
|
||||
static bool g_bPolled = false;
|
||||
static int g_currentSaveVersion = 0;
|
||||
|
||||
std::string tmpStateFilename = File::GetUserPath(D_STATESAVES_IDX) + "dtm.sav";
|
||||
static std::string tmpStateFilename = File::GetUserPath(D_STATESAVES_IDX) + "dtm.sav";
|
||||
|
||||
std::string g_InputDisplay[8];
|
||||
static std::string g_InputDisplay[8];
|
||||
|
||||
ManipFunction mfunc = nullptr;
|
||||
static ManipFunction mfunc = nullptr;
|
||||
|
||||
void EnsureTmpInputSize(size_t bound)
|
||||
static void EnsureTmpInputSize(size_t bound)
|
||||
{
|
||||
if (tmpInputAllocated >= bound)
|
||||
return;
|
||||
@ -525,7 +527,7 @@ static std::string Analog1DToString(u8 v, const std::string& prefix)
|
||||
}
|
||||
}
|
||||
|
||||
void SetInputDisplayString(ControllerState padState, int controllerID)
|
||||
static void SetInputDisplayString(ControllerState padState, int controllerID)
|
||||
{
|
||||
g_InputDisplay[controllerID] = StringFromFormat("P%d:", controllerID + 1);
|
||||
|
||||
@ -558,7 +560,7 @@ void SetInputDisplayString(ControllerState padState, int controllerID)
|
||||
g_InputDisplay[controllerID].append("\n");
|
||||
}
|
||||
|
||||
void SetWiiInputDisplayString(int remoteID, u8* const coreData, u8* const accelData, u8* const irData)
|
||||
static void SetWiiInputDisplayString(int remoteID, u8* const coreData, u8* const accelData, u8* const irData)
|
||||
{
|
||||
int controllerID = remoteID + 4;
|
||||
|
||||
|
||||
@ -49,26 +49,14 @@ static_assert(sizeof(ControllerState) == 8, "ControllerState should be 8 bytes")
|
||||
#pragma pack(pop)
|
||||
|
||||
// Global declarations
|
||||
extern bool g_bFrameStep, g_bPolled, g_bReadOnly, g_bDiscChange, g_bClearSave;
|
||||
extern PlayMode g_playMode;
|
||||
extern bool g_bDiscChange, g_bClearSave;
|
||||
extern u64 g_titleID;
|
||||
|
||||
extern u32 g_framesToSkip, g_frameSkipCounter;
|
||||
|
||||
extern u8 g_numPads;
|
||||
extern ControllerState *g_padStates;
|
||||
extern char g_playingFile[256];
|
||||
extern std::string g_recordFile;
|
||||
|
||||
extern u64 g_currentByte, g_totalBytes;
|
||||
extern u64 g_currentFrame, g_totalFrames;
|
||||
extern u64 g_currentLagCount, g_totalLagCount;
|
||||
extern u64 g_currentLagCount;
|
||||
extern u64 g_currentInputCount, g_totalInputCount;
|
||||
extern u64 g_totalTickCount, g_tickCountAtLastInput;
|
||||
extern std::string g_discChange;
|
||||
|
||||
extern u32 g_rerecords;
|
||||
|
||||
#pragma pack(push,1)
|
||||
struct DTMHeader
|
||||
{
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
#include "Core/IPC_HLE/WII_IPC_HLE_WiiMote.h"
|
||||
|
||||
|
||||
std::mutex crit_netplay_client;
|
||||
static std::mutex crit_netplay_client;
|
||||
static NetPlayClient * netplay_client = nullptr;
|
||||
NetSettings g_NetPlaySettings;
|
||||
|
||||
|
||||
@ -43,8 +43,8 @@ const char *PatchTypeStrings[] =
|
||||
"dword",
|
||||
};
|
||||
|
||||
std::vector<Patch> onFrame;
|
||||
std::map<u32, int> speedHacks;
|
||||
static std::vector<Patch> onFrame;
|
||||
static std::map<u32, int> speedHacks;
|
||||
|
||||
void LoadPatchSection(const std::string& section, std::vector<Patch>& patches, IniFile& globalIni, IniFile& localIni)
|
||||
{
|
||||
@ -174,7 +174,7 @@ void LoadPatches()
|
||||
LoadSpeedhacks("Speedhacks", merged);
|
||||
}
|
||||
|
||||
void ApplyPatches(const std::vector<Patch> &patches)
|
||||
static void ApplyPatches(const std::vector<Patch> &patches)
|
||||
{
|
||||
for (const Patch& patch : patches)
|
||||
{
|
||||
|
||||
@ -5,6 +5,8 @@
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "Common/IniFile.h"
|
||||
|
||||
namespace PatchEngine
|
||||
@ -65,3 +67,4 @@ inline int GetPatchTypeCharLength(PatchType type)
|
||||
}
|
||||
|
||||
} // namespace
|
||||
extern std::vector<PatchEngine::Patch> onFrame;
|
||||
|
||||
@ -65,9 +65,9 @@ static void patches()
|
||||
}*/
|
||||
}
|
||||
|
||||
int startTrace = 0;
|
||||
static int startTrace = 0;
|
||||
|
||||
void Trace(UGeckoInstruction& instCode)
|
||||
static void Trace(UGeckoInstruction& instCode)
|
||||
{
|
||||
std::string regs = "";
|
||||
for (int i = 0; i < 32; i++)
|
||||
|
||||
@ -142,11 +142,6 @@ ps_adds1
|
||||
|
||||
static int CODE_SIZE = 1024*1024*32;
|
||||
|
||||
namespace CPUCompare
|
||||
{
|
||||
extern u32 m_BlockStart;
|
||||
}
|
||||
|
||||
void Jit64::Init()
|
||||
{
|
||||
jo.optimizeStack = true;
|
||||
|
||||
@ -170,10 +170,10 @@ void Jit64::ComputeRC(const Gen::OpArg & arg)
|
||||
}
|
||||
}
|
||||
|
||||
u32 Add(u32 a, u32 b) {return a + b;}
|
||||
u32 Or (u32 a, u32 b) {return a | b;}
|
||||
u32 And(u32 a, u32 b) {return a & b;}
|
||||
u32 Xor(u32 a, u32 b) {return a ^ b;}
|
||||
static u32 Add(u32 a, u32 b) {return a + b;}
|
||||
static u32 Or (u32 a, u32 b) {return a | b;}
|
||||
static u32 And(u32 a, u32 b) {return a & b;}
|
||||
static u32 Xor(u32 a, u32 b) {return a ^ b;}
|
||||
|
||||
void Jit64::regimmop(int d, int a, bool binary, u32 value, Operation doop, void (XEmitter::*op)(int, const Gen::OpArg&, const Gen::OpArg&), bool Rc, bool carry)
|
||||
{
|
||||
|
||||
@ -221,7 +221,7 @@ namespace JitILProfiler
|
||||
}
|
||||
}
|
||||
};
|
||||
std::unique_ptr<JitILProfilerFinalizer> finalizer;
|
||||
static std::unique_ptr<JitILProfilerFinalizer> finalizer;
|
||||
static void Init()
|
||||
{
|
||||
finalizer = std::make_unique<JitILProfilerFinalizer>();
|
||||
@ -234,11 +234,6 @@ namespace JitILProfiler
|
||||
|
||||
static int CODE_SIZE = 1024*1024*32;
|
||||
|
||||
namespace CPUCompare
|
||||
{
|
||||
extern u32 m_BlockStart;
|
||||
}
|
||||
|
||||
void JitIL::Init()
|
||||
{
|
||||
jo.optimizeStack = true;
|
||||
|
||||
@ -26,10 +26,6 @@ using namespace ArmGen;
|
||||
using namespace PowerPC;
|
||||
|
||||
static int CODE_SIZE = 1024*1024*32;
|
||||
namespace CPUCompare
|
||||
{
|
||||
extern u32 m_BlockStart;
|
||||
}
|
||||
|
||||
void JitArm::Init()
|
||||
{
|
||||
|
||||
@ -14,8 +14,6 @@
|
||||
#include "Core/PowerPC/JitArm32/JitAsm.h"
|
||||
#include "Core/PowerPC/JitArm32/JitRegCache.h"
|
||||
|
||||
extern u32 Helper_Mask(u8 mb, u8 me);
|
||||
|
||||
// Assumes that Sign and Zero flags were set by the last operation. Preserves all flags and registers.
|
||||
// Jit64 ComputerRC is signed
|
||||
// JIT64 GenerateRC is unsigned
|
||||
|
||||
@ -25,10 +25,7 @@ using namespace ArmGen;
|
||||
using namespace PowerPC;
|
||||
|
||||
static int CODE_SIZE = 1024*1024*32;
|
||||
namespace CPUCompare
|
||||
{
|
||||
extern u32 m_BlockStart;
|
||||
}
|
||||
|
||||
void JitArmIL::Init()
|
||||
{
|
||||
AllocCodeSpace(CODE_SIZE);
|
||||
|
||||
@ -16,7 +16,6 @@
|
||||
|
||||
using namespace ArmGen;
|
||||
|
||||
JitArmILAsmRoutineManager armil_asm_routines;
|
||||
void JitArmILAsmRoutineManager::Generate()
|
||||
{
|
||||
enterCode = GetCodePtr();
|
||||
|
||||
@ -25,4 +25,3 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
extern JitArmILAsmRoutineManager armil_asm_routines;
|
||||
|
||||
@ -19,8 +19,6 @@
|
||||
|
||||
using namespace Gen;
|
||||
|
||||
extern u8 *trampolineCodePtr;
|
||||
|
||||
#if _M_X86_64
|
||||
static void BackPatchError(const std::string &text, u8 *codePtr, u32 emAddress) {
|
||||
u64 code_addr = (u64)codePtr;
|
||||
|
||||
@ -31,7 +31,7 @@
|
||||
#include "Core/PowerPC/JitArmIL/JitIL_Tables.h"
|
||||
#endif
|
||||
|
||||
bool bFakeVMEM = false;
|
||||
static bool bFakeVMEM = false;
|
||||
bool bMMU = false;
|
||||
|
||||
namespace JitInterface
|
||||
|
||||
@ -35,6 +35,5 @@ namespace JitInterface
|
||||
|
||||
void Shutdown();
|
||||
}
|
||||
extern bool bFakeVMEM;
|
||||
extern bool bMMU;
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,9 +0,0 @@
|
||||
// Copyright 2013 Dolphin Emulator Project
|
||||
// Licensed under GPLv2
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
// Gekko related unions, structs, ...
|
||||
|
||||
#pragma once
|
||||
|
||||
extern const unsigned int frsqrtex_lut[65536];
|
||||
@ -192,7 +192,7 @@ bool AnalyzeFunction(u32 startAddr, Symbol &func, int max_size)
|
||||
|
||||
// Second pass analysis, done after the first pass is done for all functions
|
||||
// so we have more information to work with
|
||||
void AnalyzeFunction2(Symbol *func)
|
||||
static void AnalyzeFunction2(Symbol *func)
|
||||
{
|
||||
u32 flags = func->flags;
|
||||
|
||||
@ -214,7 +214,7 @@ void AnalyzeFunction2(Symbol *func)
|
||||
}
|
||||
|
||||
// IMPORTANT - CURRENTLY ASSUMES THAT A IS A COMPARE
|
||||
bool CanSwapAdjacentOps(const CodeOp &a, const CodeOp &b)
|
||||
static bool CanSwapAdjacentOps(const CodeOp &a, const CodeOp &b)
|
||||
{
|
||||
const GekkoOPInfo *b_info = b.opinfo;
|
||||
int b_flags = b_info->flags;
|
||||
@ -273,7 +273,7 @@ bool CanSwapAdjacentOps(const CodeOp &a, const CodeOp &b)
|
||||
// called by another function. Therefore, let's scan the
|
||||
// entire space for bl operations and find what functions
|
||||
// get called.
|
||||
void FindFunctionsFromBranches(u32 startAddr, u32 endAddr, SymbolDB *func_db)
|
||||
static void FindFunctionsFromBranches(u32 startAddr, u32 endAddr, SymbolDB *func_db)
|
||||
{
|
||||
for (u32 addr = startAddr; addr < endAddr; addr+=4)
|
||||
{
|
||||
@ -304,7 +304,7 @@ void FindFunctionsFromBranches(u32 startAddr, u32 endAddr, SymbolDB *func_db)
|
||||
}
|
||||
}
|
||||
|
||||
void FindFunctionsAfterBLR(PPCSymbolDB *func_db)
|
||||
static void FindFunctionsAfterBLR(PPCSymbolDB *func_db)
|
||||
{
|
||||
vector<u32> funcAddrs;
|
||||
|
||||
|
||||
@ -30,10 +30,10 @@ namespace PowerPC
|
||||
|
||||
// STATE_TO_SAVE
|
||||
PowerPCState GC_ALIGNED16(ppcState);
|
||||
volatile CPUState state = CPU_STEPPING;
|
||||
static volatile CPUState state = CPU_STEPPING;
|
||||
|
||||
Interpreter * const interpreter = Interpreter::getInstance();
|
||||
CoreMode mode;
|
||||
static CoreMode mode;
|
||||
|
||||
BreakPoints breakpoints;
|
||||
MemChecks memchecks;
|
||||
@ -74,7 +74,7 @@ void DoState(PointerWrap &p)
|
||||
JitInterface::DoState(p);
|
||||
}
|
||||
|
||||
void ResetRegisters()
|
||||
static void ResetRegisters()
|
||||
{
|
||||
memset(ppcState.ps, 0, sizeof(ppcState.ps));
|
||||
memset(ppcState.gpr, 0, sizeof(ppcState.gpr));
|
||||
|
||||
@ -4,12 +4,12 @@
|
||||
|
||||
#include <string>
|
||||
#include "Core/PowerPC/JitInterface.h"
|
||||
#include "Core/PowerPC/Profiler.h"
|
||||
|
||||
namespace Profiler
|
||||
{
|
||||
|
||||
bool g_ProfileBlocks;
|
||||
bool g_ProfileInstructions;
|
||||
|
||||
void WriteProfileResults(const std::string& filename)
|
||||
{
|
||||
|
||||
@ -58,7 +58,6 @@ struct BlockStat
|
||||
namespace Profiler
|
||||
{
|
||||
extern bool g_ProfileBlocks;
|
||||
extern bool g_ProfileInstructions;
|
||||
|
||||
void WriteProfileResults(const std::string& filename);
|
||||
}
|
||||
|
||||
@ -79,7 +79,7 @@ void EnableCompression(bool compression)
|
||||
g_use_compression = compression;
|
||||
}
|
||||
|
||||
void DoState(PointerWrap &p)
|
||||
static void DoState(PointerWrap &p)
|
||||
{
|
||||
u32 version = STATE_VERSION;
|
||||
{
|
||||
@ -159,7 +159,7 @@ void VerifyBuffer(std::vector<u8>& buffer)
|
||||
}
|
||||
|
||||
// return state number not in map
|
||||
int GetEmptySlot(std::map<double, int> m)
|
||||
static int GetEmptySlot(std::map<double, int> m)
|
||||
{
|
||||
for (int i = 1; i <= (int)NUM_STATES; i++)
|
||||
{
|
||||
@ -180,7 +180,7 @@ int GetEmptySlot(std::map<double, int> m)
|
||||
static std::string MakeStateFilename(int number);
|
||||
|
||||
// read state timestamps
|
||||
std::map<double, int> GetSavedStates()
|
||||
static std::map<double, int> GetSavedStates()
|
||||
{
|
||||
StateHeader header;
|
||||
std::map<double, int> m;
|
||||
@ -209,7 +209,7 @@ struct CompressAndDumpState_args
|
||||
bool wait;
|
||||
};
|
||||
|
||||
void CompressAndDumpState(CompressAndDumpState_args save_args)
|
||||
static void CompressAndDumpState(CompressAndDumpState_args save_args)
|
||||
{
|
||||
std::lock_guard<std::mutex> lk(*save_args.buffer_mutex);
|
||||
if (!save_args.wait)
|
||||
@ -356,7 +356,7 @@ bool ReadHeader(const std::string& filename, StateHeader& header)
|
||||
return true;
|
||||
}
|
||||
|
||||
void LoadFileStateData(const std::string& filename, std::vector<u8>& ret_data)
|
||||
static void LoadFileStateData(const std::string& filename, std::vector<u8>& ret_data)
|
||||
{
|
||||
Flush();
|
||||
File::IOFile f(filename, "rb");
|
||||
|
||||
@ -7,16 +7,17 @@
|
||||
#include "Common/Common.h"
|
||||
#include "Common/FileUtil.h"
|
||||
|
||||
#include "Core/Core.h"
|
||||
#include "Core/Host.h"
|
||||
#include "Core/Tracer.h"
|
||||
#include "Core/PowerPC/PowerPC.h"
|
||||
|
||||
namespace Core {
|
||||
|
||||
File::IOFile tracefile;
|
||||
static File::IOFile tracefile;
|
||||
|
||||
bool bReadTrace = false;
|
||||
bool bWriteTrace = false;
|
||||
static bool bReadTrace = false;
|
||||
static bool bWriteTrace = false;
|
||||
|
||||
void StartTrace(bool write)
|
||||
{
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
namespace VolumeHandler
|
||||
{
|
||||
|
||||
DiscIO::IVolume* g_pVolume = nullptr;
|
||||
static DiscIO::IVolume* g_pVolume = nullptr;
|
||||
|
||||
DiscIO::IVolume *GetVolume()
|
||||
{
|
||||
|
||||
@ -123,7 +123,7 @@ void make_blanksig_ec_cert(u8 *cert_out, const char *signer, const char *name, c
|
||||
// remote_public_key is a pointer to the remote party's public key (0x3c bytes)
|
||||
// NG_priv is the device-unique private key to use
|
||||
// if NG_priv is nullptr, default builtin will be used
|
||||
void get_shared_secret(u8* shared_secret_out, u8* remote_public_key, u8* NG_priv)
|
||||
static void get_shared_secret(u8* shared_secret_out, u8* remote_public_key, u8* NG_priv)
|
||||
{
|
||||
if (NG_priv==nullptr)
|
||||
{
|
||||
|
||||
@ -25,7 +25,7 @@ namespace EMM
|
||||
|
||||
#if (defined __APPLE__ || defined __linux__ || defined __FreeBSD__) && !defined(ANDROID)
|
||||
#include <execinfo.h>
|
||||
void print_trace(const char * msg)
|
||||
static void print_trace(const char * msg)
|
||||
{
|
||||
void *array[100];
|
||||
size_t size;
|
||||
@ -41,7 +41,7 @@ void print_trace(const char * msg)
|
||||
}
|
||||
#endif
|
||||
|
||||
bool DoFault(u64 bad_address, SContext *ctx)
|
||||
static bool DoFault(u64 bad_address, SContext *ctx)
|
||||
{
|
||||
if (!JitInterface::IsInCodeSpace((u8*) ctx->CTX_PC))
|
||||
{
|
||||
@ -269,7 +269,7 @@ void InstallExceptionHandler()
|
||||
|
||||
#elif !defined(ANDROID)
|
||||
|
||||
void sigsegv_handler(int sig, siginfo_t *info, void *raw_context)
|
||||
static void sigsegv_handler(int sig, siginfo_t *info, void *raw_context)
|
||||
{
|
||||
#ifndef _M_GENERIC
|
||||
if (sig != SIGSEGV)
|
||||
|
||||
@ -24,15 +24,15 @@ namespace DiscScrubber
|
||||
|
||||
#define CLUSTER_SIZE 0x8000
|
||||
|
||||
u8* m_FreeTable = nullptr;
|
||||
u64 m_FileSize;
|
||||
u64 m_BlockCount;
|
||||
u32 m_BlockSize;
|
||||
int m_BlocksPerCluster;
|
||||
bool m_isScrubbing = false;
|
||||
static u8* m_FreeTable = nullptr;
|
||||
static u64 m_FileSize;
|
||||
static u64 m_BlockCount;
|
||||
static u32 m_BlockSize;
|
||||
static int m_BlocksPerCluster;
|
||||
static bool m_isScrubbing = false;
|
||||
|
||||
std::string m_Filename;
|
||||
IVolume* m_Disc = nullptr;
|
||||
static std::string m_Filename;
|
||||
static IVolume* m_Disc = nullptr;
|
||||
|
||||
struct SPartitionHeader
|
||||
{
|
||||
@ -67,7 +67,7 @@ struct SPartitionGroup
|
||||
u64 PartitionsOffset;
|
||||
std::vector<SPartition> PartitionsVec;
|
||||
};
|
||||
SPartitionGroup PartitionGroup[4];
|
||||
static SPartitionGroup PartitionGroup[4];
|
||||
|
||||
|
||||
void MarkAsUsed(u64 _Offset, u64 _Size);
|
||||
|
||||
@ -17,6 +17,7 @@
|
||||
#include "Core/Core.h"
|
||||
#include "Core/Boot/Boot.h"
|
||||
|
||||
#include "DiscIO/FileMonitor.h"
|
||||
#include "DiscIO/Filesystem.h"
|
||||
#include "DiscIO/Volume.h"
|
||||
#include "DiscIO/VolumeCreator.h"
|
||||
@ -24,11 +25,11 @@
|
||||
namespace FileMon
|
||||
{
|
||||
|
||||
DiscIO::IVolume *OpenISO = nullptr;
|
||||
DiscIO::IFileSystem *pFileSystem = nullptr;
|
||||
std::vector<const DiscIO::SFileInfo *> GCFiles;
|
||||
std::string ISOFile = "", CurrentFile = "";
|
||||
bool FileAccess = true;
|
||||
static DiscIO::IVolume *OpenISO = nullptr;
|
||||
static DiscIO::IFileSystem *pFileSystem = nullptr;
|
||||
static std::vector<const DiscIO::SFileInfo *> GCFiles;
|
||||
static std::string ISOFile = "", CurrentFile = "";
|
||||
static bool FileAccess = true;
|
||||
|
||||
// Filtered files
|
||||
bool IsSoundFile(const std::string& filename)
|
||||
|
||||
@ -14,6 +14,7 @@
|
||||
|
||||
#include "DiscIO/Blob.h"
|
||||
#include "DiscIO/Volume.h"
|
||||
#include "DiscIO/VolumeCreator.h"
|
||||
#include "DiscIO/VolumeDirectory.h"
|
||||
#include "DiscIO/VolumeGC.h"
|
||||
#include "DiscIO/VolumeWad.h"
|
||||
|
||||
@ -25,12 +25,11 @@
|
||||
#include "Core/ActionReplay.h"
|
||||
#include "Core/ARDecrypt.h"
|
||||
#include "DolphinWX/ARCodeAddEdit.h"
|
||||
#include "DolphinWX/ISOProperties.h"
|
||||
#include "DolphinWX/WxUtils.h"
|
||||
|
||||
class wxWindow;
|
||||
|
||||
extern std::vector<ActionReplay::ARCode> arCodes;
|
||||
|
||||
BEGIN_EVENT_TABLE(CARCodeAddEdit, wxDialog)
|
||||
EVT_BUTTON(wxID_OK, CARCodeAddEdit::SaveCheatData)
|
||||
EVT_SPIN(ID_ENTRY_SELECT, CARCodeAddEdit::ChangeEntry)
|
||||
|
||||
@ -44,13 +44,12 @@
|
||||
#include "DolphinWX/Frame.h"
|
||||
#include "DolphinWX/GeckoCodeDiag.h"
|
||||
#include "DolphinWX/ISOProperties.h"
|
||||
#include "DolphinWX/Main.h"
|
||||
#include "DolphinWX/WxUtils.h"
|
||||
|
||||
class wxWindow;
|
||||
|
||||
#define MAX_CHEAT_SEARCH_RESULTS_DISPLAY 256
|
||||
extern std::vector<ActionReplay::ARCode> arCodes;
|
||||
extern CFrame* main_frame;
|
||||
|
||||
// meh
|
||||
static wxCheatsWindow *g_cheat_window;
|
||||
|
||||
@ -71,8 +71,6 @@ const CPUCore CPUCores[] = {
|
||||
#endif
|
||||
};
|
||||
|
||||
extern CFrame* main_frame;
|
||||
|
||||
// keep these in sync with CConfigMain::InitializeGUILists
|
||||
static const wxLanguage langIds[] =
|
||||
{
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user