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

Merge pull request #1659 from PCSX2/greg/clang-format-common 

reformat main common directory
This commit is contained in:
Gregory Hainaut 2016-11-14 11:37:53 +01:00 committed by GitHub
parent e0cd520837 1fba5cb580
commit 259521ec3e
137 changed files with 15017 additions and 14373 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

328
common/include/PS2Edefs.h
View File

@ -71,12 +71,14 @@
#define KEYPRESS 1
#define KEYRELEASE 2
typedef struct {
typedef struct
{
int size;
s8 *data;
} freezeData;
typedef struct _keyEvent {
typedef struct _keyEvent
{
u32 key;
u32 evt;
} keyEvent;
@ -103,15 +105,15 @@ typedef struct _keyEvent {
#define PS2E_GS_VERSION 0x0006
#define PS2E_PAD_VERSION 0x0002 // -=[ OBSOLETE ]=-
#ifdef ENABLE_NEW_IOPDMA_SPU2
# define PS2E_SPU2_VERSION 0x0006
#define PS2E_SPU2_VERSION 0x0006
#else
# define PS2E_SPU2_VERSION 0x0005
#define PS2E_SPU2_VERSION 0x0005
#endif
#define PS2E_CDVD_VERSION 0x0005
#ifdef ENABLE_NEW_IOPDMA_DEV9
# define PS2E_DEV9_VERSION 0x0004
#define PS2E_DEV9_VERSION 0x0004
#else
# define PS2E_DEV9_VERSION 0x0003
#define PS2E_DEV9_VERSION 0x0003
#endif
#define PS2E_USB_VERSION 0x0003
#define PS2E_FW_VERSION 0x0002
@ -124,7 +126,7 @@ extern "C" {
u32 CALLBACK PS2EgetLibType(void);
u32 CALLBACK PS2EgetLibVersion2(u32 type);
char* CALLBACK PS2EgetLibName(void);
char *CALLBACK PS2EgetLibName(void);
#ifdef __cplusplus
}
@ -139,7 +141,7 @@ char* CALLBACK PS2EgetLibName(void);
*/
// for 64bit compilers
typedef char __keyEvent_Size__[(sizeof(keyEvent) == 8)?1:-1];
typedef char __keyEvent_Size__[(sizeof(keyEvent) == 8) ? 1 : -1];
// plugin types
#define SIO_TYPE_PAD 0x00000001
@ -147,11 +149,12 @@ typedef char __keyEvent_Size__[(sizeof(keyEvent) == 8)?1:-1];
#define SIO_TYPE_RM 0x00000040
#define SIO_TYPE_MC 0x00000100
typedef int (CALLBACK * SIOchangeSlotCB)(int slot);
typedef int(CALLBACK *SIOchangeSlotCB)(int slot);
typedef struct _cdvdSubQ {
u8 ctrl:4; // control and mode bits
u8 mode:4; // control and mode bits
typedef struct _cdvdSubQ
{
u8 ctrl : 4; // control and mode bits
u8 mode : 4; // control and mode bits
u8 trackNum; // current track number (1 to 99)
u8 trackIndex; // current index within track (0 to 99)
u8 trackM; // current minute location on the disc (BCD encoded)
@ -163,12 +166,14 @@ typedef struct _cdvdSubQ {
u8 discF; // current frame offset from first track (BCD encoded)
} cdvdSubQ;
typedef struct _cdvdTD { // NOT bcd coded
typedef struct _cdvdTD
{ // NOT bcd coded
u32 lsn;
u8 type;
} cdvdTD;
typedef struct _cdvdTN {
typedef struct _cdvdTN
{
u8 strack; //number of the first track (usually 1)
u8 etrack; //number of the last track
} cdvdTN;
@ -215,7 +220,8 @@ typedef int (*DEV9handler)(void);
typedef void (*USBcallback)(int cycles);
typedef int (*USBhandler)(void);
typedef struct _GSdriverInfo {
typedef struct _GSdriverInfo
{
char name[8];
void *common;
} GSdriverInfo;
@ -236,15 +242,15 @@ s32 CALLBACK GSinit();
s32 CALLBACK GSopen(void *pDsp, const char *Title, int multithread);
void CALLBACK GSclose();
void CALLBACK GSshutdown();
void CALLBACK GSsetSettingsDir( const char* dir );
void CALLBACK GSsetLogDir( const char* dir );
void CALLBACK GSsetSettingsDir(const char *dir);
void CALLBACK GSsetLogDir(const char *dir);
void CALLBACK GSvsync(int field);
void CALLBACK GSgifTransfer(const u32 *pMem, u32 addr);
void CALLBACK GSgifTransfer1(u32 *pMem, u32 addr);
void CALLBACK GSgifTransfer2(u32 *pMem, u32 size);
void CALLBACK GSgifTransfer3(u32 *pMem, u32 size);
void CALLBACK GSgetLastTag(u64* ptag); // returns the last tag processed (64 bits)
void CALLBACK GSgetLastTag(u64 *ptag); // returns the last tag processed (64 bits)
void CALLBACK GSgifSoftReset(u32 mask);
void CALLBACK GSreadFIFO(u64 *mem);
void CALLBACK GSinitReadFIFO(u64 *mem);
@ -255,12 +261,12 @@ void CALLBACK GSinitReadFIFO2(u64 *mem, int qwc);
// GSkeyEvent gets called when there is a keyEvent from the PAD plugin
void CALLBACK GSkeyEvent(keyEvent *ev);
void CALLBACK GSchangeSaveState(int, const char* filename);
void CALLBACK GSchangeSaveState(int, const char *filename);
void CALLBACK GSmakeSnapshot(char *path);
void CALLBACK GSmakeSnapshot2(char *pathname, int* snapdone, int savejpg);
void CALLBACK GSmakeSnapshot2(char *pathname, int *snapdone, int savejpg);
void CALLBACK GSirqCallback(void (*callback)());
void CALLBACK GSprintf(int timeout, char *fmt, ...);
void CALLBACK GSsetBaseMem(void*);
void CALLBACK GSsetBaseMem(void *);
void CALLBACK GSsetGameCRC(int crc, int gameoptions);
// controls frame skipping in the GS, if this routine isn't present, frame skipping won't be done
@ -269,12 +275,12 @@ void CALLBACK GSsetFrameSkip(int frameskip);
// if start is 1, starts recording spu2 data, else stops
// returns a non zero value if successful
// for now, pData is not used
int CALLBACK GSsetupRecording(int start, void* pData);
int CALLBACK GSsetupRecording(int start, void *pData);
void CALLBACK GSreset();
//deprecated: GSgetTitleInfo was used in PCSX2 but no plugin supported it prior to r4070:
//void CALLBACK GSgetTitleInfo( char dest[128] );
void CALLBACK GSgetTitleInfo2( char* dest, size_t length );
void CALLBACK GSgetTitleInfo2(char *dest, size_t length);
void CALLBACK GSwriteCSR(u32 value);
s32 CALLBACK GSfreeze(int mode, freezeData *data);
void CALLBACK GSconfigure();
@ -295,11 +301,11 @@ s32 CALLBACK PADinit(u32 flags);
s32 CALLBACK PADopen(void *pDsp);
void CALLBACK PADclose();
void CALLBACK PADshutdown();
void CALLBACK PADsetSettingsDir( const char* dir );
void CALLBACK PADsetLogDir( const char* dir );
void CALLBACK PADsetSettingsDir(const char *dir);
void CALLBACK PADsetLogDir(const char *dir);
// PADkeyEvent is called every vsync (return NULL if no event)
keyEvent* CALLBACK PADkeyEvent();
keyEvent *CALLBACK PADkeyEvent();
u8 CALLBACK PADstartPoll(int pad);
u8 CALLBACK PADpoll(u8 value);
// returns: 1 if supported pad1
@ -342,16 +348,16 @@ s32 CALLBACK SPU2init();
s32 CALLBACK SPU2open(void *pDsp);
void CALLBACK SPU2close();
void CALLBACK SPU2shutdown();
void CALLBACK SPU2setSettingsDir( const char* dir );
void CALLBACK SPU2setLogDir( const char* dir );
void CALLBACK SPU2setSettingsDir(const char *dir);
void CALLBACK SPU2setLogDir(const char *dir);
void CALLBACK SPU2reset();
void CALLBACK SPU2write(u32 mem, u16 value);
u16 CALLBACK SPU2read(u32 mem);
#ifdef ENABLE_NEW_IOPDMA_SPU2
s32 CALLBACK SPU2dmaRead(s32 channel, u32* data, u32 bytesLeft, u32* bytesProcessed);
s32 CALLBACK SPU2dmaWrite(s32 channel, u32* data, u32 bytesLeft, u32* bytesProcessed);
s32 CALLBACK SPU2dmaRead(s32 channel, u32 *data, u32 bytesLeft, u32 *bytesProcessed);
s32 CALLBACK SPU2dmaWrite(s32 channel, u32 *data, u32 bytesLeft, u32 *bytesProcessed);
void CALLBACK SPU2dmaInterrupt(s32 channel);
// dma irq callbacks not needed anymore, they are handled by the dmac
@ -360,7 +366,7 @@ void CALLBACK SPU2irqCallback(void (*SPU2callback)());
void CALLBACK SPU2readDMA4Mem(u16 *pMem, int size);
void CALLBACK SPU2writeDMA4Mem(u16 *pMem, int size);
void CALLBACK SPU2interruptDMA4();
void CALLBACK SPU2readDMA7Mem(u16* pMem, int size);
void CALLBACK SPU2readDMA7Mem(u16 *pMem, int size);
void CALLBACK SPU2writeDMA7Mem(u16 *pMem, int size);
// all addresses passed by dma will be pointers to the array starting at baseaddr
@ -370,18 +376,18 @@ void CALLBACK SPU2setDMABaseAddr(uptr baseaddr);
void CALLBACK SPU2interruptDMA7();
u32 CALLBACK SPU2ReadMemAddr(int core);
void CALLBACK SPU2WriteMemAddr(int core,u32 value);
void CALLBACK SPU2WriteMemAddr(int core, u32 value);
void CALLBACK SPU2irqCallback(void (*SPU2callback)(),void (*DMA4callback)(),void (*DMA7callback)());
void CALLBACK SPU2irqCallback(void (*SPU2callback)(), void (*DMA4callback)(), void (*DMA7callback)());
#endif
// extended funcs
// if start is 1, starts recording spu2 data, else stops
// returns a non zero value if successful
// for now, pData is not used
int CALLBACK SPU2setupRecording(int start, void* pData);
int CALLBACK SPU2setupRecording(int start, void *pData);
void CALLBACK SPU2setClockPtr(u32* ptr);
void CALLBACK SPU2setClockPtr(u32 *ptr);
void CALLBACK SPU2setTimeStretcher(short int enable);
void CALLBACK SPU2async(u32 cycles);
@ -401,21 +407,21 @@ s32 CALLBACK SPU2test();
// basic funcs
s32 CALLBACK CDVDinit();
s32 CALLBACK CDVDopen(const char* pTitleFilename);
s32 CALLBACK CDVDopen(const char *pTitleFilename);
void CALLBACK CDVDclose();
void CALLBACK CDVDshutdown();
void CALLBACK CDVDsetSettingsDir( const char* dir );
void CALLBACK CDVDsetLogDir( const char* dir );
void CALLBACK CDVDsetSettingsDir(const char *dir);
void CALLBACK CDVDsetLogDir(const char *dir);
s32 CALLBACK CDVDreadTrack(u32 lsn, int mode);
// return can be NULL (for async modes)
u8* CALLBACK CDVDgetBuffer();
u8 *CALLBACK CDVDgetBuffer();
s32 CALLBACK CDVDreadSubQ(u32 lsn, cdvdSubQ* subq);//read subq from disc (only cds have subq data)
s32 CALLBACK CDVDreadSubQ(u32 lsn, cdvdSubQ *subq); //read subq from disc (only cds have subq data)
s32 CALLBACK CDVDgetTN(cdvdTN *Buffer); //disk information
s32 CALLBACK CDVDgetTD(u8 Track, cdvdTD *Buffer); //track info: min,sec,frame,type
s32 CALLBACK CDVDgetTOC(void* toc); //gets ps2 style toc from disc
s32 CALLBACK CDVDgetTOC(void *toc); //gets ps2 style toc from disc
s32 CALLBACK CDVDgetDiskType(); //CDVD_TYPE_xxxx
s32 CALLBACK CDVDgetTrayStatus(); //CDVD_TRAY_xxxx
s32 CALLBACK CDVDctrlTrayOpen(); //open disc tray
@ -431,13 +437,13 @@ void CALLBACK CDVDnewDiskCB(void (*callback)());
// new funcs
// read a track directly
s32 CALLBACK CDVDreadSector(u8* buffer, s32 lsn, int mode);
s32 CALLBACK CDVDreadSector(u8 *buffer, s32 lsn, int mode);
// improved getBuffer
s32 CALLBACK CDVDgetBuffer2(u8* buffer);
s32 CALLBACK CDVDgetBuffer2(u8 *buffer);
// tool function
s32 CALLBACK CDVDgetDualInfo(s32* dualType, u32* _layer1start);
s32 CALLBACK CDVDgetDualInfo(s32 *dualType, u32 *_layer1start);
#endif
@ -455,8 +461,8 @@ s32 CALLBACK DEV9init();
s32 CALLBACK DEV9open(void *pDsp);
void CALLBACK DEV9close();
void CALLBACK DEV9shutdown();
void CALLBACK DEV9setSettingsDir( const char* dir );
void CALLBACK DEV9setLogDir( const char* dir );
void CALLBACK DEV9setSettingsDir(const char *dir);
void CALLBACK DEV9setLogDir(const char *dir);
u8 CALLBACK DEV9read8(u32 addr);
u16 CALLBACK DEV9read16(u32 addr);
@ -465,8 +471,8 @@ void CALLBACK DEV9write8(u32 addr, u8 value);
void CALLBACK DEV9write16(u32 addr, u16 value);
void CALLBACK DEV9write32(u32 addr, u32 value);
#ifdef ENABLE_NEW_IOPDMA_DEV9
s32 CALLBACK DEV9dmaRead(s32 channel, u32* data, u32 bytesLeft, u32* bytesProcessed);
s32 CALLBACK DEV9dmaWrite(s32 channel, u32* data, u32 bytesLeft, u32* bytesProcessed);
s32 CALLBACK DEV9dmaRead(s32 channel, u32 *data, u32 bytesLeft, u32 *bytesProcessed);
s32 CALLBACK DEV9dmaWrite(s32 channel, u32 *data, u32 bytesLeft, u32 *bytesProcessed);
void CALLBACK DEV9dmaInterrupt(s32 channel);
#else
void CALLBACK DEV9readDMA8Mem(u32 *pMem, int size);
@ -498,8 +504,8 @@ s32 CALLBACK USBinit();
s32 CALLBACK USBopen(void *pDsp);
void CALLBACK USBclose();
void CALLBACK USBshutdown();
void CALLBACK USBsetSettingsDir( const char* dir );
void CALLBACK USBsetLogDir( const char* dir );
void CALLBACK USBsetSettingsDir(const char *dir);
void CALLBACK USBsetLogDir(const char *dir);
u8 CALLBACK USBread8(u32 addr);
u16 CALLBACK USBread16(u32 addr);
@ -537,8 +543,8 @@ s32 CALLBACK FWinit();
s32 CALLBACK FWopen(void *pDsp);
void CALLBACK FWclose();
void CALLBACK FWshutdown();
void CALLBACK FWsetSettingsDir( const char* dir );
void CALLBACK FWsetLogDir( const char* dir );
void CALLBACK FWsetSettingsDir(const char *dir);
void CALLBACK FWsetLogDir(const char *dir);
u32 CALLBACK FWread32(u32 addr);
void CALLBACK FWwrite32(u32 addr, u32 value);
@ -555,168 +561,168 @@ s32 CALLBACK FWtest();
// might be useful for emulators
#ifdef PLUGINtypedefs
typedef u32 (CALLBACK* _PS2EgetLibType)(void);
typedef u32 (CALLBACK* _PS2EgetLibVersion2)(u32 type);
typedef char*(CALLBACK* _PS2EgetLibName)(void);
typedef u32(CALLBACK *_PS2EgetLibType)(void);
typedef u32(CALLBACK *_PS2EgetLibVersion2)(u32 type);
typedef char *(CALLBACK *_PS2EgetLibName)(void);
typedef void (CALLBACK* _PS2EsetEmuVersion)(const char* emuId, u32 version); // HACK to let some plugins know it's 0.9.7 PCSX2 --air
typedef void(CALLBACK *_PS2EsetEmuVersion)(const char *emuId, u32 version); // HACK to let some plugins know it's 0.9.7 PCSX2 --air
// GS
// NOTE: GSreadFIFOX/GSwriteCSR functions CANNOT use XMM/MMX regs
// If you want to use them, need to save and restore current ones
typedef s32 (CALLBACK* _GSopen)(void *pDsp, const char *Title, int multithread);
typedef s32 (CALLBACK* _GSopen2)( void *pDsp, u32 flags );
typedef void (CALLBACK* _GSvsync)(int field);
typedef void (CALLBACK* _GSgifTransfer)(const u32 *pMem, u32 size);
typedef void (CALLBACK* _GSgifTransfer1)(u32 *pMem, u32 addr);
typedef void (CALLBACK* _GSgifTransfer2)(u32 *pMem, u32 size);
typedef void (CALLBACK* _GSgifTransfer3)(u32 *pMem, u32 size);
typedef void (CALLBACK* _GSgifSoftReset)(u32 mask);
typedef void (CALLBACK* _GSreadFIFO)(u64 *pMem);
typedef void (CALLBACK* _GSreadFIFO2)(u64 *pMem, int qwc);
typedef void (CALLBACK* _GSinitReadFIFO)(u64 *pMem);
typedef void (CALLBACK* _GSinitReadFIFO2)(u64 *pMem, int qwc);
typedef s32(CALLBACK *_GSopen)(void *pDsp, const char *Title, int multithread);
typedef s32(CALLBACK *_GSopen2)(void *pDsp, u32 flags);
typedef void(CALLBACK *_GSvsync)(int field);
typedef void(CALLBACK *_GSgifTransfer)(const u32 *pMem, u32 size);
typedef void(CALLBACK *_GSgifTransfer1)(u32 *pMem, u32 addr);
typedef void(CALLBACK *_GSgifTransfer2)(u32 *pMem, u32 size);
typedef void(CALLBACK *_GSgifTransfer3)(u32 *pMem, u32 size);
typedef void(CALLBACK *_GSgifSoftReset)(u32 mask);
typedef void(CALLBACK *_GSreadFIFO)(u64 *pMem);
typedef void(CALLBACK *_GSreadFIFO2)(u64 *pMem, int qwc);
typedef void(CALLBACK *_GSinitReadFIFO)(u64 *pMem);
typedef void(CALLBACK *_GSinitReadFIFO2)(u64 *pMem, int qwc);
typedef void (CALLBACK* _GSchangeSaveState)(int, const char* filename);
typedef void (CALLBACK* _GSgetTitleInfo2)(char* dest, size_t length);
typedef void (CALLBACK* _GSirqCallback)(void (*callback)());
typedef void (CALLBACK* _GSprintf)(int timeout, char *fmt, ...);
typedef void (CALLBACK* _GSsetBaseMem)(void*);
typedef void (CALLBACK* _GSsetGameCRC)(int, int);
typedef void (CALLBACK* _GSsetFrameSkip)(int frameskip);
typedef void (CALLBACK* _GSsetFrameLimit)(int limit);
typedef void (CALLBACK* _GSsetVsync)(int enabled);
typedef void (CALLBACK* _GSsetExclusive)(int isExclusive);
typedef int (CALLBACK* _GSsetupRecording)(int, void*);
typedef void (CALLBACK* _GSreset)();
typedef void (CALLBACK* _GSwriteCSR)(u32 value);
typedef void (CALLBACK* _GSmakeSnapshot)(const char *path);
typedef void (CALLBACK* _GSmakeSnapshot2)(const char *path, int*, int);
typedef void(CALLBACK *_GSchangeSaveState)(int, const char *filename);
typedef void(CALLBACK *_GSgetTitleInfo2)(char *dest, size_t length);
typedef void(CALLBACK *_GSirqCallback)(void (*callback)());
typedef void(CALLBACK *_GSprintf)(int timeout, char *fmt, ...);
typedef void(CALLBACK *_GSsetBaseMem)(void *);
typedef void(CALLBACK *_GSsetGameCRC)(int, int);
typedef void(CALLBACK *_GSsetFrameSkip)(int frameskip);
typedef void(CALLBACK *_GSsetFrameLimit)(int limit);
typedef void(CALLBACK *_GSsetVsync)(int enabled);
typedef void(CALLBACK *_GSsetExclusive)(int isExclusive);
typedef int(CALLBACK *_GSsetupRecording)(int, void *);
typedef void(CALLBACK *_GSreset)();
typedef void(CALLBACK *_GSwriteCSR)(u32 value);
typedef void(CALLBACK *_GSmakeSnapshot)(const char *path);
typedef void(CALLBACK *_GSmakeSnapshot2)(const char *path, int *, int);
// PAD
typedef s32 (CALLBACK* _PADinit)(u32 flags);
typedef s32 (CALLBACK* _PADopen)(void *pDsp);
typedef u8 (CALLBACK* _PADstartPoll)(int pad);
typedef u8 (CALLBACK* _PADpoll)(u8 value);
typedef u32 (CALLBACK* _PADquery)(int pad);
typedef void (CALLBACK* _PADupdate)(int pad);
typedef keyEvent* (CALLBACK* _PADkeyEvent)();
typedef void (CALLBACK* _PADgsDriverInfo)(GSdriverInfo *info);
typedef s32 (CALLBACK* _PADsetSlot)(u8 port, u8 slot);
typedef s32 (CALLBACK* _PADqueryMtap)(u8 port);
typedef void (CALLBACK* _PADWriteEvent)(keyEvent &evt);
typedef s32(CALLBACK *_PADinit)(u32 flags);
typedef s32(CALLBACK *_PADopen)(void *pDsp);
typedef u8(CALLBACK *_PADstartPoll)(int pad);
typedef u8(CALLBACK *_PADpoll)(u8 value);
typedef u32(CALLBACK *_PADquery)(int pad);
typedef void(CALLBACK *_PADupdate)(int pad);
typedef keyEvent *(CALLBACK *_PADkeyEvent)();
typedef void(CALLBACK *_PADgsDriverInfo)(GSdriverInfo *info);
typedef s32(CALLBACK *_PADsetSlot)(u8 port, u8 slot);
typedef s32(CALLBACK *_PADqueryMtap)(u8 port);
typedef void(CALLBACK *_PADWriteEvent)(keyEvent &evt);
// SPU2
typedef s32 (CALLBACK* _SPU2open)(void *pDsp);
typedef void (CALLBACK* _SPU2reset)();
typedef void (CALLBACK* _SPU2write)(u32 mem, u16 value);
typedef u16 (CALLBACK* _SPU2read)(u32 mem);
typedef s32(CALLBACK *_SPU2open)(void *pDsp);
typedef void(CALLBACK *_SPU2reset)();
typedef void(CALLBACK *_SPU2write)(u32 mem, u16 value);
typedef u16(CALLBACK *_SPU2read)(u32 mem);
#ifdef ENABLE_NEW_IOPDMA_SPU2
typedef s32 (CALLBACK* _SPU2dmaRead)(s32 channel, u32* data, u32 bytesLeft, u32* bytesProcessed);
typedef s32 (CALLBACK* _SPU2dmaWrite)(s32 channel, u32* data, u32 bytesLeft, u32* bytesProcessed);
typedef void (CALLBACK* _SPU2dmaInterrupt)(s32 channel);
typedef s32(CALLBACK *_SPU2dmaRead)(s32 channel, u32 *data, u32 bytesLeft, u32 *bytesProcessed);
typedef s32(CALLBACK *_SPU2dmaWrite)(s32 channel, u32 *data, u32 bytesLeft, u32 *bytesProcessed);
typedef void(CALLBACK *_SPU2dmaInterrupt)(s32 channel);
// dma irq callbacks not needed anymore, they are handled by the dmac
typedef void (CALLBACK* _SPU2irqCallback)(void (*SPU2callback)());
typedef void(CALLBACK *_SPU2irqCallback)(void (*SPU2callback)());
#else
typedef void (CALLBACK* _SPU2readDMA4Mem)(u16 *pMem, int size);
typedef void (CALLBACK* _SPU2writeDMA4Mem)(u16 *pMem, int size);
typedef void (CALLBACK* _SPU2interruptDMA4)();
typedef void (CALLBACK* _SPU2readDMA7Mem)(u16 *pMem, int size);
typedef void (CALLBACK* _SPU2writeDMA7Mem)(u16 *pMem, int size);
typedef void (CALLBACK* _SPU2setDMABaseAddr)(uptr baseaddr);
typedef void (CALLBACK* _SPU2interruptDMA7)();
typedef void (CALLBACK* _SPU2irqCallback)(void (*SPU2callback)(),void (*DMA4callback)(),void (*DMA7callback)());
typedef u32 (CALLBACK* _SPU2ReadMemAddr)(int core);
typedef void (CALLBACK* _SPU2WriteMemAddr)(int core,u32 value);
typedef void(CALLBACK *_SPU2readDMA4Mem)(u16 *pMem, int size);
typedef void(CALLBACK *_SPU2writeDMA4Mem)(u16 *pMem, int size);
typedef void(CALLBACK *_SPU2interruptDMA4)();
typedef void(CALLBACK *_SPU2readDMA7Mem)(u16 *pMem, int size);
typedef void(CALLBACK *_SPU2writeDMA7Mem)(u16 *pMem, int size);
typedef void(CALLBACK *_SPU2setDMABaseAddr)(uptr baseaddr);
typedef void(CALLBACK *_SPU2interruptDMA7)();
typedef void(CALLBACK *_SPU2irqCallback)(void (*SPU2callback)(), void (*DMA4callback)(), void (*DMA7callback)());
typedef u32(CALLBACK *_SPU2ReadMemAddr)(int core);
typedef void(CALLBACK *_SPU2WriteMemAddr)(int core, u32 value);
#endif
typedef int (CALLBACK* _SPU2setupRecording)(int, void*);
typedef int(CALLBACK *_SPU2setupRecording)(int, void *);
typedef void (CALLBACK* _SPU2setClockPtr)(u32*ptr);
typedef void (CALLBACK* _SPU2setTimeStretcher)(short int enable);
typedef void(CALLBACK *_SPU2setClockPtr)(u32 *ptr);
typedef void(CALLBACK *_SPU2setTimeStretcher)(short int enable);
typedef void (CALLBACK* _SPU2async)(u32 cycles);
typedef void(CALLBACK *_SPU2async)(u32 cycles);
// CDVD
// NOTE: The read/write functions CANNOT use XMM/MMX regs
// If you want to use them, need to save and restore current ones
typedef s32 (CALLBACK* _CDVDopen)(const char* pTitleFilename);
typedef s32(CALLBACK *_CDVDopen)(const char *pTitleFilename);
// Initiates an asynchronous track read operation.
// Returns -1 on error (invalid track)
// Returns 0 on success.
typedef s32 (CALLBACK* _CDVDreadTrack)(u32 lsn, int mode);
typedef s32(CALLBACK *_CDVDreadTrack)(u32 lsn, int mode);
// *OBSOLETE* returns a pointer to the buffer, or NULL if data hasn't finished
// loading yet.
typedef u8* (CALLBACK* _CDVDgetBuffer)();
typedef u8 *(CALLBACK *_CDVDgetBuffer)();
// Copies loaded data to the target buffer.
// Returns -2 if the asynchronous read is still pending.
// Returns -1 if the asyncronous read failed.
// Returns 0 on success.
typedef s32 (CALLBACK* _CDVDgetBuffer2)(u8* buffer);
typedef s32(CALLBACK *_CDVDgetBuffer2)(u8 *buffer);
typedef s32 (CALLBACK* _CDVDreadSubQ)(u32 lsn, cdvdSubQ* subq);
typedef s32 (CALLBACK* _CDVDgetTN)(cdvdTN *Buffer);
typedef s32 (CALLBACK* _CDVDgetTD)(u8 Track, cdvdTD *Buffer);
typedef s32 (CALLBACK* _CDVDgetTOC)(void* toc);
typedef s32 (CALLBACK* _CDVDgetDiskType)();
typedef s32 (CALLBACK* _CDVDgetTrayStatus)();
typedef s32 (CALLBACK* _CDVDctrlTrayOpen)();
typedef s32 (CALLBACK* _CDVDctrlTrayClose)();
typedef s32 (CALLBACK* _CDVDreadSector)(u8* buffer, u32 lsn, int mode);
typedef s32 (CALLBACK* _CDVDgetDualInfo)(s32* dualType, u32* _layer1start);
typedef s32(CALLBACK *_CDVDreadSubQ)(u32 lsn, cdvdSubQ *subq);
typedef s32(CALLBACK *_CDVDgetTN)(cdvdTN *Buffer);
typedef s32(CALLBACK *_CDVDgetTD)(u8 Track, cdvdTD *Buffer);
typedef s32(CALLBACK *_CDVDgetTOC)(void *toc);
typedef s32(CALLBACK *_CDVDgetDiskType)();
typedef s32(CALLBACK *_CDVDgetTrayStatus)();
typedef s32(CALLBACK *_CDVDctrlTrayOpen)();
typedef s32(CALLBACK *_CDVDctrlTrayClose)();
typedef s32(CALLBACK *_CDVDreadSector)(u8 *buffer, u32 lsn, int mode);
typedef s32(CALLBACK *_CDVDgetDualInfo)(s32 *dualType, u32 *_layer1start);
typedef void (CALLBACK* _CDVDnewDiskCB)(void (*callback)());
typedef void(CALLBACK *_CDVDnewDiskCB)(void (*callback)());
// DEV9
// NOTE: The read/write functions CANNOT use XMM/MMX regs
// If you want to use them, need to save and restore current ones
typedef s32 (CALLBACK* _DEV9open)(void *pDsp);
typedef u8 (CALLBACK* _DEV9read8)(u32 mem);
typedef u16 (CALLBACK* _DEV9read16)(u32 mem);
typedef u32 (CALLBACK* _DEV9read32)(u32 mem);
typedef void (CALLBACK* _DEV9write8)(u32 mem, u8 value);
typedef void (CALLBACK* _DEV9write16)(u32 mem, u16 value);
typedef void (CALLBACK* _DEV9write32)(u32 mem, u32 value);
typedef s32(CALLBACK *_DEV9open)(void *pDsp);
typedef u8(CALLBACK *_DEV9read8)(u32 mem);
typedef u16(CALLBACK *_DEV9read16)(u32 mem);
typedef u32(CALLBACK *_DEV9read32)(u32 mem);
typedef void(CALLBACK *_DEV9write8)(u32 mem, u8 value);
typedef void(CALLBACK *_DEV9write16)(u32 mem, u16 value);
typedef void(CALLBACK *_DEV9write32)(u32 mem, u32 value);
#ifdef ENABLE_NEW_IOPDMA_DEV9
typedef s32 (CALLBACK* _DEV9dmaRead)(s32 channel, u32* data, u32 bytesLeft, u32* bytesProcessed);
typedef s32 (CALLBACK* _DEV9dmaWrite)(s32 channel, u32* data, u32 bytesLeft, u32* bytesProcessed);
typedef void (CALLBACK* _DEV9dmaInterrupt)(s32 channel);
typedef s32(CALLBACK *_DEV9dmaRead)(s32 channel, u32 *data, u32 bytesLeft, u32 *bytesProcessed);
typedef s32(CALLBACK *_DEV9dmaWrite)(s32 channel, u32 *data, u32 bytesLeft, u32 *bytesProcessed);
typedef void(CALLBACK *_DEV9dmaInterrupt)(s32 channel);
#else
typedef void (CALLBACK* _DEV9readDMA8Mem)(u32 *pMem, int size);
typedef void (CALLBACK* _DEV9writeDMA8Mem)(u32 *pMem, int size);
typedef void(CALLBACK *_DEV9readDMA8Mem)(u32 *pMem, int size);
typedef void(CALLBACK *_DEV9writeDMA8Mem)(u32 *pMem, int size);
#endif
typedef void (CALLBACK* _DEV9irqCallback)(DEV9callback callback);
typedef DEV9handler (CALLBACK* _DEV9irqHandler)(void);
typedef void (CALLBACK* _DEV9async)(u32 cycles);
typedef void(CALLBACK *_DEV9irqCallback)(DEV9callback callback);
typedef DEV9handler(CALLBACK *_DEV9irqHandler)(void);
typedef void(CALLBACK *_DEV9async)(u32 cycles);
// USB
// NOTE: The read/write functions CANNOT use XMM/MMX regs
// If you want to use them, need to save and restore current ones
typedef s32 (CALLBACK* _USBopen)(void *pDsp);
typedef u8 (CALLBACK* _USBread8)(u32 mem);
typedef u16 (CALLBACK* _USBread16)(u32 mem);
typedef u32 (CALLBACK* _USBread32)(u32 mem);
typedef void (CALLBACK* _USBwrite8)(u32 mem, u8 value);
typedef void (CALLBACK* _USBwrite16)(u32 mem, u16 value);
typedef void (CALLBACK* _USBwrite32)(u32 mem, u32 value);
typedef void (CALLBACK* _USBasync)(u32 cycles);
typedef s32(CALLBACK *_USBopen)(void *pDsp);
typedef u8(CALLBACK *_USBread8)(u32 mem);
typedef u16(CALLBACK *_USBread16)(u32 mem);
typedef u32(CALLBACK *_USBread32)(u32 mem);
typedef void(CALLBACK *_USBwrite8)(u32 mem, u8 value);
typedef void(CALLBACK *_USBwrite16)(u32 mem, u16 value);
typedef void(CALLBACK *_USBwrite32)(u32 mem, u32 value);
typedef void(CALLBACK *_USBasync)(u32 cycles);
typedef void (CALLBACK* _USBirqCallback)(USBcallback callback);
typedef USBhandler (CALLBACK* _USBirqHandler)(void);
typedef void (CALLBACK* _USBsetRAM)(void *mem);
typedef void(CALLBACK *_USBirqCallback)(USBcallback callback);
typedef USBhandler(CALLBACK *_USBirqHandler)(void);
typedef void(CALLBACK *_USBsetRAM)(void *mem);
//FW
typedef s32 (CALLBACK* _FWopen)(void *pDsp);
typedef u32 (CALLBACK* _FWread32)(u32 mem);
typedef void (CALLBACK* _FWwrite32)(u32 mem, u32 value);
typedef void (CALLBACK* _FWirqCallback)(void (*callback)());
typedef s32(CALLBACK *_FWopen)(void *pDsp);
typedef u32(CALLBACK *_FWread32)(u32 mem);
typedef void(CALLBACK *_FWwrite32)(u32 mem, u32 value);
typedef void(CALLBACK *_FWirqCallback)(void (*callback)());
#endif
#ifdef PLUGINfuncs

93
common/include/PS2Eext.h
View File

@ -55,8 +55,7 @@ static void __forceinline PluginNullConfigure(std::wstring desc, s32 &log);
static void __forceinline PluginNullAbout(const wchar_t *aboutText);
#endif
enum FileMode
{
enum FileMode {
READ_FILE = 0,
WRITE_FILE
};
@ -70,8 +69,7 @@ struct PluginLog
{
LogFile = fopen(logname.c_str(), "w");
if (LogFile)
{
if (LogFile) {
setvbuf(LogFile, NULL, _IONBF, 0);
return true;
}
@ -90,11 +88,14 @@ struct PluginLog
{
va_list list;
if (LogFile == NULL) return;
if (LogFile == NULL)
return;
va_start(list, fmt);
if (WriteToFile) vfprintf(LogFile, fmt, list);
if (WriteToConsole) vfprintf(stdout, fmt, list);
if (WriteToFile)
vfprintf(LogFile, fmt, list);
if (WriteToConsole)
vfprintf(stdout, fmt, list);
va_end(list);
}
@ -102,15 +103,20 @@ struct PluginLog
{
va_list list;
if (LogFile == NULL) return;
if (LogFile == NULL)
return;
va_start(list, fmt);
if (WriteToFile) vfprintf(LogFile, fmt, list);
if (WriteToConsole) vfprintf(stdout, fmt, list);
if (WriteToFile)
vfprintf(LogFile, fmt, list);
if (WriteToConsole)
vfprintf(stdout, fmt, list);
va_end(list);
if (WriteToFile) fprintf(LogFile, "\n");
if (WriteToConsole) fprintf(stdout, "\n");
if (WriteToFile)
fprintf(LogFile, "\n");
if (WriteToConsole)
fprintf(stdout, "\n");
}
#if !defined(_MSC_VER) || !defined(UNICODE)
@ -119,7 +125,8 @@ struct PluginLog
va_list list;
char buf[256];
if (LogFile == NULL) return;
if (LogFile == NULL)
return;
va_start(list, fmt);
vsprintf(buf, fmt, list);
@ -133,7 +140,8 @@ struct PluginLog
va_list list;
wchar_t buf[256];
if (LogFile == NULL) return;
if (LogFile == NULL)
return;
va_start(list, fmt);
vswprintf(buf, 256, fmt, list);
@ -151,16 +159,14 @@ struct PluginConf
bool Open(std::string name, FileMode mode = READ_FILE)
{
if (mode == READ_FILE)
{
if (mode == READ_FILE) {
ConfFile = fopen(name.c_str(), "r");
}
else
{
} else {
ConfFile = fopen(name.c_str(), "w");
}
if (ConfFile == NULL) return false;
if (ConfFile == NULL)
return false;
return true;
}
@ -173,7 +179,7 @@ struct PluginConf
}
}
int ReadInt(const std::string& item, int defval)
int ReadInt(const std::string &item, int defval)
{
int value = defval;
std::string buf = item + " = %d\n";
@ -189,7 +195,8 @@ struct PluginConf
{
std::string buf = item + " = %d\n";
if (ConfFile) fprintf(ConfFile, buf.c_str(), value);
if (ConfFile)
fprintf(ConfFile, buf.c_str(), value);
}
};
@ -204,19 +211,20 @@ static void SysMessage(const char *fmt, ...)
vsprintf(msg, fmt, list);
va_end(list);
if (msg[strlen(msg)-1] == '\n') msg[strlen(msg)-1] = 0;
if (msg[strlen(msg) - 1] == '\n')
msg[strlen(msg) - 1] = 0;
GtkWidget *dialog;
dialog = gtk_message_dialog_new (NULL,
dialog = gtk_message_dialog_new(NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"%s", msg);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
static void __forceinline set_logging(GtkToggleButton *check, int& log)
static void __forceinline set_logging(GtkToggleButton *check, int &log)
{
log = gtk_toggle_button_get_active(check);
}
@ -227,7 +235,7 @@ static void __forceinline PluginNullConfigure(std::string desc, int &log)
/* Create the widgets */
dialog = gtk_dialog_new();
label = gtk_label_new (desc.c_str());
label = gtk_label_new(desc.c_str());
check_box = gtk_check_button_new_with_label("Logging");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_box), (log != 0));
@ -236,14 +244,14 @@ static void __forceinline PluginNullConfigure(std::string desc, int &log)
g_signal_connect(check_box, "toggled", G_CALLBACK(set_logging), &log);
/* Add all our widgets, and show everything we've added to the dialog. */
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area(GTK_DIALOG(dialog))), label);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area(GTK_DIALOG(dialog))), check_box);
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), label);
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), check_box);
gtk_dialog_add_button(GTK_DIALOG(dialog), "Ok", 0);
gtk_widget_show_all (dialog);
gtk_widget_show_all(dialog);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
static void __forceinline PluginNullAbout(const char *aboutText)
@ -265,7 +273,8 @@ static void SysMessage(const char *fmt, ...)
vsprintf(msg, fmt, list);
va_end(list);
if (msg[strlen(msg)-1] == '\n') msg[strlen(msg)-1] = 0;
if (msg[strlen(msg) - 1] == '\n')
msg[strlen(msg) - 1] = 0;
// TODO OSX can we use WX MessageBox here or should Cocoa MessageBox used?
}
@ -305,10 +314,10 @@ static void __forceinline SysMessage(const char *fmt, ...)
{
va_list list;
char tmp[512];
va_start(list,fmt);
vsprintf(tmp,fmt,list);
va_start(list, fmt);
vsprintf(tmp, fmt, list);
va_end(list);
MessageBox( GetActiveWindow(), tmp, "Message", MB_SETFOREGROUND | MB_OK );
MessageBox(GetActiveWindow(), tmp, "Message", MB_SETFOREGROUND | MB_OK);
}
static void __forceinline PluginNullConfigure(std::string desc, s32 &log)
@ -351,15 +360,15 @@ static void __forceinline PluginNullAbout(const wchar_t *aboutText)
#endif
#define ENTRY_POINT \
HINSTANCE hInst; \
\
BOOL APIENTRY DllMain(HANDLE hModule, /* DLL INIT*/ \
HINSTANCE hInst; \
\
BOOL APIENTRY DllMain(HANDLE hModule, /* DLL INIT*/ \
DWORD dwReason, \
LPVOID lpReserved) \
{ \
{ \
hInst = (HINSTANCE)hModule; \
return TRUE; /* very quick :)*/ \
}
}
#endif
#endif // PS2EEXT_H_INCLUDED

2
common/include/PS2Etypes.h
View File

@ -13,7 +13,7 @@
* If not, see <http://www.gnu.org/licenses/>.
*/
// This file is just for backwards compatibility.
// This file is just for backwards compatibility.
#ifndef __PS2ETYPES_H__
#define __PS2ETYPES_H__

61
common/include/Pcsx2Api.h
View File

@ -35,61 +35,68 @@
#ifdef _MSC_VER
#define EXPORT_C(type) extern "C" type CALLBACK
#else
#define EXPORT_C(type) extern "C" __attribute__((externally_visible,visibility("default"))) type
#define EXPORT_C(type) extern "C" __attribute__((externally_visible, visibility("default"))) type
#endif
EXPORT_C(u32) PS2EgetLibType(void);
EXPORT_C(u32) PS2EgetLibVersion2(u32 type);
EXPORT_C(char*) PS2EgetLibName(void);
EXPORT_C(u32)
PS2EgetLibType(void);
EXPORT_C(u32)
PS2EgetLibVersion2(u32 type);
EXPORT_C(char *)
PS2EgetLibName(void);
// Extended functions.
// allows the plugin to see the whole configuration when started up.
// Intended for them to get the ini and plugin paths, but could allow for other things as well.
EXPORT_C_(void) PS2EpassConfig(PcsxConfig Config);
EXPORT_C_(void)
PS2EpassConfig(PcsxConfig Config);
// Alternately, this function serves the same purpose, but would work for emulators outside
// of pcsx2.
EXPORT_C_(void) PS2EpassIniPath(const char *path);
EXPORT_C_(void)
PS2EpassIniPath(const char *path);
// PS2EgetLibType returns (may be OR'd)
enum {
PS2E_LT_GS = 0x01,
PS2E_LT_PAD = 0x02, // -=[ OBSOLETE ]=-
PS2E_LT_SPU2 = 0x04,
PS2E_LT_CDVD = 0x08,
PS2E_LT_DEV9 = 0x10,
PS2E_LT_USB = 0x20,
PS2E_LT_FW = 0x40,
PS2E_LT_SIO = 0x80
PS2E_LT_GS = 0x01,
PS2E_LT_PAD = 0x02, // -=[ OBSOLETE ]=-
PS2E_LT_SPU2 = 0x04,
PS2E_LT_CDVD = 0x08,
PS2E_LT_DEV9 = 0x10,
PS2E_LT_USB = 0x20,
PS2E_LT_FW = 0x40,
PS2E_LT_SIO = 0x80
} PluginLibType;
// PS2EgetLibVersion2 (high 16 bits)
enum {
PS2E_GS_VERSION = 0x0006,
PS2E_PAD_VERSION = 0x0002, // -=[ OBSOLETE ]=-
PS2E_SPU2_VERSION = 0x0005,
PS2E_CDVD_VERSION = 0x0005,
PS2E_DEV9_VERSION = 0x0003,
PS2E_USB_VERSION = 0x0003,
PS2E_FW_VERSION = 0x0002,
PS2E_SIO_VERSION = 0x0001
PS2E_GS_VERSION = 0x0006,
PS2E_PAD_VERSION = 0x0002, // -=[ OBSOLETE ]=-
PS2E_SPU2_VERSION = 0x0005,
PS2E_CDVD_VERSION = 0x0005,
PS2E_DEV9_VERSION = 0x0003,
PS2E_USB_VERSION = 0x0003,
PS2E_FW_VERSION = 0x0002,
PS2E_SIO_VERSION = 0x0001
} PluginLibVersion;
// freeze modes:
enum {
FREEZE_LOAD = 0,
FREEZE_SAVE = 1,
FREEZE_SIZE = 2
FREEZE_LOAD = 0,
FREEZE_SAVE = 1,
FREEZE_SIZE = 2
} FreezeModes;
typedef struct _GSdriverInfo {
typedef struct _GSdriverInfo
{
char name[8];
void *common;
} GSdriverInfo;
#ifdef _MSC_VER
typedef struct _winInfo { // unsupported values must be set to zero
typedef struct _winInfo
{ // unsupported values must be set to zero
HWND hWnd;
HMENU hMenu;
HWND hStatusWnd;

152
common/include/Pcsx2Defs.h
View File

@ -26,9 +26,9 @@
// make sure __POSIX__ is defined for all systems where we assume POSIX
// compliance
#if defined(__linux__) || defined(__APPLE__) || defined(__unix__) || defined(__CYGWIN__) || defined(__LINUX__)
# if !defined(__POSIX__)
# define __POSIX__ 1
# endif
#if !defined(__POSIX__)
#define __POSIX__ 1
#endif
#endif
#include "Pcsx2Types.h"
@ -39,7 +39,7 @@
// Notes: I'd have used ARRAY_SIZE instead but ran into cross-platform lib conflicts with
// that as well. >_<
#ifndef ArraySize
# define ArraySize(x) (sizeof(x)/sizeof((x)[0]))
#define ArraySize(x) (sizeof(x) / sizeof((x)[0]))
#endif
// --------------------------------------------------------------------------------------
@ -51,51 +51,51 @@
// some tight loops it will likely make debug builds unusably slow.
//
#ifdef __cplusplus
# ifdef PCSX2_DEVBUILD
static const bool IsDevBuild = true;
# else
static const bool IsDevBuild = false;
# endif
# ifdef PCSX2_DEBUG
static const bool IsDebugBuild = true;
# else
static const bool IsDebugBuild = false;
# endif
#ifdef PCSX2_DEVBUILD
static const bool IsDevBuild = true;
#else
# ifdef PCSX2_DEVBUILD
static const u8 IsDevBuild = 1;
# else
static const u8 IsDevBuild = 0;
# endif
# ifdef PCSX2_DEBUG
static const u8 IsDebugBuild = 1;
# else
static const u8 IsDebugBuild = 0;
# endif
static const bool IsDevBuild = false;
#endif
#ifdef PCSX2_DEBUG
# define pxDebugCode(code) code
static const bool IsDebugBuild = true;
#else
# define pxDebugCode(code)
static const bool IsDebugBuild = false;
#endif
#else
#ifdef PCSX2_DEVBUILD
static const u8 IsDevBuild = 1;
#else
static const u8 IsDevBuild = 0;
#endif
#ifdef PCSX2_DEBUG
static const u8 IsDebugBuild = 1;
#else
static const u8 IsDebugBuild = 0;
#endif
#endif
#ifdef PCSX2_DEBUG
#define pxDebugCode(code) code
#else
#define pxDebugCode(code)
#endif
#ifdef PCSX2_DEVBUILD
# define pxDevelCode(code) code
#define pxDevelCode(code) code
#else
# define pxDevelCode(code)
#define pxDevelCode(code)
#endif
#if defined(PCSX2_DEBUG) || defined(PCSX2_DEVBUILD)
# define pxReleaseCode(code)
# define pxNonReleaseCode(code) code
#define pxReleaseCode(code)
#define pxNonReleaseCode(code) code
#else
# define pxReleaseCode(code) code
# define pxNonReleaseCode(code)
#define pxReleaseCode(code) code
#define pxNonReleaseCode(code)
#endif
// --------------------------------------------------------------------------------------
@ -154,27 +154,27 @@ static const int __pagesize = PCSX2_PAGESIZE;
// This is the 2005/earlier compatible packing define, which must be used in conjunction
// with #ifdef _MSC_VER/#pragma pack() directives (ugly).
# define __packed
#define __packed
# define __aligned(alig) __declspec(align(alig))
# define __aligned16 __declspec(align(16))
# define __aligned32 __declspec(align(32))
# define __pagealigned __declspec(align(PCSX2_PAGESIZE))
#define __aligned(alig) __declspec(align(alig))
#define __aligned16 __declspec(align(16))
#define __aligned32 __declspec(align(32))
#define __pagealigned __declspec(align(PCSX2_PAGESIZE))
// Deprecated; use __align instead.
# define PCSX2_ALIGNED(alig,x) __declspec(align(alig)) x
# define PCSX2_ALIGNED_EXTERN(alig,x) extern __declspec(align(alig)) x
# define PCSX2_ALIGNED16(x) __declspec(align(16)) x
# define PCSX2_ALIGNED16_EXTERN(x) extern __declspec(align(16)) x
// Deprecated; use __align instead.
#define PCSX2_ALIGNED(alig, x) __declspec(align(alig)) x
#define PCSX2_ALIGNED_EXTERN(alig, x) extern __declspec(align(alig)) x
#define PCSX2_ALIGNED16(x) __declspec(align(16)) x
#define PCSX2_ALIGNED16_EXTERN(x) extern __declspec(align(16)) x
# define __noinline __declspec(noinline)
# define __threadlocal __declspec(thread)
#define __noinline __declspec(noinline)
#define __threadlocal __declspec(thread)
// Don't know if there are Visual C++ equivalents of these.
# define likely(x) (!!(x))
# define unlikely(x) (!!(x))
#define likely(x) (!!(x))
#define unlikely(x) (!!(x))
# define CALLBACK __stdcall
#define CALLBACK __stdcall
#else
@ -183,42 +183,42 @@ static const int __pagesize = PCSX2_PAGESIZE;
// --------------------------------------------------------------------------------------
#ifndef __packed
# define __packed __attribute__((packed))
#define __packed __attribute__((packed))
#endif
#ifndef __aligned
# define __aligned(alig) __attribute__((aligned(alig)))
#define __aligned(alig) __attribute__((aligned(alig)))
#endif
# define __aligned16 __attribute__((aligned(16)))
# define __aligned32 __attribute__((aligned(32)))
# define __pagealigned __attribute__((aligned(PCSX2_PAGESIZE)))
// Deprecated; use __align instead.
# define PCSX2_ALIGNED(alig,x) x __attribute((aligned(alig)))
# define PCSX2_ALIGNED16(x) x __attribute((aligned(16)))
# define PCSX2_ALIGNED_EXTERN(alig,x) extern x __attribute((aligned(alig)))
# define PCSX2_ALIGNED16_EXTERN(x) extern x __attribute((aligned(16)))
#define __aligned16 __attribute__((aligned(16)))
#define __aligned32 __attribute__((aligned(32)))
#define __pagealigned __attribute__((aligned(PCSX2_PAGESIZE)))
// Deprecated; use __align instead.
#define PCSX2_ALIGNED(alig, x) x __attribute((aligned(alig)))
#define PCSX2_ALIGNED16(x) x __attribute((aligned(16)))
#define PCSX2_ALIGNED_EXTERN(alig, x) extern x __attribute((aligned(alig)))
#define PCSX2_ALIGNED16_EXTERN(x) extern x __attribute((aligned(16)))
# define __assume(cond) ((void)0) // GCC has no equivalent for __assume
# define CALLBACK __attribute__((stdcall))
#define __assume(cond) ((void)0) // GCC has no equivalent for __assume
#define CALLBACK __attribute__((stdcall))
// Inlining note: GCC needs ((unused)) attributes defined on inlined functions to suppress
// warnings when a static inlined function isn't used in the scope of a single file (which
// happens *by design* like all the friggen time >_<)
#ifndef __fastcall
# define __fastcall __attribute__((fastcall))
#define __fastcall __attribute__((fastcall))
#endif
#define _inline __inline__ __attribute__((unused))
#ifdef NDEBUG
#define __forceinline __attribute__((always_inline, unused))
#else
#define __forceinline __attribute__((unused))
#endif
# define _inline __inline__ __attribute__((unused))
# ifdef NDEBUG
# define __forceinline __attribute__((always_inline,unused))
# else
# define __forceinline __attribute__((unused))
# endif
#ifndef __noinline
# define __noinline __attribute__((noinline))
#define __noinline __attribute__((noinline))
#endif
# define __threadlocal __thread
# define likely(x) __builtin_expect(!!(x), 1)
# define unlikely(x) __builtin_expect(!!(x), 0)
#define __threadlocal __thread
#define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)
#endif
// --------------------------------------------------------------------------------------
@ -233,9 +233,9 @@ static const int __pagesize = PCSX2_PAGESIZE;
// environment.
//
#ifdef PCSX2_DEVBUILD
# define __releaseinline
#define __releaseinline
#else
# define __releaseinline __forceinline
#define __releaseinline __forceinline
#endif
#define __ri __releaseinline

32
common/include/Pcsx2Types.h
View File

@ -24,9 +24,9 @@
// depend on these types will not be usable (they will yield linker errors).
#ifdef __cplusplus
class wxString;
class FastFormatAscii;
class FastFormatUnicode;
class wxString;
class FastFormatAscii;
class FastFormatUnicode;
#endif
@ -77,7 +77,7 @@ union u128
u8 _u8[16];
// Explicit conversion from u64. Zero-extends the source through 128 bits.
static u128 From64( u64 src )
static u128 From64(u64 src)
{
u128 retval;
retval.lo = src;
@ -86,7 +86,7 @@ union u128
}
// Explicit conversion from u32. Zero-extends the source through 128 bits.
static u128 From32( u32 src )
static u128 From32(u32 src)
{
u128 retval;
retval._u32[0] = src;
@ -99,12 +99,12 @@ union u128
operator u16() const { return _u16[0]; }
operator u8() const { return _u8[0]; }
bool operator==( const u128& right ) const
bool operator==(const u128 &right) const
{
return (lo == right.lo) && (hi == right.hi);
}
bool operator!=( const u128& right ) const
bool operator!=(const u128 &right) const
{
return (lo != right.lo) || (hi != right.hi);
}
@ -116,9 +116,9 @@ union u128
wxString ToString64() const;
wxString ToString8() const;
void WriteTo( FastFormatAscii& dest ) const;
void WriteTo8( FastFormatAscii& dest ) const;
void WriteTo64( FastFormatAscii& dest ) const;
void WriteTo(FastFormatAscii &dest) const;
void WriteTo8(FastFormatAscii &dest) const;
void WriteTo64(FastFormatAscii &dest) const;
};
struct s128
@ -127,16 +127,16 @@ struct s128
s64 hi;
// explicit conversion from s64, with sign extension.
static s128 From64( s64 src )
static s128 From64(s64 src)
{
s128 retval = { src, (src < 0) ? -1 : 0 };
s128 retval = {src, (src < 0) ? -1 : 0};
return retval;
}
// explicit conversion from s32, with sign extension.
static s128 From64( s32 src )
static s128 From64(s32 src)
{
s128 retval = { src, (src < 0) ? -1 : 0 };
s128 retval = {src, (src < 0) ? -1 : 0};
return retval;
}
@ -144,12 +144,12 @@ struct s128
operator u16() const { return (s16)lo; }
operator u8() const { return (s8)lo; }
bool operator==( const s128& right ) const
bool operator==(const s128 &right) const
{
return (lo == right.lo) && (hi == right.hi);
}
bool operator!=( const s128& right ) const
bool operator!=(const s128 &right) const
{
return (lo != right.lo) || (hi != right.hi);
}

251
common/include/PluginCallbacks.h
View File

@ -107,7 +107,7 @@
#ifndef BOOL
typedef int BOOL;
typedef int BOOL;
#endif
// --------------------------------------------------------------------------------------
@ -122,15 +122,15 @@
// on its HWND define that could be useful, and well it's probably good practice to use
// platform available defines when they exist.
//
#if defined( _WX_DEFS_H_ )
typedef WXWidget PS2E_HWND;
#elif defined( _WINDEF_ )
// For Windows let's use HWND, since it has some type strictness applied to it.
typedef HWND PS2E_HWND;
#if defined(_WX_DEFS_H_)
typedef WXWidget PS2E_HWND;
#elif defined(_WINDEF_)
// For Windows let's use HWND, since it has some type strictness applied to it.
typedef HWND PS2E_HWND;
#else
// Unsupported platform... use void* as a best guess. Should work fine for almost
// any GUI platform, and certainly works for any currently supported one.
typedef void* PS2E_HWND;
// Unsupported platform... use void* as a best guess. Should work fine for almost
// any GUI platform, and certainly works for any currently supported one.
typedef void *PS2E_HWND;
#endif
// --------------------------------------------------------------------------------------
@ -144,20 +144,20 @@
// pointer type.
//
#ifndef PS2E_THISPTR
# define PS2E_THISPTR struct _PS2E_ComponentAPI*
#define PS2E_THISPTR struct _PS2E_ComponentAPI *
#else
// Ensure the user's defined PS2E_THISPTR retains the correct signature for our
// plugin API.
static_assert( sizeof(PS2E_THISPTR) == sizeof(void*), "Incorrect signature for PS2E_THISPTR" );
// Ensure the user's defined PS2E_THISPTR retains the correct signature for our
// plugin API.
static_assert(sizeof(PS2E_THISPTR) == sizeof(void *), "Incorrect signature for PS2E_THISPTR");
#endif
// PS2E_LIB_THISPTR - (library scope version of PS2E_THISPTR)
#ifndef PS2E_LIB_THISPTR
# define PS2E_LIB_THISPTR void*
#define PS2E_LIB_THISPTR void *
#else
// Ensure the user's defined PS2E_THISPTR retains the correct signature for our
// plugin API.
static_assert( sizeof(PS2E_LIB_THISPTR) == sizeof(void*), "Incorrect signature for PS2E_LIB_THISPTR" );
// Ensure the user's defined PS2E_THISPTR retains the correct signature for our
// plugin API.
static_assert(sizeof(PS2E_LIB_THISPTR) == sizeof(void *), "Incorrect signature for PS2E_LIB_THISPTR");
#endif
// Use fastcall by default, since under most circumstances the object-model approach of the
@ -174,8 +174,7 @@ extern "C" {
// Plugin Type / Version Enumerations
// ------------------------------------------------------------------------------------
enum PS2E_ComponentTypes
{
enum PS2E_ComponentTypes {
PS2E_TYPE_GS = 0,
PS2E_TYPE_PAD,
PS2E_TYPE_SPU2,
@ -187,8 +186,7 @@ enum PS2E_ComponentTypes
PS2E_TYPE_Mcd,
};
enum PluginLibVersion
{
enum PluginLibVersion {
PS2E_VER_GS = 0x1000,
PS2E_VER_PAD = 0x1000,
PS2E_VER_SPU2 = 0x1000,
@ -199,8 +197,7 @@ enum PluginLibVersion
PS2E_VER_SIO = 0x1000
};
enum OSDIconTypes
{
enum OSDIconTypes {
OSD_Icon_None = 0,
OSD_Icon_Error,
OSD_Icon_Notice, // An exclamation point maybe?
@ -215,17 +212,16 @@ enum OSDIconTypes
OSD_Icon_ReserveEnd = 0x1000
};
enum PS2E_MenuItemStyle
{
enum PS2E_MenuItemStyle {
MenuType_Normal = 0,
MenuType_Checked,
MenuType_Radio,
MenuType_Separator
};
typedef void* PS2E_MenuHandle;
typedef void* PS2E_MenuItemHandle;
typedef void PS2E_CALLBACK PS2E_OnMenuItemClicked( PS2E_THISPTR* thisptr, void* userptr );
typedef void *PS2E_MenuHandle;
typedef void *PS2E_MenuItemHandle;
typedef void PS2E_CALLBACK PS2E_OnMenuItemClicked(PS2E_THISPTR *thisptr, void *userptr);
// --------------------------------------------------------------------------------------
// PS2E_ConsoleWriterAPI
@ -250,18 +246,18 @@ typedef void PS2E_CALLBACK PS2E_OnMenuItemClicked( PS2E_THISPTR* thisptr, void*
typedef struct _PS2E_ConsoleWriterAPI
{
// Writes text to console; no newline is appended.
void (PS2E_CALLBACK* Write)( const char* fmt, ... );
void(PS2E_CALLBACK *Write)(const char *fmt, ...);
// Appends an automatic newline to the specified formatted output.
void (PS2E_CALLBACK* WriteLn)( const char* fmt, ... );
void(PS2E_CALLBACK *WriteLn)(const char *fmt, ...);
// This function always appends a newline.
void (PS2E_CALLBACK* Error)( const char* fmt, ... );
void(PS2E_CALLBACK *Error)(const char *fmt, ...);
// This function always appends a newline.
void (PS2E_CALLBACK* Warning)( const char* fmt, ... );
void(PS2E_CALLBACK *Warning)(const char *fmt, ...);
void* reserved[4];
void *reserved[4];
} PS2E_ConsoleWriterAPI;
@ -279,18 +275,18 @@ typedef struct _PS2E_ConsoleWriterAPI
typedef struct _PS2E_ConsoleWriterWideAPI
{
// Writes text to console; no newline is appended.
void (PS2E_CALLBACK* Write)( const wchar_t* fmt, ... );
void(PS2E_CALLBACK *Write)(const wchar_t *fmt, ...);
// Appends an automatic newline to the specified formatted output.
void (PS2E_CALLBACK* WriteLn)( const wchar_t* fmt, ... );
void(PS2E_CALLBACK *WriteLn)(const wchar_t *fmt, ...);
// This function always appends a newline.
void (PS2E_CALLBACK* Error)( const wchar_t* fmt, ... );
void(PS2E_CALLBACK *Error)(const wchar_t *fmt, ...);
// This function always appends a newline.
void (PS2E_CALLBACK* Warning)( const wchar_t* fmt, ... );
void(PS2E_CALLBACK *Warning)(const wchar_t *fmt, ...);
void* reserved[4];
void *reserved[4];
} PS2E_ConsoleWriterWideAPI;
@ -307,7 +303,7 @@ typedef struct _PS2E_Image
{
u32 width;
u32 height;
u8* data; // RGBA data. top to bottom.
u8 *data; // RGBA data. top to bottom.
} PS2E_Image;
@ -316,13 +312,13 @@ typedef struct _PS2E_Image
// --------------------------------------------------------------------------------------
typedef struct _PS2E_MenuItemInfo
{
const char* LabelText;
const char* HelpText;
const char *LabelText;
const char *HelpText;
// Optional image displayed with the menu option. The emulator may not support
// this option, or may choose to ignore or resize the image if the size parameters
// are outside a valid threshold.
const PS2E_Image* Image;
const PS2E_Image *Image;
// Specifies the style of the menu, either Normal, Checked, Radio, or Separator.
// This option is overridden if the SubMenu field is non-NULL (in such case the
@ -343,11 +339,11 @@ typedef struct _PS2E_MenuItemInfo
BOOL Enabled;
// Optional user data pointer (or typecast integer value)
void* UserPtr;
void *UserPtr;
// Callback issued when the menu is clicked/activated. If NULL, the menu will be
// disabled (grayed).
PS2E_OnMenuItemClicked* OnClicked;
PS2E_OnMenuItemClicked *OnClicked;
} PS2E_MenuItemInfo;
@ -358,27 +354,27 @@ typedef struct _PS2E_MenuItemAPI
{
// Allocates a new MenuItem and returns its handle. The returned item can be added to any
// menu.
PS2E_MenuItemHandle (PS2E_CALLBACK* MenuItem_Create)( PS2E_THISPTR thisptr );
PS2E_MenuItemHandle(PS2E_CALLBACK *MenuItem_Create)(PS2E_THISPTR thisptr);
// Deletes the menu item and frees allocated resources. The menu item will be removed from
// whatever menu it is attached to. If the menu item has a SubMenu, the SubMenu is not
// deleted.
void (PS2E_CALLBACK* MenuItem_Delete)( PS2E_MenuItemHandle mitem );
void(PS2E_CALLBACK *MenuItem_Delete)(PS2E_MenuItemHandle mitem);
// (Re-)Assigns all properties for a menu. Assignment generally takes effect immediately.
void (PS2E_CALLBACK* MenuItem_SetEverything)( PS2E_MenuItemHandle mitem, const PS2E_MenuItemInfo* info );
void(PS2E_CALLBACK *MenuItem_SetEverything)(PS2E_MenuItemHandle mitem, const PS2E_MenuItemInfo *info);
// Sets the text label of a menu item.
void (PS2E_CALLBACK* MenuItem_SetText)( PS2E_MenuItemHandle mitem, const char* text );
void(PS2E_CALLBACK *MenuItem_SetText)(PS2E_MenuItemHandle mitem, const char *text);
// Assigns the help text for a menu item. This text is typically shown in a status
// bar at the bottom of the current window. This value may be ignored if the emu
// interface does not have a context for help text.
void (PS2E_CALLBACK* MenuItem_SetHelpText)( PS2E_MenuItemHandle mitem, const char* helptxt );
void(PS2E_CALLBACK *MenuItem_SetHelpText)(PS2E_MenuItemHandle mitem, const char *helptxt);
// Gives the menu item an accompanying image (orientation of the image may depend
// on the operating system platform).
void (PS2E_CALLBACK* MenuItem_SetImage)( PS2E_MenuItemHandle mitem, const PS2E_Image* image );
void(PS2E_CALLBACK *MenuItem_SetImage)(PS2E_MenuItemHandle mitem, const PS2E_Image *image);
// Gives the menu item an accompanying image (orientation of the image may depend
// on the operating system platform).
@ -386,7 +382,8 @@ typedef struct _PS2E_MenuItemAPI
// Returns:
// TRUE if the image was loaded successfully, or FALSE if the image was not found,
// could not be opened, or the image data is invalid (not a PNG, or data corrupted).
BOOL (PS2E_CALLBACK* MenuItem_SetImagePng_FromFile)( PS2E_MenuItemHandle mitem, const char* filename );
BOOL(PS2E_CALLBACK *MenuItem_SetImagePng_FromFile)
(PS2E_MenuItemHandle mitem, const char *filename);
// Gives the menu item an accompanying image (orientation of the image may depend on
// the operating system platform). Image is loaded from memory using a memory stream
@ -395,33 +392,35 @@ typedef struct _PS2E_MenuItemAPI
// Returns:
// TRUE if the image was loaded successfully, or FALSE if the image data is invalid
// (not a PNG, or data corrupted).
BOOL (PS2E_CALLBACK* MenuItem_SetImagePng_FromMemory)( PS2E_MenuItemHandle mitem, const u8* data );
BOOL(PS2E_CALLBACK *MenuItem_SetImagePng_FromMemory)
(PS2E_MenuItemHandle mitem, const u8 *data);
// Assigns the menu item's style.
void (PS2E_CALLBACK* MenuItem_SetStyle)( PS2E_MenuItemHandle mitem, PS2E_MenuItemStyle style );
void(PS2E_CALLBACK *MenuItem_SetStyle)(PS2E_MenuItemHandle mitem, PS2E_MenuItemStyle style);
// Assigns a pointer value that the plugin can use to attach user-defined data to
// specific menu items. The value can be any integer typecast if you don't actually
// need more than an integers worth of data.
void (PS2E_CALLBACK* MenuItem_SetUserData)( PS2E_MenuItemHandle mitem, void* dataptr );
void(PS2E_CALLBACK *MenuItem_SetUserData)(PS2E_MenuItemHandle mitem, void *dataptr);
// Assigns a submenu to the menu item, causing it to open the sub menu in cascade
// fashion. When a submenu is assigned, the Style attribute of the menu will be
// ignored. Passing NULL into this function will clear the submenu and return the
// menu item to whatever its current Style attribute is set to.
void (PS2E_CALLBACK* MenuItem_SetSubMenu)( PS2E_MenuItemHandle mitem, PS2E_MenuHandle submenu );
void(PS2E_CALLBACK *MenuItem_SetSubMenu)(PS2E_MenuItemHandle mitem, PS2E_MenuHandle submenu);
// Assigns the callback function for this menu (important!). If passed NULL, the menu
// item will be automatically disabled (grayed out) by the emulator.
void (PS2E_CALLBACK* MenuItem_SetCallback)( PS2E_MenuItemHandle mitem, PS2E_OnMenuItemClicked* onClickedCallback );
void(PS2E_CALLBACK *MenuItem_SetCallback)(PS2E_MenuItemHandle mitem, PS2E_OnMenuItemClicked *onClickedCallback);
// Assigns the enabled status of a MenuItem. Use FALSE to gray out the menuitem option.
void (PS2E_CALLBACK* MenuItem_Enable)( PS2E_MenuItemHandle mitem, BOOL enable );
void(PS2E_CALLBACK *MenuItem_Enable)(PS2E_MenuItemHandle mitem, BOOL enable);
// Returns the current enable status of the specified menu item.
BOOL (PS2E_CALLBACK* MenuItem_IsEnabled)( PS2E_MenuItemHandle mitem );
BOOL(PS2E_CALLBACK *MenuItem_IsEnabled)
(PS2E_MenuItemHandle mitem);
void* reserved[4];
void *reserved[4];
} PS2E_MenuItemAPI;
@ -456,8 +455,8 @@ typedef struct _PS2E_SessionInfo
{
PS2E_HWND window;
u32* CycleEE; // current EE cycle count
u32* CycleIOP; // current IOP cycle count
u32 *CycleEE; // current EE cycle count
u32 *CycleIOP; // current IOP cycle count
u32 ElfCRC; // CRC of the ELF header for this app/game
@ -493,7 +492,7 @@ typedef struct _PS2E_EmulatorInfo
// Brief name of the emulator (ex: "PCSX2") [required]
// Depending on the design of the emulator, this string may optionally include version
// information, however that is not recommended since it can inhibit backward support.
const char* EmuName;
const char *EmuName;
// Version information. All fields besides the emulator's name are optional.
PS2E_VersionInfo EmuVersion;
@ -526,7 +525,8 @@ typedef struct _PS2E_EmulatorInfo
// Returns:
// 0 - Value was retrieved successfully.
// 1 - Unknown value. Contents of dest are unchanged.
BOOL (PS2E_CALLBACK* GetInt)( const char* name, int* dest );
BOOL(PS2E_CALLBACK *GetInt)
(const char *name, int *dest);
// GetBoolean
// Assigns *dest either 1 (true) or 0 (false). Note to Emulators: Returning any non-
@ -536,7 +536,8 @@ typedef struct _PS2E_EmulatorInfo
// Returns:
// 0 - Value was retrieved successfully.
// 1 - Unknown value. Contents of dest are unchanged.
BOOL (PS2E_CALLBACK* GetBoolean)( const char* name, BOOL* result );
BOOL(PS2E_CALLBACK *GetBoolean)
(const char *name, BOOL *result);
// GetString
// Copies an ASCII-Z string into the dest pointer, to max length allowed. The result
@ -546,7 +547,8 @@ typedef struct _PS2E_EmulatorInfo
// Returns:
// 0 - Value was retrieved successfully.
// 1 - Unknown value. Contents of dest are unchanged.
BOOL (PS2E_CALLBACK* GetString)( const char* name, char* dest, int maxlen );
BOOL(PS2E_CALLBACK *GetString)
(const char *name, char *dest, int maxlen);
// GetStringAlloc
// Provides an alternative to GetString, that can retrieve strings of arbitrary length.
@ -556,7 +558,7 @@ typedef struct _PS2E_EmulatorInfo
// It is then the responsibility of the plugin to free the allocated pointer when it
// is done with it.
//
char* (PS2E_CALLBACK* GetStringAlloc)( const char* name, void* (PS2E_CALLBACK *allocator)(int size) );
char *(PS2E_CALLBACK *GetStringAlloc)(const char *name, void *(PS2E_CALLBACK *allocator)(int size));
// OSD_WriteLn
// This function allows the plugin to post messages to the emulator's On-Screen Display.
@ -578,30 +580,30 @@ typedef struct _PS2E_EmulatorInfo
//
// msg - string message displayed to the user.
//
void (PS2E_CALLBACK* OSD_WriteLn)( int icon, const char* msg );
void(PS2E_CALLBACK *OSD_WriteLn)(int icon, const char *msg);
// ----------------------------------------------------------------------------
// Menu / MenuItem Section
// ----------------------------------------------------------------------------
void (PS2E_CALLBACK* AddMenuItem)( const PS2E_MenuItemInfo* item );
void(PS2E_CALLBACK *AddMenuItem)(const PS2E_MenuItemInfo *item);
// Allocates a new menu handle and returns it. The returned menu can have any valid existing
// menu items bound to it, and can be assigned as a submenu to any created MenuItem. The menu
// can belong to multiple menu items, however menu items can only belong to a single menu.
PS2E_MenuHandle (PS2E_CALLBACK* Menu_Create)( PS2E_THISPTR thisptr );
PS2E_MenuHandle(PS2E_CALLBACK *Menu_Create)(PS2E_THISPTR thisptr);
// Deletes the specified menu and frees its allocated memory resources. NULL pointers are
// safely ignored. Any menu items also attached to this menu will be deleted. Even if you
// do not explicitly delete your plugin's menu resources, the emulator will do automatic
// cleanup after the plugin's instance is freed.
void (PS2E_CALLBACK* Menu_Delete)( PS2E_MenuHandle handle );
void(PS2E_CALLBACK *Menu_Delete)(PS2E_MenuHandle handle);
// Adds the specified menu item to this menu. Menu items can only belong to one menu at a
// time. If you assign an item to a created menu that already belongs to another menu, it
// will be removed from the other menu and moved to this one. To append a menu item to
// multiple menus, you will need to create multiple instances of the item.
void (PS2E_CALLBACK* Menu_AddItem)( PS2E_MenuHandle menu, PS2E_MenuItemHandle mitem );
void(PS2E_CALLBACK *Menu_AddItem)(PS2E_MenuHandle menu, PS2E_MenuItemHandle mitem);
// Interface for creating menu items and modifying their properties.
PS2E_MenuItemAPI MenuItem;
@ -617,7 +619,7 @@ typedef struct _PS2E_EmulatorInfo
// side before using this interface. See PS2E_ConsoleWriterWideAPI comments for more info.
PS2E_ConsoleWriterWideAPI ConsoleW;
void* reserved2[8];
void *reserved2[8];
} PS2E_EmulatorInfo;
@ -630,7 +632,7 @@ typedef struct _PS2E_EmulatorInfo
typedef struct _PS2E_FreezeData
{
u32 Size; // size of the data being frozen or thawed. This value is allowed to be changed by Freeze().
void* Data; // pointer to the data target (freeze) or source (thaw)
void *Data; // pointer to the data target (freeze) or source (thaw)
} PS2E_FreezeData;
@ -661,7 +663,7 @@ typedef struct _PS2E_ComponentAPI
// Threading: EmuOpen is called from the GUI thread. All other emulation threads are
// guaranteed to be suspended or closed at the time of this call (no locks required).
//
void (PS2E_CALLBACK* EmuOpen)( PS2E_THISPTR thisptr, const PS2E_SessionInfo *session );
void(PS2E_CALLBACK *EmuOpen)(PS2E_THISPTR thisptr, const PS2E_SessionInfo *session);
// EmuClose
// This function is called by the emulator prior to stopping emulation. The window
@ -671,7 +673,7 @@ typedef struct _PS2E_ComponentAPI
// Threading: EmuClose is called from the GUI thread. All other emulation threads are
// guaranteed to be suspended or closed at the time of this call (no locks required).
//
void (PS2E_CALLBACK* EmuClose)( PS2E_THISPTR thisptr );
void(PS2E_CALLBACK *EmuClose)(PS2E_THISPTR thisptr);
// CalcFreezeSize
// This function should calculate and return the amount of memory needed for the plugin
@ -685,7 +687,7 @@ typedef struct _PS2E_ComponentAPI
// May be called from any thread (GUI, Emu, GS, Unknown, etc).
// All Emulation threads are halted at a PS2 logical vsync-end event.
// No locking is necessary.
u32 (PS2E_CALLBACK* CalcFreezeSize)( PS2E_THISPTR thisptr );
u32(PS2E_CALLBACK *CalcFreezeSize)(PS2E_THISPTR thisptr);
// Freeze
// This function should make a complete copy of the plugin's emulation state into the
@ -700,7 +702,7 @@ typedef struct _PS2E_ComponentAPI
// May be called from any thread (GUI, Emu, GS, Unknown, etc).
// All Emulation threads are halted at a PS2 logical vsync-end event.
// No locking is necessary.
void (PS2E_CALLBACK* Freeze)( PS2E_THISPTR thisptr, PS2E_FreezeData* dest );
void(PS2E_CALLBACK *Freeze)(PS2E_THISPTR thisptr, PS2E_FreezeData *dest);
// Thaw
// Plugin should restore a complete emulation state from the given FreezeData. The
@ -711,7 +713,7 @@ typedef struct _PS2E_ComponentAPI
// May be called from any thread (GUI, Emu, GS, Unknown, etc).
// All Emulation threads are halted at a PS2 logical vsync-end event.
// No locking is necessary.
void (PS2E_CALLBACK* Thaw)( PS2E_THISPTR thisptr, const PS2E_FreezeData* src );
void(PS2E_CALLBACK *Thaw)(PS2E_THISPTR thisptr, const PS2E_FreezeData *src);
// Configure
// The plugin should open a modal dialog box with plugin-specific settings and prop-
@ -730,7 +732,7 @@ typedef struct _PS2E_ComponentAPI
// Thread Safety:
// Always called from the GUI thread, with emulation in a halted state (no locks
// needed).
void (PS2E_CALLBACK* Configure)( PS2E_THISPTR thisptr );
void(PS2E_CALLBACK *Configure)(PS2E_THISPTR thisptr);
// GetLastError
// This is an optional method with allows the emulator to retrieve extended formatted
@ -754,10 +756,10 @@ typedef struct _PS2E_ComponentAPI
// * Interlocking: Instance. All calls from the emu are fully interlocked against
// the plugin instance.
//
void (PS2E_CALLBACK* GetLastError)( PS2E_THISPTR thisptr, char* const* msg_diag, wchar_t* const* msg_user );
void(PS2E_CALLBACK *GetLastError)(PS2E_THISPTR thisptr, char *const *msg_diag, wchar_t *const *msg_user);
// Reserved area at the end of the structure, for future API expansion.
void* reserved[8];
void *reserved[8];
} PS2E_ComponentAPI;
@ -791,7 +793,7 @@ typedef struct _PS2E_LibraryAPI
//
// This function may be called multiple times by the emulator, so it should accommodate
// for such if it performs heap allocations or other initialization procedures.
const char* (PS2E_CALLBACK* GetName)();
const char *(PS2E_CALLBACK *GetName)();
// GetVersion
// This function returns name and version information for the requested PS2 component.
@ -812,7 +814,7 @@ typedef struct _PS2E_LibraryAPI
// component - indicates the ps2 component plugin to be versioned. If the plugin
// does not support the requested component, the function should return NULL.
//
const PS2E_VersionInfo* (PS2E_CALLBACK* GetVersion)( u32 component );
const PS2E_VersionInfo *(PS2E_CALLBACK *GetVersion)(u32 component);
// Test
// Called by the plugin enumerator to check the hardware availability of the specified
@ -824,7 +826,8 @@ typedef struct _PS2E_LibraryAPI
// have provisions in its interface to allow for the forced disabling of extended CPU cap-
// abilities, for testing purposes.
//
BOOL (PS2E_CALLBACK* Test)( u32 component, const PS2E_EmulatorInfo* xinfo );
BOOL(PS2E_CALLBACK *Test)
(u32 component, const PS2E_EmulatorInfo *xinfo);
// NewComponentInstance
// The emulator calls this function to fetch the API for the requested component.
@ -851,12 +854,13 @@ typedef struct _PS2E_LibraryAPI
// Plugins may optionally prepare more detailed information on why the plugin failed
// it's availability test which the emu can request via GetLastError.
//
PS2E_THISPTR (PS2E_CALLBACK* NewComponentInstance)( u32 component );
PS2E_THISPTR(PS2E_CALLBACK *NewComponentInstance)
(u32 component);
// DeleteComponentInstance
// Called by the emulator when the plugin component is to be shutdown. The component API
// instance pointer can be safely deleted here.
void (PS2E_CALLBACK* DeleteComponentInstance)( PS2E_THISPTR instance );
void(PS2E_CALLBACK *DeleteComponentInstance)(PS2E_THISPTR instance);
// SetSettingsFolder
// Callback is passed an ASCII-Z string representing the folder where the emulator's
@ -868,7 +872,7 @@ typedef struct _PS2E_LibraryAPI
// emulation state, shutdown plugins, and restart everything anew from the new settings
// in such an event as a dynamic change of the settings folder.
//
void (PS2E_CALLBACK* SetSettingsFolder)( const char* folder );
void(PS2E_CALLBACK *SetSettingsFolder)(const char *folder);
// SetLogFolder
// This callback may be issued at any time. It is the responsibility of the plugin
@ -879,12 +883,12 @@ typedef struct _PS2E_LibraryAPI
// This function is always called from the GUI thread. All emulation threads are
// suspended during the call, so no locking is required.
//
void (PS2E_CALLBACK* SetLogFolder)( const char* folder );
void(PS2E_CALLBACK *SetLogFolder)(const char *folder);
// Reserved area at the end of the structure, for future API expansion. This area
// should always be zeroed out, so that future versions of emulators that may have
// defined functions here will recognize the functions as not supported by the plugin.
void* reserved[12];
void *reserved[12];
} PS2E_LibraryAPI;
@ -911,7 +915,7 @@ typedef struct _PS2E_ComponentAPI_GS
// This function may be called from either GUI thread or GS thread. Emulators calling
// it from non-GS threads must ensure mutex locking with TakeSnapshot (meaning the
// plugin should be free to disregard threading concerns).
void (PS2E_CALLBACK* GsSetSnapshotsFolder)( PS2E_THISPTR thisptr, const char* folder );
void(PS2E_CALLBACK *GsSetSnapshotsFolder)(PS2E_THISPTR thisptr, const char *folder);
// TakeSnapshot
// The GS plugin is to save the current frame into the given target image. This
@ -920,7 +924,8 @@ typedef struct _PS2E_ComponentAPI_GS
//
// Returns TRUE if the snapshot succeeded, or FALSE if it failed (contents of dest
// are considered indeterminate and will be ignored by the emu).
BOOL (PS2E_CALLBACK* GsTakeSnapshot)( PS2E_THISPTR thisptr, PS2E_Image* dest );
BOOL(PS2E_CALLBACK *GsTakeSnapshot)
(PS2E_THISPTR thisptr, PS2E_Image *dest);
// OSD_QueueMessage
// Queues a message to the GS for display to the user. The GS can print the message
@ -937,7 +942,7 @@ typedef struct _PS2E_ComponentAPI_GS
// timeout - Suggested timeout period, in milliseconds. This is a hint and need
// not be strictly adhered to by the GS.
//
void (PS2E_CALLBACK* OSD_QueueMessage)( PS2E_THISPTR thisptr, const char* msg, int timeout );
void(PS2E_CALLBACK *OSD_QueueMessage)(PS2E_THISPTR thisptr, const char *msg, int timeout);
// OSD_IconStatus
// Sets the visibility status of an icon. Icon placement can be determined by the GS,
@ -949,7 +954,7 @@ typedef struct _PS2E_ComponentAPI_GS
// alpha - 0.0 is hdden, 1.0 is visible. Other alpha values may be used as either
// transparency or as a scrolling factor (ie, to scroll the icon in and out of view, in
// any way the GS plugin sees fit).
void (PS2E_CALLBACK* OSD_IconStatus)( PS2E_THISPTR thisptr, OSDIconTypes iconId, float alpha );
void(PS2E_CALLBACK *OSD_IconStatus)(PS2E_THISPTR thisptr, OSDIconTypes iconId, float alpha);
// GSvsync
//
@ -958,7 +963,8 @@ typedef struct _PS2E_ComponentAPI_GS
// (if any critical errors accumulated during GStransferTags or GStransferImage, they
// should also be handled here by returning FALSE)
//
BOOL (PS2E_CALLBACK* GsVsync)(int field);
BOOL(PS2E_CALLBACK *GsVsync)
(int field);
// GSwriteRegs
// Sends a GIFtag and associated register data. This is the main transfer method for all
@ -980,7 +986,7 @@ typedef struct _PS2E_ComponentAPI_GS
//
// nloop - number of loops of register data. Valid range is 1->32767 (upper 17
// bits are always zero). This value will never be zero.
void (PS2E_CALLBACK* GsWriteRegs)(const u128 *pMem, int regcnt, int nloop);
void(PS2E_CALLBACK *GsWriteRegs)(const u128 *pMem, int regcnt, int nloop);
// GSwritePrim
// Starts a new prim by sending the specified value to the PRIM register. The emulator
@ -990,7 +996,7 @@ typedef struct _PS2E_ComponentAPI_GS
// Parameters:
// primData - value to write to the PRIM register. Only the bottom 10 bits are
// valid. Upper bits are always zero.
void (PS2E_CALLBACK* GsWritePrim)(int primData);
void(PS2E_CALLBACK *GsWritePrim)(int primData);
// GSwriteImage
// Uploads new image data. Data uploaded may be in any number of partial chunks, for
@ -1000,16 +1006,16 @@ typedef struct _PS2E_ComponentAPI_GS
// larger texture buffer, or for games to modify several portions of a single large
// buffer, by using mid-transfer writes to TRXPOS and TRXDIR (TRXPOS writes only become
// effective once TRXDIR has been written).
void (PS2E_CALLBACK* GsWriteImage)(const u128 *pMem, int qwc_cnt);
void(PS2E_CALLBACK *GsWriteImage)(const u128 *pMem, int qwc_cnt);
// GSreadImage
// This special callback is for implementing the Read mode direction of the GIFpath.
// The GS plugin writes the texture data as requested by it's internally managed state
// values for TRXPOS/TRXREG to the buffer provided by pMem. The buffer size is qwc_cnt
// and the GS must not write more than that.
void (PS2E_CALLBACK* GsReadImage)(u128 *pMem, int qwc_cnt);
void(PS2E_CALLBACK *GsReadImage)(u128 *pMem, int qwc_cnt);
void* reserved[8];
void *reserved[8];
} PS2E_ComponentAPI_GS;
@ -1047,7 +1053,8 @@ typedef struct _PS2E_ComponentAPI_Mcd
// Returns:
// False if the card is not available, or True if it is available.
//
BOOL (PS2E_CALLBACK* McdIsPresent)( PS2E_THISPTR thisptr, uint port, uint slot );
BOOL(PS2E_CALLBACK *McdIsPresent)
(PS2E_THISPTR thisptr, uint port, uint slot);
// McdGetSectorSize (can be NULL)
// Requests memorycard formatting information from the Mcd provider. See the description of
@ -1057,7 +1064,7 @@ typedef struct _PS2E_ComponentAPI_Mcd
// Returns:
// Assigned values for memorycard sector size and sector count in 'outways.'
//
void (PS2E_CALLBACK* McdGetSizeInfo)( PS2E_THISPTR thisptr, uint port, uint slot, PS2E_McdSizeInfo* outways );
void(PS2E_CALLBACK *McdGetSizeInfo)(PS2E_THISPTR thisptr, uint port, uint slot, PS2E_McdSizeInfo *outways);
// McdIsPSX
// Checks if the memorycard is a PSX one from the Mcd provider.
@ -1065,7 +1072,7 @@ typedef struct _PS2E_ComponentAPI_Mcd
// Returns:
// False: PS2, True: PSX
//
bool (PS2E_CALLBACK* McdIsPSX)( PS2E_THISPTR thisptr, uint port, uint slot );
bool(PS2E_CALLBACK *McdIsPSX)(PS2E_THISPTR thisptr, uint port, uint slot);
// McdRead
// Requests that a block of data be loaded from the memorycard into the specified dest
@ -1077,7 +1084,8 @@ typedef struct _PS2E_ComponentAPI_Mcd
// False on failure, and True on success. Emulator may use GetLastError to retrieve additional
// information for logging or displaying to the user.
//
BOOL (PS2E_CALLBACK* McdRead)( PS2E_THISPTR thisptr, uint port, uint slot, u8 *dest, u32 adr, int size );
BOOL(PS2E_CALLBACK *McdRead)
(PS2E_THISPTR thisptr, uint port, uint slot, u8 *dest, u32 adr, int size);
// McdSave
// Saves the provided block of data to the memorycard at the specified seek address.
@ -1088,7 +1096,8 @@ typedef struct _PS2E_ComponentAPI_Mcd
// False on failure, and True on success. Emulator may use GetLastError to retrieve additional
// information for logging or displaying to the user.
//
BOOL (PS2E_CALLBACK* McdSave)( PS2E_THISPTR thisptr, uint port, uint slot, const u8 *src, u32 adr, int size );
BOOL(PS2E_CALLBACK *McdSave)
(PS2E_THISPTR thisptr, uint port, uint slot, const u8 *src, u32 adr, int size);
// McdEraseBlock
// Saves "cleared" data to the memorycard at the specified seek address. Cleared data
@ -1100,18 +1109,19 @@ typedef struct _PS2E_ComponentAPI_Mcd
// False on failure, and True on success. Emulator may use GetLastError to retrieve additional
// information for logging or displaying to the user.
//
BOOL (PS2E_CALLBACK* McdEraseBlock)( PS2E_THISPTR thisptr, uint port, uint slot, u32 adr );
BOOL(PS2E_CALLBACK *McdEraseBlock)
(PS2E_THISPTR thisptr, uint port, uint slot, u32 adr);
u64 (PS2E_CALLBACK* McdGetCRC)( PS2E_THISPTR thisptr, uint port, uint slot );
u64(PS2E_CALLBACK *McdGetCRC)(PS2E_THISPTR thisptr, uint port, uint slot);
// McdNextFrame
// Inform the memory card that a frame of emulation time has passed.
// Used by the FolderMemoryCard to find a good time to flush written data to the host file system.
void (PS2E_CALLBACK* McdNextFrame)( PS2E_THISPTR thisptr, uint port, uint slot );
void(PS2E_CALLBACK *McdNextFrame)(PS2E_THISPTR thisptr, uint port, uint slot);
bool (PS2E_CALLBACK* McdReIndex)( PS2E_THISPTR thisptr, uint port, uint slot, const wxString& filter );
bool(PS2E_CALLBACK *McdReIndex)(PS2E_THISPTR thisptr, uint port, uint slot, const wxString &filter);
void* reserved[6];
void *reserved[6];
} PS2E_ComponentAPI_Mcd;
@ -1120,14 +1130,12 @@ typedef struct _PS2E_ComponentAPI_Mcd
// KeyEvent type enumerations
// ------------------------------------------------------------------------------------
enum PS2E_KeyEventTypes
{
enum PS2E_KeyEventTypes {
PS2E_KEY_UP = 0,
PS2E_KEY_DOWN
};
enum PS2E_KeyModifiers
{
enum PS2E_KeyModifiers {
PS2E_SHIFT = 1,
PS2E_CONTROL = 2,
PS2E_ALT = 4
@ -1176,7 +1184,8 @@ typedef struct _PS2E_ComponentAPI_Pad
// Returns:
// False if the card/pad is not available, or True if it is available.
//
BOOL (PS2E_CALLBACK* PadIsPresent)( PS2E_THISPTR thisptr, uint port, uint slot );
BOOL(PS2E_CALLBACK *PadIsPresent)
(PS2E_THISPTR thisptr, uint port, uint slot);
// PadStartPoll
// Called by the emulator to start polling the specified pad.
@ -1188,7 +1197,7 @@ typedef struct _PS2E_ComponentAPI_Pad
// Called from the EEcore thread. The emulator performs no locking of its own, so
// calls to this may occur concurrently with calls to PadUpdate.
//
u8 (PS2E_CALLBACK* PadStartPoll)( PS2E_THISPTR thisptr, uint port, uint slot );
u8(PS2E_CALLBACK *PadStartPoll)(PS2E_THISPTR thisptr, uint port, uint slot);
// PadPoll
// Continues polling the specified pad, sending the given value.
@ -1200,7 +1209,7 @@ typedef struct _PS2E_ComponentAPI_Pad
// Called from the EEcore thread. The emulator performs no locking of its own, so
// calls to this may occur concurrently with calls to PadUpdate.
//
u8 (PS2E_CALLBACK* PadPoll)( PS2E_THISPTR thisptr, u8 value );
u8(PS2E_CALLBACK *PadPoll)(PS2E_THISPTR thisptr, u8 value);
// PadKeyEvent
// Called by the emulator in the gui thread to check for keys being pressed or released.
@ -1213,7 +1222,7 @@ typedef struct _PS2E_ComponentAPI_Pad
// May be called from any thread. The emulator performs no locking of its own, so
// calls to this may occur concurrently with calls to PadUpdate.
//
PS2E_KeyEvent* (PS2E_CALLBACK* PadGetKeyEvent)( PS2E_THISPTR thisptr );
PS2E_KeyEvent *(PS2E_CALLBACK *PadGetKeyEvent)(PS2E_THISPTR thisptr);
// PadUpdate
// This callback is issued from the thread that owns the GSwindow, at roughly 50/60hz,
@ -1225,9 +1234,9 @@ typedef struct _PS2E_ComponentAPI_Pad
// or an MTGS thread). The emulator performs no locking of its own, so calls to this
// may occur concurrently with calls to PadKeyEvent and PadPoll.
//
void (PS2E_CALLBACK* PadUpdate)( PS2E_THISPTR thisptr );
void(PS2E_CALLBACK *PadUpdate)(PS2E_THISPTR thisptr);
void* reserved[8];
void *reserved[8];
} PS2E_ComponentAPI_Pad;
@ -1260,7 +1269,7 @@ typedef struct _PS2E_ComponentAPI_Pad
// * Affinity: Called only from the Main/GUI thread.
// * Interlocking: Full interlocking garaunteed.
//
typedef const PS2E_LibraryAPI* (PS2E_CALLBACK* _PS2E_InitAPI)( const PS2E_EmulatorInfo* emuinfo );
typedef const PS2E_LibraryAPI *(PS2E_CALLBACK *_PS2E_InitAPI)(const PS2E_EmulatorInfo *emuinfo);
// --------------------------------------------------------------------------------------
// PS2E_GetLastError
@ -1277,7 +1286,7 @@ typedef const PS2E_LibraryAPI* (PS2E_CALLBACK* _PS2E_InitAPI)( const PS2E_Emulat
// msg_user - optional translated user message, which is displayed as a popup to explain
// to the user why the plugin failed to initialize.
//
typedef void (PS2E_CALLBACK* _PS2E_GetLastError)( char* const* msg_diag, wchar_t* const* msg_user );
typedef void(PS2E_CALLBACK *_PS2E_GetLastError)(char *const *msg_diag, wchar_t *const *msg_user);
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////

5
common/include/Utilities/AppTrait.h
View File

@ -31,10 +31,9 @@ class Pcsx2AppTraits : public wxGUIAppTraits
public:
virtual ~Pcsx2AppTraits() {}
wxMessageOutput* CreateMessageOutput();
wxMessageOutput *CreateMessageOutput();
#ifdef wxUSE_STDPATHS
wxStandardPaths& GetStandardPaths();
wxStandardPaths &GetStandardPaths();
#endif
};

137
common/include/Utilities/Assertions.h
View File

@ -17,14 +17,14 @@
#ifndef __pxFUNCTION__
#if defined(__GNUG__)
# define __pxFUNCTION__ __PRETTY_FUNCTION__
#define __pxFUNCTION__ __PRETTY_FUNCTION__
#else
# define __pxFUNCTION__ __FUNCTION__
#define __pxFUNCTION__ __FUNCTION__
#endif
#endif
#ifndef wxNullChar
# define wxNullChar ((wxChar*)NULL)
#define wxNullChar ((wxChar *)NULL)
#endif
// FnChar_t - function name char type; typedef'd in case it ever changes between compilers
@ -36,29 +36,29 @@ typedef char FnChar_t;
// --------------------------------------------------------------------------------------
struct DiagnosticOrigin
{
const wxChar* srcfile;
const FnChar_t* function;
const wxChar* condition;
const wxChar *srcfile;
const FnChar_t *function;
const wxChar *condition;
int line;
DiagnosticOrigin( const wxChar *_file, int _line, const FnChar_t *_func, const wxChar* _cond = NULL )
: srcfile( _file )
, function( _func )
, condition( _cond )
, line( _line )
DiagnosticOrigin(const wxChar *_file, int _line, const FnChar_t *_func, const wxChar *_cond = NULL)
: srcfile(_file)
, function(_func)
, condition(_cond)
, line(_line)
{
}
wxString ToString( const wxChar* msg=NULL ) const;
wxString ToString(const wxChar *msg = NULL) const;
};
// Returns ture if the assertion is to trap into the debugger, or false if execution
// of the program should continue unimpeded.
typedef bool pxDoAssertFnType(const DiagnosticOrigin& origin, const wxChar *msg);
typedef bool pxDoAssertFnType(const DiagnosticOrigin &origin, const wxChar *msg);
extern pxDoAssertFnType pxAssertImpl_LogIt;
extern pxDoAssertFnType* pxDoAssert;
extern pxDoAssertFnType *pxDoAssert;
// ----------------------------------------------------------------------------------------
// pxAssert / pxAssertDev
@ -97,95 +97,99 @@ extern pxDoAssertFnType* pxDoAssert;
// it can lead to the compiler optimizing out code and leading to crashes in dev/release
// builds. To have code optimized, explicitly use pxAssume(false) or pxAssumeDev(false,msg);
#define pxDiagSpot DiagnosticOrigin( __TFILE__, __LINE__, __pxFUNCTION__ )
#define pxAssertSpot(cond) DiagnosticOrigin( __TFILE__, __LINE__, __pxFUNCTION__, _T(#cond) )
#define pxDiagSpot DiagnosticOrigin(__TFILE__, __LINE__, __pxFUNCTION__)
#define pxAssertSpot(cond) DiagnosticOrigin(__TFILE__, __LINE__, __pxFUNCTION__, _T(#cond))
// pxAssertRel ->
// Special release-mode assertion. Limited use since stack traces in release mode builds
// (especially with LTCG) are highly suspect. But when troubleshooting crashes that only
// rear ugly heads in optimized builds, this is one of the few tools we have.
#define pxAssertRel(cond, msg) ( (likely(cond)) || (pxOnAssert(pxAssertSpot(cond), msg), false) )
#define pxAssumeRel(cond, msg) ((void) ( (!likely(cond)) && (pxOnAssert(pxAssertSpot(cond), msg), false) ))
#define pxAssertRel(cond, msg) ((likely(cond)) || (pxOnAssert(pxAssertSpot(cond), msg), false))
#define pxAssumeRel(cond, msg) ((void)((!likely(cond)) && (pxOnAssert(pxAssertSpot(cond), msg), false)))
#define pxFailRel(msg) pxAssertRel(false, msg)
#if defined(PCSX2_DEBUG)
# define pxAssertMsg(cond, msg) pxAssertRel(cond, msg)
# define pxAssertDev(cond, msg) pxAssertMsg(cond, msg)
#define pxAssertMsg(cond, msg) pxAssertRel(cond, msg)
#define pxAssertDev(cond, msg) pxAssertMsg(cond, msg)
# define pxAssumeMsg(cond, msg) pxAssumeRel(cond, msg)
# define pxAssumeDev(cond, msg) pxAssumeRel(cond, msg)
#define pxAssumeMsg(cond, msg) pxAssumeRel(cond, msg)
#define pxAssumeDev(cond, msg) pxAssumeRel(cond, msg)
# define pxFail(msg) pxAssertMsg(false, msg)
# define pxFailDev(msg) pxAssertDev(false, msg)
#define pxFail(msg) pxAssertMsg(false, msg)
#define pxFailDev(msg) pxAssertDev(false, msg)
#elif defined(PCSX2_DEVBUILD)
// Devel builds now will give you a release-mode assertion dialog window if any of the
// following macro's 'cond' field is false.
// Note: Only use pxAssume/Msg/Dev if you know what you're doing, __assume is supposed
// to be used as an optimization hint, yet many devs have been using psAssume
// thinking its the same as an assertion.
// __assume(0) is also very dangerous because it is a special case of __assume() which
// tells the compiler that the code path is not reachable, and it can cause unpredictable
// results if the code path can be reached.
// i.e. if (1) { __assume(0); something(); }
// In the above example, something() may never be called.
// __assume(0)'s real use is in optimizing stuff such as "default:" cases on a switch
// statement. See jNO_DEFAULT
// Devel builds now will give you a release-mode assertion dialog window if any of the
// following macro's 'cond' field is false.
// Note: Only use pxAssume/Msg/Dev if you know what you're doing, __assume is supposed
// to be used as an optimization hint, yet many devs have been using psAssume
// thinking its the same as an assertion.
// __assume(0) is also very dangerous because it is a special case of __assume() which
// tells the compiler that the code path is not reachable, and it can cause unpredictable
// results if the code path can be reached.
// i.e. if (1) { __assume(0); something(); }
// In the above example, something() may never be called.
// __assume(0)'s real use is in optimizing stuff such as "default:" cases on a switch
// statement. See jNO_DEFAULT
# define pxAssertMsg(cond, msg) pxAssertRel(cond, msg)
# define pxAssertDev(cond, msg) pxAssertRel(cond, msg)
#define pxAssertMsg(cond, msg) pxAssertRel(cond, msg)
#define pxAssertDev(cond, msg) pxAssertRel(cond, msg)
# define pxAssumeMsg(cond, msg) pxAssumeRel(cond, msg) //(__assume(cond))
# define pxAssumeDev(cond, msg) pxAssumeRel(cond, msg)
#define pxAssumeMsg(cond, msg) pxAssumeRel(cond, msg) //(__assume(cond))
#define pxAssumeDev(cond, msg) pxAssumeRel(cond, msg)
# define pxFail(msg) pxAssertDev(false, msg)
# define pxFailDev(msg) pxAssertDev(false, msg)
#define pxFail(msg) pxAssertDev(false, msg)
#define pxFailDev(msg) pxAssertDev(false, msg)
#else
// Release Builds just use __assume as an optimization, and return the conditional
// as a result (which is optimized to nil if unused).
// Release Builds just use __assume as an optimization, and return the conditional
// as a result (which is optimized to nil if unused).
# define pxAssertMsg(cond, msg) (likely(cond))
# define pxAssertDev(cond, msg) (likely(cond))
#define pxAssertMsg(cond, msg) (likely(cond))
#define pxAssertDev(cond, msg) (likely(cond))
# define pxAssumeMsg(cond, msg) (__assume(cond))
# define pxAssumeDev(cond, msg) (__assume(cond))
#define pxAssumeMsg(cond, msg) (__assume(cond))
#define pxAssumeDev(cond, msg) (__assume(cond))
# define pxFail(msg) do{} while(0)
# define pxFailDev(msg) do{} while(0)
#define pxFail(msg) \
do { \
} while (0)
#define pxFailDev(msg) \
do { \
} while (0)
#endif
#define pxAssert(cond) pxAssertMsg(cond, wxNullChar)
#define pxAssume(cond) pxAssumeMsg(cond, wxNullChar)
#define pxAssertRelease( cond, msg )
#define pxAssertRelease(cond, msg)
// Performs an unsigned index bounds check, and generates a debug assertion if the check fails.
// For stricter checking in Devel builds as well as debug builds (but possibly slower), use
// IndexBoundsCheckDev.
#define IndexBoundsCheck( objname, idx, sze ) pxAssertMsg( (uint)(idx) < (uint)(sze), \
pxsFmt( L"Array index out of bounds accessing object '%s' (index=%d, size=%d)", objname, (idx), (sze) ) )
#define IndexBoundsCheck(objname, idx, sze) pxAssertMsg((uint)(idx) < (uint)(sze), \
pxsFmt(L"Array index out of bounds accessing object '%s' (index=%d, size=%d)", objname, (idx), (sze)))
#define IndexBoundsCheckDev( objname, idx, sze ) pxAssertDev( (uint)(idx) < (uint)(sze), \
pxsFmt( L"Array index out of bounds accessing object '%s' (index=%d, size=%d)", objname, (idx), (sze) ) )
#define IndexBoundsCheckDev(objname, idx, sze) pxAssertDev((uint)(idx) < (uint)(sze), \
pxsFmt(L"Array index out of bounds accessing object '%s' (index=%d, size=%d)", objname, (idx), (sze)))
#define IndexBoundsAssume( objname, idx, sze ) pxAssumeMsg( (uint)(idx) < (uint)(sze), \
pxsFmt( L"Array index out of bounds accessing object '%s' (index=%d, size=%d)", objname, (idx), (sze) ) )
#define IndexBoundsAssume(objname, idx, sze) pxAssumeMsg((uint)(idx) < (uint)(sze), \
pxsFmt(L"Array index out of bounds accessing object '%s' (index=%d, size=%d)", objname, (idx), (sze)))
#define IndexBoundsAssumeDev( objname, idx, sze ) pxAssumeDev( (uint)(idx) < (uint)(sze), \
pxsFmt( L"Array index out of bounds accessing object '%s' (index=%d, size=%d)", objname, (idx), (sze) ) )
#define IndexBoundsAssumeDev(objname, idx, sze) pxAssumeDev((uint)(idx) < (uint)(sze), \
pxsFmt(L"Array index out of bounds accessing object '%s' (index=%d, size=%d)", objname, (idx), (sze)))
extern void pxOnAssert( const DiagnosticOrigin& origin, const wxChar* msg=NULL );
extern void pxOnAssert( const DiagnosticOrigin& origin, const char* msg );
extern void pxOnAssert( const DiagnosticOrigin& origin, const wxString& msg);
extern void pxOnAssert( const DiagnosticOrigin& origin, const FastFormatUnicode& msg);
extern void pxOnAssert(const DiagnosticOrigin &origin, const wxChar *msg = NULL);
extern void pxOnAssert(const DiagnosticOrigin &origin, const char *msg);
extern void pxOnAssert(const DiagnosticOrigin &origin, const wxString &msg);
extern void pxOnAssert(const DiagnosticOrigin &origin, const FastFormatUnicode &msg);
// --------------------------------------------------------------------------------------
// jNO_DEFAULT -- disables the default case in a switch, which improves switch optimization
@ -198,10 +202,9 @@ extern void pxOnAssert( const DiagnosticOrigin& origin, const FastFormatUnicode&
// * In debug/devel builds the default case will cause an assertion.
//
#ifndef jNO_DEFAULT
# define jNO_DEFAULT \
default: \
{ \
pxAssumeDev( 0, "Incorrect usage of jNO_DEFAULT detected (default case is not unreachable!)" ); \
#define jNO_DEFAULT \
default: { \
pxAssumeDev(0, "Incorrect usage of jNO_DEFAULT detected (default case is not unreachable!)"); \
break; \
}
#endif

12
common/include/Utilities/CheckedStaticBox.h
View File

@ -22,16 +22,16 @@ class CheckedStaticBox : public wxPanelWithHelpers
typedef wxPanelWithHelpers _parent;
public:
wxBoxSizer& ThisSizer; // Boxsizer which holds all child items.
wxCheckBox& ThisToggle; // toggle which can enable/disable all child controls
wxBoxSizer &ThisSizer; // Boxsizer which holds all child items.
wxCheckBox &ThisToggle; // toggle which can enable/disable all child controls
public:
CheckedStaticBox( wxWindow* parent, int orientation, const wxString& title=wxEmptyString );
CheckedStaticBox(wxWindow *parent, int orientation, const wxString &title = wxEmptyString);
void SetValue( bool val );
void SetValue(bool val);
bool GetValue() const;
bool Enable( bool enable = true );
bool Enable(bool enable = true);
public:
virtual void MainToggle_Click( wxCommandEvent& evt );
virtual void MainToggle_Click(wxCommandEvent &evt);
};

121
common/include/Utilities/Console.h
View File

@ -17,8 +17,7 @@
#include "StringHelpers.h"
enum ConsoleColors
{
enum ConsoleColors {
Color_Current = -1,
Color_Default = 0,
@ -73,28 +72,28 @@ struct IConsoleWriter
{
// A direct console write, without tabbing or newlines. Useful to devs who want to do quick
// logging of various junk; but should *not* be used in production code due.
void (__concall *WriteRaw)( const wxString& fmt );
void(__concall *WriteRaw)(const wxString &fmt);
// WriteLn implementation for internal use only. Bypasses tabbing, prefixing, and other
// formatting.
void (__concall *DoWriteLn)( const wxString& fmt );
void(__concall *DoWriteLn)(const wxString &fmt);
// SetColor implementation for internal use only.
void (__concall *DoSetColor)( ConsoleColors color );
void(__concall *DoSetColor)(ConsoleColors color);
// Special implementation of DoWrite that's pretty much for MSVC use only.
// All implementations should map to DoWrite, except Stdio which should map to Null.
// (This avoids circular/recursive stdio output)
void (__concall *DoWriteFromStdout)( const wxString& fmt );
void(__concall *DoWriteFromStdout)(const wxString &fmt);
void (__concall *Newline)();
void (__concall *SetTitle)( const wxString& title );
void(__concall *Newline)();
void(__concall *SetTitle)(const wxString &title);
// internal value for indentation of individual lines. Use the Indent() member to invoke.
int _imm_indentation;
// For internal use only.
wxString _addIndentation( const wxString& src, int glob_indent ) const;
wxString _addIndentation(const wxString &src, int glob_indent) const;
// ----------------------------------------------------------------------------
// Public members; call these to print stuff to console!
@ -103,28 +102,28 @@ struct IConsoleWriter
// disable logs at compile time using the "0&&action" macro trick.
ConsoleColors GetColor() const;
const IConsoleWriter& SetColor( ConsoleColors color ) const;
const IConsoleWriter& ClearColor() const;
const IConsoleWriter& SetIndent( int tabcount=1 ) const;
const IConsoleWriter &SetColor(ConsoleColors color) const;
const IConsoleWriter &ClearColor() const;
const IConsoleWriter &SetIndent(int tabcount = 1) const;
IConsoleWriter Indent( int tabcount=1 ) const;
IConsoleWriter Indent(int tabcount = 1) const;
bool FormatV( const char* fmt, va_list args ) const;
bool WriteLn( ConsoleColors color, const char* fmt, ... ) const;
bool WriteLn( const char* fmt, ... ) const;
bool Error( const char* fmt, ... ) const;
bool Warning( const char* fmt, ... ) const;
bool FormatV(const char *fmt, va_list args) const;
bool WriteLn(ConsoleColors color, const char *fmt, ...) const;
bool WriteLn(const char *fmt, ...) const;
bool Error(const char *fmt, ...) const;
bool Warning(const char *fmt, ...) const;
bool FormatV( const wxChar* fmt, va_list args ) const;
bool WriteLn( ConsoleColors color, const wxChar* fmt, ... ) const;
bool WriteLn( const wxChar* fmt, ... ) const;
bool Error( const wxChar* fmt, ... ) const;
bool Warning( const wxChar* fmt, ... ) const;
bool FormatV(const wxChar *fmt, va_list args) const;
bool WriteLn(ConsoleColors color, const wxChar *fmt, ...) const;
bool WriteLn(const wxChar *fmt, ...) const;
bool Error(const wxChar *fmt, ...) const;
bool Warning(const wxChar *fmt, ...) const;
bool WriteLn( ConsoleColors color, const wxString fmt, ... ) const;
bool WriteLn( const wxString fmt, ... ) const;
bool Error( const wxString fmt, ... ) const;
bool Warning( const wxString fmt, ... ) const;
bool WriteLn(ConsoleColors color, const wxString fmt, ...) const;
bool WriteLn(const wxString fmt, ...) const;
bool Error(const wxString fmt, ...) const;
bool Warning(const wxString fmt, ...) const;
};
// --------------------------------------------------------------------------------------
@ -134,37 +133,37 @@ struct IConsoleWriter
//
struct NullConsoleWriter
{
void WriteRaw( const wxString& fmt ) {}
void DoWriteLn( const wxString& fmt ) {}
void DoSetColor( ConsoleColors color ) {}
void DoWriteFromStdout( const wxString& fmt ) {}
void WriteRaw(const wxString &fmt) {}
void DoWriteLn(const wxString &fmt) {}
void DoSetColor(ConsoleColors color) {}
void DoWriteFromStdout(const wxString &fmt) {}
void Newline() {}
void SetTitle( const wxString& title ) {}
void SetTitle(const wxString &title) {}
ConsoleColors GetColor() const { return Color_Current; }
const NullConsoleWriter& SetColor( ConsoleColors color ) const { return *this; }
const NullConsoleWriter& ClearColor() const { return *this; }
const NullConsoleWriter& SetIndent( int tabcount=1 ) const { return *this; }
const NullConsoleWriter &SetColor(ConsoleColors color) const { return *this; }
const NullConsoleWriter &ClearColor() const { return *this; }
const NullConsoleWriter &SetIndent(int tabcount = 1) const { return *this; }
NullConsoleWriter Indent( int tabcount=1 ) const { return NullConsoleWriter(); }
NullConsoleWriter Indent(int tabcount = 1) const { return NullConsoleWriter(); }
bool FormatV( const char* fmt, va_list args ) const { return false; }
bool WriteLn( ConsoleColors color, const char* fmt, ... ) const { return false; }
bool WriteLn( const char* fmt, ... ) const { return false; }
bool Error( const char* fmt, ... ) const { return false; }
bool Warning( const char* fmt, ... ) const { return false; }
bool FormatV(const char *fmt, va_list args) const { return false; }
bool WriteLn(ConsoleColors color, const char *fmt, ...) const { return false; }
bool WriteLn(const char *fmt, ...) const { return false; }
bool Error(const char *fmt, ...) const { return false; }
bool Warning(const char *fmt, ...) const { return false; }
bool FormatV( const wxChar* fmt, va_list args ) const { return false; }
bool WriteLn( ConsoleColors color, const wxChar* fmt, ... ) const { return false; }
bool WriteLn( const wxChar* fmt, ... ) const { return false; }
bool Error( const wxChar* fmt, ... ) const { return false; }
bool Warning( const wxChar* fmt, ... ) const { return false; }
bool FormatV(const wxChar *fmt, va_list args) const { return false; }
bool WriteLn(ConsoleColors color, const wxChar *fmt, ...) const { return false; }
bool WriteLn(const wxChar *fmt, ...) const { return false; }
bool Error(const wxChar *fmt, ...) const { return false; }
bool Warning(const wxChar *fmt, ...) const { return false; }
bool WriteLn( ConsoleColors color, const wxString fmt, ... ) const { return false; }
bool WriteLn( const wxString fmt, ... ) const { return false; }
bool Error( const wxString fmt, ... ) const { return false; }
bool Warning( const wxString fmt, ... ) const { return false; }
bool WriteLn(ConsoleColors color, const wxString fmt, ...) const { return false; }
bool WriteLn(const wxString fmt, ...) const { return false; }
bool Error(const wxString fmt, ...) const { return false; }
bool Warning(const wxString fmt, ...) const { return false; }
};
// --------------------------------------------------------------------------------------
@ -180,7 +179,7 @@ struct NullConsoleWriter
//
class ConsoleIndentScope
{
DeclareNoncopyableObject( ConsoleIndentScope );
DeclareNoncopyableObject(ConsoleIndentScope);
protected:
int m_amount;
@ -189,7 +188,7 @@ protected:
public:
// Constructor: The specified number of tabs will be appended to the current indentation
// setting. The tabs will be unrolled when the object leaves scope or is destroyed.
ConsoleIndentScope( int tabs=1 );
ConsoleIndentScope(int tabs = 1);
virtual ~ConsoleIndentScope() throw();
void EnterScope();
void LeaveScope();
@ -200,7 +199,7 @@ public:
// --------------------------------------------------------------------------------------
class ConsoleColorScope
{
DeclareNoncopyableObject( ConsoleColorScope );
DeclareNoncopyableObject(ConsoleColorScope);
protected:
ConsoleColors m_newcolor;
@ -208,7 +207,7 @@ protected:
bool m_IsScoped;
public:
ConsoleColorScope( ConsoleColors newcolor );
ConsoleColorScope(ConsoleColors newcolor);
virtual ~ConsoleColorScope() throw();
void EnterScope();
void LeaveScope();
@ -221,14 +220,14 @@ public:
//
class ConsoleAttrScope
{
DeclareNoncopyableObject( ConsoleAttrScope );
DeclareNoncopyableObject(ConsoleAttrScope);
protected:
ConsoleColors m_old_color;
int m_tabsize;
public:
ConsoleAttrScope( ConsoleColors newcolor, int indent=0 );
ConsoleAttrScope(ConsoleColors newcolor, int indent = 0);
virtual ~ConsoleAttrScope() throw();
};
@ -237,7 +236,7 @@ extern IConsoleWriter Console;
#if defined(__unix__)
extern void Console_SetStdout(FILE *fp);
#endif
extern void Console_SetActiveHandler( const IConsoleWriter& writer, FILE* flushfp=NULL );
extern void Console_SetActiveHandler(const IConsoleWriter &writer, FILE *flushfp = NULL);
extern const IConsoleWriter ConsoleWriter_Null;
extern const IConsoleWriter ConsoleWriter_Stdout;
@ -249,14 +248,14 @@ extern IConsoleWriter DevConWriter;
extern bool DevConWriterEnabled;
#ifdef PCSX2_DEVBUILD
# define DevCon DevConWriter
#define DevCon DevConWriter
#else
# define DevCon DevConWriterEnabled && DevConWriter
#define DevCon DevConWriterEnabled &&DevConWriter
#endif
#ifdef PCSX2_DEBUG
extern IConsoleWriter DbgConWriter;
# define DbgCon DbgConWriter
#define DbgCon DbgConWriter
#else
# define DbgCon 0&&NullCon
#define DbgCon 0 && NullCon
#endif

108
common/include/Utilities/Dependencies.h
View File

@ -24,19 +24,19 @@
#define wxsFormat wxString::Format
#ifdef PCSX2_DEBUG
# define tryDEBUG try
# define catchDEBUG(clause) catch(clause)
#define tryDEBUG try
#define catchDEBUG(clause) catch (clause)
#else
# define tryDEBUG if(true)
# define catchDEBUG(clause) if(false)
#define tryDEBUG if (true)
#define catchDEBUG(clause) if (false)
#endif
#if defined(PCSX2_DEVBUILD) || defined(PCSX2_DEBUG)
# define tryDEVEL try
# define catchDEVEL catch(clause)
#define tryDEVEL try
#define catchDEVEL catch (clause)
#else
# define tryDEBUG if(true)
# define catchDEBUG(clause) if(false)
#define tryDEBUG if (true)
#define catchDEBUG(clause) if (false)
#endif
// --------------------------------------------------------------------------------------
@ -61,24 +61,48 @@
// method is not implemented! You must implement it yourself if you want to use it:
// EnumToString(value);
//
#define ImplementEnumOperators( enumName ) \
static __fi enumName& operator++ ( enumName& src ) { src = (enumName)((int)src+1); return src; } \
static __fi enumName& operator-- ( enumName& src ) { src = (enumName)((int)src-1); return src; } \
static __fi enumName operator++ ( enumName& src, int ) { enumName orig = src; src = (enumName)((int)src+1); return orig; } \
static __fi enumName operator-- ( enumName& src, int ) { enumName orig = src; src = (enumName)((int)src-1); return orig; } \
#define ImplementEnumOperators(enumName) \
static __fi enumName &operator++(enumName &src) \
{ \
src = (enumName)((int)src + 1); \
return src; \
} \
static __fi enumName &operator--(enumName &src) \
{ \
src = (enumName)((int)src - 1); \
return src; \
} \
static __fi enumName operator++(enumName &src, int) \
{ \
enumName orig = src; \
src = (enumName)((int)src + 1); \
return orig; \
} \
static __fi enumName operator--(enumName &src, int) \
{ \
enumName orig = src; \
src = (enumName)((int)src - 1); \
return orig; \
} \
\
static __fi bool operator< ( const enumName& left, const pxEnumEnd_t& ) { return (int)left < enumName##_COUNT; } \
static __fi bool operator!=( const enumName& left, const pxEnumEnd_t& ) { return (int)left != enumName##_COUNT; } \
static __fi bool operator==( const enumName& left, const pxEnumEnd_t& ) { return (int)left == enumName##_COUNT; } \
static __fi bool operator<(const enumName &left, const pxEnumEnd_t &) { return (int)left < enumName##_COUNT; } \
static __fi bool operator!=(const enumName &left, const pxEnumEnd_t &) { return (int)left != enumName##_COUNT; } \
static __fi bool operator==(const enumName &left, const pxEnumEnd_t &) { return (int)left == enumName##_COUNT; } \
\
static __fi bool EnumIsValid( enumName id ) { \
return ((int)id >= enumName##_FIRST) && ((int)id < enumName##_COUNT); } \
static __fi void EnumAssert( enumName id ) { \
pxAssert( EnumIsValid(id) ); } \
static __fi bool EnumIsValid(enumName id) \
{ \
return ((int)id >= enumName##_FIRST) && ((int)id < enumName##_COUNT); \
} \
static __fi void EnumAssert(enumName id) \
{ \
pxAssert(EnumIsValid(id)); \
} \
\
extern const wxChar* EnumToString( enumName id )
extern const wxChar *EnumToString(enumName id)
class pxEnumEnd_t { };
class pxEnumEnd_t
{
};
static const pxEnumEnd_t pxEnumEnd = {};
// --------------------------------------------------------------------------------------
@ -105,10 +129,10 @@ static const pxEnumEnd_t pxEnumEnd = {};
// of wx dependencies though, and has a nicer typeset. :)
//
#ifndef DeclareNoncopyableObject
# define DeclareNoncopyableObject(classname) \
private: \
explicit classname(const classname&); \
classname& operator=(const classname&)
#define DeclareNoncopyableObject(classname) \
private: \
explicit classname(const classname &); \
classname &operator=(const classname &)
#endif
@ -120,10 +144,10 @@ static const pxEnumEnd_t pxEnumEnd = {};
class ScopedBool
{
protected:
bool* m_boolme;
bool *m_boolme;
public:
ScopedBool(bool& boolme)
ScopedBool(bool &boolme)
{
boolme = true;
m_boolme = &boolme;
@ -149,15 +173,15 @@ public:
#define WXINTL_NO_GETTEXT_MACRO
#ifndef _
# define _(s) pxGetTranslation(_T(s))
#define _(s) pxGetTranslation(_T(s))
#endif
#ifndef _t
# define _t(s) pxGetTranslation(_T(s))
#define _t(s) pxGetTranslation(_T(s))
#endif
#ifndef _d
# define _d(s) pxGetTranslation(_T(s))
#define _d(s) pxGetTranslation(_T(s))
#endif
// pxL / pxLt / pxDt -- macros provided for tagging translation strings, without actually running
@ -167,15 +191,15 @@ public:
// debug/devel specific translations.
//
#ifndef pxL
# define pxL(a) wxT(a)
#define pxL(a) wxT(a)
#endif
#ifndef pxLt
# define pxLt(a) wxT(a)
#define pxLt(a) wxT(a)
#endif
#ifndef pxDt
# define pxDt(a) wxT(a)
#define pxDt(a) wxT(a)
#endif
@ -228,21 +252,21 @@ static const s64 _4gb = _1gb * 4;
// --------------------------------------------------------------------------------------
// pxE(msg) and pxEt(msg) [macros] => now same as _/_t/_d
// --------------------------------------------------------------------------------------
#define pxE(english) pxExpandMsg( (english) )
#define pxE(english) pxExpandMsg((english))
// For use with tertiary translations (low priority).
#define pxEt(english) pxExpandMsg( (english) )
#define pxEt(english) pxExpandMsg((english))
// For use with Dev/debug build translations (low priority).
#define pxE_dev(english) pxExpandMsg( (english) )
#define pxE_dev(english) pxExpandMsg((english))
extern const wxChar* __fastcall pxExpandMsg( const wxChar* englishContent );
extern const wxChar* __fastcall pxGetTranslation( const wxChar* message );
extern bool pxIsEnglish( int id );
extern const wxChar *__fastcall pxExpandMsg(const wxChar *englishContent);
extern const wxChar *__fastcall pxGetTranslation(const wxChar *message);
extern bool pxIsEnglish(int id);
extern wxString fromUTF8( const char* src );
extern wxString fromAscii( const char* src );
extern wxString fromUTF8(const char *src);
extern wxString fromAscii(const char *src);
#include "Utilities/Assertions.h"

40
common/include/Utilities/EmbeddedImage.h
View File

@ -25,8 +25,8 @@
class IEmbeddedImage
{
public:
virtual const wxImage& Get()=0;
virtual wxImage Scale( int width, int height )=0;
virtual const wxImage &Get() = 0;
virtual wxImage Scale(int width, int height) = 0;
};
//////////////////////////////////////////////////////////////////////////////////////////
@ -38,7 +38,7 @@ public:
// Note: Get() only loads the image once. All subsequent calls to Get will use the
// previously loaded image data.
//
template< typename ImageType >
template <typename ImageType>
class EmbeddedImage : public IEmbeddedImage
{
protected:
@ -52,20 +52,19 @@ protected:
//
void _loadImage()
{
if( !m_Image.Ok() )
{
wxMemoryInputStream joe( ImageType::Data, ImageType::Length );
m_Image.LoadFile( joe, ImageType::GetFormat() );
if (!m_Image.Ok()) {
wxMemoryInputStream joe(ImageType::Data, ImageType::Length);
m_Image.LoadFile(joe, ImageType::GetFormat());
if( m_ResampleTo.IsFullySpecified() && ( m_ResampleTo.GetWidth() != m_Image.GetWidth() || m_ResampleTo.GetHeight() != m_Image.GetHeight() ) )
m_Image.Rescale( m_ResampleTo.GetWidth(), m_ResampleTo.GetHeight(), wxIMAGE_QUALITY_HIGH );
if (m_ResampleTo.IsFullySpecified() && (m_ResampleTo.GetWidth() != m_Image.GetWidth() || m_ResampleTo.GetHeight() != m_Image.GetHeight()))
m_Image.Rescale(m_ResampleTo.GetWidth(), m_ResampleTo.GetHeight(), wxIMAGE_QUALITY_HIGH);
}
}
public:
EmbeddedImage() :
m_Image()
, m_ResampleTo( wxDefaultSize )
EmbeddedImage()
: m_Image()
, m_ResampleTo(wxDefaultSize)
{
}
@ -78,9 +77,9 @@ public:
// sampling images (basically resembles a pixel resize). ResampleBox produces much cleaner
// results.
//
EmbeddedImage( int newWidth, int newHeight ) :
m_Image()
, m_ResampleTo( newWidth, newHeight )
EmbeddedImage(int newWidth, int newHeight)
: m_Image()
, m_ResampleTo(newWidth, newHeight)
{
}
@ -91,7 +90,7 @@ public:
// and only happens when the image is actually fetched. Simply creating an instance
// of an EmbeddedImage object uses no excess memory nor cpu overhead. :)
//
const wxImage& Get()
const wxImage &Get()
{
_loadImage();
return m_Image;
@ -100,7 +99,7 @@ public:
wxIcon GetIcon()
{
wxIcon retval;
retval.CopyFromBitmap( Get() );
retval.CopyFromBitmap(Get());
return retval;
}
@ -109,14 +108,13 @@ public:
// is left unmodified).
//
wxImage Scale( int width, int height )
wxImage Scale(int width, int height)
{
_loadImage();
// Not strictly necessary - wxWidgets does the dimensions check anyway.
if( width != m_Image.GetWidth() || height != m_Image.GetHeight() )
return m_Image.Scale( width, height, wxIMAGE_QUALITY_HIGH );
if (width != m_Image.GetWidth() || height != m_Image.GetHeight())
return m_Image.Scale(width, height, wxIMAGE_QUALITY_HIGH);
else
return m_Image;
}
};

34
common/include/Utilities/EventSource.h
View File

@ -22,12 +22,12 @@
// EventSource< template EvtType >
// --------------------------------------------------------------------------------------
template< typename ListenerType >
template <typename ListenerType>
class EventSource
{
public:
typedef typename ListenerType::EvtParams EvtParams;
typedef typename std::list< ListenerType* > ListenerList;
typedef typename std::list<ListenerType *> ListenerList;
typedef typename ListenerList::iterator ListenerIterator;
protected:
@ -51,27 +51,29 @@ public:
virtual ~EventSource() throw() {}
virtual ListenerIterator Add( ListenerType& listener );
virtual void Remove( ListenerType& listener );
virtual void Remove( const ListenerIterator& listenerHandle );
virtual ListenerIterator Add(ListenerType &listener);
virtual void Remove(ListenerType &listener);
virtual void Remove(const ListenerIterator &listenerHandle);
void Add( ListenerType* listener )
void Add(ListenerType *listener)
{
if( listener == NULL ) return;
Add( *listener );
if (listener == NULL)
return;
Add(*listener);
}
void Remove( ListenerType* listener )
void Remove(ListenerType *listener)
{
if( listener == NULL ) return;
Remove( *listener );
if (listener == NULL)
return;
Remove(*listener);
}
void Dispatch( const EvtParams& params );
void Dispatch(const EvtParams &params);
protected:
virtual ListenerIterator _AddFast_without_lock( ListenerType& listener );
virtual void _DispatchRaw( ListenerIterator iter, const ListenerIterator& iend, const EvtParams& params );
virtual ListenerIterator _AddFast_without_lock(ListenerType &listener);
virtual void _DispatchRaw(ListenerIterator iter, const ListenerIterator &iend, const EvtParams &params);
};
// --------------------------------------------------------------------------------------
@ -80,7 +82,7 @@ protected:
// This class is used as a base interface for EventListeners. It allows the listeners to do
// customized dispatching of several event types into "user friendly" function overrides.
//
template< typename EvtParams >
template <typename EvtParams>
class IEventDispatcher
{
protected:
@ -88,5 +90,5 @@ protected:
public:
virtual ~IEventDispatcher() throw() {}
virtual void DispatchEvent( const EvtParams& params )=0;
virtual void DispatchEvent(const EvtParams &params) = 0;
};

82
common/include/Utilities/EventSource.inl
View File

@ -19,88 +19,80 @@
using Threading::ScopedLock;
template< typename ListenerType >
typename EventSource<ListenerType>::ListenerIterator EventSource<ListenerType>::Add( ListenerType& listener )
template <typename ListenerType>
typename EventSource<ListenerType>::ListenerIterator EventSource<ListenerType>::Add(ListenerType &listener)
{
ScopedLock locker( m_listeners_lock );
ScopedLock locker(m_listeners_lock);
// Check for duplicates before adding the event.
if( IsDebugBuild )
{
if (IsDebugBuild) {
ListenerIterator iter = m_listeners.begin();
while( iter != m_listeners.end() )
{
if( (*iter) == &listener ) return iter;
while (iter != m_listeners.end()) {
if ((*iter) == &listener)
return iter;
++iter;
}
}
return _AddFast_without_lock( listener );
return _AddFast_without_lock(listener);
}
template< typename ListenerType >
void EventSource<ListenerType>::Remove( ListenerType& listener )
template <typename ListenerType>
void EventSource<ListenerType>::Remove(ListenerType &listener)
{
ScopedLock locker( m_listeners_lock );
ScopedLock locker(m_listeners_lock);
m_cache_valid = false;
m_listeners.remove( &listener );
m_listeners.remove(&listener);
}
template< typename ListenerType >
void EventSource<ListenerType>::Remove( const ListenerIterator& listenerHandle )
template <typename ListenerType>
void EventSource<ListenerType>::Remove(const ListenerIterator &listenerHandle)
{
ScopedLock locker( m_listeners_lock );
ScopedLock locker(m_listeners_lock);
m_cache_valid = false;
m_listeners.erase( listenerHandle );
m_listeners.erase(listenerHandle);
}
template< typename ListenerType >
typename EventSource<ListenerType>::ListenerIterator EventSource<ListenerType>::_AddFast_without_lock( ListenerType& listener )
template <typename ListenerType>
typename EventSource<ListenerType>::ListenerIterator EventSource<ListenerType>::_AddFast_without_lock(ListenerType &listener)
{
m_cache_valid = false;
m_listeners.push_front( &listener );
m_listeners.push_front(&listener);
return m_listeners.begin();
}
template< typename ListenerType >
__fi void EventSource<ListenerType>::_DispatchRaw( ListenerIterator iter, const ListenerIterator& iend, const EvtParams& evtparams )
template <typename ListenerType>
__fi void EventSource<ListenerType>::_DispatchRaw(ListenerIterator iter, const ListenerIterator &iend, const EvtParams &evtparams)
{
while( iter != iend )
{
while (iter != iend) {
try {
(*iter)->DispatchEvent( evtparams );
(*iter)->DispatchEvent(evtparams);
} catch (Exception::RuntimeError &ex) {
if (IsDevBuild) {
pxFailDev(L"Ignoring runtime error thrown from event listener (event listeners should not throw exceptions!): " + ex.FormatDiagnosticMessage());
} else {
Console.Error(L"Ignoring runtime error thrown from event listener: " + ex.FormatDiagnosticMessage());
}
catch( Exception::RuntimeError& ex )
{
if( IsDevBuild ) {
pxFailDev( L"Ignoring runtime error thrown from event listener (event listeners should not throw exceptions!): " + ex.FormatDiagnosticMessage() );
}
else {
Console.Error( L"Ignoring runtime error thrown from event listener: " + ex.FormatDiagnosticMessage() );
}
}
catch( BaseException& ex )
{
if( IsDevBuild )
{
} catch (BaseException &ex) {
if (IsDevBuild) {
ex.DiagMsg() = L"Non-runtime BaseException thrown from event listener .. " + ex.DiagMsg();
throw;
}
Console.Error( L"Ignoring non-runtime BaseException thrown from event listener: " + ex.FormatDiagnosticMessage() );
Console.Error(L"Ignoring non-runtime BaseException thrown from event listener: " + ex.FormatDiagnosticMessage());
}
++iter;
}
}
template< typename ListenerType >
void EventSource<ListenerType>::Dispatch( const EvtParams& evtparams )
template <typename ListenerType>
void EventSource<ListenerType>::Dispatch(const EvtParams &evtparams)
{
if( !m_cache_valid )
{
if (!m_cache_valid) {
m_cache_copy = m_listeners;
m_cache_valid = true;
}
if( m_cache_copy.empty() ) return;
_DispatchRaw( m_cache_copy.begin(), m_cache_copy.end(), evtparams );
if (m_cache_copy.empty())
return;
_DispatchRaw(m_cache_copy.begin(), m_cache_copy.end(), evtparams);
}

421
common/include/Utilities/Exceptions.h
View File

@ -30,71 +30,72 @@ void pxTrap();
// friendly error log in their wake.
//
// Note: Console can also fire an Exception::OutOfMemory
#define __DESTRUCTOR_CATCHALL( funcname ) \
catch( BaseException& ex ) \
#define __DESTRUCTOR_CATCHALL(funcname) \
catch (BaseException & ex) \
{ \
try { \
Console.Error( "Unhandled BaseException in %s (ignored!):", funcname ); \
Console.Error( ex.FormatDiagnosticMessage() ); \
Console.Error("Unhandled BaseException in %s (ignored!):", funcname); \
Console.Error(ex.FormatDiagnosticMessage()); \
} catch (...) { \
fprintf(stderr, "ERROR: (out of memory?)\n"); \
} \
} \
catch( std::exception& ex ) \
catch (std::exception & ex) \
{ \
try { \
Console.Error( "Unhandled std::exception in %s (ignored!):", funcname ); \
Console.Error( ex.what() ); \
Console.Error("Unhandled std::exception in %s (ignored!):", funcname); \
Console.Error(ex.what()); \
} catch (...) { \
fprintf(stderr, "ERROR: (out of memory?)\n"); \
} \
} \
catch(...) { \
catch (...) \
{ \
/* Unreachable code */ \
}
#define DESTRUCTOR_CATCHALL __DESTRUCTOR_CATCHALL( __pxFUNCTION__ )
#define DESTRUCTOR_CATCHALL __DESTRUCTOR_CATCHALL(__pxFUNCTION__)
namespace Exception
{
int MakeNewType();
BaseException* FromErrno( const wxString& streamname, int errcode );
int MakeNewType();
BaseException *FromErrno(const wxString &streamname, int errcode);
// --------------------------------------------------------------------------------------
// BaseException
// --------------------------------------------------------------------------------------
// std::exception sucks, and isn't entirely cross-platform reliable in its implementation,
// so I made a replacement. The internal messages are non-const, which means that a
// catch clause can optionally modify them and then re-throw to a top-level handler.
//
// Note, this class is "abstract" which means you shouldn't use it directly like, ever.
// Use Exception::RuntimeError instead for generic exceptions.
//
// Because exceptions are the (only!) really useful example of multiple inheritance,
// this class has only a trivial constructor, and must be manually initialized using
// InitBaseEx() or by individual member assignments. This is because C++ multiple inheritence
// is, by design, a lot of fail, especially when class initializers are mixed in.
//
// [TODO] : Add an InnerException component, and Clone() facility.
//
class BaseException
{
protected:
// --------------------------------------------------------------------------------------
// BaseException
// --------------------------------------------------------------------------------------
// std::exception sucks, and isn't entirely cross-platform reliable in its implementation,
// so I made a replacement. The internal messages are non-const, which means that a
// catch clause can optionally modify them and then re-throw to a top-level handler.
//
// Note, this class is "abstract" which means you shouldn't use it directly like, ever.
// Use Exception::RuntimeError instead for generic exceptions.
//
// Because exceptions are the (only!) really useful example of multiple inheritance,
// this class has only a trivial constructor, and must be manually initialized using
// InitBaseEx() or by individual member assignments. This is because C++ multiple inheritence
// is, by design, a lot of fail, especially when class initializers are mixed in.
//
// [TODO] : Add an InnerException component, and Clone() facility.
//
class BaseException
{
protected:
wxString m_message_diag; // (untranslated) a "detailed" message of what disastrous thing has occurred!
wxString m_message_user; // (translated) a "detailed" message of what disastrous thing has occurred!
public:
virtual ~BaseException() throw()=0; // the =0; syntax forces this class into "abstract" mode.
public:
virtual ~BaseException() throw() = 0; // the =0; syntax forces this class into "abstract" mode.
const wxString& DiagMsg() const { return m_message_diag; }
const wxString& UserMsg() const { return m_message_user; }
const wxString &DiagMsg() const { return m_message_diag; }
const wxString &UserMsg() const { return m_message_user; }
wxString& DiagMsg() { return m_message_diag; }
wxString& UserMsg() { return m_message_user; }
wxString &DiagMsg() { return m_message_diag; }
wxString &UserMsg() { return m_message_user; }
BaseException& SetBothMsgs( const wxChar* msg_diag );
BaseException& SetDiagMsg( const wxString& msg_diag );
BaseException& SetUserMsg( const wxString& msg_user );
BaseException &SetBothMsgs(const wxChar *msg_diag);
BaseException &SetDiagMsg(const wxString &msg_diag);
BaseException &SetUserMsg(const wxString &msg_user);
// Returns a message suitable for diagnostic / logging purposes.
// This message is always in English, and includes a full stack trace.
@ -104,38 +105,38 @@ namespace Exception
// This message is usually meant for display in a user popup or such.
virtual wxString FormatDisplayMessage() const;
virtual void Rethrow() const=0;
virtual BaseException* Clone() const=0;
};
virtual void Rethrow() const = 0;
virtual BaseException *Clone() const = 0;
};
typedef std::unique_ptr<BaseException> ScopedExcept;
typedef std::unique_ptr<BaseException> ScopedExcept;
// --------------------------------------------------------------------------------------
// Ps2Generic Exception
// --------------------------------------------------------------------------------------
// This class is used as a base exception for things tossed by PS2 cpus (EE, IOP, etc).
//
// Implementation note: does not derive from BaseException, so that we can use different
// catch block hierarchies to handle them (if needed).
//
// Translation Note: Currently these exceptions are never translated. English/diagnostic
// format only. :)
//
class Ps2Generic
{
protected:
// --------------------------------------------------------------------------------------
// Ps2Generic Exception
// --------------------------------------------------------------------------------------
// This class is used as a base exception for things tossed by PS2 cpus (EE, IOP, etc).
//
// Implementation note: does not derive from BaseException, so that we can use different
// catch block hierarchies to handle them (if needed).
//
// Translation Note: Currently these exceptions are never translated. English/diagnostic
// format only. :)
//
class Ps2Generic
{
protected:
wxString m_message; // a "detailed" message of what disastrous thing has occurred!
public:
public:
virtual ~Ps2Generic() throw() {}
virtual u32 GetPc() const=0;
virtual bool IsDelaySlot() const=0;
virtual wxString& Message() { return m_message; }
virtual u32 GetPc() const = 0;
virtual bool IsDelaySlot() const = 0;
virtual wxString &Message() { return m_message; }
virtual void Rethrow() const=0;
virtual Ps2Generic* Clone() const=0;
};
virtual void Rethrow() const = 0;
virtual Ps2Generic *Clone() const = 0;
};
// Some helper macros for defining the standard constructors of internationalized constructors
// Parameters:
@ -151,58 +152,71 @@ namespace Exception
//
// (update: web searches indicate it's MSVC specific -- happens in 2008, not sure about 2010).
//
#define DEFINE_EXCEPTION_COPYTORS( classname, parent ) \
#define DEFINE_EXCEPTION_COPYTORS(classname, parent) \
private: \
typedef parent _parent; \
\
public: \
virtual ~classname() throw() {} \
virtual void Rethrow() const { throw *this; } \
virtual classname* Clone() const { return new classname( *this ); }
virtual void Rethrow() const { throw * this; } \
virtual classname *Clone() const { return new classname(*this); }
#define DEFINE_EXCEPTION_MESSAGES( classname ) \
#define DEFINE_EXCEPTION_MESSAGES(classname) \
public: \
classname& SetBothMsgs( const wxChar* msg_diag ) { BaseException::SetBothMsgs(msg_diag); return *this; } \
classname& SetDiagMsg( const wxString& msg_diag ) { m_message_diag = msg_diag; return *this; } \
classname& SetUserMsg( const wxString& msg_user ) { m_message_user = msg_user; return *this; }
classname &SetBothMsgs(const wxChar *msg_diag) \
{ \
BaseException::SetBothMsgs(msg_diag); \
return *this; \
} \
classname &SetDiagMsg(const wxString &msg_diag) \
{ \
m_message_diag = msg_diag; \
return *this; \
} \
classname &SetUserMsg(const wxString &msg_user) \
{ \
m_message_user = msg_user; \
return *this; \
}
#define DEFINE_RUNTIME_EXCEPTION( classname, parent, message ) \
DEFINE_EXCEPTION_COPYTORS( classname, parent ) \
#define DEFINE_RUNTIME_EXCEPTION(classname, parent, message) \
DEFINE_EXCEPTION_COPYTORS(classname, parent) \
classname() { SetDiagMsg(message); } \
DEFINE_EXCEPTION_MESSAGES( classname )
DEFINE_EXCEPTION_MESSAGES(classname)
// ---------------------------------------------------------------------------------------
// RuntimeError - Generalized Exceptions with Recoverable Traits!
// ---------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------
// RuntimeError - Generalized Exceptions with Recoverable Traits!
// ---------------------------------------------------------------------------------------
class RuntimeError : public BaseException
{
DEFINE_EXCEPTION_COPYTORS( RuntimeError, BaseException )
DEFINE_EXCEPTION_MESSAGES( RuntimeError )
class RuntimeError : public BaseException
{
DEFINE_EXCEPTION_COPYTORS(RuntimeError, BaseException)
DEFINE_EXCEPTION_MESSAGES(RuntimeError)
public:
public:
bool IsSilent;
RuntimeError() { IsSilent = false; }
RuntimeError( const std::runtime_error& ex, const wxString& prefix=wxEmptyString );
RuntimeError( const std::exception& ex, const wxString& prefix=wxEmptyString );
};
RuntimeError(const std::runtime_error &ex, const wxString &prefix = wxEmptyString);
RuntimeError(const std::exception &ex, const wxString &prefix = wxEmptyString);
};
// --------------------------------------------------------------------------------------
// CancelAppEvent - Exception for canceling an event in a non-verbose fashion
// --------------------------------------------------------------------------------------
// Typically the PCSX2 interface issues popup dialogs for runtime errors. This exception
// instead issues a "silent" cancelation that is handled by the app gracefully (generates
// log, and resumes messages queue processing).
//
// I chose to have this exception derive from RuntimeError, since if one is thrown from outside
// an App message loop we'll still want it to be handled in a reasonably graceful manner.
class CancelEvent : public RuntimeError
{
DEFINE_RUNTIME_EXCEPTION( CancelEvent, RuntimeError, pxLt("No reason given.") )
// --------------------------------------------------------------------------------------
// CancelAppEvent - Exception for canceling an event in a non-verbose fashion
// --------------------------------------------------------------------------------------
// Typically the PCSX2 interface issues popup dialogs for runtime errors. This exception
// instead issues a "silent" cancelation that is handled by the app gracefully (generates
// log, and resumes messages queue processing).
//
// I chose to have this exception derive from RuntimeError, since if one is thrown from outside
// an App message loop we'll still want it to be handled in a reasonably graceful manner.
class CancelEvent : public RuntimeError
{
DEFINE_RUNTIME_EXCEPTION(CancelEvent, RuntimeError, pxLt("No reason given."))
public:
explicit CancelEvent( const wxString& logmsg )
public:
explicit CancelEvent(const wxString &logmsg)
{
m_message_diag = logmsg;
// overridden message formatters only use the diagnostic version...
@ -210,158 +224,167 @@ public: \
virtual wxString FormatDisplayMessage() const;
virtual wxString FormatDiagnosticMessage() const;
};
};
// ---------------------------------------------------------------------------------------
// OutOfMemory
// ---------------------------------------------------------------------------------------
// This exception has a custom-formatted Diagnostic string. The parameter give when constructing
// the exception is a block/alloc name, which is used as a formatting parameter in the diagnostic
// output. The default diagnostic message is "Out of memory exception, while allocating the %s."
// where %s is filled in with the block name.
//
// The user string is not custom-formatted, and should contain *NO* %s tags.
//
class OutOfMemory : public RuntimeError
{
DEFINE_RUNTIME_EXCEPTION( OutOfMemory, RuntimeError, wxEmptyString )
// ---------------------------------------------------------------------------------------
// OutOfMemory
// ---------------------------------------------------------------------------------------
// This exception has a custom-formatted Diagnostic string. The parameter give when constructing
// the exception is a block/alloc name, which is used as a formatting parameter in the diagnostic
// output. The default diagnostic message is "Out of memory exception, while allocating the %s."
// where %s is filled in with the block name.
//
// The user string is not custom-formatted, and should contain *NO* %s tags.
//
class OutOfMemory : public RuntimeError
{
DEFINE_RUNTIME_EXCEPTION(OutOfMemory, RuntimeError, wxEmptyString)
public:
public:
wxString AllocDescription;
public:
OutOfMemory( const wxString& allocdesc );
public:
OutOfMemory(const wxString &allocdesc);
virtual wxString FormatDisplayMessage() const;
virtual wxString FormatDiagnosticMessage() const;
};
};
class ParseError : public RuntimeError
{
DEFINE_RUNTIME_EXCEPTION( ParseError, RuntimeError, pxL("Parse error") );
};
class ParseError : public RuntimeError
{
DEFINE_RUNTIME_EXCEPTION(ParseError, RuntimeError, pxL("Parse error"));
};
// ---------------------------------------------------------------------------------------
// Hardware/OS Exceptions:
// HardwareDeficiency / VirtualMemoryMapConflict
// ---------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------
// Hardware/OS Exceptions:
// HardwareDeficiency / VirtualMemoryMapConflict
// ---------------------------------------------------------------------------------------
// This exception is a specific type of OutOfMemory error that isn't "really" an out of
// memory error. More likely it's caused by a plugin or driver reserving a range of memory
// we'd really like to have access to.
class VirtualMemoryMapConflict : public OutOfMemory
{
DEFINE_RUNTIME_EXCEPTION( VirtualMemoryMapConflict, OutOfMemory, wxEmptyString )
// This exception is a specific type of OutOfMemory error that isn't "really" an out of
// memory error. More likely it's caused by a plugin or driver reserving a range of memory
// we'd really like to have access to.
class VirtualMemoryMapConflict : public OutOfMemory
{
DEFINE_RUNTIME_EXCEPTION(VirtualMemoryMapConflict, OutOfMemory, wxEmptyString)
VirtualMemoryMapConflict( const wxString& allocdesc );
VirtualMemoryMapConflict(const wxString &allocdesc);
virtual wxString FormatDisplayMessage() const;
virtual wxString FormatDiagnosticMessage() const;
};
};
class HardwareDeficiency : public RuntimeError
{
public:
DEFINE_RUNTIME_EXCEPTION( HardwareDeficiency, RuntimeError, pxL("Your machine's hardware is incapable of running PCSX2. Sorry dood.") );
};
class HardwareDeficiency : public RuntimeError
{
public:
DEFINE_RUNTIME_EXCEPTION(HardwareDeficiency, RuntimeError, pxL("Your machine's hardware is incapable of running PCSX2. Sorry dood."));
};
// ---------------------------------------------------------------------------------------
// Streaming (file) Exceptions:
// Stream / BadStream / CannotCreateStream / FileNotFound / AccessDenied / EndOfStream
// ---------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------
// Streaming (file) Exceptions:
// Stream / BadStream / CannotCreateStream / FileNotFound / AccessDenied / EndOfStream
// ---------------------------------------------------------------------------------------
#define DEFINE_STREAM_EXCEPTION_ACCESSORS( classname ) \
virtual classname& SetStreamName( const wxString& name ) { StreamName = name; return *this; } \
virtual classname& SetStreamName( const char* name ) { StreamName = fromUTF8(name); return *this; }
#define DEFINE_STREAM_EXCEPTION_ACCESSORS(classname) \
virtual classname &SetStreamName(const wxString &name) \
{ \
StreamName = name; \
return *this; \
} \
virtual classname &SetStreamName(const char *name) \
{ \
StreamName = fromUTF8(name); \
return *this; \
}
#define DEFINE_STREAM_EXCEPTION( classname, parent ) \
DEFINE_RUNTIME_EXCEPTION( classname, parent, wxEmptyString ) \
classname( const wxString& filename ) { \
#define DEFINE_STREAM_EXCEPTION(classname, parent) \
DEFINE_RUNTIME_EXCEPTION(classname, parent, wxEmptyString) \
classname(const wxString &filename) \
{ \
StreamName = filename; \
} \
DEFINE_STREAM_EXCEPTION_ACCESSORS( classname )
DEFINE_STREAM_EXCEPTION_ACCESSORS(classname)
// A generic base error class for bad streams -- corrupted data, sudden closures, loss of
// connection, or anything else that would indicate a failure to open a stream or read the
// data after the stream was successfully opened.
//
class BadStream : public RuntimeError
{
DEFINE_STREAM_EXCEPTION( BadStream, RuntimeError )
// A generic base error class for bad streams -- corrupted data, sudden closures, loss of
// connection, or anything else that would indicate a failure to open a stream or read the
// data after the stream was successfully opened.
//
class BadStream : public RuntimeError
{
DEFINE_STREAM_EXCEPTION(BadStream, RuntimeError)
public:
public:
wxString StreamName; // name of the stream (if applicable)
virtual wxString FormatDiagnosticMessage() const;
virtual wxString FormatDisplayMessage() const;
protected:
void _formatDiagMsg( FastFormatUnicode& dest ) const;
void _formatUserMsg( FastFormatUnicode& dest ) const;
};
protected:
void _formatDiagMsg(FastFormatUnicode &dest) const;
void _formatUserMsg(FastFormatUnicode &dest) const;
};
// A generic exception for odd-ball stream creation errors.
//
class CannotCreateStream : public BadStream
{
DEFINE_STREAM_EXCEPTION( CannotCreateStream, BadStream )
// A generic exception for odd-ball stream creation errors.
//
class CannotCreateStream : public BadStream
{
DEFINE_STREAM_EXCEPTION(CannotCreateStream, BadStream)
virtual wxString FormatDiagnosticMessage() const;
virtual wxString FormatDisplayMessage() const;
};
};
// Exception thrown when an attempt to open a non-existent file is made.
// (this exception can also mean file permissions are invalid)
//
class FileNotFound : public CannotCreateStream
{
public:
DEFINE_STREAM_EXCEPTION( FileNotFound, CannotCreateStream )
// Exception thrown when an attempt to open a non-existent file is made.
// (this exception can also mean file permissions are invalid)
//
class FileNotFound : public CannotCreateStream
{
public:
DEFINE_STREAM_EXCEPTION(FileNotFound, CannotCreateStream)
virtual wxString FormatDiagnosticMessage() const;
virtual wxString FormatDisplayMessage() const;
};
};
class AccessDenied : public CannotCreateStream
{
public:
DEFINE_STREAM_EXCEPTION( AccessDenied, CannotCreateStream )
class AccessDenied : public CannotCreateStream
{
public:
DEFINE_STREAM_EXCEPTION(AccessDenied, CannotCreateStream)
virtual wxString FormatDiagnosticMessage() const;
virtual wxString FormatDisplayMessage() const;
};
};
// EndOfStream can be used either as an error, or used just as a shortcut for manual
// feof checks.
//
class EndOfStream : public BadStream
{
public:
DEFINE_STREAM_EXCEPTION( EndOfStream, BadStream )
// EndOfStream can be used either as an error, or used just as a shortcut for manual
// feof checks.
//
class EndOfStream : public BadStream
{
public:
DEFINE_STREAM_EXCEPTION(EndOfStream, BadStream)
virtual wxString FormatDiagnosticMessage() const;
virtual wxString FormatDisplayMessage() const;
};
};
#ifdef __WXMSW__
// --------------------------------------------------------------------------------------
// Exception::WinApiError
// --------------------------------------------------------------------------------------
class WinApiError : public RuntimeError
{
DEFINE_EXCEPTION_COPYTORS( WinApiError, RuntimeError )
DEFINE_EXCEPTION_MESSAGES( WinApiError )
// --------------------------------------------------------------------------------------
// Exception::WinApiError
// --------------------------------------------------------------------------------------
class WinApiError : public RuntimeError
{
DEFINE_EXCEPTION_COPYTORS(WinApiError, RuntimeError)
DEFINE_EXCEPTION_MESSAGES(WinApiError)
public:
public:
int ErrorId;
public:
public:
WinApiError();
wxString GetMsgFromWindows() const;
virtual wxString FormatDisplayMessage() const;
virtual wxString FormatDiagnosticMessage() const;
};
};
#endif
}

58
common/include/Utilities/FixedPointTypes.h
View File

@ -17,58 +17,58 @@
#include "Dependencies.h"
template< int Precision >
template <int Precision>
struct FixedInt
{
s32 Raw;
FixedInt();
FixedInt( int signedval );
FixedInt( double doubval );
FixedInt( float floval );
FixedInt(int signedval);
FixedInt(double doubval);
FixedInt(float floval);
bool operator ==( const FixedInt<Precision>& right ) const { return Raw == right.Raw; }
bool operator !=( const FixedInt<Precision>& right ) const { return Raw != right.Raw; }
bool operator==(const FixedInt<Precision> &right) const { return Raw == right.Raw; }
bool operator!=(const FixedInt<Precision> &right) const { return Raw != right.Raw; }
bool operator>( const FixedInt<Precision>& right ) const { return Raw > right.Raw; };
bool operator>=( const FixedInt<Precision>& right ) const { return Raw >= right.Raw; };
bool operator<( const FixedInt<Precision>& right ) const { return Raw < right.Raw; };
bool operator<=( const FixedInt<Precision>& right ) const { return Raw <= right.Raw; };
bool operator>(const FixedInt<Precision> &right) const { return Raw > right.Raw; };
bool operator>=(const FixedInt<Precision> &right) const { return Raw >= right.Raw; };
bool operator<(const FixedInt<Precision> &right) const { return Raw < right.Raw; };
bool operator<=(const FixedInt<Precision> &right) const { return Raw <= right.Raw; };
FixedInt<Precision> operator+( const FixedInt<Precision>& right ) const;
FixedInt<Precision> operator-( const FixedInt<Precision>& right ) const;
FixedInt<Precision>& operator+=( const FixedInt<Precision>& right );
FixedInt<Precision>& operator-=( const FixedInt<Precision>& right );
FixedInt<Precision> operator+(const FixedInt<Precision> &right) const;
FixedInt<Precision> operator-(const FixedInt<Precision> &right) const;
FixedInt<Precision> &operator+=(const FixedInt<Precision> &right);
FixedInt<Precision> &operator-=(const FixedInt<Precision> &right);
FixedInt<Precision>& ConfineTo( const FixedInt<Precision>& low, const FixedInt<Precision>& high );
FixedInt<Precision> &ConfineTo(const FixedInt<Precision> &low, const FixedInt<Precision> &high);
FixedInt<Precision> operator*( const FixedInt<Precision>& right ) const;
FixedInt<Precision> operator/( const FixedInt<Precision>& right ) const;
FixedInt<Precision>& operator*=( const FixedInt<Precision>& right );
FixedInt<Precision>& operator/=( const FixedInt<Precision>& right );
FixedInt<Precision> operator*(const FixedInt<Precision> &right) const;
FixedInt<Precision> operator/(const FixedInt<Precision> &right) const;
FixedInt<Precision> &operator*=(const FixedInt<Precision> &right);
FixedInt<Precision> &operator/=(const FixedInt<Precision> &right);
static bool OverflowCheck( int signedval );
static bool OverflowCheck( double signedval );
static bool OverflowCheck(int signedval);
static bool OverflowCheck(double signedval);
int GetWhole() const;
int GetFraction() const;
FixedInt<Precision>& SetRaw( s32 rawsrc );
FixedInt<Precision>& Round();
FixedInt<Precision>& SetWhole( s32 wholepart );
FixedInt<Precision>& SetFraction( u32 fracpart );
FixedInt<Precision> &SetRaw(s32 rawsrc);
FixedInt<Precision> &Round();
FixedInt<Precision> &SetWhole(s32 wholepart);
FixedInt<Precision> &SetFraction(u32 fracpart);
wxString ToString() const;
wxString ToString( int fracDigits ) const;
wxString ToString(int fracDigits) const;
double ToDouble() const;
float ToFloat() const;
int ToIntTruncated() const;
int ToIntRounded() const;
static bool TryFromString( FixedInt<Precision>& dest, const wxString& parseFrom );
static FixedInt<Precision> FromString( const wxString& parseFrom, const FixedInt<Precision>& defval );
static FixedInt<Precision> FromString( const wxString parseFrom );
static bool TryFromString(FixedInt<Precision> &dest, const wxString &parseFrom);
static FixedInt<Precision> FromString(const wxString &parseFrom, const FixedInt<Precision> &defval);
static FixedInt<Precision> FromString(const wxString parseFrom);
};
typedef FixedInt<256> Fixed256;

183
common/include/Utilities/FixedPointTypes.inl
View File

@ -18,223 +18,234 @@
#include "FixedPointTypes.h"
#include <cmath> // for pow!
template< int Precision >
template <int Precision>
FixedInt<Precision>::FixedInt()
{
Raw = 0;
}
template< int Precision >
FixedInt<Precision>::FixedInt( int signedval )
template <int Precision>
FixedInt<Precision>::FixedInt(int signedval)
{
Raw = signedval * Precision;
}
template< int Precision >
FixedInt<Precision>::FixedInt( double doubval )
template <int Precision>
FixedInt<Precision>::FixedInt(double doubval)
{
Raw = lround(doubval * (double)Precision);
}
template< int Precision >
FixedInt<Precision>::FixedInt( float floval )
template <int Precision>
FixedInt<Precision>::FixedInt(float floval)
{
Raw = lroundf(floval * (float)Precision);
}
template< int Precision >
FixedInt<Precision> FixedInt<Precision>::operator+( const FixedInt<Precision>& right ) const
template <int Precision>
FixedInt<Precision> FixedInt<Precision>::operator+(const FixedInt<Precision> &right) const
{
return FixedInt<Precision>().SetRaw( Raw + right.Raw );
return FixedInt<Precision>().SetRaw(Raw + right.Raw);
}
template< int Precision >
FixedInt<Precision> FixedInt<Precision>::operator-( const FixedInt<Precision>& right ) const
template <int Precision>
FixedInt<Precision> FixedInt<Precision>::operator-(const FixedInt<Precision> &right) const
{
return FixedInt<Precision>().SetRaw( Raw + right.Raw );
return FixedInt<Precision>().SetRaw(Raw + right.Raw);
}
template< int Precision >
FixedInt<Precision>& FixedInt<Precision>::operator+=( const FixedInt<Precision>& right )
template <int Precision>
FixedInt<Precision> &FixedInt<Precision>::operator+=(const FixedInt<Precision> &right)
{
return SetRaw( Raw + right.Raw );
return SetRaw(Raw + right.Raw);
}
template< int Precision >
FixedInt<Precision>& FixedInt<Precision>::operator-=( const FixedInt<Precision>& right )
template <int Precision>
FixedInt<Precision> &FixedInt<Precision>::operator-=(const FixedInt<Precision> &right)
{
return SetRaw( Raw + right.Raw );
return SetRaw(Raw + right.Raw);
}
template< int Precision >
FixedInt<Precision>& FixedInt<Precision>::ConfineTo( const FixedInt<Precision>& low, const FixedInt<Precision>& high )
template <int Precision>
FixedInt<Precision> &FixedInt<Precision>::ConfineTo(const FixedInt<Precision> &low, const FixedInt<Precision> &high)
{
return SetRaw( std::min( std::max( Raw, low.Raw ), high.Raw ) );
return SetRaw(std::min(std::max(Raw, low.Raw), high.Raw));
}
// Uses 64 bit internally to avoid overflows. For more precise/optimized 32 bit math
// you'll need to use the Raw values directly.
template< int Precision >
FixedInt<Precision> FixedInt<Precision>::operator*( const FixedInt<Precision>& right ) const
template <int Precision>
FixedInt<Precision> FixedInt<Precision>::operator*(const FixedInt<Precision> &right) const
{
s64 mulres = (s64)Raw * right.Raw;
return FixedInt<Precision>().SetRaw( (s32)(mulres / Precision) );
return FixedInt<Precision>().SetRaw((s32)(mulres / Precision));
}
// Uses 64 bit internally to avoid overflows. For more precise/optimized 32 bit math
// you'll need to use the Raw values directly.
template< int Precision >
FixedInt<Precision> FixedInt<Precision>::operator/( const FixedInt<Precision>& right ) const
template <int Precision>
FixedInt<Precision> FixedInt<Precision>::operator/(const FixedInt<Precision> &right) const
{
s64 divres = Raw * Precision;
return FixedInt<Precision>().SetRaw( (s32)(divres / right.Raw) );
return FixedInt<Precision>().SetRaw((s32)(divres / right.Raw));
}
// Uses 64 bit internally to avoid overflows. For more precise/optimized 32 bit math
// you'll need to use the Raw values directly.
template< int Precision >
FixedInt<Precision>& FixedInt<Precision>::operator*=( const FixedInt<Precision>& right )
template <int Precision>
FixedInt<Precision> &FixedInt<Precision>::operator*=(const FixedInt<Precision> &right)
{
s64 mulres = (s64)Raw * right.Raw;
return SetRaw( (s32)(mulres / Precision) );
return SetRaw((s32)(mulres / Precision));
}
// Uses 64 bit internally to avoid overflows. For more precise/optimized 32 bit math
// you'll need to use the Raw values directly.
template< int Precision >
FixedInt<Precision>& FixedInt<Precision>::operator/=( const FixedInt<Precision>& right )
template <int Precision>
FixedInt<Precision> &FixedInt<Precision>::operator/=(const FixedInt<Precision> &right)
{
s64 divres = Raw * Precision;
return SetRaw( (s32)(divres / right.Raw) );
return SetRaw((s32)(divres / right.Raw));
}
// returns TRUE if the value overflows the legal integer range of this container.
template< int Precision >
bool FixedInt<Precision>::OverflowCheck( int signedval )
template <int Precision>
bool FixedInt<Precision>::OverflowCheck(int signedval)
{
return ( signedval >= (INT_MAX / Precision) );
return (signedval >= (INT_MAX / Precision));
}
// returns TRUE if the value overflows the legal integer range of this container.
template< int Precision >
bool FixedInt<Precision>::OverflowCheck( double signedval )
template <int Precision>
bool FixedInt<Precision>::OverflowCheck(double signedval)
{
return ( signedval >= (INT_MAX / Precision) );
return (signedval >= (INT_MAX / Precision));
}
template< int Precision > int FixedInt<Precision>::GetWhole() const { return Raw / Precision; }
template< int Precision > int FixedInt<Precision>::GetFraction() const { return Raw % Precision; }
template <int Precision>
int FixedInt<Precision>::GetWhole() const
{
return Raw / Precision;
}
template <int Precision>
int FixedInt<Precision>::GetFraction() const
{
return Raw % Precision;
}
template< int Precision >
FixedInt<Precision>& FixedInt<Precision>::SetRaw( s32 rawsrc )
template <int Precision>
FixedInt<Precision> &FixedInt<Precision>::SetRaw(s32 rawsrc)
{
Raw = rawsrc;
return *this;
}
template< int Precision >
FixedInt<Precision>& FixedInt<Precision>::Round()
template <int Precision>
FixedInt<Precision> &FixedInt<Precision>::Round()
{
Raw = ToIntRounded();
return *this;
}
template< int Precision >
FixedInt<Precision>& FixedInt<Precision>::SetWhole( s32 wholepart )
template <int Precision>
FixedInt<Precision> &FixedInt<Precision>::SetWhole(s32 wholepart)
{
pxAssert( wholepart < (INT_MAX / Precision) );
pxAssert(wholepart < (INT_MAX / Precision));
Raw = GetFraction() + (wholepart * Precision);
return *this;
}
template< int Precision >
FixedInt<Precision>& FixedInt<Precision>::SetFraction( u32 fracpart )
template <int Precision>
FixedInt<Precision> &FixedInt<Precision>::SetFraction(u32 fracpart)
{
Raw = (GetWhole() * Precision) + fracpart;
return *this;
}
template< int Precision >
template <int Precision>
wxString FixedInt<Precision>::ToString() const
{
return wxsFormat( L"%d.%02d", GetWhole(), (GetFraction() * 100) / Precision );
return wxsFormat(L"%d.%02d", GetWhole(), (GetFraction() * 100) / Precision);
}
template< int Precision >
wxString FixedInt<Precision>::ToString( int fracDigits ) const
template <int Precision>
wxString FixedInt<Precision>::ToString(int fracDigits) const
{
if( fracDigits == 0 ) return wxsFormat( L"%d", GetWhole() );
if (fracDigits == 0)
return wxsFormat(L"%d", GetWhole());
pxAssert( fracDigits <= 7 ); // higher numbers would just cause overflows and bad mojo.
int mulby = (int)pow( 10.0, fracDigits );
wxString fmt=wxsFormat(L"%%d.%%0%dd", fracDigits);
return wxsFormat( fmt, GetWhole(), (GetFraction() * mulby) / Precision );
pxAssert(fracDigits <= 7); // higher numbers would just cause overflows and bad mojo.
int mulby = (int)pow(10.0, fracDigits);
wxString fmt = wxsFormat(L"%%d.%%0%dd", fracDigits);
return wxsFormat(fmt, GetWhole(), (GetFraction() * mulby) / Precision);
}
template< int Precision >
template <int Precision>
double FixedInt<Precision>::ToDouble() const
{
return ((double)Raw / (double)Precision);
}
template< int Precision >
template <int Precision>
float FixedInt<Precision>::ToFloat() const
{
return ((float)Raw / (float)Precision);
}
template< int Precision >
template <int Precision>
int FixedInt<Precision>::ToIntTruncated() const
{
return Raw / Precision;
}
template< int Precision >
template <int Precision>
int FixedInt<Precision>::ToIntRounded() const
{
return (Raw + (Precision/2)) / Precision;
return (Raw + (Precision / 2)) / Precision;
}
template< int Precision >
bool FixedInt<Precision>::TryFromString( FixedInt<Precision>& dest, const wxString& parseFrom )
template <int Precision>
bool FixedInt<Precision>::TryFromString(FixedInt<Precision> &dest, const wxString &parseFrom)
{
long whole=0, frac=0;
const wxString beforeFirst( parseFrom.BeforeFirst( L'.' ) );
const wxString afterFirst( parseFrom.AfterFirst( L'.' ).Mid(0, 5) );
long whole = 0, frac = 0;
const wxString beforeFirst(parseFrom.BeforeFirst(L'.'));
const wxString afterFirst(parseFrom.AfterFirst(L'.').Mid(0, 5));
bool success = true;
if( !beforeFirst.IsEmpty() )
success = success && beforeFirst.ToLong( &whole );
if (!beforeFirst.IsEmpty())
success = success && beforeFirst.ToLong(&whole);
if( !afterFirst.IsEmpty() )
success = success && afterFirst.ToLong( &frac );
if (!afterFirst.IsEmpty())
success = success && afterFirst.ToLong(&frac);
if( !success ) return false;
if (!success)
return false;
dest.SetWhole( whole );
dest.SetWhole(whole);
if( afterFirst.Length() != 0 && frac != 0 )
{
int fracPower = (int)pow( 10.0, (int)afterFirst.Length() );
dest.SetFraction( (frac * Precision) / fracPower );
if (afterFirst.Length() != 0 && frac != 0) {
int fracPower = (int)pow(10.0, (int)afterFirst.Length());
dest.SetFraction((frac * Precision) / fracPower);
}
return true;
}
template< int Precision >
FixedInt<Precision> FixedInt<Precision>::FromString( const wxString& parseFrom, const FixedInt<Precision>& defval )
template <int Precision>
FixedInt<Precision> FixedInt<Precision>::FromString(const wxString &parseFrom, const FixedInt<Precision> &defval)
{
FixedInt<Precision> dest;
if( !TryFromString( dest, parseFrom ) ) return defval;
if (!TryFromString(dest, parseFrom))
return defval;
return dest;
}
// This version of FromString throws a ParseError exception if the conversion fails.
template< int Precision >
FixedInt<Precision> FixedInt<Precision>::FromString( const wxString parseFrom )
template <int Precision>
FixedInt<Precision> FixedInt<Precision>::FromString(const wxString parseFrom)
{
FixedInt<Precision> dest;
if( !TryFromString( dest, parseFrom ) ) throw Exception::ParseError()
if (!TryFromString(dest, parseFrom))
throw Exception::ParseError()
.SetDiagMsg(wxsFormat(L"Parse error on FixedInt<%d>::FromString", Precision));
return dest;

87
common/include/Utilities/General.h
View File

@ -17,16 +17,22 @@
// This macro is actually useful for about any and every possible application of C++
// equality operators.
#define OpEqu( field ) (field == right.field)
#define OpEqu(field) (field == right.field)
// Macro used for removing some of the redtape involved in defining bitfield/union helpers.
//
#define BITFIELD32() \
union { \
union \
{ \
u32 bitset; \
struct {
struct \
{
#define BITFIELD_END }; };
#define BITFIELD_END \
} \
; \
} \
;
// ----------------------------------------------------------------------------------------
@ -42,13 +48,18 @@
class RecursionGuard
{
public:
int& Counter;
int &Counter;
RecursionGuard( int& counter ) : Counter( counter )
{ ++Counter; }
RecursionGuard(int &counter)
: Counter(counter)
{
++Counter;
}
virtual ~RecursionGuard() throw()
{ --Counter; }
{
--Counter;
}
bool IsReentrant() const { return Counter > 1; }
};
@ -60,13 +71,13 @@ class IActionInvocation
{
public:
virtual ~IActionInvocation() throw() {}
virtual void InvokeAction()=0;
virtual void InvokeAction() = 0;
};
class ICloneable
{
public:
virtual ICloneable* Clone() const=0;
virtual ICloneable *Clone() const = 0;
};
class IDeletableObject
@ -74,15 +85,15 @@ class IDeletableObject
public:
virtual ~IDeletableObject() throw() {}
virtual void DeleteSelf()=0;
virtual bool IsBeingDeleted()=0;
virtual void DeleteSelf() = 0;
virtual bool IsBeingDeleted() = 0;
protected:
// This function is GUI implementation dependent! It's implemented by PCSX2's AppHost,
// but if the SysCore is being linked to another front end, you'll need to implement this
// yourself. Most GUIs have built in message pumps. If a platform lacks one then you'll
// need to implement one yourself (yay?).
virtual void DoDeletion()=0;
virtual void DoDeletion() = 0;
};
// --------------------------------------------------------------------------------------
@ -146,28 +157,28 @@ protected:
public:
PageProtectionMode()
{
All( false );
All(false);
}
PageProtectionMode& Read( bool allow=true )
PageProtectionMode &Read(bool allow = true)
{
m_read = allow;
return *this;
}
PageProtectionMode& Write( bool allow=true )
PageProtectionMode &Write(bool allow = true)
{
m_write = allow;
return *this;
}
PageProtectionMode& Execute( bool allow=true )
PageProtectionMode &Execute(bool allow = true)
{
m_exec = allow;
return *this;
}
PageProtectionMode& All( bool allow=true )
PageProtectionMode &All(bool allow = true)
{
m_read = m_write = m_exec = allow;
return *this;
@ -218,35 +229,35 @@ static __fi PageProtectionMode PageAccess_Any()
// platform prior to wxWidgets .. it should prolly be removed -- air)
namespace HostSys
{
void* MmapReserve(uptr base, size_t size);
bool MmapCommit(uptr base, size_t size, const PageProtectionMode& mode);
void MmapReset(uptr base, size_t size);
void *MmapReserve(uptr base, size_t size);
bool MmapCommit(uptr base, size_t size, const PageProtectionMode &mode);
void MmapReset(uptr base, size_t size);
void* MmapReservePtr(void* base, size_t size);
bool MmapCommitPtr(void* base, size_t size, const PageProtectionMode& mode);
void MmapResetPtr(void* base, size_t size);
void *MmapReservePtr(void *base, size_t size);
bool MmapCommitPtr(void *base, size_t size, const PageProtectionMode &mode);
void MmapResetPtr(void *base, size_t size);
// Maps a block of memory for use as a recompiled code buffer.
// Returns NULL on allocation failure.
extern void* Mmap(uptr base, size_t size);
// Maps a block of memory for use as a recompiled code buffer.
// Returns NULL on allocation failure.
extern void *Mmap(uptr base, size_t size);
// Unmaps a block allocated by SysMmap
extern void Munmap(uptr base, size_t size);
// Unmaps a block allocated by SysMmap
extern void Munmap(uptr base, size_t size);
extern void MemProtect( void* baseaddr, size_t size, const PageProtectionMode& mode );
extern void MemProtect(void *baseaddr, size_t size, const PageProtectionMode &mode);
extern void Munmap( void* base, size_t size );
extern void Munmap(void *base, size_t size);
template< uint size >
void MemProtectStatic( u8 (&arr)[size], const PageProtectionMode& mode )
{
MemProtect( arr, size, mode );
}
template <uint size>
void MemProtectStatic(u8 (&arr)[size], const PageProtectionMode &mode)
{
MemProtect(arr, size, mode);
}
}
// Safe version of Munmap -- NULLs the pointer variable immediately after free'ing it.
#define SafeSysMunmap( ptr, size ) \
((void) ( HostSys::Munmap( (uptr)(ptr), size ), (ptr) = NULL ))
#define SafeSysMunmap(ptr, size) \
((void)(HostSys::Munmap((uptr)(ptr), size), (ptr) = NULL))
extern void InitCPUTicks();
extern u64 GetTickFrequency();

7
common/include/Utilities/HashMap.h
View File

@ -15,7 +15,8 @@
#pragma once
namespace HashTools {
namespace HashTools
{
/// <summary>
/// Type that represents a hashcode; returned by all hash functions.
@ -26,7 +27,5 @@ namespace HashTools {
/// </remarks>
typedef u32 hash_key_t;
hash_key_t Hash(const char* data, int len);
hash_key_t Hash(const char *data, int len);
}

130
common/include/Utilities/IniInterface.h
View File

@ -32,53 +32,57 @@
class IniInterface
{
protected:
wxConfigBase* m_Config;
wxConfigBase *m_Config;
public:
virtual ~IniInterface();
explicit IniInterface();
explicit IniInterface( wxConfigBase& config );
explicit IniInterface( wxConfigBase* config );
explicit IniInterface(wxConfigBase &config);
explicit IniInterface(wxConfigBase *config);
void SetPath( const wxString& path );
void SetPath(const wxString &path);
void Flush();
wxConfigBase& GetConfig() { pxAssert( m_Config ); return *m_Config; }
wxConfigBase &GetConfig()
{
pxAssert(m_Config);
return *m_Config;
}
bool IsOk() const { return m_Config != NULL; }
virtual bool IsLoading() const=0;
virtual bool IsLoading() const = 0;
bool IsSaving() const { return !IsLoading(); }
virtual void Entry( const wxString& var, wxString& value, const wxString defvalue=wxString() )=0;
virtual void Entry( const wxString& var, wxDirName& value, const wxDirName defvalue=wxDirName(), bool isAllowRelative=false )=0;
virtual void Entry( const wxString& var, wxFileName& value, const wxFileName defvalue=wxFileName(), bool isAllowRelative=false )=0;
virtual void Entry( const wxString& var, int& value, const int defvalue=0 )=0;
virtual void Entry( const wxString& var, uint& value, const uint defvalue=0 )=0;
virtual void Entry( const wxString& var, bool& value, const bool defvalue=false )=0;
virtual void Entry(const wxString &var, wxString &value, const wxString defvalue = wxString()) = 0;
virtual void Entry(const wxString &var, wxDirName &value, const wxDirName defvalue = wxDirName(), bool isAllowRelative = false) = 0;
virtual void Entry(const wxString &var, wxFileName &value, const wxFileName defvalue = wxFileName(), bool isAllowRelative = false) = 0;
virtual void Entry(const wxString &var, int &value, const int defvalue = 0) = 0;
virtual void Entry(const wxString &var, uint &value, const uint defvalue = 0) = 0;
virtual void Entry(const wxString &var, bool &value, const bool defvalue = false) = 0;
// This special form of Entry is provided for bitfields, which cannot be passed by reference.
virtual bool EntryBitBool( const wxString& var, bool value, const bool defvalue=false )=0;
virtual int EntryBitfield( const wxString& var, int value, const int defvalue=0 )=0;
virtual bool EntryBitBool(const wxString &var, bool value, const bool defvalue = false) = 0;
virtual int EntryBitfield(const wxString &var, int value, const int defvalue = 0) = 0;
virtual void Entry( const wxString& var, Fixed100& value, const Fixed100 defvalue=Fixed100() )=0;
virtual void Entry(const wxString &var, Fixed100 &value, const Fixed100 defvalue = Fixed100()) = 0;
virtual void Entry( const wxString& var, wxPoint& value, const wxPoint defvalue=wxDefaultPosition )=0;
virtual void Entry( const wxString& var, wxSize& value, const wxSize defvalue=wxDefaultSize )=0;
virtual void Entry( const wxString& var, wxRect& value, const wxRect defvalue=wxDefaultRect )=0;
virtual void Entry(const wxString &var, wxPoint &value, const wxPoint defvalue = wxDefaultPosition) = 0;
virtual void Entry(const wxString &var, wxSize &value, const wxSize defvalue = wxDefaultSize) = 0;
virtual void Entry(const wxString &var, wxRect &value, const wxRect defvalue = wxDefaultRect) = 0;
template< typename T >
void EnumEntry( const wxString& var, T& value, const wxChar* const* enumArray=NULL, const T defvalue=(T)0 )
template <typename T>
void EnumEntry(const wxString &var, T &value, const wxChar *const *enumArray = NULL, const T defvalue = (T)0)
{
int tstore = (int)value;
if( enumArray == NULL )
Entry( var, tstore, defvalue );
if (enumArray == NULL)
Entry(var, tstore, defvalue);
else
_EnumEntry( var, tstore, enumArray, defvalue );
_EnumEntry(var, tstore, enumArray, defvalue);
value = (T)tstore;
}
protected:
virtual void _EnumEntry( const wxString& var, int& value, const wxChar* const* enumArray, int defvalue )=0;
virtual void _EnumEntry(const wxString &var, int &value, const wxChar *const *enumArray, int defvalue) = 0;
};
// --------------------------------------------------------------------------------------
@ -87,10 +91,10 @@ protected:
class ScopedIniGroup
{
protected:
IniInterface& m_mom;
IniInterface &m_mom;
public:
ScopedIniGroup( IniInterface& mommy, const wxString& group );
ScopedIniGroup(IniInterface &mommy, const wxString &group);
virtual ~ScopedIniGroup();
};
@ -107,29 +111,29 @@ class IniLoader : public IniInterface
public:
virtual ~IniLoader() throw();
explicit IniLoader();
explicit IniLoader( wxConfigBase& config );
explicit IniLoader( wxConfigBase* config );
explicit IniLoader(wxConfigBase &config);
explicit IniLoader(wxConfigBase *config);
bool IsLoading() const { return true; }
void Entry( const wxString& var, wxString& value, const wxString defvalue=wxEmptyString );
void Entry( const wxString& var, wxDirName& value, const wxDirName defvalue=wxDirName(), bool isAllowRelative=false );
void Entry( const wxString& var, wxFileName& value, const wxFileName defvalue=wxFileName(), bool isAllowRelative=false );
void Entry( const wxString& var, int& value, const int defvalue=0 );
void Entry( const wxString& var, uint& value, const uint defvalue=0 );
void Entry( const wxString& var, bool& value, const bool defvalue=false );
void Entry(const wxString &var, wxString &value, const wxString defvalue = wxEmptyString);
void Entry(const wxString &var, wxDirName &value, const wxDirName defvalue = wxDirName(), bool isAllowRelative = false);
void Entry(const wxString &var, wxFileName &value, const wxFileName defvalue = wxFileName(), bool isAllowRelative = false);
void Entry(const wxString &var, int &value, const int defvalue = 0);
void Entry(const wxString &var, uint &value, const uint defvalue = 0);
void Entry(const wxString &var, bool &value, const bool defvalue = false);
bool EntryBitBool( const wxString& var, bool value, const bool defvalue=false );
int EntryBitfield( const wxString& var, int value, const int defvalue=0 );
bool EntryBitBool(const wxString &var, bool value, const bool defvalue = false);
int EntryBitfield(const wxString &var, int value, const int defvalue = 0);
void Entry( const wxString& var, Fixed100& value, const Fixed100 defvalue=Fixed100() );
void Entry(const wxString &var, Fixed100 &value, const Fixed100 defvalue = Fixed100());
void Entry( const wxString& var, wxPoint& value, const wxPoint defvalue=wxDefaultPosition );
void Entry( const wxString& var, wxSize& value, const wxSize defvalue=wxDefaultSize );
void Entry( const wxString& var, wxRect& value, const wxRect defvalue=wxDefaultRect );
void Entry(const wxString &var, wxPoint &value, const wxPoint defvalue = wxDefaultPosition);
void Entry(const wxString &var, wxSize &value, const wxSize defvalue = wxDefaultSize);
void Entry(const wxString &var, wxRect &value, const wxRect defvalue = wxDefaultRect);
protected:
void _EnumEntry( const wxString& var, int& value, const wxChar* const* enumArray, int defvalue );
void _EnumEntry(const wxString &var, int &value, const wxChar *const *enumArray, int defvalue);
};
// --------------------------------------------------------------------------------------
@ -145,43 +149,43 @@ class IniSaver : public IniInterface
public:
virtual ~IniSaver();
explicit IniSaver();
explicit IniSaver( wxConfigBase& config );
explicit IniSaver( wxConfigBase* config );
explicit IniSaver(wxConfigBase &config);
explicit IniSaver(wxConfigBase *config);
bool IsLoading() const { return false; }
void Entry( const wxString& var, wxString& value, const wxString defvalue=wxString() );
void Entry( const wxString& var, wxDirName& value, const wxDirName defvalue=wxDirName(), bool isAllowRelative=false );
void Entry( const wxString& var, wxFileName& value, const wxFileName defvalue=wxFileName(), bool isAllowRelative=false );
void Entry( const wxString& var, int& value, const int defvalue=0 );
void Entry( const wxString& var, uint& value, const uint defvalue=0 );
void Entry( const wxString& var, bool& value, const bool defvalue=false );
void Entry(const wxString &var, wxString &value, const wxString defvalue = wxString());
void Entry(const wxString &var, wxDirName &value, const wxDirName defvalue = wxDirName(), bool isAllowRelative = false);
void Entry(const wxString &var, wxFileName &value, const wxFileName defvalue = wxFileName(), bool isAllowRelative = false);
void Entry(const wxString &var, int &value, const int defvalue = 0);
void Entry(const wxString &var, uint &value, const uint defvalue = 0);
void Entry(const wxString &var, bool &value, const bool defvalue = false);
bool EntryBitBool( const wxString& var, bool value, const bool defvalue=false );
int EntryBitfield( const wxString& var, int value, const int defvalue=0 );
bool EntryBitBool(const wxString &var, bool value, const bool defvalue = false);
int EntryBitfield(const wxString &var, int value, const int defvalue = 0);
void Entry( const wxString& var, Fixed100& value, const Fixed100 defvalue=Fixed100() );
void Entry(const wxString &var, Fixed100 &value, const Fixed100 defvalue = Fixed100());
void Entry( const wxString& var, wxPoint& value, const wxPoint defvalue=wxDefaultPosition );
void Entry( const wxString& var, wxSize& value, const wxSize defvalue=wxDefaultSize );
void Entry( const wxString& var, wxRect& value, const wxRect defvalue=wxDefaultRect );
void Entry(const wxString &var, wxPoint &value, const wxPoint defvalue = wxDefaultPosition);
void Entry(const wxString &var, wxSize &value, const wxSize defvalue = wxDefaultSize);
void Entry(const wxString &var, wxRect &value, const wxRect defvalue = wxDefaultRect);
protected:
void _EnumEntry( const wxString& var, int& value, const wxChar* const* enumArray, int defvalue );
void _EnumEntry(const wxString &var, int &value, const wxChar *const *enumArray, int defvalue);
};
// ------------------------------------------------------------------------
// GCC Note: wxT() macro is required when using string token pasting. For some reason L generates
// syntax errors. >_<
//
#define IniEntry( varname ) ini.Entry( wxT(#varname), varname, varname )
#define IniEntryDirFile( varname, isAllowRelative ) ini.Entry( wxT(#varname), varname, varname, isAllowRelative )
#define IniBitfield( varname ) varname = ini.EntryBitfield( wxT(#varname), varname, varname )
#define IniBitBool( varname ) varname = ini.EntryBitBool( wxT(#varname), !!varname, varname )
#define IniEntry(varname) ini.Entry(wxT(#varname), varname, varname)
#define IniEntryDirFile(varname, isAllowRelative) ini.Entry(wxT(#varname), varname, varname, isAllowRelative)
#define IniBitfield(varname) varname = ini.EntryBitfield(wxT(#varname), varname, varname)
#define IniBitBool(varname) varname = ini.EntryBitBool(wxT(#varname), !!varname, varname)
#define IniBitfieldEx( varname, textname ) varname = ini.EntryBitfield( wxT(textname), varname, varname )
#define IniBitBoolEx( varname, textname ) varname = ini.EntryBitBool( wxT(textname), !!varname, varname )
#define IniBitfieldEx(varname, textname) varname = ini.EntryBitfield(wxT(textname), varname, varname)
#define IniBitBoolEx(varname, textname) varname = ini.EntryBitBool(wxT(textname), !!varname, varname)
//used for filenames and folder names as ini values.
//Set to app root folder, so all files and folders which are inside appRoot will be written as relative.
void SetFullBaseDir( wxDirName appRoot );
void SetFullBaseDir(wxDirName appRoot);

6
common/include/Utilities/MathUtils.h
View File

@ -20,7 +20,8 @@
#include "Pcsx2Defs.h"
// On GCC >= 4.7, this is equivalent to __builtin_clrsb(n);
inline u32 count_leading_sign_bits(s32 n) {
inline u32 count_leading_sign_bits(s32 n)
{
// If the sign bit is 1, we invert the bits to 0 for count-leading-zero.
if (n < 0)
n = ~n;
@ -29,7 +30,7 @@ inline u32 count_leading_sign_bits(s32 n) {
if (n == 0)
return 32;
// Perform our count leading zero.
// Perform our count leading zero.
#ifdef _MSC_VER
unsigned long ret;
_BitScanReverse(&ret, n);
@ -38,4 +39,3 @@ inline u32 count_leading_sign_bits(s32 n) {
return __builtin_clz(n);
#endif
}

6
common/include/Utilities/MemcpyFast.h
View File

@ -16,15 +16,15 @@
#pragma once
#if defined(__POSIX__)
# include "lnx_memzero.h"
#include "lnx_memzero.h"
#else
# include "win_memzero.h"
#include "win_memzero.h"
#endif
// For 32-bit MSVC compiles, memcmp performs much worse than memcmp_mmx and
// other implementations. So for this combination only, prefer memcmp_mmx
#if defined(_MSC_VER) && !defined(_M_X86_64)
extern u8 memcmp_mmx(const void* src1, const void* src2, int cmpsize);
extern u8 memcmp_mmx(const void *src1, const void *src2, int cmpsize);
#else
#define memcmp_mmx memcmp
#endif

48
common/include/Utilities/MemsetFast.inl
View File

@ -17,29 +17,28 @@
#include <xmmintrin.h>
#define StoreDestIdx(idx) case idx: _mm_store_ps(&destxmm[idx-1][0], srcreg)
#define StoreDestIdx(idx) \
case idx: \
_mm_store_ps(&destxmm[idx - 1][0], srcreg)
template< u8 data >
__noinline void memset_sse_a( void* dest, const size_t size )
template <u8 data>
__noinline void memset_sse_a(void *dest, const size_t size)
{
const uint MZFqwc = size / 16;
pxAssert( (size & 0xf) == 0 );
pxAssert((size & 0xf) == 0);
__m128 srcreg;
if (data != 0)
{
static __aligned16 const u8 loadval[8] = { data,data,data,data,data,data,data,data };
srcreg = _mm_loadh_pi( _mm_load_ps( (float*)loadval ), (__m64*)loadval );
}
else
if (data != 0) {
static __aligned16 const u8 loadval[8] = {data, data, data, data, data, data, data, data};
srcreg = _mm_loadh_pi(_mm_load_ps((float *)loadval), (__m64 *)loadval);
} else
srcreg = _mm_setzero_ps();
float (*destxmm)[4] = (float(*)[4])dest;
float(*destxmm)[4] = (float(*)[4])dest;
switch( MZFqwc & 0x07 )
{
switch (MZFqwc & 0x07) {
StoreDestIdx(0x07);
StoreDestIdx(0x06);
StoreDestIdx(0x05);
@ -50,8 +49,7 @@ __noinline void memset_sse_a( void* dest, const size_t size )
}
destxmm += (MZFqwc & 0x07);
for( uint i=0; i<MZFqwc / 8; ++i, destxmm+=8 )
{
for (uint i = 0; i < MZFqwc / 8; ++i, destxmm += 8) {
_mm_store_ps(&destxmm[0][0], srcreg);
_mm_store_ps(&destxmm[1][0], srcreg);
_mm_store_ps(&destxmm[2][0], srcreg);
@ -63,23 +61,23 @@ __noinline void memset_sse_a( void* dest, const size_t size )
}
};
static __fi void memzero_sse_a( void* dest, const size_t size )
static __fi void memzero_sse_a(void *dest, const size_t size)
{
memset_sse_a<0>( dest, size );
memset_sse_a<0>(dest, size);
}
#undef StoreDestIdx
template< u8 data, typename T >
__noinline void memset_sse_a( T& dest )
template <u8 data, typename T>
__noinline void memset_sse_a(T &dest)
{
static_assert( (sizeof(dest) & 0xf) == 0, "Bad size for SSE memset" );
memset_sse_a<data>( &dest, sizeof(dest) );
static_assert((sizeof(dest) & 0xf) == 0, "Bad size for SSE memset");
memset_sse_a<data>(&dest, sizeof(dest));
}
template< typename T >
void memzero_sse_a( T& dest )
template <typename T>
void memzero_sse_a(T &dest)
{
static_assert( (sizeof(dest) & 0xf) == 0, "Bad size for SSE memset" );
memset_sse_a<0>( &dest, sizeof(dest) );
static_assert((sizeof(dest) & 0xf) == 0, "Bad size for SSE memset");
memset_sse_a<0>(&dest, sizeof(dest));
}

123
common/include/Utilities/PageFaultSource.h
View File

@ -30,7 +30,7 @@ struct PageFaultInfo
{
uptr addr;
PageFaultInfo( uptr address )
PageFaultInfo(uptr address)
{
addr = address;
}
@ -47,17 +47,17 @@ public:
public:
virtual ~IEventListener_PageFault() throw() {}
virtual void DispatchEvent( const PageFaultInfo& evtinfo, bool& handled )
virtual void DispatchEvent(const PageFaultInfo &evtinfo, bool &handled)
{
OnPageFaultEvent( evtinfo, handled );
OnPageFaultEvent(evtinfo, handled);
}
virtual void DispatchEvent( const PageFaultInfo& evtinfo )
virtual void DispatchEvent(const PageFaultInfo &evtinfo)
{
pxFailRel( "Don't call me, damnit. Use DispatchException instead." );
pxFailRel("Don't call me, damnit. Use DispatchException instead.");
}
virtual void OnPageFaultEvent( const PageFaultInfo& evtinfo, bool& handled ) {}
virtual void OnPageFaultEvent(const PageFaultInfo &evtinfo, bool &handled) {}
};
// --------------------------------------------------------------------------------------
@ -70,19 +70,19 @@ public:
virtual ~EventListener_PageFault() throw();
};
template< typename TypeToDispatchTo >
template <typename TypeToDispatchTo>
class EventListenerHelper_PageFault : public EventListener_PageFault
{
public:
TypeToDispatchTo* Owner;
TypeToDispatchTo *Owner;
public:
EventListenerHelper_PageFault( TypeToDispatchTo& dispatchTo )
EventListenerHelper_PageFault(TypeToDispatchTo &dispatchTo)
{
Owner = &dispatchTo;
}
EventListenerHelper_PageFault( TypeToDispatchTo* dispatchTo )
EventListenerHelper_PageFault(TypeToDispatchTo *dispatchTo)
{
Owner = dispatchTo;
}
@ -90,11 +90,10 @@ public:
virtual ~EventListenerHelper_PageFault() throw() {}
protected:
virtual void OnPageFaultEvent( const PageFaultInfo& info, bool& handled )
virtual void OnPageFaultEvent(const PageFaultInfo &info, bool &handled)
{
Owner->OnPageFaultEvent( info, handled );
Owner->OnPageFaultEvent(info, handled);
}
};
// --------------------------------------------------------------------------------------
@ -109,14 +108,17 @@ protected:
bool m_handled;
public:
SrcType_PageFault() : m_handled(false) {}
virtual ~SrcType_PageFault() throw() { }
SrcType_PageFault()
: m_handled(false)
{
}
virtual ~SrcType_PageFault() throw() {}
bool WasHandled() const { return m_handled; }
virtual void Dispatch( const PageFaultInfo& params );
virtual void Dispatch(const PageFaultInfo &params);
protected:
virtual void _DispatchRaw( ListenerIterator iter, const ListenerIterator& iend, const PageFaultInfo& evt );
virtual void _DispatchRaw(ListenerIterator iter, const ListenerIterator &iend, const PageFaultInfo &evt);
};
@ -125,7 +127,7 @@ protected:
// --------------------------------------------------------------------------------------
class VirtualMemoryReserve
{
DeclareNoncopyableObject( VirtualMemoryReserve );
DeclareNoncopyableObject(VirtualMemoryReserve);
protected:
wxString m_name;
@ -135,7 +137,7 @@ protected:
// in the Reserve parameters.
size_t m_defsize;
void* m_baseptr;
void *m_baseptr;
// reserved memory (in pages).
uptr m_pages_reserved;
@ -154,21 +156,21 @@ protected:
bool m_allow_writes;
public:
VirtualMemoryReserve( const wxString& name=wxEmptyString, size_t size = 0 );
VirtualMemoryReserve(const wxString &name = wxEmptyString, size_t size = 0);
virtual ~VirtualMemoryReserve() throw()
{
Release();
}
virtual void* Reserve( size_t size = 0, uptr base = 0, uptr upper_bounds = 0 );
virtual void* ReserveAt( uptr base = 0, uptr upper_bounds = 0 )
virtual void *Reserve(size_t size = 0, uptr base = 0, uptr upper_bounds = 0);
virtual void *ReserveAt(uptr base = 0, uptr upper_bounds = 0)
{
return Reserve(m_defsize, base, upper_bounds);
}
virtual void Reset();
virtual void Release();
virtual bool TryResize( uint newsize );
virtual bool TryResize(uint newsize);
virtual bool Commit();
virtual void ForbidModification();
@ -182,35 +184,35 @@ public:
uint GetCommittedPageCount() const { return m_pages_commited; }
uint GetCommittedBytes() const { return m_pages_commited * __pagesize; }
u8* GetPtr() { return (u8*)m_baseptr; }
const u8* GetPtr() const { return (u8*)m_baseptr; }
u8* GetPtrEnd() { return (u8*)m_baseptr + (m_pages_reserved * __pagesize); }
const u8* GetPtrEnd() const { return (u8*)m_baseptr + (m_pages_reserved * __pagesize); }
u8 *GetPtr() { return (u8 *)m_baseptr; }
const u8 *GetPtr() const { return (u8 *)m_baseptr; }
u8 *GetPtrEnd() { return (u8 *)m_baseptr + (m_pages_reserved * __pagesize); }
const u8 *GetPtrEnd() const { return (u8 *)m_baseptr + (m_pages_reserved * __pagesize); }
VirtualMemoryReserve& SetName( const wxString& newname );
VirtualMemoryReserve& SetBaseAddr( uptr newaddr );
VirtualMemoryReserve& SetPageAccessOnCommit( const PageProtectionMode& mode );
VirtualMemoryReserve &SetName(const wxString &newname);
VirtualMemoryReserve &SetBaseAddr(uptr newaddr);
VirtualMemoryReserve &SetPageAccessOnCommit(const PageProtectionMode &mode);
operator void*() { return m_baseptr; }
operator const void*() const { return m_baseptr; }
operator void *() { return m_baseptr; }
operator const void *() const { return m_baseptr; }
operator u8*() { return (u8*)m_baseptr; }
operator const u8*() const { return (u8*)m_baseptr; }
operator u8 *() { return (u8 *)m_baseptr; }
operator const u8 *() const { return (u8 *)m_baseptr; }
u8& operator[](uint idx)
u8 &operator[](uint idx)
{
pxAssert(idx < (m_pages_reserved * __pagesize));
return *((u8*)m_baseptr + idx);
return *((u8 *)m_baseptr + idx);
}
const u8& operator[](uint idx) const
const u8 &operator[](uint idx) const
{
pxAssert(idx < (m_pages_reserved * __pagesize));
return *((u8*)m_baseptr + idx);
return *((u8 *)m_baseptr + idx);
}
protected:
virtual void ReprotectCommittedBlocks( const PageProtectionMode& newmode );
virtual void ReprotectCommittedBlocks(const PageProtectionMode &newmode);
};
// --------------------------------------------------------------------------------------
@ -218,7 +220,7 @@ protected:
// --------------------------------------------------------------------------------------
class BaseVmReserveListener : public VirtualMemoryReserve
{
DeclareNoncopyableObject( BaseVmReserveListener );
DeclareNoncopyableObject(BaseVmReserveListener);
typedef VirtualMemoryReserve _parent;
@ -229,20 +231,20 @@ protected:
uptr m_blocksize;
public:
BaseVmReserveListener( const wxString& name, size_t size = 0 );
virtual ~BaseVmReserveListener() throw() { }
BaseVmReserveListener(const wxString &name, size_t size = 0);
virtual ~BaseVmReserveListener() throw() {}
operator void*() { return m_baseptr; }
operator const void*() const { return m_baseptr; }
operator void *() { return m_baseptr; }
operator const void *() const { return m_baseptr; }
operator u8*() { return (u8*)m_baseptr; }
operator const u8*() const { return (u8*)m_baseptr; }
operator u8 *() { return (u8 *)m_baseptr; }
operator const u8 *() const { return (u8 *)m_baseptr; }
using _parent::operator[];
void OnPageFaultEvent( const PageFaultInfo& info, bool& handled );
void OnPageFaultEvent(const PageFaultInfo &info, bool &handled);
virtual uptr SetBlockSize( uptr bytes )
virtual uptr SetBlockSize(uptr bytes)
{
m_blocksize = (bytes + __pagesize - 1) / __pagesize;
return m_blocksize * __pagesize;
@ -254,7 +256,6 @@ public:
}
protected:
// This function is called from OnPageFaultEvent after the address has been translated
// and confirmed to apply to this reserved area in question. OnPageFaultEvent contains
// a try/catch exception handler, which ensures "reasonable" error response behavior if
@ -263,35 +264,35 @@ protected:
// Important: This method is called from the context of an exception/signal handler. On
// Windows this isn't a big deal (most operations are ok). On Linux, however, logging
// and other facilities are probably not a good idea.
virtual void DoCommitAndProtect( uptr offset )=0;
virtual void DoCommitAndProtect(uptr offset) = 0;
// This function is called for every committed block.
virtual void OnCommittedBlock( void* block )=0;
virtual void OnCommittedBlock(void *block) = 0;
virtual void CommitBlocks( uptr page, uint blocks );
virtual void CommitBlocks(uptr page, uint blocks);
};
#ifdef __POSIX__
# define PCSX2_PAGEFAULT_PROTECT
# define PCSX2_PAGEFAULT_EXCEPT
#define PCSX2_PAGEFAULT_PROTECT
#define PCSX2_PAGEFAULT_EXCEPT
#elif defined( _WIN32 )
#elif defined(_WIN32)
struct _EXCEPTION_POINTERS;
extern int SysPageFaultExceptionFilter(struct _EXCEPTION_POINTERS* eps);
extern int SysPageFaultExceptionFilter(struct _EXCEPTION_POINTERS *eps);
# define PCSX2_PAGEFAULT_PROTECT __try
# define PCSX2_PAGEFAULT_EXCEPT __except(SysPageFaultExceptionFilter(GetExceptionInformation())) {}
#define PCSX2_PAGEFAULT_PROTECT __try
#define PCSX2_PAGEFAULT_EXCEPT \
__except (SysPageFaultExceptionFilter(GetExceptionInformation())) {}
#else
# error PCSX2 - Unsupported operating system platform.
#error PCSX2 - Unsupported operating system platform.
#endif
extern void pxInstallSignalHandler();
extern void _platform_InstallSignalHandler();
#include "Threading.h"
extern SrcType_PageFault* Source_PageFault;
extern SrcType_PageFault *Source_PageFault;
extern Threading::Mutex PageFault_Mutex;

160
common/include/Utilities/Path.h
View File

@ -26,30 +26,36 @@
class wxDirName : protected wxFileName
{
public:
explicit wxDirName( const wxFileName& src )
explicit wxDirName(const wxFileName &src)
{
Assign( src.GetPath(), wxEmptyString );
Assign(src.GetPath(), wxEmptyString);
}
wxDirName() : wxFileName() {}
wxDirName( const wxDirName& src ) : wxFileName( src ) { }
explicit wxDirName( const char* src ) { Assign( fromUTF8(src) ); }
explicit wxDirName( const wxString& src ) { Assign( src ); }
wxDirName()
: wxFileName()
{
}
wxDirName(const wxDirName &src)
: wxFileName(src)
{
}
explicit wxDirName(const char *src) { Assign(fromUTF8(src)); }
explicit wxDirName(const wxString &src) { Assign(src); }
// ------------------------------------------------------------------------
void Assign( const wxString& volume, const wxString& path )
void Assign(const wxString &volume, const wxString &path)
{
wxFileName::Assign( volume, path, wxEmptyString );
wxFileName::Assign(volume, path, wxEmptyString);
}
void Assign( const wxString& path )
void Assign(const wxString &path)
{
wxFileName::Assign( path, wxEmptyString );
wxFileName::Assign(path, wxEmptyString);
}
void Assign( const wxDirName& path )
void Assign(const wxDirName &path)
{
wxFileName::Assign( path );
wxFileName::Assign(path);
}
void Clear() { wxFileName::Clear(); }
@ -67,25 +73,24 @@ public:
bool IsRelative() const { return wxFileName::IsRelative(); }
bool IsAbsolute() const { return wxFileName::IsAbsolute(); }
bool SameAs( const wxDirName& filepath ) const
bool SameAs(const wxDirName &filepath) const
{
return wxFileName::SameAs( filepath );
return wxFileName::SameAs(filepath);
}
//Returns true if the file is somewhere inside this directory (and both file and directory are not relative).
bool IsContains( const wxFileName& file ) const
bool IsContains(const wxFileName &file) const
{
if( this->IsRelative() || file.IsRelative() )
if (this->IsRelative() || file.IsRelative())
return false;
wxFileName f( file );
wxFileName f(file);
while( 1 )
{
if( this->SameAs( wxDirName(f.GetPath()) ) )
while (1) {
if (this->SameAs(wxDirName(f.GetPath())))
return true;
if( f.GetDirCount() == 0 )
if (f.GetDirCount() == 0)
return false;
f.RemoveLastDir();
@ -94,9 +99,9 @@ public:
return false;
}
bool IsContains( const wxDirName& dir ) const
bool IsContains(const wxDirName &dir) const
{
return IsContains( (wxFileName)dir );
return IsContains((wxFileName)dir);
}
@ -107,22 +112,21 @@ public:
// 4. else, result is absolute path of subject.
//
// returns ok if both this and base are absolute paths.
static wxString MakeAutoRelativeTo(const wxFileName _subject, const wxString& pathbase)
static wxString MakeAutoRelativeTo(const wxFileName _subject, const wxString &pathbase)
{
wxFileName subject( _subject );
wxDirName base ( pathbase );
if( base.IsRelative() || subject.IsRelative() )
wxFileName subject(_subject);
wxDirName base(pathbase);
if (base.IsRelative() || subject.IsRelative())
return subject.GetFullPath();
wxString bv( base.GetVolume() ); bv.MakeUpper();
wxString sv( subject.GetVolume() ); sv.MakeUpper();
wxString bv(base.GetVolume());
bv.MakeUpper();
wxString sv(subject.GetVolume());
sv.MakeUpper();
if( base.IsContains( subject ) )
{
subject.MakeRelativeTo( base.GetFullPath() );
}
else if( base.HasVolume() && subject.HasVolume() && bv == sv )
{
if (base.IsContains(subject)) {
subject.MakeRelativeTo(base.GetFullPath());
} else if (base.HasVolume() && subject.HasVolume() && bv == sv) {
wxString unusedVolume;
wxString pathSansVolume;
subject.SplitVolume(subject.GetFullPath(), &unusedVolume, &pathSansVolume);
@ -133,28 +137,28 @@ public:
return subject.GetFullPath();
}
static wxString MakeAutoRelativeTo(const wxDirName subject, const wxString& pathbase)
static wxString MakeAutoRelativeTo(const wxDirName subject, const wxString &pathbase)
{
return MakeAutoRelativeTo( wxFileName( subject ), pathbase );
return MakeAutoRelativeTo(wxFileName(subject), pathbase);
}
// Returns the number of sub folders in this directory path
size_t GetCount() const { return GetDirCount(); }
// ------------------------------------------------------------------------
wxFileName Combine( const wxFileName& right ) const;
wxDirName Combine( const wxDirName& right ) const;
wxFileName Combine(const wxFileName &right) const;
wxDirName Combine(const wxDirName &right) const;
// removes the lastmost directory from the path
void RemoveLast() { wxFileName::RemoveDir(GetCount() - 1); }
wxDirName& Normalize( int flags = wxPATH_NORM_ALL, const wxString& cwd = wxEmptyString );
wxDirName& MakeRelativeTo( const wxString& pathBase = wxEmptyString );
wxDirName& MakeAbsolute( const wxString& cwd = wxEmptyString );
wxDirName &Normalize(int flags = wxPATH_NORM_ALL, const wxString &cwd = wxEmptyString);
wxDirName &MakeRelativeTo(const wxString &pathBase = wxEmptyString);
wxDirName &MakeAbsolute(const wxString &cwd = wxEmptyString);
// ------------------------------------------------------------------------
void AssignCwd( const wxString& volume = wxEmptyString ) { wxFileName::AssignCwd( volume ); }
void AssignCwd(const wxString &volume = wxEmptyString) { wxFileName::AssignCwd(volume); }
bool SetCwd() { return wxFileName::SetCwd(); }
// wxWidgets is missing the const qualifier for this one! Shame!
@ -163,27 +167,39 @@ public:
// ------------------------------------------------------------------------
wxDirName& operator=(const wxDirName& dirname) { Assign( dirname ); return *this; }
wxDirName& operator=(const wxString& dirname) { Assign( dirname ); return *this; }
wxDirName& operator=(const char* dirname) { Assign( fromUTF8(dirname) ); return *this; }
wxDirName &operator=(const wxDirName &dirname)
{
Assign(dirname);
return *this;
}
wxDirName &operator=(const wxString &dirname)
{
Assign(dirname);
return *this;
}
wxDirName &operator=(const char *dirname)
{
Assign(fromUTF8(dirname));
return *this;
}
wxFileName operator+( const wxFileName& right ) const { return Combine( right ); }
wxDirName operator+( const wxDirName& right ) const { return Combine( right ); }
wxFileName operator+( const wxString& right ) const { return Combine( wxFileName(right) ); }
wxFileName operator+( const char* right ) const { return Combine( wxFileName(fromUTF8(right)) ); }
wxFileName operator+(const wxFileName &right) const { return Combine(right); }
wxDirName operator+(const wxDirName &right) const { return Combine(right); }
wxFileName operator+(const wxString &right) const { return Combine(wxFileName(right)); }
wxFileName operator+(const char *right) const { return Combine(wxFileName(fromUTF8(right))); }
bool operator==(const wxDirName& filename) const { return SameAs(filename); }
bool operator!=(const wxDirName& filename) const { return !SameAs(filename); }
bool operator==(const wxDirName &filename) const { return SameAs(filename); }
bool operator!=(const wxDirName &filename) const { return !SameAs(filename); }
bool operator==(const wxFileName& filename) const { return SameAs(wxDirName(filename)); }
bool operator!=(const wxFileName& filename) const { return !SameAs(wxDirName(filename)); }
bool operator==(const wxFileName &filename) const { return SameAs(wxDirName(filename)); }
bool operator!=(const wxFileName &filename) const { return !SameAs(wxDirName(filename)); }
// compare with a filename string interpreted as a native file name
bool operator==(const wxString& filename) const { return SameAs(wxDirName(filename)); }
bool operator!=(const wxString& filename) const { return !SameAs(wxDirName(filename)); }
bool operator==(const wxString &filename) const { return SameAs(wxDirName(filename)); }
bool operator!=(const wxString &filename) const { return !SameAs(wxDirName(filename)); }
const wxFileName& GetFilename() const { return *this; }
wxFileName& GetFilename() { return *this; }
const wxFileName &GetFilename() const { return *this; }
wxFileName &GetFilename() { return *this; }
};
// --------------------------------------------------------------------------------------
@ -195,20 +211,20 @@ public:
//
namespace Path
{
extern bool IsRelative( const wxString& path );
extern s64 GetFileSize( const wxString& path );
extern bool IsRelative(const wxString &path);
extern s64 GetFileSize(const wxString &path);
extern wxString Normalize( const wxString& srcpath );
extern wxString Normalize( const wxDirName& srcpath );
extern wxString MakeAbsolute( const wxString& srcpath );
extern wxString Normalize(const wxString &srcpath);
extern wxString Normalize(const wxDirName &srcpath);
extern wxString MakeAbsolute(const wxString &srcpath);
extern wxString Combine( const wxString& srcPath, const wxString& srcFile );
extern wxString Combine( const wxDirName& srcPath, const wxFileName& srcFile );
extern wxString Combine( const wxString& srcPath, const wxDirName& srcFile );
extern wxString ReplaceExtension( const wxString& src, const wxString& ext );
extern wxString ReplaceFilename( const wxString& src, const wxString& newfilename );
extern wxString GetFilename( const wxString& src );
extern wxString GetDirectory( const wxString& src );
extern wxString GetFilenameWithoutExt( const wxString& src );
extern wxString GetRootDirectory( const wxString& src );
extern wxString Combine(const wxString &srcPath, const wxString &srcFile);
extern wxString Combine(const wxDirName &srcPath, const wxFileName &srcFile);
extern wxString Combine(const wxString &srcPath, const wxDirName &srcFile);
extern wxString ReplaceExtension(const wxString &src, const wxString &ext);
extern wxString ReplaceFilename(const wxString &src, const wxString &newfilename);
extern wxString GetFilename(const wxString &src);
extern wxString GetDirectory(const wxString &src);
extern wxString GetFilenameWithoutExt(const wxString &src);
extern wxString GetRootDirectory(const wxString &src);
}

43
common/include/Utilities/Perf.h
View File

@ -15,10 +15,11 @@
#pragma once
namespace Perf {
namespace Perf
{
struct Info
{
struct Info
{
uptr m_x86;
u32 m_size;
char m_symbol[20];
@ -26,32 +27,30 @@ namespace Perf {
// once.
bool m_dynamic;
Info(uptr x86, u32 size, const char* symbol);
Info(uptr x86, u32 size, const char* symbol, u32 pc);
void Print(FILE* fp);
};
Info(uptr x86, u32 size, const char *symbol);
Info(uptr x86, u32 size, const char *symbol, u32 pc);
void Print(FILE *fp);
};
class InfoVector
{
class InfoVector
{
std::vector<Info> m_v;
char m_prefix[20];
public:
public:
InfoVector(const char *prefix);
InfoVector(const char* prefix);
void print(FILE* fp);
void map(uptr x86, u32 size, const char* symbol);
void print(FILE *fp);
void map(uptr x86, u32 size, const char *symbol);
void map(uptr x86, u32 size, u32 pc);
void reset();
};
};
void dump();
void dump_and_reset();
void dump();
void dump_and_reset();
extern InfoVector any;
extern InfoVector ee;
extern InfoVector iop;
extern InfoVector vu;
extern InfoVector any;
extern InfoVector ee;
extern InfoVector iop;
extern InfoVector vu;
}

111
common/include/Utilities/PersistentThread.h
View File

@ -25,15 +25,15 @@ namespace Threading
// --------------------------------------------------------------------------------------
// ThreadDeleteEvent
// --------------------------------------------------------------------------------------
class EventListener_Thread : public IEventDispatcher<int>
{
public:
class EventListener_Thread : public IEventDispatcher<int>
{
public:
typedef int EvtParams;
protected:
pxThread* m_thread;
protected:
pxThread *m_thread;
public:
public:
EventListener_Thread()
{
m_thread = NULL;
@ -41,22 +41,22 @@ namespace Threading
virtual ~EventListener_Thread() throw() {}
void SetThread( pxThread& thr ) { m_thread = &thr; }
void SetThread( pxThread* thr ) { m_thread = thr; }
void SetThread(pxThread &thr) { m_thread = &thr; }
void SetThread(pxThread *thr) { m_thread = thr; }
void DispatchEvent( const int& params )
void DispatchEvent(const int &params)
{
OnThreadCleanup();
}
protected:
protected:
// Invoked by the pxThread when the thread execution is ending. This is
// typically more useful than a delete listener since the extended thread information
// provided by virtualized functions/methods will be available.
// Important! This event is executed *by the thread*, so care must be taken to ensure
// thread sync when necessary (posting messages to the main thread, etc).
virtual void OnThreadCleanup()=0;
};
virtual void OnThreadCleanup() = 0;
};
// --------------------------------------------------------------------------------------
// pxThread - Helper class for the basics of starting/managing persistent threads.
@ -85,13 +85,13 @@ namespace Threading
// no dependency options for ensuring correct static var initializations). Use heap
// allocation to create thread objects instead.
//
class pxThread
{
class pxThread
{
DeclareNoncopyableObject(pxThread);
friend void pxYield( int ms );
friend void pxYield(int ms);
protected:
protected:
wxString m_name; // diagnostic name for our thread.
pthread_t m_thread;
uptr m_native_id; // typically an id, but implementing platforms can do whatever.
@ -113,41 +113,42 @@ namespace Threading
EventSource<EventListener_Thread> m_evtsrc_OnDelete;
public:
public:
virtual ~pxThread() throw();
pxThread( const wxString& name=L"pxThread" );
pxThread(const wxString &name = L"pxThread");
pthread_t GetId() const { return m_thread; }
u64 GetCpuTime() const;
virtual void Start();
virtual void Cancel( bool isBlocking = true );
virtual bool Cancel( const wxTimeSpan& timeout );
virtual void Cancel(bool isBlocking = true);
virtual bool Cancel(const wxTimeSpan &timeout);
virtual bool Detach();
virtual void Block();
virtual bool Block( const wxTimeSpan& timeout );
virtual bool Block(const wxTimeSpan &timeout);
virtual void RethrowException() const;
void AddListener( EventListener_Thread& evt );
void AddListener( EventListener_Thread* evt )
void AddListener(EventListener_Thread &evt);
void AddListener(EventListener_Thread *evt)
{
if( evt == NULL ) return;
AddListener( *evt );
if (evt == NULL)
return;
AddListener(*evt);
}
void WaitOnSelf( Semaphore& mutex ) const;
void WaitOnSelf( Mutex& mutex ) const;
bool WaitOnSelf( Semaphore& mutex, const wxTimeSpan& timeout ) const;
bool WaitOnSelf( Mutex& mutex, const wxTimeSpan& timeout ) const;
void WaitOnSelf(Semaphore &mutex) const;
void WaitOnSelf(Mutex &mutex) const;
bool WaitOnSelf(Semaphore &mutex, const wxTimeSpan &timeout) const;
bool WaitOnSelf(Mutex &mutex, const wxTimeSpan &timeout) const;
bool IsRunning() const;
bool IsSelf() const;
bool HasPendingException() const { return !!m_except; }
wxString GetName() const;
void SetName( const wxString& newname );
void SetName(const wxString &newname);
protected:
protected:
// Extending classes should always implement your own OnStart(), which is called by
// Start() once necessary locks have been obtained. Do not override Start() directly
// unless you're really sure that's what you need to do. ;)
@ -160,7 +161,7 @@ namespace Threading
virtual void OnCleanupInThread();
// Implemented by derived class to perform actual threaded task!
virtual void ExecuteTaskInThread()=0;
virtual void ExecuteTaskInThread() = 0;
void TestCancel() const;
@ -173,17 +174,17 @@ namespace Threading
// depending on operating system/platform). If ms is 0 or unspecified, then a single
// timeslice is yielded to other contending threads. If no threads are contending for
// time when ms==0, then no yield is done, but cancellation is still tested.
void Yield( int ms = 0 )
void Yield(int ms = 0)
{
pxAssert( IsSelf() );
Threading::Sleep( ms );
pxAssert(IsSelf());
Threading::Sleep(ms);
TestCancel();
}
void FrankenMutex( Mutex& mutex );
void FrankenMutex(Mutex &mutex);
bool AffinityAssert_AllowFromSelf( const DiagnosticOrigin& origin ) const;
bool AffinityAssert_DisallowFromSelf( const DiagnosticOrigin& origin ) const;
bool AffinityAssert_AllowFromSelf(const DiagnosticOrigin &origin) const;
bool AffinityAssert_DisallowFromSelf(const DiagnosticOrigin &origin) const;
// ----------------------------------------------------------------------------
// Section of methods for internal use only.
@ -191,16 +192,16 @@ namespace Threading
void _platform_specific_OnStartInThread();
void _platform_specific_OnCleanupInThread();
bool _basecancel();
void _selfRunningTest( const wxChar* name ) const;
void _DoSetThreadName( const wxString& name );
void _DoSetThreadName( const char* name );
void _selfRunningTest(const wxChar *name) const;
void _DoSetThreadName(const wxString &name);
void _DoSetThreadName(const char *name);
void _internal_execute();
void _try_virtual_invoke( void (pxThread::*method)() );
void _try_virtual_invoke(void (pxThread::*method)());
void _ThreadCleanup();
static void* _internal_callback( void* func );
static void _pt_callback_cleanup( void* handle );
};
static void *_internal_callback(void *func);
static void _pt_callback_cleanup(void *handle);
};
// --------------------------------------------------------------------------------------
@ -240,19 +241,19 @@ namespace Threading
// into smaller sections. For example, if you have 20,000 items to process, the task
// can be divided into two threads of 10,000 items each.
//
class BaseTaskThread : public pxThread
{
protected:
class BaseTaskThread : public pxThread
{
protected:
std::atomic<bool> m_Done;
std::atomic<bool> m_TaskPending;
Semaphore m_post_TaskComplete;
Mutex m_lock_TaskComplete;
public:
public:
virtual ~BaseTaskThread() throw() {}
BaseTaskThread() :
m_Done( false )
, m_TaskPending( false )
BaseTaskThread()
: m_Done(false)
, m_TaskPending(false)
, m_post_TaskComplete()
{
}
@ -261,11 +262,11 @@ namespace Threading
void PostTask();
void WaitForResult();
protected:
protected:
// Abstract method run when a task has been posted. Implementing classes should do
// all your necessary processing work here.
virtual void Task()=0;
virtual void Task() = 0;
virtual void ExecuteTaskInThread();
};
};
}

2
common/include/Utilities/RedtapeWindows.h
View File

@ -16,7 +16,7 @@
#pragma once
#ifdef __WXMSW__
# include <wx/msw/wrapwin.h>
#include <wx/msw/wrapwin.h>
#else
//////////////////////////////////////////////////////////////////////////////////////////

50
common/include/Utilities/RwMutex.h
View File

@ -22,14 +22,14 @@ namespace Threading
// --------------------------------------------------------------------------------------
// RwMutex
// --------------------------------------------------------------------------------------
class RwMutex
{
class RwMutex
{
DeclareNoncopyableObject(RwMutex);
protected:
protected:
pthread_rwlock_t m_rwlock;
public:
public:
RwMutex();
virtual ~RwMutex() throw();
@ -39,22 +39,22 @@ namespace Threading
virtual bool TryAcquireWrite();
virtual void Release();
};
};
// --------------------------------------------------------------------------------------
// BaseScopedReadWriteLock
// --------------------------------------------------------------------------------------
class BaseScopedReadWriteLock
{
class BaseScopedReadWriteLock
{
DeclareNoncopyableObject(BaseScopedReadWriteLock);
protected:
RwMutex& m_lock;
protected:
RwMutex &m_lock;
bool m_IsLocked;
public:
BaseScopedReadWriteLock( RwMutex& locker )
: m_lock( locker )
public:
BaseScopedReadWriteLock(RwMutex &locker)
: m_lock(locker)
{
}
@ -62,29 +62,29 @@ namespace Threading
void Release();
bool IsLocked() const { return m_IsLocked; }
};
};
// --------------------------------------------------------------------------------------
// ScopedReadLock / ScopedWriteLock
// --------------------------------------------------------------------------------------
class ScopedReadLock : public BaseScopedReadWriteLock
{
public:
ScopedReadLock( RwMutex& locker );
class ScopedReadLock : public BaseScopedReadWriteLock
{
public:
ScopedReadLock(RwMutex &locker);
virtual ~ScopedReadLock() throw() {}
void Acquire();
};
};
class ScopedWriteLock : public BaseScopedReadWriteLock
{
public:
ScopedWriteLock( RwMutex& locker );
class ScopedWriteLock : public BaseScopedReadWriteLock
{
public:
ScopedWriteLock(RwMutex &locker);
virtual ~ScopedWriteLock() throw() {}
void Acquire();
protected:
ScopedWriteLock( RwMutex& locker, bool isTryLock );
};
protected:
ScopedWriteLock(RwMutex &locker, bool isTryLock);
};
}

101
common/include/Utilities/SafeArray.h
View File

@ -23,8 +23,8 @@
// Microsoft Windows only macro, useful for freeing out COM objects:
#define safe_release( ptr ) \
((void) (( ( (ptr) != NULL ) && ((ptr)->Release(), !!0) ), (ptr) = NULL))
#define safe_release(ptr) \
((void)((((ptr) != NULL) && ((ptr)->Release(), !!0)), (ptr) = NULL))
// --------------------------------------------------------------------------------------
// SafeArray
@ -32,7 +32,7 @@
// Handy little class for allocating a resizable memory block, complete with exception
// error handling and automatic cleanup. A lightweight alternative to std::vector.
//
template< typename T >
template <typename T>
class SafeArray
{
DeclareNoncopyableObject(SafeArray);
@ -45,32 +45,32 @@ public:
int ChunkSize;
protected:
T* m_ptr;
T *m_ptr;
int m_size; // size of the allocation of memory
protected:
SafeArray( const wxChar* name, T* allocated_mem, int initSize );
virtual T* _virtual_realloc( int newsize );
SafeArray(const wxChar *name, T *allocated_mem, int initSize);
virtual T *_virtual_realloc(int newsize);
// A safe array index fetcher. Asserts if the index is out of bounds (dev and debug
// builds only -- no bounds checking is done in release builds).
T* _getPtr( uint i ) const;
T *_getPtr(uint i) const;
public:
virtual ~SafeArray() throw();
explicit SafeArray( const wxChar* name=L"Unnamed" );
explicit SafeArray( int initialSize, const wxChar* name=L"Unnamed" );
explicit SafeArray(const wxChar *name = L"Unnamed");
explicit SafeArray(int initialSize, const wxChar *name = L"Unnamed");
void Dispose();
void ExactAlloc( int newsize );
void MakeRoomFor( int newsize )
void ExactAlloc(int newsize);
void MakeRoomFor(int newsize)
{
if( newsize > m_size )
ExactAlloc( newsize );
if (newsize > m_size)
ExactAlloc(newsize);
}
bool IsDisposed() const { return (m_ptr==NULL); }
bool IsDisposed() const { return (m_ptr == NULL); }
// Returns the size of the memory allocation, as according to the array type.
int GetLength() const { return m_size; }
@ -79,28 +79,28 @@ public:
// Extends the containment area of the array. Extensions are performed
// in chunks.
void GrowBy( int items )
void GrowBy(int items)
{
MakeRoomFor( m_size + ChunkSize + items + 1 );
MakeRoomFor(m_size + ChunkSize + items + 1);
}
// Gets a pointer to the requested allocation index.
// DevBuilds : Generates assertion if the index is invalid.
T* GetPtr( uint idx=0 ) { return _getPtr( idx ); }
const T* GetPtr( uint idx=0 ) const { return _getPtr( idx ); }
T *GetPtr(uint idx = 0) { return _getPtr(idx); }
const T *GetPtr(uint idx = 0) const { return _getPtr(idx); }
// Gets a pointer to the element directly after the last element in the array.
// This is equivalent to doing GetPtr(GetLength()), except that this call *avoids*
// the out-of-bounds assertion check that typically occurs when you do that. :)
T* GetPtrEnd() { return &m_ptr[m_size]; }
const T* GetPtrEnd() const { return &m_ptr[m_size]; }
T *GetPtrEnd() { return &m_ptr[m_size]; }
const T *GetPtrEnd() const { return &m_ptr[m_size]; }
// Gets an element of this memory allocation much as if it were an array.
// DevBuilds : Generates assertion if the index is invalid.
T& operator[]( int idx ) { return *_getPtr( (uint)idx ); }
const T& operator[]( int idx ) const { return *_getPtr( (uint)idx ); }
T &operator[](int idx) { return *_getPtr((uint)idx); }
const T &operator[](int idx) const { return *_getPtr((uint)idx); }
virtual SafeArray<T>* Clone() const;
virtual SafeArray<T> *Clone() const;
};
//////////////////////////////////////////////////////////////////////////////////////////
@ -113,7 +113,7 @@ public:
// * Classes with copy constructors (copying is done using performance memcpy)
// * Classes with destructors (they're not called, sorry!)
//
template< typename T >
template <typename T>
class SafeList
{
DeclareNoncopyableObject(SafeList);
@ -126,28 +126,28 @@ public:
int ChunkSize; // assigned DefaultChunkSize on init, reconfigurable at any time.
protected:
T* m_ptr;
T *m_ptr;
int m_allocsize; // size of the allocation of memory
uint m_length; // length of the array (active items, not buffer allocation)
protected:
virtual T* _virtual_realloc( int newsize );
void _MakeRoomFor_threshold( int newsize );
virtual T *_virtual_realloc(int newsize);
void _MakeRoomFor_threshold(int newsize);
T* _getPtr( uint i ) const;
T *_getPtr(uint i) const;
public:
virtual ~SafeList() throw();
explicit SafeList( const wxChar* name=L"Unnamed" );
explicit SafeList( int initialSize, const wxChar* name=L"Unnamed" );
virtual SafeList<T>* Clone() const;
explicit SafeList(const wxChar *name = L"Unnamed");
explicit SafeList(int initialSize, const wxChar *name = L"Unnamed");
virtual SafeList<T> *Clone() const;
void Remove( int index );
void MakeRoomFor( int blockSize );
void Remove(int index);
void MakeRoomFor(int blockSize);
T& New();
int Add( const T& src );
T& AddNew( const T& src );
T &New();
int Add(const T &src);
T &AddNew(const T &src);
// Returns the size of the list, as according to the array type. This includes
// mapped items only. The actual size of the allocation may differ.
@ -162,9 +162,9 @@ public:
m_length = m_allocsize;
}
void GrowBy( int items )
void GrowBy(int items)
{
MakeRoomFor( m_length + ChunkSize + items + 1 );
MakeRoomFor(m_length + ChunkSize + items + 1);
}
// Sets the item length to zero. Does not free memory allocations.
@ -175,14 +175,14 @@ public:
// Gets an element of this memory allocation much as if it were an array.
// DevBuilds : Generates assertion if the index is invalid.
T& operator[]( int idx ) { return *_getPtr( (uint)idx ); }
const T& operator[]( int idx ) const { return *_getPtr( (uint)idx ); }
T &operator[](int idx) { return *_getPtr((uint)idx); }
const T &operator[](int idx) const { return *_getPtr((uint)idx); }
T* GetPtr() { return m_ptr; }
const T* GetPtr() const { return m_ptr; }
T *GetPtr() { return m_ptr; }
const T *GetPtr() const { return m_ptr; }
T& GetLast() { return m_ptr[m_length-1]; }
const T& GetLast() const{ return m_ptr[m_length-1]; }
T &GetLast() { return m_ptr[m_length - 1]; }
const T &GetLast() const { return m_ptr[m_length - 1]; }
};
// --------------------------------------------------------------------------------------
@ -192,25 +192,24 @@ public:
// exception-based error handling and automatic cleanup.
// This one supports aligned data allocations too!
template< typename T, uint Alignment >
template <typename T, uint Alignment>
class SafeAlignedArray : public SafeArray<T>
{
typedef SafeArray<T> _parent;
protected:
T* _virtual_realloc( int newsize );
T *_virtual_realloc(int newsize);
public:
using _parent::operator[];
virtual ~SafeAlignedArray() throw();
explicit SafeAlignedArray( const wxChar* name=L"Unnamed" ) :
SafeArray<T>::SafeArray( name )
explicit SafeAlignedArray(const wxChar *name = L"Unnamed")
: SafeArray<T>::SafeArray(name)
{
}
explicit SafeAlignedArray( int initialSize, const wxChar* name=L"Unnamed" );
virtual SafeAlignedArray<T,Alignment>* Clone() const;
explicit SafeAlignedArray(int initialSize, const wxChar *name = L"Unnamed");
virtual SafeAlignedArray<T, Alignment> *Clone() const;
};

206
common/include/Utilities/SafeArray.inl
View File

@ -21,103 +21,103 @@
// use its own memory allocation (with an aligned memory, for example).
// Throws:
// Exception::OutOfMemory if the allocated_mem pointer is NULL.
template< typename T >
SafeArray<T>::SafeArray( const wxChar* name, T* allocated_mem, int initSize )
: Name( name )
template <typename T>
SafeArray<T>::SafeArray(const wxChar *name, T *allocated_mem, int initSize)
: Name(name)
{
ChunkSize = DefaultChunkSize;
m_ptr = allocated_mem;
m_size = initSize;
if( m_ptr == NULL )
if (m_ptr == NULL)
throw Exception::OutOfMemory(name)
.SetDiagMsg(wxsFormat(L"Called from 'SafeArray::ctor' [size=%d]", initSize));
}
template< typename T >
T* SafeArray<T>::_virtual_realloc( int newsize )
template <typename T>
T *SafeArray<T>::_virtual_realloc(int newsize)
{
T* retval = (T*)((m_ptr == NULL) ?
malloc( newsize * sizeof(T) ) :
realloc( m_ptr, newsize * sizeof(T) )
);
T *retval = (T *)((m_ptr == NULL) ?
malloc(newsize * sizeof(T)) :
realloc(m_ptr, newsize * sizeof(T)));
if( IsDebugBuild && (retval != NULL))
{
if (IsDebugBuild && (retval != NULL)) {
// Zero everything out to 0xbaadf00d, so that its obviously uncleared
// to a debuggee
u32* fill = (u32*)&retval[m_size];
const u32* end = (u32*)((((uptr)&retval[newsize-1])-3) & ~0x3);
for( ; fill<end; ++fill ) *fill = 0xbaadf00d;
u32 *fill = (u32 *)&retval[m_size];
const u32 *end = (u32 *)((((uptr)&retval[newsize - 1]) - 3) & ~0x3);
for (; fill < end; ++fill)
*fill = 0xbaadf00d;
}
return retval;
}
template< typename T >
template <typename T>
SafeArray<T>::~SafeArray() throw()
{
safe_free( m_ptr );
safe_free(m_ptr);
}
template< typename T >
SafeArray<T>::SafeArray( const wxChar* name )
: Name( name )
template <typename T>
SafeArray<T>::SafeArray(const wxChar *name)
: Name(name)
{
ChunkSize = DefaultChunkSize;
m_ptr = NULL;
m_size = 0;
}
template< typename T >
SafeArray<T>::SafeArray( int initialSize, const wxChar* name )
: Name( name )
template <typename T>
SafeArray<T>::SafeArray(int initialSize, const wxChar *name)
: Name(name)
{
ChunkSize = DefaultChunkSize;
m_ptr = (initialSize==0) ? NULL : (T*)malloc( initialSize * sizeof(T) );
m_ptr = (initialSize == 0) ? NULL : (T *)malloc(initialSize * sizeof(T));
m_size = initialSize;
if( (initialSize != 0) && (m_ptr == NULL) )
if ((initialSize != 0) && (m_ptr == NULL))
throw Exception::OutOfMemory(name)
.SetDiagMsg(wxsFormat(L"Called from 'SafeArray::ctor' [size=%d]", initialSize));
}
// Clears the contents of the array to zero, and frees all memory allocations.
template< typename T >
template <typename T>
void SafeArray<T>::Dispose()
{
m_size = 0;
safe_free( m_ptr );
safe_free(m_ptr);
}
template< typename T >
T* SafeArray<T>::_getPtr( uint i ) const
template <typename T>
T *SafeArray<T>::_getPtr(uint i) const
{
IndexBoundsAssumeDev( WX_STR(Name), i, m_size );
IndexBoundsAssumeDev(WX_STR(Name), i, m_size);
return &m_ptr[i];
}
// reallocates the array to the explicit size. Can be used to shrink or grow an
// array, and bypasses the internal threshold growth indicators.
template< typename T >
void SafeArray<T>::ExactAlloc( int newsize )
template <typename T>
void SafeArray<T>::ExactAlloc(int newsize)
{
if( newsize == m_size ) return;
if (newsize == m_size)
return;
m_ptr = _virtual_realloc( newsize );
if( m_ptr == NULL )
m_ptr = _virtual_realloc(newsize);
if (m_ptr == NULL)
throw Exception::OutOfMemory(Name)
.SetDiagMsg(wxsFormat(L"Called from 'SafeArray::ExactAlloc' [oldsize=%d] [newsize=%d]", m_size, newsize));
m_size = newsize;
}
template< typename T >
SafeArray<T>* SafeArray<T>::Clone() const
template <typename T>
SafeArray<T> *SafeArray<T>::Clone() const
{
SafeArray<T>* retval = new SafeArray<T>( m_size );
memcpy( retval->GetPtr(), m_ptr, sizeof(T) * m_size );
SafeArray<T> *retval = new SafeArray<T>(m_size);
memcpy(retval->GetPtr(), m_ptr, sizeof(T) * m_size);
return retval;
}
@ -126,40 +126,38 @@ SafeArray<T>* SafeArray<T>::Clone() const
// SafeAlignedArray<T> (implementations)
// --------------------------------------------------------------------------------------
template< typename T, uint Alignment >
T* SafeAlignedArray<T,Alignment>::_virtual_realloc( int newsize )
template <typename T, uint Alignment>
T *SafeAlignedArray<T, Alignment>::_virtual_realloc(int newsize)
{
return (T*)( ( this->m_ptr == NULL ) ?
_aligned_malloc( newsize * sizeof(T), Alignment ) :
pcsx2_aligned_realloc( this->m_ptr, newsize * sizeof(T), Alignment, this->m_size * sizeof(T) )
);
return (T *)((this->m_ptr == NULL) ?
_aligned_malloc(newsize * sizeof(T), Alignment) :
pcsx2_aligned_realloc(this->m_ptr, newsize * sizeof(T), Alignment, this->m_size * sizeof(T)));
}
// Appends "(align: xx)" to the name of the allocation in devel builds.
// Maybe useful,maybe not... no harm in attaching it. :D
template< typename T, uint Alignment >
SafeAlignedArray<T,Alignment>::~SafeAlignedArray() throw()
template <typename T, uint Alignment>
SafeAlignedArray<T, Alignment>::~SafeAlignedArray() throw()
{
safe_aligned_free( this->m_ptr );
safe_aligned_free(this->m_ptr);
// mptr is set to null, so the parent class's destructor won't re-free it.
}
template< typename T, uint Alignment >
SafeAlignedArray<T,Alignment>::SafeAlignedArray( int initialSize, const wxChar* name ) :
SafeArray<T>::SafeArray(
template <typename T, uint Alignment>
SafeAlignedArray<T, Alignment>::SafeAlignedArray(int initialSize, const wxChar *name)
: SafeArray<T>::SafeArray(
name,
(T*)_aligned_malloc( initialSize * sizeof(T), Alignment ),
initialSize
)
(T *)_aligned_malloc(initialSize * sizeof(T), Alignment),
initialSize)
{
}
template< typename T, uint Alignment >
SafeAlignedArray<T,Alignment>* SafeAlignedArray<T,Alignment>::Clone() const
template <typename T, uint Alignment>
SafeAlignedArray<T, Alignment> *SafeAlignedArray<T, Alignment>::Clone() const
{
SafeAlignedArray<T,Alignment>* retval = new SafeAlignedArray<T,Alignment>( this->m_size );
memcpy( retval->GetPtr(), this->m_ptr, sizeof(T) * this->m_size );
SafeAlignedArray<T, Alignment> *retval = new SafeAlignedArray<T, Alignment>(this->m_size);
memcpy(retval->GetPtr(), this->m_ptr, sizeof(T) * this->m_size);
return retval;
}
@ -167,21 +165,21 @@ SafeAlignedArray<T,Alignment>* SafeAlignedArray<T,Alignment>::Clone() const
// SafeList<T> (implementations)
// --------------------------------------------------------------------------------------
template< typename T >
T* SafeList<T>::_virtual_realloc( int newsize )
template <typename T>
T *SafeList<T>::_virtual_realloc(int newsize)
{
return (T*)realloc( m_ptr, newsize * sizeof(T) );
return (T *)realloc(m_ptr, newsize * sizeof(T));
}
template< typename T >
template <typename T>
SafeList<T>::~SafeList() throw()
{
safe_free( m_ptr );
safe_free(m_ptr);
}
template< typename T >
SafeList<T>::SafeList( const wxChar* name )
: Name( name )
template <typename T>
SafeList<T>::SafeList(const wxChar *name)
: Name(name)
{
ChunkSize = DefaultChunkSize;
m_ptr = NULL;
@ -189,74 +187,70 @@ SafeList<T>::SafeList( const wxChar* name )
m_length = 0;
}
template< typename T >
SafeList<T>::SafeList( int initialSize, const wxChar* name )
: Name( name )
template <typename T>
SafeList<T>::SafeList(int initialSize, const wxChar *name)
: Name(name)
{
ChunkSize = DefaultChunkSize;
m_allocsize = initialSize;
m_length = 0;
m_ptr = (T*)malloc( initialSize * sizeof(T) );
m_ptr = (T *)malloc(initialSize * sizeof(T));
if( m_ptr == NULL )
if (m_ptr == NULL)
throw Exception::OutOfMemory(Name)
.SetDiagMsg(wxsFormat(L"called from 'SafeList::ctor' [length=%d]", m_length));
for( int i=0; i<m_allocsize; ++i )
{
for (int i = 0; i < m_allocsize; ++i) {
new (&m_ptr[i]) T();
}
}
template< typename T >
T* SafeList<T>::_getPtr( uint i ) const
template <typename T>
T *SafeList<T>::_getPtr(uint i) const
{
IndexBoundsAssumeDev( WX_STR(Name), i, m_length );
IndexBoundsAssumeDev(WX_STR(Name), i, m_length);
return &m_ptr[i];
}
// Ensures that the allocation is large enough to fit data of the
// amount requested. The memory allocation is not resized smaller.
template< typename T >
void SafeList<T>::MakeRoomFor( int blockSize )
template <typename T>
void SafeList<T>::MakeRoomFor(int blockSize)
{
if( blockSize > m_allocsize )
{
if (blockSize > m_allocsize) {
const int newalloc = blockSize + ChunkSize;
m_ptr = _virtual_realloc( newalloc );
if( m_ptr == NULL )
m_ptr = _virtual_realloc(newalloc);
if (m_ptr == NULL)
throw Exception::OutOfMemory(Name)
.SetDiagMsg(wxsFormat(L"Called from 'SafeList::MakeRoomFor' [oldlen=%d] [newlen=%d]", m_length, blockSize));
for( ; m_allocsize<newalloc; ++m_allocsize )
{
for (; m_allocsize < newalloc; ++m_allocsize) {
new (&m_ptr[m_allocsize]) T();
}
}
}
// Appends an item to the end of the list and returns a handle to it.
template< typename T >
T& SafeList<T>::New()
template <typename T>
T &SafeList<T>::New()
{
_MakeRoomFor_threshold( m_length + 1 );
_MakeRoomFor_threshold(m_length + 1);
return m_ptr[m_length++];
}
template< typename T >
int SafeList<T>::Add( const T& src )
template <typename T>
int SafeList<T>::Add(const T &src)
{
_MakeRoomFor_threshold( m_length + 1 );
_MakeRoomFor_threshold(m_length + 1);
m_ptr[m_length] = src;
return m_length++;
}
// Same as Add, but returns the handle of the new object instead of it's array index.
template< typename T >
T& SafeList<T>::AddNew( const T& src )
template <typename T>
T &SafeList<T>::AddNew(const T &src)
{
_MakeRoomFor_threshold( m_length + 1 );
_MakeRoomFor_threshold(m_length + 1);
m_ptr[m_length] = src;
return m_ptr[m_length];
}
@ -264,26 +258,26 @@ T& SafeList<T>::AddNew( const T& src )
// Performs a standard array-copy removal of the given item. All items past the
// given item are copied over.
// DevBuilds : Generates assertion if the index is invalid.
template< typename T >
void SafeList<T>::Remove( int index )
template <typename T>
void SafeList<T>::Remove(int index)
{
IndexBoundsAssumeDev( Name.c_str(), index, m_length );
IndexBoundsAssumeDev(Name.c_str(), index, m_length);
int copylen = m_length - index;
if( copylen > 0 )
memcpy( &m_ptr[index], &m_ptr[index+1], copylen );
if (copylen > 0)
memcpy(&m_ptr[index], &m_ptr[index + 1], copylen);
}
template< typename T >
SafeList<T>* SafeList<T>::Clone() const
template <typename T>
SafeList<T> *SafeList<T>::Clone() const
{
SafeList<T>* retval = new SafeList<T>( m_length );
memcpy( retval->m_ptr, m_ptr, sizeof(T) * m_length );
SafeList<T> *retval = new SafeList<T>(m_length);
memcpy(retval->m_ptr, m_ptr, sizeof(T) * m_length);
return retval;
}
template< typename T >
void SafeList<T>::_MakeRoomFor_threshold( int newsize )
template <typename T>
void SafeList<T>::_MakeRoomFor_threshold(int newsize)
{
MakeRoomFor( newsize + ChunkSize );
MakeRoomFor(newsize + ChunkSize);
}

103
common/include/Utilities/ScopedAlloc.h
View File

@ -27,32 +27,32 @@
// Safe deallocation macros -- checks pointer validity (non-null) when needed, and sets
// pointer to null after deallocation.
#define safe_delete( ptr ) \
((void) (delete (ptr)), (ptr) = NULL)
#define safe_delete(ptr) \
((void)(delete (ptr)), (ptr) = NULL)
#define safe_delete_array( ptr ) \
((void) (delete[] (ptr)), (ptr) = NULL)
#define safe_delete_array(ptr) \
((void)(delete[](ptr)), (ptr) = NULL)
// No checks for NULL -- wxWidgets says it's safe to skip NULL checks and it runs on
// just about every compiler and libc implementation of any recentness.
#define safe_free( ptr ) \
( (void) (free( ptr ), !!0), (ptr) = NULL )
#define safe_free(ptr) \
((void)(free(ptr), !!0), (ptr) = NULL)
//((void) (( ( (ptr) != NULL ) && (free( ptr ), !!0) ), (ptr) = NULL))
#define safe_fclose( ptr ) \
((void) (( ( (ptr) != NULL ) && (fclose( ptr ), !!0) ), (ptr) = NULL))
#define safe_fclose(ptr) \
((void)((((ptr) != NULL) && (fclose(ptr), !!0)), (ptr) = NULL))
// Implementation note: all known implementations of _aligned_free check the pointer for
// NULL status (our implementation under GCC, and microsoft's under MSVC), so no need to
// do it here.
#define safe_aligned_free( ptr ) \
((void) ( _aligned_free( ptr ), (ptr) = NULL ))
#define safe_aligned_free(ptr) \
((void)(_aligned_free(ptr), (ptr) = NULL))
// aligned_malloc: Implement/declare linux equivalents here!
#if !defined(_MSC_VER)
extern void* __fastcall _aligned_malloc(size_t size, size_t align);
extern void* __fastcall pcsx2_aligned_realloc(void* handle, size_t new_size, size_t align, size_t old_size);
extern void _aligned_free(void* pmem);
extern void *__fastcall _aligned_malloc(size_t size, size_t align);
extern void *__fastcall pcsx2_aligned_realloc(void *handle, size_t new_size, size_t align, size_t old_size);
extern void _aligned_free(void *pmem);
#else
#define pcsx2_aligned_realloc(handle, new_size, align, old_size) \
_aligned_realloc(handle, new_size, align)
@ -62,8 +62,8 @@ extern void _aligned_free(void* pmem);
// pxDoOutOfMemory
// --------------------------------------------------------------------------------------
typedef void FnType_OutOfMemory( uptr blocksize );
typedef FnType_OutOfMemory* Fnptr_OutOfMemory;
typedef void FnType_OutOfMemory(uptr blocksize);
typedef FnType_OutOfMemory *Fnptr_OutOfMemory;
// This method is meant to be assigned by applications that link against pxWex. It is called
// (invoked) prior to most pxWex built-in memory/array classes throwing exceptions, and can be
@ -89,11 +89,11 @@ extern Fnptr_OutOfMemory pxDoOutOfMemory;
// destructing container for malloc. The entire class is almost completely dependency free,
// and thus can be included everywhere and anywhere without dependency hassles.
//
template< typename T >
template <typename T>
class BaseScopedAlloc
{
protected:
T* m_buffer;
T *m_buffer;
uint m_size;
public:
@ -117,47 +117,48 @@ public:
// Parameter:
// newSize - size of the new allocation, in elements (not bytes!). If the specified
// size is 0, the the allocation is freed, same as calling Free().
virtual void Alloc( size_t newsize )=0;
virtual void Alloc(size_t newsize) = 0;
// Re-sizes the allocation to the requested size, without any data loss.
// Parameter:
// newSize - size of the new allocation, in elements (not bytes!). If the specified
// size is 0, the the allocation is freed, same as calling Free().
virtual void Resize( size_t newsize )=0;
virtual void Resize(size_t newsize) = 0;
void Free()
{
Alloc( 0 );
Alloc(0);
}
// Makes enough room for the requested size. Existing data in the array is retained.
void MakeRoomFor( uint size )
void MakeRoomFor(uint size)
{
if (size <= m_size) return;
Resize( size );
if (size <= m_size)
return;
Resize(size);
}
T* GetPtr( uint idx=0 ) const
T *GetPtr(uint idx = 0) const
{
#if pxUSE_SECURE_MALLOC
IndexBoundsAssumeDev( "ScopedAlloc", idx, m_size );
#endif
#if pxUSE_SECURE_MALLOC
IndexBoundsAssumeDev("ScopedAlloc", idx, m_size);
#endif
return &m_buffer[idx];
}
T& operator[]( uint idx )
T &operator[](uint idx)
{
#if pxUSE_SECURE_MALLOC
IndexBoundsAssumeDev( "ScopedAlloc", idx, m_size );
#endif
#if pxUSE_SECURE_MALLOC
IndexBoundsAssumeDev("ScopedAlloc", idx, m_size);
#endif
return m_buffer[idx];
}
const T& operator[]( uint idx ) const
const T &operator[](uint idx) const
{
#if pxUSE_SECURE_MALLOC
IndexBoundsAssumeDev( "ScopedAlloc", idx, m_size );
#endif
#if pxUSE_SECURE_MALLOC
IndexBoundsAssumeDev("ScopedAlloc", idx, m_size);
#endif
return m_buffer[idx];
}
};
@ -171,13 +172,14 @@ public:
//
// See docs for BaseScopedAlloc for details and rationale.
//
template< typename T >
template <typename T>
class ScopedAlloc : public BaseScopedAlloc<T>
{
typedef BaseScopedAlloc<T> _parent;
public:
ScopedAlloc( size_t size=0 ) : _parent()
ScopedAlloc(size_t size = 0)
: _parent()
{
Alloc(size);
}
@ -187,21 +189,22 @@ public:
safe_free(this->m_buffer);
}
virtual void Alloc( size_t newsize )
virtual void Alloc(size_t newsize)
{
safe_free(this->m_buffer);
this->m_size = newsize;
if (!this->m_size) return;
if (!this->m_size)
return;
this->m_buffer = (T*)malloc( this->m_size * sizeof(T) );
this->m_buffer = (T *)malloc(this->m_size * sizeof(T));
if (!this->m_buffer)
throw Exception::OutOfMemory(L"ScopedAlloc");
}
virtual void Resize( size_t newsize )
virtual void Resize(size_t newsize)
{
this->m_size = newsize;
this->m_buffer = (T*)realloc(this->m_buffer, this->m_size * sizeof(T));
this->m_buffer = (T *)realloc(this->m_buffer, this->m_size * sizeof(T));
if (!this->m_buffer)
throw Exception::OutOfMemory(L"ScopedAlloc::Resize");
@ -219,13 +222,14 @@ public:
//
// See docs for BaseScopedAlloc for details and rationale.
//
template< typename T, uint align >
template <typename T, uint align>
class ScopedAlignedAlloc : public BaseScopedAlloc<T>
{
typedef BaseScopedAlloc<T> _parent;
public:
ScopedAlignedAlloc( size_t size=0 ) : _parent()
ScopedAlignedAlloc(size_t size = 0)
: _parent()
{
Alloc(size);
}
@ -235,20 +239,21 @@ public:
safe_aligned_free(this->m_buffer);
}
virtual void Alloc( size_t newsize )
virtual void Alloc(size_t newsize)
{
safe_aligned_free(this->m_buffer);
this->m_size = newsize;
if (!this->m_size) return;
if (!this->m_size)
return;
this->m_buffer = (T*)_aligned_malloc( this->m_size * sizeof(T), align );
this->m_buffer = (T *)_aligned_malloc(this->m_size * sizeof(T), align);
if (!this->m_buffer)
throw Exception::OutOfMemory(L"ScopedAlignedAlloc");
}
virtual void Resize( size_t newsize )
virtual void Resize(size_t newsize)
{
this->m_buffer = (T*)pcsx2_aligned_realloc(this->m_buffer, newsize * sizeof(T), align, this->m_size * sizeof(T));
this->m_buffer = (T *)pcsx2_aligned_realloc(this->m_buffer, newsize * sizeof(T), align, this->m_size * sizeof(T));
this->m_size = newsize;
if (!this->m_buffer)

39
common/include/Utilities/ScopedPtrMT.h
View File

@ -22,35 +22,36 @@ using Threading::ScopedLock;
// ScopedPtrMT
// --------------------------------------------------------------------------------------
template< typename T >
template <typename T>
class ScopedPtrMT
{
DeclareNoncopyableObject(ScopedPtrMT);
protected:
std::atomic<T*> m_ptr;
std::atomic<T *> m_ptr;
Threading::Mutex m_mtx;
public:
typedef T element_type;
wxEXPLICIT ScopedPtrMT(T * ptr = nullptr)
wxEXPLICIT ScopedPtrMT(T *ptr = nullptr)
{
m_ptr = ptr;
}
~ScopedPtrMT() throw() { _Delete_unlocked(); }
ScopedPtrMT& Reassign(T * ptr = nullptr)
ScopedPtrMT &Reassign(T *ptr = nullptr)
{
T* doh = m_ptr.exchange(ptr);
if ( ptr != doh ) delete doh;
T *doh = m_ptr.exchange(ptr);
if (ptr != doh)
delete doh;
return *this;
}
ScopedPtrMT& Delete() throw()
ScopedPtrMT &Delete() throw()
{
ScopedLock lock( m_mtx );
ScopedLock lock(m_mtx);
_Delete_unlocked();
}
@ -58,23 +59,23 @@ public:
// (ScopedPtr will be nullptr after this method)
T *DetachPtr()
{
ScopedLock lock( m_mtx );
ScopedLock lock(m_mtx);
return m_ptr.exchange(nullptr);
}
// Returns the managed pointer. Can return nullptr as a valid result if the ScopedPtrMT
// has no object in management.
T* GetPtr() const
T *GetPtr() const
{
return m_ptr;
}
void SwapPtr(ScopedPtrMT& other)
void SwapPtr(ScopedPtrMT &other)
{
ScopedLock lock( m_mtx );
ScopedLock lock(m_mtx);
m_ptr.exchange(other.m_ptr.exchange(m_ptr.load()));
T * const tmp = other.m_ptr;
T *const tmp = other.m_ptr;
other.m_ptr = m_ptr;
m_ptr = tmp;
}
@ -92,25 +93,25 @@ public:
}
// Equality
bool operator==(T* pT) const throw()
bool operator==(T *pT) const throw()
{
return m_ptr == pT;
}
// Inequality
bool operator!=(T* pT) const throw()
bool operator!=(T *pT) const throw()
{
return !operator==(pT);
}
// Convenient assignment operator. ScopedPtrMT = nullptr will issue an automatic deletion
// of the managed pointer.
ScopedPtrMT& operator=( T* src )
ScopedPtrMT &operator=(T *src)
{
return Reassign( src );
return Reassign(src);
}
#if 0
#if 0
operator T*() const
{
return m_ptr;
@ -129,7 +130,7 @@ public:
pxAssert(m_ptr != nullptr);
return m_ptr;
}
#endif
#endif
protected:
void _Delete_unlocked() throw()

110
common/include/Utilities/StringHelpers.h
View File

@ -22,10 +22,10 @@
#include <wx/tokenzr.h>
#if _WIN32
#define WX_STR(str) (str.wc_str())
#define WX_STR(str) (str.wc_str())
#else
// Stupid wx3.0 doesn't support c_str for vararg function
#define WX_STR(str) (static_cast<const char*>(str.c_str()))
#define WX_STR(str) (static_cast<const char *>(str.c_str()))
#endif
// --------------------------------------------------------------------------------------
@ -34,59 +34,59 @@
// Converts a string to UTF8 and provides an interface for getting its length.
class pxToUTF8
{
DeclareNoncopyableObject( pxToUTF8 );
DeclareNoncopyableObject(pxToUTF8);
protected:
wxCharBuffer m_result;
int m_length;
public:
explicit pxToUTF8(const wxString& src)
: m_result( src.ToUTF8() )
explicit pxToUTF8(const wxString &src)
: m_result(src.ToUTF8())
{
m_length = -1;
}
size_t Length()
{
if( -1 == m_length )
m_length = strlen( m_result );
if (-1 == m_length)
m_length = strlen(m_result);
return m_length;
}
void Convert( const wxString& src )
void Convert(const wxString &src)
{
m_result = src.ToUTF8();
m_length = -1;
}
const char* data() const { return m_result; }
const char *data() const { return m_result; }
operator const char*() const
operator const char *() const
{
return m_result.data();
}
};
extern void px_fputs( FILE* fp, const char* src );
extern void px_fputs(FILE *fp, const char *src);
// wxWidgets lacks one of its own...
extern const wxRect wxDefaultRect;
extern void SplitString( wxArrayString& dest, const wxString& src, const wxString& delims, wxStringTokenizerMode mode = wxTOKEN_RET_EMPTY_ALL );
extern wxString JoinString( const wxArrayString& src, const wxString& separator );
extern wxString JoinString( const wxChar** src, const wxString& separator );
extern void SplitString(wxArrayString &dest, const wxString &src, const wxString &delims, wxStringTokenizerMode mode = wxTOKEN_RET_EMPTY_ALL);
extern wxString JoinString(const wxArrayString &src, const wxString &separator);
extern wxString JoinString(const wxChar **src, const wxString &separator);
extern wxString ToString( const wxPoint& src, const wxString& separator=L"," );
extern wxString ToString( const wxSize& src, const wxString& separator=L"," );
extern wxString ToString( const wxRect& src, const wxString& separator=L"," );
extern wxString ToString(const wxPoint &src, const wxString &separator = L",");
extern wxString ToString(const wxSize &src, const wxString &separator = L",");
extern wxString ToString(const wxRect &src, const wxString &separator = L",");
extern bool TryParse( wxPoint& dest, const wxStringTokenizer& parts );
extern bool TryParse( wxSize& dest, const wxStringTokenizer& parts );
extern bool TryParse(wxPoint &dest, const wxStringTokenizer &parts);
extern bool TryParse(wxSize &dest, const wxStringTokenizer &parts);
extern bool TryParse( wxPoint& dest, const wxString& src, const wxPoint& defval=wxDefaultPosition, const wxString& separators=L",");
extern bool TryParse( wxSize& dest, const wxString& src, const wxSize& defval=wxDefaultSize, const wxString& separators=L",");
extern bool TryParse( wxRect& dest, const wxString& src, const wxRect& defval=wxDefaultRect, const wxString& separators=L",");
extern bool TryParse(wxPoint &dest, const wxString &src, const wxPoint &defval = wxDefaultPosition, const wxString &separators = L",");
extern bool TryParse(wxSize &dest, const wxString &src, const wxSize &defval = wxDefaultSize, const wxString &separators = L",");
extern bool TryParse(wxRect &dest, const wxString &src, const wxRect &defval = wxDefaultRect, const wxString &separators = L",");
// --------------------------------------------------------------------------------------
// ParsedAssignmentString
@ -108,7 +108,7 @@ struct ParsedAssignmentString
wxString rvalue;
bool IsComment;
ParsedAssignmentString( const wxString& src );
ParsedAssignmentString(const wxString &src);
};
// ======================================================================================
@ -145,33 +145,33 @@ protected:
public:
FastFormatAscii();
~FastFormatAscii() throw();
FastFormatAscii& Write( const char* fmt, ... );
FastFormatAscii& WriteV( const char* fmt, va_list argptr );
FastFormatAscii &Write(const char *fmt, ...);
FastFormatAscii &WriteV(const char *fmt, va_list argptr);
void Clear();
bool IsEmpty() const;
const char* c_str() const { return m_dest.GetPtr(); }
operator const char*() const { return m_dest.GetPtr(); }
const char *c_str() const { return m_dest.GetPtr(); }
operator const char *() const { return m_dest.GetPtr(); }
const wxString GetString() const;
//operator wxString() const;
FastFormatAscii& operator+=(const wxString& s)
FastFormatAscii &operator+=(const wxString &s)
{
Write( "%s", WX_STR(s) );
Write("%s", WX_STR(s));
return *this;
}
FastFormatAscii& operator+=(const wxChar* psz )
FastFormatAscii &operator+=(const wxChar *psz)
{
Write( "%ls", psz );
Write("%ls", psz);
return *this;
}
FastFormatAscii& operator+=(const char* psz )
FastFormatAscii &operator+=(const char *psz)
{
Write( "%s", psz );
Write("%s", psz);
return *this;
}
};
@ -189,50 +189,50 @@ public:
FastFormatUnicode();
~FastFormatUnicode() throw();
FastFormatUnicode& Write( const char* fmt, ... );
FastFormatUnicode& Write( const wxChar* fmt, ... );
FastFormatUnicode& Write( const wxString fmt, ... );
FastFormatUnicode& WriteV( const char* fmt, va_list argptr );
FastFormatUnicode& WriteV( const wxChar* fmt, va_list argptr );
FastFormatUnicode &Write(const char *fmt, ...);
FastFormatUnicode &Write(const wxChar *fmt, ...);
FastFormatUnicode &Write(const wxString fmt, ...);
FastFormatUnicode &WriteV(const char *fmt, va_list argptr);
FastFormatUnicode &WriteV(const wxChar *fmt, va_list argptr);
void Clear();
bool IsEmpty() const;
uint Length() const { return m_Length; }
FastFormatUnicode& ToUpper();
FastFormatUnicode& ToLower();
FastFormatUnicode &ToUpper();
FastFormatUnicode &ToLower();
const wxChar* c_str() const { return (const wxChar*)m_dest.GetPtr(); }
operator const wxChar*() const { return (const wxChar*)m_dest.GetPtr(); }
operator wxString() const { return (const wxChar*)m_dest.GetPtr(); }
const wxChar *c_str() const { return (const wxChar *)m_dest.GetPtr(); }
operator const wxChar *() const { return (const wxChar *)m_dest.GetPtr(); }
operator wxString() const { return (const wxChar *)m_dest.GetPtr(); }
FastFormatUnicode& operator+=(const wxString& s)
FastFormatUnicode &operator+=(const wxString &s)
{
Write( L"%s", WX_STR(s) );
Write(L"%s", WX_STR(s));
return *this;
}
FastFormatUnicode& operator+=(const wxChar* psz )
FastFormatUnicode &operator+=(const wxChar *psz)
{
Write( L"%s", psz );
Write(L"%s", psz);
return *this;
}
FastFormatUnicode& operator+=(const char* psz );
FastFormatUnicode &operator+=(const char *psz);
};
extern bool pxParseAssignmentString( const wxString& src, wxString& ldest, wxString& rdest );
extern bool pxParseAssignmentString(const wxString &src, wxString &ldest, wxString &rdest);
#define pxsFmt FastFormatUnicode().Write
#define pxsFmtV FastFormatUnicode().WriteV
#define pxsPtr(ptr) pxsFmt("0x%08X", (ptr)).c_str()
extern wxString& operator+=(wxString& str1, const FastFormatUnicode& str2);
extern wxString operator+(const wxString& str1, const FastFormatUnicode& str2);
extern wxString operator+(const wxChar* str1, const FastFormatUnicode& str2);
extern wxString operator+(const FastFormatUnicode& str1, const wxString& str2);
extern wxString operator+(const FastFormatUnicode& str1, const wxChar* str2);
extern wxString &operator+=(wxString &str1, const FastFormatUnicode &str2);
extern wxString operator+(const wxString &str1, const FastFormatUnicode &str2);
extern wxString operator+(const wxChar *str1, const FastFormatUnicode &str2);
extern wxString operator+(const FastFormatUnicode &str1, const wxString &str2);
extern wxString operator+(const FastFormatUnicode &str1, const wxChar *str2);
//////////////////////////////////////////////////////////////////////////////////////////
@ -241,4 +241,4 @@ extern wxString operator+(const FastFormatUnicode& str1, const wxChar* str2);
// These functions are useful since they are ASCII always, even under Unicode. Typically
// even in a unicode app.
extern void ssappendf(std::string& dest, const char* format, ...);
extern void ssappendf(std::string &dest, const char *format, ...);

296
common/include/Utilities/Threading.h
View File

@ -29,7 +29,7 @@
#undef Yield // release the burden of windows.h global namespace spam.
#define AffinityAssert_AllowFrom_MainUI() \
pxAssertMsg( wxThread::IsMain(), "Thread affinity violation: Call allowed from main thread only." )
pxAssertMsg(wxThread::IsMain(), "Thread affinity violation: Call allowed from main thread only.")
// --------------------------------------------------------------------------------------
// pxThreadLog / ConsoleLogSource_Threading
@ -44,14 +44,17 @@ public:
ConsoleLogSource_Threading();
bool Write( const wxString& thrname, const wxChar* msg ) {
return _parent::Write( wxsFormat(L"(thread:%s) ", WX_STR(thrname)) + msg );
bool Write(const wxString &thrname, const wxChar *msg)
{
return _parent::Write(wxsFormat(L"(thread:%s) ", WX_STR(thrname)) + msg);
}
bool Warn( const wxString& thrname, const wxChar* msg ) {
return _parent::Warn( wxsFormat(L"(thread:%s) ", WX_STR(thrname)) + msg );
bool Warn(const wxString &thrname, const wxChar *msg)
{
return _parent::Warn(wxsFormat(L"(thread:%s) ", WX_STR(thrname)) + msg);
}
bool Error( const wxString& thrname, const wxChar* msg ) {
return _parent::Error( wxsFormat(L"(thread:%s) ", WX_STR(thrname)) + msg );
bool Error(const wxString &thrname, const wxChar *msg)
{
return _parent::Error(wxsFormat(L"(thread:%s) ", WX_STR(thrname)) + msg);
}
};
@ -69,50 +72,51 @@ extern ConsoleLogSource_Threading pxConLog_Thread;
//#define PCSX2_THREAD_LOCAL 0 // uncomment this line to force-disable native TLS (useful for testing TlsVariable on windows/linux)
#ifndef PCSX2_THREAD_LOCAL
# define PCSX2_THREAD_LOCAL 1
#define PCSX2_THREAD_LOCAL 1
#endif
class wxTimeSpan;
namespace Threading
{
class pxThread;
class RwMutex;
class pxThread;
class RwMutex;
extern void pxTestCancel();
extern pxThread* pxGetCurrentThread();
extern wxString pxGetCurrentThreadName();
extern u64 GetThreadCpuTime();
extern u64 GetThreadTicksPerSecond();
extern void pxTestCancel();
extern pxThread *pxGetCurrentThread();
extern wxString pxGetCurrentThreadName();
extern u64 GetThreadCpuTime();
extern u64 GetThreadTicksPerSecond();
// Yields the current thread and provides cancellation points if the thread is managed by
// pxThread. Unmanaged threads use standard Sleep.
extern void pxYield( int ms );
// Yields the current thread and provides cancellation points if the thread is managed by
// pxThread. Unmanaged threads use standard Sleep.
extern void pxYield(int ms);
}
namespace Exception
{
class BaseThreadError : public RuntimeError
class BaseThreadError : public RuntimeError
{
DEFINE_EXCEPTION_COPYTORS(BaseThreadError, RuntimeError)
DEFINE_EXCEPTION_MESSAGES(BaseThreadError)
public:
Threading::pxThread *m_thread;
protected:
BaseThreadError()
{
DEFINE_EXCEPTION_COPYTORS( BaseThreadError, RuntimeError )
DEFINE_EXCEPTION_MESSAGES( BaseThreadError )
public:
Threading::pxThread* m_thread;
protected:
BaseThreadError() {
m_thread = NULL;
}
public:
explicit BaseThreadError( Threading::pxThread* _thread )
public:
explicit BaseThreadError(Threading::pxThread *_thread)
{
m_thread = _thread;
m_message_diag = L"An unspecified thread-related error occurred (thread=%s)";
}
explicit BaseThreadError( Threading::pxThread& _thread )
explicit BaseThreadError(Threading::pxThread &_thread)
{
m_thread = &_thread;
m_message_diag = L"An unspecified thread-related error occurred (thread=%s)";
@ -121,27 +125,27 @@ namespace Exception
virtual wxString FormatDiagnosticMessage() const;
virtual wxString FormatDisplayMessage() const;
Threading::pxThread& Thread();
const Threading::pxThread& Thread() const;
};
Threading::pxThread &Thread();
const Threading::pxThread &Thread() const;
};
class ThreadCreationError : public BaseThreadError
{
DEFINE_EXCEPTION_COPYTORS( ThreadCreationError, BaseThreadError )
class ThreadCreationError : public BaseThreadError
{
DEFINE_EXCEPTION_COPYTORS(ThreadCreationError, BaseThreadError)
public:
explicit ThreadCreationError( Threading::pxThread* _thread )
public:
explicit ThreadCreationError(Threading::pxThread *_thread)
{
m_thread = _thread;
SetBothMsgs( L"Thread creation failure. An unspecified error occurred while trying to create the %s thread." );
SetBothMsgs(L"Thread creation failure. An unspecified error occurred while trying to create the %s thread.");
}
explicit ThreadCreationError( Threading::pxThread& _thread )
explicit ThreadCreationError(Threading::pxThread &_thread)
{
m_thread = &_thread;
SetBothMsgs( L"Thread creation failure. An unspecified error occurred while trying to create the %s thread." );
SetBothMsgs(L"Thread creation failure. An unspecified error occurred while trying to create the %s thread.");
}
};
};
}
@ -153,22 +157,22 @@ namespace Threading
// The following set of documented functions have Linux/Win32 specific implementations,
// which are found in WinThreads.cpp and LnxThreads.cpp
// Releases a timeslice to other threads.
extern void Timeslice();
// Releases a timeslice to other threads.
extern void Timeslice();
// For use in spin/wait loops.
extern void SpinWait();
// For use in spin/wait loops.
extern void SpinWait();
// Optional implementation to enable hires thread/process scheduler for the operating system.
// Needed by Windows, but might not be relevant to other platforms.
extern void EnableHiresScheduler();
extern void DisableHiresScheduler();
// Optional implementation to enable hires thread/process scheduler for the operating system.
// Needed by Windows, but might not be relevant to other platforms.
extern void EnableHiresScheduler();
extern void DisableHiresScheduler();
// sleeps the current thread for the given number of milliseconds.
extern void Sleep( int ms );
// sleeps the current thread for the given number of milliseconds.
extern void Sleep(int ms);
// pthread Cond is an evil api that is not suited for Pcsx2 needs.
// Let's not use it. Use mutexes and semaphores instead to create waits. (Air)
// pthread Cond is an evil api that is not suited for Pcsx2 needs.
// Let's not use it. Use mutexes and semaphores instead to create waits. (Air)
#if 0
struct WaitEvent
{
@ -194,12 +198,12 @@ namespace Threading
// If TryAcquire() returns true, you've locked the object and are *responsible* for unlocking
// it later.
//
class NonblockingMutex
{
protected:
class NonblockingMutex
{
protected:
std::atomic_flag val;
public:
public:
NonblockingMutex() { val.clear(); }
virtual ~NonblockingMutex() throw() {}
@ -210,17 +214,20 @@ namespace Threading
// Can be done with a TryAcquire/Release but it is likely better to do it outside of the object
bool IsLocked()
{ pxAssertMsg(0, "IsLocked isn't supported for NonblockingMutex"); return false; }
{
pxAssertMsg(0, "IsLocked isn't supported for NonblockingMutex");
return false;
}
void Release()
{
val.clear();
}
};
};
class Semaphore
{
protected:
class Semaphore
{
protected:
#ifdef __APPLE__
semaphore_t m_sema;
int m_counter;
@ -228,30 +235,30 @@ namespace Threading
sem_t m_sema;
#endif
public:
public:
Semaphore();
virtual ~Semaphore() throw();
void Reset();
void Post();
void Post( int multiple );
void Post(int multiple);
void WaitWithoutYield();
bool WaitWithoutYield( const wxTimeSpan& timeout );
bool WaitWithoutYield(const wxTimeSpan &timeout);
void WaitNoCancel();
void WaitNoCancel( const wxTimeSpan& timeout );
void WaitNoCancel(const wxTimeSpan &timeout);
int Count();
void Wait();
bool Wait( const wxTimeSpan& timeout );
};
bool Wait(const wxTimeSpan &timeout);
};
class Mutex
{
protected:
class Mutex
{
protected:
pthread_mutex_t m_mutex;
public:
public:
Mutex();
virtual ~Mutex() throw();
virtual bool IsRecursive() const { return false; }
@ -261,114 +268,117 @@ namespace Threading
void Detach();
void Acquire();
bool Acquire( const wxTimeSpan& timeout );
bool Acquire(const wxTimeSpan &timeout);
bool TryAcquire();
void Release();
void AcquireWithoutYield();
bool AcquireWithoutYield( const wxTimeSpan& timeout );
bool AcquireWithoutYield(const wxTimeSpan &timeout);
void Wait();
bool Wait( const wxTimeSpan& timeout );
bool Wait(const wxTimeSpan &timeout);
void WaitWithoutYield();
bool WaitWithoutYield( const wxTimeSpan& timeout );
bool WaitWithoutYield(const wxTimeSpan &timeout);
protected:
protected:
// empty constructor used by MutexLockRecursive
Mutex( bool ) {}
};
Mutex(bool) {}
};
class MutexRecursive : public Mutex
{
public:
class MutexRecursive : public Mutex
{
public:
MutexRecursive();
virtual ~MutexRecursive() throw();
virtual bool IsRecursive() const { return true; }
};
};
// --------------------------------------------------------------------------------------
// ScopedLock
// --------------------------------------------------------------------------------------
// Helper class for using Mutexes. Using this class provides an exception-safe (and
// generally clean) method of locking code inside a function or conditional block. The lock
// will be automatically released on any return or exit from the function.
//
// Const qualification note:
// ScopedLock takes const instances of the mutex, even though the mutex is modified
// by locking and unlocking. Two rationales:
//
// 1) when designing classes with accessors (GetString, GetValue, etc) that need mutexes,
// this class needs a const hack to allow those accessors to be const (which is typically
// *very* important).
//
// 2) The state of the Mutex is guaranteed to be unchanged when the calling function or
// scope exits, by any means. Only via manual calls to Release or Acquire does that
// change, and typically those are only used in very special circumstances of their own.
//
class ScopedLock
{
// --------------------------------------------------------------------------------------
// ScopedLock
// --------------------------------------------------------------------------------------
// Helper class for using Mutexes. Using this class provides an exception-safe (and
// generally clean) method of locking code inside a function or conditional block. The lock
// will be automatically released on any return or exit from the function.
//
// Const qualification note:
// ScopedLock takes const instances of the mutex, even though the mutex is modified
// by locking and unlocking. Two rationales:
//
// 1) when designing classes with accessors (GetString, GetValue, etc) that need mutexes,
// this class needs a const hack to allow those accessors to be const (which is typically
// *very* important).
//
// 2) The state of the Mutex is guaranteed to be unchanged when the calling function or
// scope exits, by any means. Only via manual calls to Release or Acquire does that
// change, and typically those are only used in very special circumstances of their own.
//
class ScopedLock
{
DeclareNoncopyableObject(ScopedLock);
protected:
Mutex* m_lock;
protected:
Mutex *m_lock;
bool m_IsLocked;
public:
public:
virtual ~ScopedLock() throw();
explicit ScopedLock( const Mutex* locker=NULL );
explicit ScopedLock( const Mutex& locker );
void AssignAndLock( const Mutex& locker );
void AssignAndLock( const Mutex* locker );
explicit ScopedLock(const Mutex *locker = NULL);
explicit ScopedLock(const Mutex &locker);
void AssignAndLock(const Mutex &locker);
void AssignAndLock(const Mutex *locker);
void Assign( const Mutex& locker );
void Assign( const Mutex* locker );
void Assign(const Mutex &locker);
void Assign(const Mutex *locker);
void Release();
void Acquire();
bool IsLocked() const { return m_IsLocked; }
protected:
protected:
// Special constructor used by ScopedTryLock
ScopedLock( const Mutex& locker, bool isTryLock );
};
ScopedLock(const Mutex &locker, bool isTryLock);
};
class ScopedTryLock : public ScopedLock
class ScopedTryLock : public ScopedLock
{
public:
ScopedTryLock(const Mutex &locker)
: ScopedLock(locker, true)
{
public:
ScopedTryLock( const Mutex& locker ) : ScopedLock( locker, true ) { }
}
virtual ~ScopedTryLock() throw() {}
bool Failed() const { return !m_IsLocked; }
};
};
// --------------------------------------------------------------------------------------
// ScopedNonblockingLock
// --------------------------------------------------------------------------------------
// A ScopedTryLock branded for use with Nonblocking mutexes. See ScopedTryLock for details.
//
class ScopedNonblockingLock
{
class ScopedNonblockingLock
{
DeclareNoncopyableObject(ScopedNonblockingLock);
protected:
NonblockingMutex& m_lock;
protected:
NonblockingMutex &m_lock;
bool m_IsLocked;
public:
ScopedNonblockingLock( NonblockingMutex& locker ) :
m_lock( locker )
, m_IsLocked( m_lock.TryAcquire() )
public:
ScopedNonblockingLock(NonblockingMutex &locker)
: m_lock(locker)
, m_IsLocked(m_lock.TryAcquire())
{
}
virtual ~ScopedNonblockingLock() throw()
{
if( m_IsLocked )
if (m_IsLocked)
m_lock.Release();
}
bool Failed() const { return !m_IsLocked; }
};
};
// --------------------------------------------------------------------------------------
// ScopedLockBool
@ -377,26 +387,30 @@ namespace Threading
// Note that the isLockedBool should only be used as an indicator for the locked status,
// and not actually depended on for thread synchronization...
struct ScopedLockBool {
struct ScopedLockBool
{
ScopedLock m_lock;
std::atomic<bool>& m_bool;
std::atomic<bool> &m_bool;
ScopedLockBool(Mutex& mutexToLock, std::atomic<bool>& isLockedBool)
: m_lock(mutexToLock),
m_bool(isLockedBool) {
ScopedLockBool(Mutex &mutexToLock, std::atomic<bool> &isLockedBool)
: m_lock(mutexToLock)
, m_bool(isLockedBool)
{
m_bool.store(m_lock.IsLocked(), std::memory_order_relaxed);
}
virtual ~ScopedLockBool() throw() {
virtual ~ScopedLockBool() throw()
{
m_bool.store(false, std::memory_order_relaxed);
}
void Acquire() {
void Acquire()
{
m_lock.Acquire();
m_bool.store(m_lock.IsLocked(), std::memory_order_relaxed);
}
void Release() {
void Release()
{
m_bool.store(false, std::memory_order_relaxed);
m_lock.Release();
}
};
};
}

35
common/include/Utilities/ThreadingDialogs.h
View File

@ -22,32 +22,31 @@ wxDECLARE_EVENT(pxEvt_ThreadedTaskComplete, wxCommandEvent);
namespace Threading
{
// --------------------------------------------------------------------------------------
// WaitForTaskDialog
// --------------------------------------------------------------------------------------
// This dialog is displayed whenever the main thread is recursively waiting on multiple
// mutexes or semaphores. wxwidgets does not support recursive yielding to pending events
// but it *does* support opening a modal dialog, which disables the interface (preventing
// the user from starting additional actions), and processes messages (allowing the system
// to continue to manage threads and process logging).
//
class WaitForTaskDialog : public wxDialogWithHelpers
{
// --------------------------------------------------------------------------------------
// WaitForTaskDialog
// --------------------------------------------------------------------------------------
// This dialog is displayed whenever the main thread is recursively waiting on multiple
// mutexes or semaphores. wxwidgets does not support recursive yielding to pending events
// but it *does* support opening a modal dialog, which disables the interface (preventing
// the user from starting additional actions), and processes messages (allowing the system
// to continue to manage threads and process logging).
//
class WaitForTaskDialog : public wxDialogWithHelpers
{
DECLARE_DYNAMIC_CLASS_NO_COPY(WaitForTaskDialog)
typedef wxDialogWithHelpers _parent;
protected:
protected:
SynchronousActionState m_sync;
public:
WaitForTaskDialog( const wxString& title=wxEmptyString, const wxString& heading=wxEmptyString );
public:
WaitForTaskDialog(const wxString &title = wxEmptyString, const wxString &heading = wxEmptyString);
virtual ~WaitForTaskDialog() throw() {}
virtual int ShowModal();
protected:
void OnTaskComplete( wxCommandEvent& evt );
protected:
void OnTaskComplete(wxCommandEvent &evt);
//void OnTimer( wxTimerEvent& evt );
};
};
}

91
common/include/Utilities/TlsVariable.inl
View File

@ -18,9 +18,9 @@
#include "Threading.h"
#if PCSX2_THREAD_LOCAL
# define DeclareTls(x) __threadlocal x
#define DeclareTls(x) __threadlocal x
#else
# define DeclareTls(x) Threading::TlsVariable<x>
#define DeclareTls(x) Threading::TlsVariable<x>
#endif
namespace Threading
@ -38,7 +38,7 @@ namespace Threading
// result in repeated calls to pthread_getspecific. (if the function inlines then it
// should actually optimize well enough, but I doubt it does).
//
template< typename T >
template <typename T>
class BaseTlsVariable
{
DeclareNoncopyableObject(BaseTlsVariable<T>);
@ -55,16 +55,15 @@ public:
Dispose();
}
T* GetPtr() const;
T& GetRef() const { return *GetPtr(); }
T *GetPtr() const;
T &GetRef() const { return *GetPtr(); }
operator T&() const { return GetRef(); }
T* operator->() const { return GetPtr(); }
operator T &() const { return GetRef(); }
T *operator->() const { return GetPtr(); }
void Dispose()
{
if (!m_IsDisposed)
{
if (!m_IsDisposed) {
m_IsDisposed = true;
KillKey();
}
@ -74,20 +73,21 @@ protected:
void CreateKey();
void KillKey();
virtual void CreateInstance( T* result ) const
virtual void CreateInstance(T *result) const
{
new (result) T();
}
static void _aligned_delete_and_free( void* ptr )
static void _aligned_delete_and_free(void *ptr)
{
if (!ptr) return;
((T*)ptr)->~T();
if (!ptr)
return;
((T *)ptr)->~T();
_aligned_free(ptr);
}
};
template< typename T >
template <typename T>
class TlsVariable : public BaseTlsVariable<T>
{
DeclareNoncopyableObject(TlsVariable<T>);
@ -97,8 +97,10 @@ protected:
public:
TlsVariable() {}
TlsVariable( const T& initval )
: m_initval(initval) { }
TlsVariable(const T &initval)
: m_initval(initval)
{
}
// This is needed; The C++ standard likes making life suck for programmers.
using BaseTlsVariable<T>::GetRef;
@ -115,75 +117,74 @@ public:
this->m_IsDisposed = true;
}
TlsVariable<T>& operator=( const T& src )
TlsVariable<T> &operator=(const T &src)
{
GetRef() = src;
return *this;
}
bool operator==( const T& src ) const { return GetRef() == src; }
bool operator!=( const T& src ) const { return GetRef() != src; }
bool operator>( const T& src ) const { return GetRef() > src; }
bool operator<( const T& src ) const { return GetRef() < src; }
bool operator>=( const T& src ) const { return GetRef() >= src; }
bool operator<=( const T& src ) const { return GetRef() <= src; }
bool operator==(const T &src) const { return GetRef() == src; }
bool operator!=(const T &src) const { return GetRef() != src; }
bool operator>(const T &src) const { return GetRef() > src; }
bool operator<(const T &src) const { return GetRef() < src; }
bool operator>=(const T &src) const { return GetRef() >= src; }
bool operator<=(const T &src) const { return GetRef() <= src; }
T operator+( const T& src ) const { return GetRef() + src; }
T operator-( const T& src ) const { return GetRef() - src; }
T operator+(const T &src) const { return GetRef() + src; }
T operator-(const T &src) const { return GetRef() - src; }
void operator+=( const T& src ) { GetRef() += src; }
void operator-=( const T& src ) { GetRef() -= src; }
void operator+=(const T &src) { GetRef() += src; }
void operator-=(const T &src) { GetRef() -= src; }
protected:
virtual void CreateInstance( T* result ) const
virtual void CreateInstance(T *result) const
{
new (result) T(m_initval);
}
};
};
template< typename T >
template <typename T>
Threading::BaseTlsVariable<T>::BaseTlsVariable()
{
m_IsDisposed = false;
CreateKey();
}
template< typename T >
template <typename T>
void Threading::BaseTlsVariable<T>::KillKey()
{
if (!m_thread_key) return;
if (!m_thread_key)
return;
// Delete the handle for the current thread (which should always be the main/UI thread!)
// This is needed because pthreads does *not* clean up the dangling objects when you delete
// the key. The TLS for the process main thread will only be deleted when the process
// ends; which is too damn late (it shows up int he leaked memory blocks).
BaseTlsVariable<T>::_aligned_delete_and_free( pthread_getspecific(m_thread_key) );
BaseTlsVariable<T>::_aligned_delete_and_free(pthread_getspecific(m_thread_key));
pthread_key_delete( m_thread_key );
pthread_key_delete(m_thread_key);
m_thread_key = 0;
}
template< typename T >
T* Threading::BaseTlsVariable<T>::GetPtr() const
template <typename T>
T *Threading::BaseTlsVariable<T>::GetPtr() const
{
T* result = (T*)pthread_getspecific( m_thread_key );
if( result == NULL )
{
pthread_setspecific( m_thread_key, result = (T*)_aligned_malloc(sizeof(T), 16) );
T *result = (T *)pthread_getspecific(m_thread_key);
if (result == NULL) {
pthread_setspecific(m_thread_key, result = (T *)_aligned_malloc(sizeof(T), 16));
CreateInstance(result);
if( result == NULL )
throw Exception::OutOfMemory( L"thread local storage variable instance" );
if (result == NULL)
throw Exception::OutOfMemory(L"thread local storage variable instance");
}
return result;
}
template< typename T >
template <typename T>
void Threading::BaseTlsVariable<T>::CreateKey()
{
if( 0 != pthread_key_create(&m_thread_key, BaseTlsVariable<T>::_aligned_delete_and_free) )
{
pxFailRel( "Thread Local Storage Error: key creation failed. This will most likely lead to a rapid application crash." );
if (0 != pthread_key_create(&m_thread_key, BaseTlsVariable<T>::_aligned_delete_and_free)) {
pxFailRel("Thread Local Storage Error: key creation failed. This will most likely lead to a rapid application crash.");
}
}

141
common/include/Utilities/TraceLog.h
View File

@ -30,13 +30,13 @@
struct TraceLogDescriptor
{
// short name, alphanumerics only: used for saving/loading options.
const wxChar* ShortName;
const wxChar *ShortName;
// Standard UI name for this log source. Used in menus, options dialogs.
const wxChar* Name;
const wxChar *Name;
// Length description for use as a tooltip or menu item description.
const wxChar* Description;
const wxChar *Description;
wxString GetShortName() const
{
@ -66,7 +66,7 @@ struct TraceLogDescriptor
class BaseTraceLogSource
{
protected:
const TraceLogDescriptor* m_Descriptor;
const TraceLogDescriptor *m_Descriptor;
public:
// Indicates if the user has enabled this specific log. This boolean only represents
@ -77,14 +77,18 @@ public:
bool Enabled;
protected:
BaseTraceLogSource() : m_Descriptor(NULL), Enabled(false) {}
BaseTraceLogSource()
: m_Descriptor(NULL)
, Enabled(false)
{
}
public:
TraceLog_ImplementBaseAPI(BaseTraceLogSource)
BaseTraceLogSource( const TraceLogDescriptor* desc )
BaseTraceLogSource(const TraceLogDescriptor *desc)
{
pxAssumeDev( desc, "Trace logs must have a valid (non-NULL) descriptor." );
pxAssumeDev(desc, "Trace logs must have a valid (non-NULL) descriptor.");
Enabled = false;
m_Descriptor = desc;
}
@ -100,14 +104,13 @@ public:
virtual bool IsActive() const { return Enabled; }
virtual wxString GetShortName() const { return m_Descriptor->GetShortName(); }
virtual const wxChar* GetName() const { return m_Descriptor->Name; }
virtual const wxChar* GetDescription() const
virtual const wxChar *GetName() const { return m_Descriptor->Name; }
virtual const wxChar *GetDescription() const
{
return (m_Descriptor->Description!=NULL) ? pxGetTranslation(m_Descriptor->Description) : wxEmptyString;
return (m_Descriptor->Description != NULL) ? pxGetTranslation(m_Descriptor->Description) : wxEmptyString;
}
virtual bool HasDescription() const { return m_Descriptor->Description != NULL;}
virtual bool HasDescription() const { return m_Descriptor->Description != NULL; }
};
// --------------------------------------------------------------------------------------
@ -119,32 +122,32 @@ public:
class TextFileTraceLog : public BaseTraceLogSource
{
public:
TextFileTraceLog( const TraceLogDescriptor* desc )
: BaseTraceLogSource( desc )
TextFileTraceLog(const TraceLogDescriptor *desc)
: BaseTraceLogSource(desc)
{
}
bool Write( const char* fmt, ... ) const
bool Write(const char *fmt, ...) const
{
va_list list;
va_start( list, fmt );
WriteV( fmt, list );
va_end( list );
va_start(list, fmt);
WriteV(fmt, list);
va_end(list);
return false;
}
bool WriteV( const char *fmt, va_list list ) const
bool WriteV(const char *fmt, va_list list) const
{
FastFormatAscii ascii;
ApplyPrefix(ascii);
ascii.WriteV( fmt, list );
DoWrite( ascii );
ascii.WriteV(fmt, list);
DoWrite(ascii);
return false;
}
virtual void ApplyPrefix( FastFormatAscii& ascii ) const {}
virtual void DoWrite( const char* fmt ) const=0;
virtual void ApplyPrefix(FastFormatAscii &ascii) const {}
virtual void DoWrite(const char *fmt) const = 0;
};
// --------------------------------------------------------------------------------------
@ -159,12 +162,15 @@ public:
ConsoleColors DefaultColor;
protected:
ConsoleLogSource() : DefaultColor(Color_Gray) {}
ConsoleLogSource()
: DefaultColor(Color_Gray)
{
}
public:
ConsoleLog_ImplementBaseAPI(ConsoleLogSource)
ConsoleLogSource( const TraceLogDescriptor* desc, ConsoleColors defaultColor = Color_Gray )
ConsoleLogSource(const TraceLogDescriptor *desc, ConsoleColors defaultColor = Color_Gray)
: BaseTraceLogSource(desc)
{
DefaultColor = defaultColor;
@ -173,111 +179,110 @@ public:
// Writes to the console using the source's default color. Note that the source's default
// color will always be used, thus ConsoleColorScope() will not be effectual unless the
// console's default color is Color_Default.
bool Write( const char* fmt, ... ) const
bool Write(const char *fmt, ...) const
{
va_list list;
va_start( list, fmt );
WriteV( fmt, list );
va_end( list );
va_start(list, fmt);
WriteV(fmt, list);
va_end(list);
return false;
}
bool Write( const wxChar* fmt, ... ) const
bool Write(const wxChar *fmt, ...) const
{
va_list list;
va_start( list, fmt );
WriteV( fmt, list );
va_end( list );
va_start(list, fmt);
WriteV(fmt, list);
va_end(list);
return false;
}
bool Write( const wxString fmt, ... ) const
bool Write(const wxString fmt, ...) const
{
va_list list;
va_start( list, fmt );
WriteV( fmt.wx_str(), list );
va_end( list );
va_start(list, fmt);
WriteV(fmt.wx_str(), list);
va_end(list);
return false;
}
// Writes to the console using the specified color. This overrides the default color setting
// for this log.
bool Write( ConsoleColors color, const char* fmt, ... ) const
bool Write(ConsoleColors color, const char *fmt, ...) const
{
va_list list;
va_start( list, fmt );
WriteV( color, fmt, list );
va_end( list );
va_start(list, fmt);
WriteV(color, fmt, list);
va_end(list);
return false;
}
bool Write( ConsoleColors color, const wxChar* fmt, ... ) const
bool Write(ConsoleColors color, const wxChar *fmt, ...) const
{
va_list list;
va_start( list, fmt );
WriteV( color, fmt, list );
va_end( list );
va_start(list, fmt);
WriteV(color, fmt, list);
va_end(list);
return false;
}
// Writes to the console using bold yellow text -- overrides the log source's default
// color settings.
bool Warn( const wxChar* fmt, ... ) const
bool Warn(const wxChar *fmt, ...) const
{
va_list list;
va_start( list, fmt );
WriteV( Color_StrongYellow, fmt, list );
va_end( list );
va_start(list, fmt);
WriteV(Color_StrongYellow, fmt, list);
va_end(list);
return false;
}
bool Warn( const wxString fmt, ... ) const
bool Warn(const wxString fmt, ...) const
{
va_list list;
va_start( list, fmt );
WriteV( Color_StrongYellow, fmt.wx_str(), list );
va_end( list );
va_start(list, fmt);
WriteV(Color_StrongYellow, fmt.wx_str(), list);
va_end(list);
return false;
}
// Writes to the console using bold red text -- overrides the log source's default
// color settings.
bool Error( const wxChar* fmt, ... ) const
bool Error(const wxChar *fmt, ...) const
{
va_list list;
va_start( list, fmt );
WriteV( Color_StrongRed, fmt, list );
va_end( list );
va_start(list, fmt);
WriteV(Color_StrongRed, fmt, list);
va_end(list);
return false;
}
bool Error( const wxString fmt, ... ) const
bool Error(const wxString fmt, ...) const
{
va_list list;
va_start( list, fmt );
WriteV( Color_StrongRed, fmt.wx_str(), list );
va_end( list );
va_start(list, fmt);
WriteV(Color_StrongRed, fmt.wx_str(), list);
va_end(list);
return false;
}
bool WriteV( const char *fmt, va_list list ) const;
bool WriteV( const wxChar *fmt, va_list list ) const;
bool WriteV(const char *fmt, va_list list) const;
bool WriteV(const wxChar *fmt, va_list list) const;
bool WriteV( ConsoleColors color, const char *fmt, va_list list ) const;
bool WriteV( ConsoleColors color, const wxChar *fmt, va_list list ) const;
bool WriteV(ConsoleColors color, const char *fmt, va_list list) const;
bool WriteV(ConsoleColors color, const wxChar *fmt, va_list list) const;
virtual void DoWrite( const wxChar* msg ) const
virtual void DoWrite(const wxChar *msg) const
{
Console.DoWriteLn( msg );
Console.DoWriteLn(msg);
}
};

30
common/include/Utilities/lnx_memzero.h
View File

@ -18,8 +18,8 @@
// This header contains non-optimized implementation of memzero_ptr and memset8, etc
template< u32 data, typename T >
static __fi void memset32( T& obj )
template <u32 data, typename T>
static __fi void memset32(T &obj)
{
// this function works on 32-bit aligned lengths of data only.
// If the data length is not a factor of 32 bits, the C++ optimizing compiler will
@ -27,32 +27,32 @@ static __fi void memset32( T& obj )
pxAssume((sizeof(T) & 0x3) == 0);
u32* dest = (u32*)&obj;
for( int i=sizeof(T)>>2; i; --i, ++dest )
u32 *dest = (u32 *)&obj;
for (int i = sizeof(T) >> 2; i; --i, ++dest)
*dest = data;
}
template< typename T >
static __fi void memzero( T& obj )
template <typename T>
static __fi void memzero(T &obj)
{
memset( &obj, 0, sizeof( T ) );
memset(&obj, 0, sizeof(T));
}
template< u8 data, typename T >
static __fi void memset8( T& obj )
template <u8 data, typename T>
static __fi void memset8(T &obj)
{
// Aligned sizes use the optimized 32 bit inline memset. Unaligned sizes use memset.
if( (sizeof(T) & 0x3) != 0 )
memset( &obj, data, sizeof( T ) );
if ((sizeof(T) & 0x3) != 0)
memset(&obj, data, sizeof(T));
else {
const u32 data32 = data + (data<<8) + (data<<16) + (data<<24);
memset32<data32>( obj );
const u32 data32 = data + (data << 8) + (data << 16) + (data << 24);
memset32<data32>(obj);
}
}
// Code is only called in the init so no need to bother with ASM
template< u8 data, size_t bytes >
static __fi void memset_8( void *dest )
template <u8 data, size_t bytes>
static __fi void memset_8(void *dest)
{
memset(dest, data, bytes);
}

78
common/include/Utilities/pxCheckBox.h
View File

@ -29,50 +29,74 @@
class pxCheckBox : public wxPanelWithHelpers
{
protected:
wxCheckBox* m_checkbox;
pxStaticText* m_subtext;
wxCheckBox *m_checkbox;
pxStaticText *m_subtext;
// padding below the subtext (if there's subtext). If there's no subtext, this value is unused.
int m_subPadding;
wxSizerItem* m_sizerItem_subtext;
wxSizerItem *m_sizerItem_subtext;
public:
pxCheckBox( wxWindow* parent, const wxString& label, const wxString& subtext=wxEmptyString, int flags = wxCHK_2STATE );
pxCheckBox( wxWindow* parent, const wxString& label, int flags );
pxCheckBox(wxWindow *parent, const wxString &label, const wxString &subtext = wxEmptyString, int flags = wxCHK_2STATE);
pxCheckBox(wxWindow *parent, const wxString &label, int flags);
virtual ~pxCheckBox() throw() {}
bool HasSubText() const { return m_subtext != NULL; }
const pxStaticText* GetSubText() const { return m_subtext; }
const pxStaticText *GetSubText() const { return m_subtext; }
pxCheckBox& SetSubPadding( int pad );
pxCheckBox& SetToolTip( const wxString& tip );
pxCheckBox& SetValue( bool val );
pxCheckBox& SetIndeterminate();
pxCheckBox& SetState( wxCheckBoxState state );
pxCheckBox &SetSubPadding(int pad);
pxCheckBox &SetToolTip(const wxString &tip);
pxCheckBox &SetValue(bool val);
pxCheckBox &SetIndeterminate();
pxCheckBox &SetState(wxCheckBoxState state);
wxCheckBoxState GetState() const { pxAssert( m_checkbox != NULL ); return m_checkbox->Get3StateValue(); }
bool GetValue() const { pxAssert( m_checkbox != NULL ); return m_checkbox->GetValue(); }
bool IsChecked() const { pxAssert( m_checkbox != NULL ); return m_checkbox->IsChecked(); }
bool IsIndeterminate() const { pxAssert( m_checkbox != NULL ); return m_checkbox->Get3StateValue() == wxCHK_UNDETERMINED; }
operator wxCheckBox&() { pxAssert( m_checkbox != NULL ); return *m_checkbox; }
operator const wxCheckBox&() const { pxAssert( m_checkbox != NULL ); return *m_checkbox; }
wxCheckBoxState GetState() const
{
pxAssert(m_checkbox != NULL);
return m_checkbox->Get3StateValue();
}
bool GetValue() const
{
pxAssert(m_checkbox != NULL);
return m_checkbox->GetValue();
}
bool IsChecked() const
{
pxAssert(m_checkbox != NULL);
return m_checkbox->IsChecked();
}
bool IsIndeterminate() const
{
pxAssert(m_checkbox != NULL);
return m_checkbox->Get3StateValue() == wxCHK_UNDETERMINED;
}
operator wxCheckBox &()
{
pxAssert(m_checkbox != NULL);
return *m_checkbox;
}
operator const wxCheckBox &() const
{
pxAssert(m_checkbox != NULL);
return *m_checkbox;
}
wxCheckBox* GetWxPtr() { return m_checkbox; }
const wxCheckBox* GetWxPtr() const { return m_checkbox; }
wxCheckBox *GetWxPtr() { return m_checkbox; }
const wxCheckBox *GetWxPtr() const { return m_checkbox; }
//wxWindowID GetId() const { pxAssert( m_checkbox != NULL ); return m_checkbox->GetId(); }
protected:
void Init( const wxString& label, const wxString& subtext, int flags );
void OnCheckpartCommand( wxCommandEvent& evt );
void OnSubtextClicked( wxCommandEvent& evt );
void Init(const wxString &label, const wxString &subtext, int flags);
void OnCheckpartCommand(wxCommandEvent &evt);
void OnSubtextClicked(wxCommandEvent &evt);
};
extern void operator+=( wxSizer& target, pxCheckBox& src );
extern void operator+=(wxSizer &target, pxCheckBox &src);
template<>
inline void operator+=( wxSizer& target, const pxWindowAndFlags<pxCheckBox>& src )
template <>
inline void operator+=(wxSizer &target, const pxWindowAndFlags<pxCheckBox> &src)
{
target.Add( src.window, src.flags );
target.Add(src.window, src.flags);
}

222
common/include/Utilities/pxEvents.h
View File

@ -26,7 +26,7 @@ typedef void FnType_Void();
// --------------------------------------------------------------------------------------
class SynchronousActionState
{
DeclareNoncopyableObject( SynchronousActionState );
DeclareNoncopyableObject(SynchronousActionState);
protected:
bool m_posted;
@ -44,16 +44,16 @@ public:
virtual ~SynchronousActionState() throw() {}
void SetException( const BaseException& ex );
void SetException( BaseException* ex );
void SetException(const BaseException &ex);
void SetException(BaseException *ex);
Threading::Semaphore& GetSemaphore() { return m_sema; }
const Threading::Semaphore& GetSemaphore() const { return m_sema; }
Threading::Semaphore &GetSemaphore() { return m_sema; }
const Threading::Semaphore &GetSemaphore() const { return m_sema; }
void RethrowException() const;
int WaitForResult();
int WaitForResult_NoExceptions();
void PostResult( int res );
void PostResult(int res);
void ClearResult();
void PostResult();
};
@ -71,13 +71,15 @@ class pxSimpleEvent : public wxEvent
DECLARE_DYNAMIC_CLASS_NO_ASSIGN(pxSimpleEvent)
public:
explicit pxSimpleEvent( int evtid=0 )
explicit pxSimpleEvent(int evtid = 0)
: wxEvent(0, evtid)
{ }
{
}
pxSimpleEvent( wxWindowID winId, int evtid )
pxSimpleEvent(wxWindowID winId, int evtid)
: wxEvent(winId, evtid)
{ }
{
}
virtual wxEvent *Clone() const { return new pxSimpleEvent(*this); }
};
@ -94,26 +96,26 @@ class pxActionEvent : public wxEvent
DECLARE_DYNAMIC_CLASS_NO_ASSIGN(pxActionEvent)
protected:
SynchronousActionState* m_state;
SynchronousActionState *m_state;
public:
virtual ~pxActionEvent() throw() { }
virtual ~pxActionEvent() throw() {}
virtual pxActionEvent *Clone() const { return new pxActionEvent(*this); }
explicit pxActionEvent( SynchronousActionState* sema=NULL, int msgtype=pxEvt_InvokeAction );
explicit pxActionEvent( SynchronousActionState& sema, int msgtype=pxEvt_InvokeAction );
pxActionEvent( const pxActionEvent& src );
explicit pxActionEvent(SynchronousActionState *sema = NULL, int msgtype = pxEvt_InvokeAction);
explicit pxActionEvent(SynchronousActionState &sema, int msgtype = pxEvt_InvokeAction);
pxActionEvent(const pxActionEvent &src);
Threading::Semaphore* GetSemaphore() const { return m_state ? &m_state->GetSemaphore() : NULL; }
Threading::Semaphore *GetSemaphore() const { return m_state ? &m_state->GetSemaphore() : NULL; }
const SynchronousActionState* GetSyncState() const { return m_state; }
SynchronousActionState* GetSyncState() { return m_state; }
const SynchronousActionState *GetSyncState() const { return m_state; }
SynchronousActionState *GetSyncState() { return m_state; }
void SetSyncState( SynchronousActionState* obj ) { m_state = obj; }
void SetSyncState( SynchronousActionState& obj ) { m_state = &obj; }
void SetSyncState(SynchronousActionState *obj) { m_state = obj; }
void SetSyncState(SynchronousActionState &obj) { m_state = &obj; }
virtual void SetException( BaseException* ex );
void SetException( const BaseException& ex );
virtual void SetException(BaseException *ex);
void SetException(const BaseException &ex);
virtual void _DoInvokeEvent();
@ -137,15 +139,15 @@ class pxExceptionEvent : public pxActionEvent
typedef pxActionEvent _parent;
protected:
BaseException* m_except;
BaseException *m_except;
public:
pxExceptionEvent( BaseException* ex=NULL )
pxExceptionEvent(BaseException *ex = NULL)
{
m_except = ex;
}
pxExceptionEvent( const BaseException& ex );
pxExceptionEvent(const BaseException &ex);
virtual ~pxExceptionEvent() throw()
{
@ -166,26 +168,26 @@ class pxSynchronousCommandEvent : public wxCommandEvent
DECLARE_DYNAMIC_CLASS_NO_ASSIGN(pxSynchronousCommandEvent)
protected:
SynchronousActionState* m_sync;
SynchronousActionState *m_sync;
wxEventType m_realEvent;
public:
virtual ~pxSynchronousCommandEvent() throw() { }
virtual ~pxSynchronousCommandEvent() throw() {}
virtual pxSynchronousCommandEvent *Clone() const { return new pxSynchronousCommandEvent(*this); }
pxSynchronousCommandEvent(SynchronousActionState* sema=NULL, wxEventType commandType = wxEVT_NULL, int winid = 0);
pxSynchronousCommandEvent(SynchronousActionState& sema, wxEventType commandType = wxEVT_NULL, int winid = 0);
pxSynchronousCommandEvent(SynchronousActionState *sema = NULL, wxEventType commandType = wxEVT_NULL, int winid = 0);
pxSynchronousCommandEvent(SynchronousActionState &sema, wxEventType commandType = wxEVT_NULL, int winid = 0);
pxSynchronousCommandEvent(SynchronousActionState* sema, const wxCommandEvent& evt);
pxSynchronousCommandEvent(SynchronousActionState& sema, const wxCommandEvent& evt);
pxSynchronousCommandEvent(SynchronousActionState *sema, const wxCommandEvent &evt);
pxSynchronousCommandEvent(SynchronousActionState &sema, const wxCommandEvent &evt);
pxSynchronousCommandEvent(const pxSynchronousCommandEvent& src);
pxSynchronousCommandEvent(const pxSynchronousCommandEvent &src);
Threading::Semaphore* GetSemaphore() { return m_sync ? &m_sync->GetSemaphore() : NULL; }
Threading::Semaphore *GetSemaphore() { return m_sync ? &m_sync->GetSemaphore() : NULL; }
wxEventType GetRealEventType() const { return m_realEvent; }
void SetException( BaseException* ex );
void SetException( const BaseException& ex );
void SetException(BaseException *ex);
void SetException(const BaseException &ex);
};
wxDECLARE_EVENT(pxEvt_SynchronousCommand, pxSynchronousCommandEvent);
@ -202,12 +204,12 @@ protected:
wxString m_Content;
public:
virtual ~BaseMessageBoxEvent() throw() { }
virtual ~BaseMessageBoxEvent() throw() {}
virtual BaseMessageBoxEvent *Clone() const { return new BaseMessageBoxEvent(*this); }
explicit BaseMessageBoxEvent( const wxString& content=wxEmptyString, SynchronousActionState* instdata=NULL );
BaseMessageBoxEvent( const wxString& content, SynchronousActionState& instdata );
BaseMessageBoxEvent( const BaseMessageBoxEvent& event );
explicit BaseMessageBoxEvent(const wxString &content = wxEmptyString, SynchronousActionState *instdata = NULL);
BaseMessageBoxEvent(const wxString &content, SynchronousActionState &instdata);
BaseMessageBoxEvent(const BaseMessageBoxEvent &event);
protected:
virtual void InvokeEvent();
@ -222,17 +224,17 @@ class MsgButtons
protected:
BITFIELD32()
bool
m_OK :1,
m_Cancel :1,
m_Yes :1,
m_No :1,
m_AllowToAll:1,
m_Apply :1,
m_Abort :1,
m_Retry :1,
m_Ignore :1,
m_Reset :1,
m_Close :1;
m_OK : 1,
m_Cancel : 1,
m_Yes : 1,
m_No : 1,
m_AllowToAll : 1,
m_Apply : 1,
m_Abort : 1,
m_Retry : 1,
m_Ignore : 1,
m_Reset : 1,
m_Close : 1;
BITFIELD_END
wxString m_CustomLabel;
@ -241,37 +243,89 @@ protected:
public:
MsgButtons() { bitset = 0; }
MsgButtons& OK() { m_OK = true; return *this; }
MsgButtons& Cancel() { m_Cancel = true; return *this; }
MsgButtons& Apply() { m_Apply = true; return *this; }
MsgButtons& Yes() { m_Yes = true; return *this; }
MsgButtons& No() { m_No = true; return *this; }
MsgButtons& ToAll() { m_AllowToAll = true; return *this; }
MsgButtons &OK()
{
m_OK = true;
return *this;
}
MsgButtons &Cancel()
{
m_Cancel = true;
return *this;
}
MsgButtons &Apply()
{
m_Apply = true;
return *this;
}
MsgButtons &Yes()
{
m_Yes = true;
return *this;
}
MsgButtons &No()
{
m_No = true;
return *this;
}
MsgButtons &ToAll()
{
m_AllowToAll = true;
return *this;
}
MsgButtons& Abort() { m_Abort = true; return *this; }
MsgButtons& Retry() { m_Retry = true; return *this; }
MsgButtons& Ignore() { m_Ignore = true; return *this; }
MsgButtons& Reset() { m_Reset = true; return *this; }
MsgButtons& Close() { m_Close = true; return *this; }
MsgButtons &Abort()
{
m_Abort = true;
return *this;
}
MsgButtons &Retry()
{
m_Retry = true;
return *this;
}
MsgButtons &Ignore()
{
m_Ignore = true;
return *this;
}
MsgButtons &Reset()
{
m_Reset = true;
return *this;
}
MsgButtons &Close()
{
m_Close = true;
return *this;
}
// label - native language label displayed to user
// id - raw ASCII identifier used in the config file (do not translate, hence char*)
MsgButtons& Custom( const wxString& label, const char* id )
MsgButtons &Custom(const wxString &label, const char *id)
{
m_CustomLabel = label;
m_CustomLabelId = fromUTF8(id);
return *this;
}
MsgButtons& OKCancel() { m_OK = m_Cancel = true; return *this; }
MsgButtons& YesNo() { m_Yes = m_No = true; return *this; }
MsgButtons &OKCancel()
{
m_OK = m_Cancel = true;
return *this;
}
MsgButtons &YesNo()
{
m_Yes = m_No = true;
return *this;
}
bool HasOK() const { return m_OK; }
bool HasCancel() const { return m_Cancel; }
bool HasApply() const { return m_Apply; }
bool HasYes() const { return m_Yes; }
bool HasNo() const { return m_No; }
bool AllowsToAll() const{ return m_AllowToAll; }
bool AllowsToAll() const { return m_AllowToAll; }
bool HasAbort() const { return m_Abort; }
bool HasRetry() const { return m_Retry; }
@ -280,21 +334,21 @@ public:
bool HasClose() const { return m_Close; }
bool HasCustom() const { return !m_CustomLabel.IsEmpty(); }
const wxString& GetCustomLabel() const { return m_CustomLabel; }
const wxString& GetCustomLabelId() const { return m_CustomLabelId; }
const wxString &GetCustomLabel() const { return m_CustomLabel; }
const wxString &GetCustomLabelId() const { return m_CustomLabelId; }
bool Allows( wxWindowID id ) const;
void SetBestFocus( wxWindow* dialog ) const;
void SetBestFocus( wxWindow& dialog ) const;
bool Allows(wxWindowID id) const;
void SetBestFocus(wxWindow *dialog) const;
void SetBestFocus(wxWindow &dialog) const;
bool operator ==( const MsgButtons& right ) const
bool operator==(const MsgButtons &right) const
{
return OpEqu( bitset );
return OpEqu(bitset);
}
bool operator !=( const MsgButtons& right ) const
bool operator!=(const MsgButtons &right) const
{
return !OpEqu( bitset );
return !OpEqu(bitset);
}
};
@ -326,13 +380,13 @@ protected:
MsgButtons m_Buttons;
public:
virtual ~pxMessageBoxEvent() throw() { }
virtual ~pxMessageBoxEvent() throw() {}
virtual pxMessageBoxEvent *Clone() const { return new pxMessageBoxEvent(*this); }
pxMessageBoxEvent() {}
pxMessageBoxEvent( const wxString& title, const wxString& content, const MsgButtons& buttons, SynchronousActionState& instdata );
pxMessageBoxEvent( const wxString& title, const wxString& content, const MsgButtons& buttons, SynchronousActionState* instdata=NULL );
pxMessageBoxEvent( const pxMessageBoxEvent& event );
pxMessageBoxEvent(const wxString &title, const wxString &content, const MsgButtons &buttons, SynchronousActionState &instdata);
pxMessageBoxEvent(const wxString &title, const wxString &content, const MsgButtons &buttons, SynchronousActionState *instdata = NULL);
pxMessageBoxEvent(const pxMessageBoxEvent &event);
protected:
int _DoDialog() const;
@ -344,20 +398,20 @@ protected:
class pxAssertionEvent : public BaseMessageBoxEvent
{
typedef BaseMessageBoxEvent _parent;
DECLARE_DYNAMIC_CLASS_NO_ASSIGN( pxAssertionEvent )
DECLARE_DYNAMIC_CLASS_NO_ASSIGN(pxAssertionEvent)
protected:
wxString m_Stacktrace;
public:
virtual ~pxAssertionEvent() throw() { }
virtual ~pxAssertionEvent() throw() {}
virtual pxAssertionEvent *Clone() const { return new pxAssertionEvent(*this); }
pxAssertionEvent( const wxString& content=wxEmptyString, const wxString& trace=wxEmptyString, SynchronousActionState* instdata=NULL );
pxAssertionEvent( const wxString& content, const wxString& trace, SynchronousActionState& instdata );
pxAssertionEvent( const pxAssertionEvent& event );
pxAssertionEvent(const wxString &content = wxEmptyString, const wxString &trace = wxEmptyString, SynchronousActionState *instdata = NULL);
pxAssertionEvent(const wxString &content, const wxString &trace, SynchronousActionState &instdata);
pxAssertionEvent(const pxAssertionEvent &event);
pxAssertionEvent& SetStacktrace( const wxString& trace );
pxAssertionEvent &SetStacktrace(const wxString &trace);
protected:
int _DoDialog() const;

8
common/include/Utilities/pxForwardDefs.h
View File

@ -40,12 +40,12 @@ extern const wxPoint wxDefaultPosition;
namespace Threading
{
class Mutex;
class Semaphore;
class pxThread;
class Mutex;
class Semaphore;
class pxThread;
}
namespace Exception
{
class BaseException;
class BaseException;
}

78
common/include/Utilities/pxRadioPanel.h
View File

@ -30,36 +30,36 @@ struct RadioPanelItem
wxString ToolTip;
int SomeInt;
void* SomePtr;
void *SomePtr;
RadioPanelItem( const wxString& label, const wxString& subtext=wxEmptyString, const wxString& tooltip=wxEmptyString )
: Label( label )
, SubText( subtext )
, ToolTip( tooltip )
RadioPanelItem(const wxString &label, const wxString &subtext = wxEmptyString, const wxString &tooltip = wxEmptyString)
: Label(label)
, SubText(subtext)
, ToolTip(tooltip)
{
SomeInt = 0;
SomePtr = NULL;
}
RadioPanelItem& SetToolTip( const wxString& tip )
RadioPanelItem &SetToolTip(const wxString &tip)
{
ToolTip = tip;
return *this;
}
RadioPanelItem& SetSubText( const wxString& text )
RadioPanelItem &SetSubText(const wxString &text)
{
SubText = text;
return *this;
}
RadioPanelItem& SetInt( int intval )
RadioPanelItem &SetInt(int intval)
{
SomeInt = intval;
return *this;
}
RadioPanelItem& SetPtr( void* ptrval )
RadioPanelItem &SetPtr(void *ptrval)
{
SomePtr = ptrval;
return *this;
@ -71,8 +71,8 @@ struct RadioPanelItem
// wrapped and re-wrapped with multiple calls to OnResize().
struct RadioPanelObjects
{
wxRadioButton* LabelObj;
pxStaticText* SubTextObj;
wxRadioButton *LabelObj;
pxStaticText *SubTextObj;
};
// --------------------------------------------------------------------------------------
@ -104,15 +104,15 @@ protected:
int m_DefaultIdx; // index of the default option (gets specific color/font treatment)
public:
template< int size >
pxRadioPanel( wxWindow* parent, const RadioPanelItem (&src)[size] )
: wxPanelWithHelpers( parent, wxVERTICAL )
template <int size>
pxRadioPanel(wxWindow *parent, const RadioPanelItem (&src)[size])
: wxPanelWithHelpers(parent, wxVERTICAL)
{
Init( src, size );
Init(src, size);
}
pxRadioPanel( wxWindow* parent )
: wxPanelWithHelpers( parent, wxVERTICAL )
pxRadioPanel(wxWindow *parent)
: wxPanelWithHelpers(parent, wxVERTICAL)
{
Init();
}
@ -122,55 +122,55 @@ public:
void Reset();
void Realize();
pxStaticText* GetSubText( int idx );
const pxStaticText* GetSubText( int idx ) const;
pxRadioPanel& Append( const RadioPanelItem& entry );
pxStaticText *GetSubText(int idx);
const pxStaticText *GetSubText(int idx) const;
pxRadioPanel &Append(const RadioPanelItem &entry);
pxRadioPanel& SetToolTip( int idx, const wxString& tip );
pxRadioPanel& SetSelection( int idx );
pxRadioPanel& SetDefaultItem( int idx );
pxRadioPanel& EnableItem( int idx, bool enable=true );
pxRadioPanel &SetToolTip(int idx, const wxString &tip);
pxRadioPanel &SetSelection(int idx);
pxRadioPanel &SetDefaultItem(int idx);
pxRadioPanel &EnableItem(int idx, bool enable = true);
const RadioPanelItem& Item(int idx) const;
RadioPanelItem& Item(int idx);
const RadioPanelItem &Item(int idx) const;
RadioPanelItem &Item(int idx);
int GetSelection() const;
wxWindowID GetSelectionId() const;
bool IsSelected( int idx ) const;
bool IsSelected(int idx) const;
const RadioPanelItem& SelectedItem() const { return Item(GetSelection()); }
RadioPanelItem& SelectedItem() { return Item(GetSelection()); }
const RadioPanelItem &SelectedItem() const { return Item(GetSelection()); }
RadioPanelItem &SelectedItem() { return Item(GetSelection()); }
wxRadioButton* GetButton( int idx );
const wxRadioButton* GetButton( int idx ) const;
wxRadioButton *GetButton(int idx);
const wxRadioButton *GetButton(int idx) const;
int GetPaddingVert() const { return m_padding.GetHeight(); }
int GetIndentation() const { return m_Indentation; }
pxRadioPanel& SetPaddingHoriz( int newpad )
pxRadioPanel &SetPaddingHoriz(int newpad)
{
m_padding.SetHeight( newpad );
m_padding.SetHeight(newpad);
return *this;
}
pxRadioPanel& SetIndentation( int newdent )
pxRadioPanel &SetIndentation(int newdent)
{
m_Indentation = newdent;
return *this;
}
bool HasSubText( int idx ) const
bool HasSubText(int idx) const
{
return !m_buttonStrings[idx].SubText.IsEmpty();
}
pxRadioPanel& Append( const wxString& label, const wxString& subtext=wxEmptyString, const wxString& tooltip=wxEmptyString )
pxRadioPanel &Append(const wxString &label, const wxString &subtext = wxEmptyString, const wxString &tooltip = wxEmptyString)
{
return Append( RadioPanelItem(label, subtext, tooltip) );
return Append(RadioPanelItem(label, subtext, tooltip));
}
protected:
void Init( const RadioPanelItem* srcArray=NULL, int arrsize=0 );
void _setToolTipImmediate( int idx, const wxString &tip );
void Init(const RadioPanelItem *srcArray = NULL, int arrsize = 0);
void _setToolTipImmediate(int idx, const wxString &tip);
void _RealizeDefaultOption();
};

59
common/include/Utilities/pxStaticText.h
View File

@ -50,7 +50,7 @@ protected:
float m_paddingPct_vert;
protected:
explicit pxStaticText( wxWindow* parent=NULL );
explicit pxStaticText(wxWindow *parent = NULL);
// wxWindow overloads!
bool AcceptsFocus() const { return false; }
@ -58,47 +58,47 @@ protected:
void DoSetSize(int x, int y, int w, int h, int sizeFlags = wxSIZE_AUTO);
public:
pxStaticText( wxWindow* parent, const wxString& label, wxAlignment align=wxALIGN_CENTRE_HORIZONTAL );
pxStaticText( wxWindow* parent, int heightInLines, const wxString& label, wxAlignment align=wxALIGN_CENTRE_HORIZONTAL );
pxStaticText(wxWindow *parent, const wxString &label, wxAlignment align = wxALIGN_CENTRE_HORIZONTAL);
pxStaticText(wxWindow *parent, int heightInLines, const wxString &label, wxAlignment align = wxALIGN_CENTRE_HORIZONTAL);
virtual ~pxStaticText() throw() {}
wxFont GetFontOk() const;
bool Enable( bool enabled=true );
bool Enable(bool enabled = true);
virtual void SetLabel(const wxString& label);
virtual void SetLabel(const wxString &label);
virtual wxString GetLabel() const { return m_label; }
pxStaticText& SetMinWidth( int width );
pxStaticText& SetMinHeight( int height );
pxStaticText &SetMinWidth(int width);
pxStaticText &SetMinHeight(int height);
pxStaticText& SetHeight( int lines );
pxStaticText& Align( wxAlignment align );
pxStaticText& Bold();
pxStaticText& WrapAt( int width );
pxStaticText &SetHeight(int lines);
pxStaticText &Align(wxAlignment align);
pxStaticText &Bold();
pxStaticText &WrapAt(int width);
pxStaticText& Unwrapped();
pxStaticText &Unwrapped();
pxStaticText& PaddingPixH( int pixels );
pxStaticText& PaddingPixV( int pixels );
pxStaticText &PaddingPixH(int pixels);
pxStaticText &PaddingPixV(int pixels);
pxStaticText& PaddingPctH( float pct );
pxStaticText& PaddingPctV( float pct );
pxStaticText &PaddingPctH(float pct);
pxStaticText &PaddingPctV(float pct);
//pxStaticText& DoBestGuessHeight();
protected:
void SetPaddingDefaults();
void Init( const wxString& label );
void Init(const wxString &label);
wxSize GetBestWrappedSize( const wxClientDC& dc ) const;
wxSize GetBestWrappedSize(const wxClientDC &dc) const;
wxSize DoGetBestSize() const;
int calcPaddingWidth( int newWidth ) const;
int calcPaddingHeight( int newHeight ) const;
int calcPaddingWidth(int newWidth) const;
int calcPaddingHeight(int newHeight) const;
void paintEvent(wxPaintEvent& evt);
void paintEvent(wxPaintEvent &evt);
void UpdateWrapping( bool textChanged );
bool _updateWrapping( bool textChanged );
void UpdateWrapping(bool textChanged);
bool _updateWrapping(bool textChanged);
};
@ -107,19 +107,18 @@ class pxStaticHeading : public pxStaticText
typedef pxStaticText _parent;
public:
pxStaticHeading( wxWindow* parent=NULL, const wxString& label=wxEmptyString );
pxStaticHeading( wxWindow* parent, int heightInLines, const wxString& label=wxEmptyString );
pxStaticHeading(wxWindow *parent = NULL, const wxString &label = wxEmptyString);
pxStaticHeading(wxWindow *parent, int heightInLines, const wxString &label = wxEmptyString);
virtual ~pxStaticHeading() throw() {}
protected:
void SetPaddingDefaults();
};
extern void operator+=( wxSizer& target, pxStaticText& src );
extern void operator+=(wxSizer &target, pxStaticText &src);
template<>
inline void operator+=( wxSizer& target, const pxWindowAndFlags<pxStaticText>& src )
template <>
inline void operator+=(wxSizer &target, const pxWindowAndFlags<pxStaticText> &src)
{
target.Add( src.window, src.flags );
target.Add(src.window, src.flags);
}

50
common/include/Utilities/pxStreams.h
View File

@ -32,15 +32,15 @@ protected:
wxString m_filename;
public:
pxStreamBase(const wxString& filename);
pxStreamBase(const wxString &filename);
virtual ~pxStreamBase() throw() {}
// Implementing classes should return the base wxStream object (usually either a wxInputStream
// or wxOputStream derivative).
virtual wxStreamBase* GetWxStreamBase() const=0;
virtual void Close()=0;
virtual wxFileOffset Tell() const=0;
virtual wxFileOffset Seek( wxFileOffset ofs, wxSeekMode mode = wxFromStart )=0;
virtual wxStreamBase *GetWxStreamBase() const = 0;
virtual void Close() = 0;
virtual wxFileOffset Tell() const = 0;
virtual wxFileOffset Seek(wxFileOffset ofs, wxSeekMode mode = wxFromStart) = 0;
virtual wxFileOffset Length() const;
bool IsOk() const;
@ -59,27 +59,27 @@ protected:
std::unique_ptr<wxOutputStream> m_stream_out;
public:
pxOutputStream(const wxString& filename, std::unique_ptr<wxOutputStream>& output);
pxOutputStream(const wxString& filename, wxOutputStream* output);
pxOutputStream(const wxString &filename, std::unique_ptr<wxOutputStream> &output);
pxOutputStream(const wxString &filename, wxOutputStream *output);
virtual ~pxOutputStream() throw() {}
virtual void Write( const void* data, size_t size );
virtual void Write(const void *data, size_t size);
void SetStream( const wxString& filename, std::unique_ptr<wxOutputStream>& stream );
void SetStream( const wxString& filename, wxOutputStream* stream );
void SetStream(const wxString &filename, std::unique_ptr<wxOutputStream> &stream);
void SetStream(const wxString &filename, wxOutputStream *stream);
void Close() { m_stream_out = nullptr; }
virtual wxStreamBase* GetWxStreamBase() const;
virtual wxStreamBase *GetWxStreamBase() const;
template< typename T >
void Write( const T& data )
template <typename T>
void Write(const T &data)
{
Write( &data, sizeof(data) );
Write(&data, sizeof(data));
}
wxFileOffset Tell() const;
wxFileOffset Seek( wxFileOffset ofs, wxSeekMode mode = wxFromStart );
wxFileOffset Seek(wxFileOffset ofs, wxSeekMode mode = wxFromStart);
};
// --------------------------------------------------------------------------------------
@ -93,25 +93,25 @@ protected:
std::unique_ptr<wxInputStream> m_stream_in;
public:
pxInputStream(const wxString& filename, std::unique_ptr<wxInputStream>& input);
pxInputStream(const wxString& filename, wxInputStream* input);
pxInputStream(const wxString &filename, std::unique_ptr<wxInputStream> &input);
pxInputStream(const wxString &filename, wxInputStream *input);
virtual ~pxInputStream() throw() {}
virtual void Read( void* dest, size_t size );
virtual void Read(void *dest, size_t size);
void SetStream( const wxString& filename, std::unique_ptr<wxInputStream>& stream );
void SetStream( const wxString& filename, wxInputStream* stream );
void SetStream(const wxString &filename, std::unique_ptr<wxInputStream> &stream);
void SetStream(const wxString &filename, wxInputStream *stream);
void Close() { m_stream_in = nullptr; }
virtual wxStreamBase* GetWxStreamBase() const;
virtual wxStreamBase *GetWxStreamBase() const;
template< typename T >
void Read( T& dest )
template <typename T>
void Read(T &dest)
{
Read( &dest, sizeof(dest) );
Read(&dest, sizeof(dest));
}
wxFileOffset Tell() const;
wxFileOffset Seek( wxFileOffset ofs, wxSeekMode mode = wxFromStart );
wxFileOffset Seek(wxFileOffset ofs, wxSeekMode mode = wxFromStart);
};

16
common/include/Utilities/win_memzero.h
View File

@ -16,14 +16,14 @@
#pragma once
#ifdef _MSC_VER
# pragma warning(disable:4063) // case '1' is not a valid value for switch()
#pragma warning(disable : 4063) // case '1' is not a valid value for switch()
#endif
// These functions are meant for memset operations of constant length only.
// For dynamic length clears, use the C-compiler provided memset instead.
template< u8 data, size_t bytes >
static __fi void memset_8( void *dest )
template <u8 data, size_t bytes>
static __fi void memset_8(void *dest)
{
memset(dest, data, bytes);
}
@ -31,15 +31,15 @@ static __fi void memset_8( void *dest )
// This method can clear any object-like entity -- which is anything that is not a pointer.
// Structures, static arrays, etc. No need to include sizeof() crap, this does it automatically
// for you!
template< typename T >
static __fi void memzero( T& object )
template <typename T>
static __fi void memzero(T &object)
{
memset(&object, 0, sizeof(T));
}
// This method clears an object with the given 8 bit value.
template< u8 data, typename T >
static __fi void memset8( T& object )
template <u8 data, typename T>
static __fi void memset8(T &object)
{
memset_8<data, sizeof(T)>( &object );
memset_8<data, sizeof(T)>(&object);
}

87
common/include/Utilities/wxAppWithHelpers.h
View File

@ -49,16 +49,16 @@ extern ConsoleLogSource_App pxConLog_App;
class ModalButtonPanel : public wxPanelWithHelpers
{
public:
ModalButtonPanel( wxWindow* window, const MsgButtons& buttons );
virtual ~ModalButtonPanel() throw() { }
ModalButtonPanel(wxWindow *window, const MsgButtons &buttons);
virtual ~ModalButtonPanel() throw() {}
virtual void AddActionButton( wxWindowID id );
virtual void AddCustomButton( wxWindowID id, const wxString& label );
virtual void AddActionButton(wxWindowID id);
virtual void AddCustomButton(wxWindowID id, const wxString &label);
virtual void OnActionButtonClicked( wxCommandEvent& evt );
virtual void OnActionButtonClicked(wxCommandEvent &evt);
};
typedef std::list< wxEvent* > wxEventList;
typedef std::list<wxEvent *> wxEventList;
// --------------------------------------------------------------------------------------
// wxAppWithHelpers
@ -78,67 +78,68 @@ public:
wxAppWithHelpers();
virtual ~wxAppWithHelpers() {}
wxAppTraits* CreateTraits();
wxAppTraits *CreateTraits();
void CleanUp();
void DeleteObject( BaseDeletableObject& obj );
void DeleteObject( BaseDeletableObject* obj )
void DeleteObject(BaseDeletableObject &obj);
void DeleteObject(BaseDeletableObject *obj)
{
if( obj == NULL ) return;
DeleteObject( *obj );
if (obj == NULL)
return;
DeleteObject(*obj);
}
void DeleteThread( Threading::pxThread& obj );
void DeleteThread( Threading::pxThread* obj )
void DeleteThread(Threading::pxThread &obj);
void DeleteThread(Threading::pxThread *obj)
{
if( obj == NULL ) return;
DeleteThread( *obj );
if (obj == NULL)
return;
DeleteThread(*obj);
}
void PostCommand( void* clientData, int evtType, int intParam=0, long longParam=0, const wxString& stringParam=wxEmptyString );
void PostCommand( int evtType, int intParam=0, long longParam=0, const wxString& stringParam=wxEmptyString );
void PostMethod( FnType_Void* method );
void PostIdleMethod( FnType_Void* method );
void ProcessMethod( FnType_Void* method );
void PostCommand(void *clientData, int evtType, int intParam = 0, long longParam = 0, const wxString &stringParam = wxEmptyString);
void PostCommand(int evtType, int intParam = 0, long longParam = 0, const wxString &stringParam = wxEmptyString);
void PostMethod(FnType_Void *method);
void PostIdleMethod(FnType_Void *method);
void ProcessMethod(FnType_Void *method);
bool Rpc_TryInvoke( FnType_Void* method );
bool Rpc_TryInvokeAsync( FnType_Void* method );
bool Rpc_TryInvoke(FnType_Void *method);
bool Rpc_TryInvokeAsync(FnType_Void *method);
sptr ProcessCommand( void* clientData, int evtType, int intParam=0, long longParam=0, const wxString& stringParam=wxEmptyString );
sptr ProcessCommand( int evtType, int intParam=0, long longParam=0, const wxString& stringParam=wxEmptyString );
sptr ProcessCommand(void *clientData, int evtType, int intParam = 0, long longParam = 0, const wxString &stringParam = wxEmptyString);
sptr ProcessCommand(int evtType, int intParam = 0, long longParam = 0, const wxString &stringParam = wxEmptyString);
void ProcessAction( pxActionEvent& evt );
void PostAction( const pxActionEvent& evt );
void ProcessAction(pxActionEvent &evt);
void PostAction(const pxActionEvent &evt);
void Ping();
bool OnInit();
//int OnExit();
void AddIdleEvent( const wxEvent& evt );
void AddIdleEvent(const wxEvent &evt);
void PostEvent( const wxEvent& evt );
bool ProcessEvent( wxEvent& evt );
bool ProcessEvent( wxEvent* evt );
void PostEvent(const wxEvent &evt);
bool ProcessEvent(wxEvent &evt);
bool ProcessEvent(wxEvent *evt);
bool ProcessEvent( pxActionEvent& evt );
bool ProcessEvent( pxActionEvent* evt );
bool ProcessEvent(pxActionEvent &evt);
bool ProcessEvent(pxActionEvent *evt);
protected:
void IdleEventDispatcher( const wxChar* action=wxEmptyString );
void OnIdleEvent( wxIdleEvent& evt );
void OnStartIdleEventTimer( wxCommandEvent& evt );
void OnIdleEventTimeout( wxTimerEvent& evt );
void OnDeleteObject( wxCommandEvent& evt );
void OnDeleteThread( wxCommandEvent& evt );
void OnSynchronousCommand( pxSynchronousCommandEvent& evt );
void OnInvokeAction( pxActionEvent& evt );
void IdleEventDispatcher(const wxChar *action = wxEmptyString);
void OnIdleEvent(wxIdleEvent &evt);
void OnStartIdleEventTimer(wxCommandEvent &evt);
void OnIdleEventTimeout(wxTimerEvent &evt);
void OnDeleteObject(wxCommandEvent &evt);
void OnDeleteThread(wxCommandEvent &evt);
void OnSynchronousCommand(pxSynchronousCommandEvent &evt);
void OnInvokeAction(pxActionEvent &evt);
};
namespace Msgbox
{
extern int ShowModal( BaseMessageBoxEvent& evt );
extern int ShowModal( const wxString& title, const wxString& content, const MsgButtons& buttons );
extern int ShowModal(BaseMessageBoxEvent &evt);
extern int ShowModal(const wxString &title, const wxString &content, const MsgButtons &buttons);
}

27
common/include/Utilities/wxBaseTools.h
View File

@ -26,11 +26,11 @@
// which require wxCore, see wxGuiTools.h
// --------------------------------------------------------------------------------------
extern void pxExplore( const wxString& path );
extern void pxExplore( const char *path );
extern void pxExplore(const wxString &path);
extern void pxExplore(const char *path);
extern void pxLaunch( const wxString& path );
extern void pxLaunch( const char *path );
extern void pxLaunch(const wxString &path);
extern void pxLaunch(const char *path);
// --------------------------------------------------------------------------------------
// wxDoNotLogInThisScope
@ -52,21 +52,20 @@ protected:
public:
wxDoNotLogInThisScope()
{
m_prev = wxLog::EnableLogging( false );
m_prev = wxLog::EnableLogging(false);
}
virtual ~wxDoNotLogInThisScope() throw()
{
wxLog::EnableLogging( m_prev );
wxLog::EnableLogging(m_prev);
}
};
extern wxString pxReadLine( wxInputStream& input );
extern void pxReadLine( wxInputStream& input, wxString& dest );
extern void pxReadLine( wxInputStream& input, wxString& dest, std::string& intermed );
extern bool pxReadLine( wxInputStream& input, std::string& dest );
extern void pxWriteLine( wxOutputStream& output );
extern void pxWriteLine( wxOutputStream& output, const wxString& text );
extern void pxWriteMultiline( wxOutputStream& output, const wxString& src );
extern wxString pxReadLine(wxInputStream &input);
extern void pxReadLine(wxInputStream &input, wxString &dest);
extern void pxReadLine(wxInputStream &input, wxString &dest, std::string &intermed);
extern bool pxReadLine(wxInputStream &input, std::string &dest);
extern void pxWriteLine(wxOutputStream &output);
extern void pxWriteLine(wxOutputStream &output, const wxString &text);
extern void pxWriteMultiline(wxOutputStream &output, const wxString &src);

387
common/include/Utilities/wxGuiTools.h
View File

@ -40,15 +40,15 @@ class wxSpinCtrl;
namespace pxSizerFlags
{
static const int StdPadding = 4;
static const int StdPadding = 4;
extern wxSizerFlags StdSpace();
extern wxSizerFlags StdCenter();
extern wxSizerFlags StdExpand();
extern wxSizerFlags TopLevelBox();
extern wxSizerFlags SubGroup();
extern wxSizerFlags StdButton();
extern wxSizerFlags Checkbox();
extern wxSizerFlags StdSpace();
extern wxSizerFlags StdCenter();
extern wxSizerFlags StdExpand();
extern wxSizerFlags TopLevelBox();
extern wxSizerFlags SubGroup();
extern wxSizerFlags StdButton();
extern wxSizerFlags Checkbox();
};
#define wxSF wxSizerFlags()
@ -61,8 +61,7 @@ namespace pxSizerFlags
//
struct pxAlignmentType
{
enum
{
enum {
Centre,
Center = Centre,
Middle,
@ -74,11 +73,11 @@ struct pxAlignmentType
int intval;
wxSizerFlags Apply( wxSizerFlags flags=wxSizerFlags() ) const;
wxSizerFlags Apply(wxSizerFlags flags = wxSizerFlags()) const;
wxSizerFlags operator& ( const wxSizerFlags& _flgs ) const
wxSizerFlags operator&(const wxSizerFlags &_flgs) const
{
return Apply( _flgs );
return Apply(_flgs);
}
wxSizerFlags Expand() const
@ -86,14 +85,14 @@ struct pxAlignmentType
return Apply().Expand();
}
wxSizerFlags Border( int dir, int padding ) const
wxSizerFlags Border(int dir, int padding) const
{
return Apply().Border( dir, padding );
return Apply().Border(dir, padding);
}
wxSizerFlags Proportion() const
{
return Apply().Proportion( intval );
return Apply().Proportion(intval);
}
operator wxSizerFlags() const
@ -104,8 +103,7 @@ struct pxAlignmentType
struct pxStretchType
{
enum
{
enum {
Shrink,
Expand,
Shaped,
@ -115,21 +113,21 @@ struct pxStretchType
int intval;
wxSizerFlags Apply( wxSizerFlags flags=wxSizerFlags() ) const;
wxSizerFlags Apply(wxSizerFlags flags = wxSizerFlags()) const;
wxSizerFlags operator& ( const wxSizerFlags& _flgs ) const
wxSizerFlags operator&(const wxSizerFlags &_flgs) const
{
return Apply( _flgs );
return Apply(_flgs);
}
wxSizerFlags Border( int dir, int padding ) const
wxSizerFlags Border(int dir, int padding) const
{
return Apply().Border( dir, padding );
return Apply().Border(dir, padding);
}
wxSizerFlags Proportion() const
{
return Apply().Proportion( intval );
return Apply().Proportion(intval);
}
operator wxSizerFlags() const
@ -138,14 +136,14 @@ struct pxStretchType
}
};
static __fi wxSizerFlags pxProportion( int prop )
static __fi wxSizerFlags pxProportion(int prop)
{
return wxSizerFlags( prop );
return wxSizerFlags(prop);
}
static __fi wxSizerFlags pxBorder( int dir=wxALL, int pad=pxSizerFlags::StdPadding )
static __fi wxSizerFlags pxBorder(int dir = wxALL, int pad = pxSizerFlags::StdPadding)
{
return wxSizerFlags().Border( dir, pad );
return wxSizerFlags().Border(dir, pad);
}
class pxStretchSpacer
@ -153,7 +151,7 @@ class pxStretchSpacer
public:
int proportion;
pxStretchSpacer( int prop=0 )
pxStretchSpacer(int prop = 0)
{
proportion = prop;
}
@ -190,27 +188,27 @@ extern const pxStretchType
// template, the type of the window would only be known as "wxWindow" when it's added to the
// sizer, and would thus fail to invoke the correct operator overload.
//
template< typename WinType >
template <typename WinType>
struct pxWindowAndFlags
{
WinType* window;
WinType *window;
wxSizerFlags flags;
};
extern wxSizerFlags operator& ( const wxSizerFlags& _flgs, const wxSizerFlags& _flgs2 );
extern wxSizerFlags operator&(const wxSizerFlags &_flgs, const wxSizerFlags &_flgs2);
template< typename WinType >
pxWindowAndFlags<WinType> operator | ( WinType* _win, const wxSizerFlags& _flgs )
template <typename WinType>
pxWindowAndFlags<WinType> operator|(WinType *_win, const wxSizerFlags &_flgs)
{
pxWindowAndFlags<WinType> result = { _win, _flgs };
pxWindowAndFlags<WinType> result = {_win, _flgs};
return result;
}
template< typename WinType >
pxWindowAndFlags<WinType> operator | ( WinType& _win, const wxSizerFlags& _flgs )
template <typename WinType>
pxWindowAndFlags<WinType> operator|(WinType &_win, const wxSizerFlags &_flgs)
{
pxWindowAndFlags<WinType> result = { &_win, _flgs };
pxWindowAndFlags<WinType> result = {&_win, _flgs};
return result;
}
@ -226,48 +224,51 @@ pxWindowAndFlags<WinType> operator | ( WinType& _win, const wxSizerFlags& _flgs
// has no sizer set via SetSizer(), an assertion is generated.
//
extern void operator+=( wxSizer& target, wxWindow* src );
extern void operator+=( wxSizer& target, wxSizer* src );
extern void operator+=( wxSizer& target, wxWindow& src );
extern void operator+=( wxSizer& target, wxSizer& src );
extern void operator+=(wxSizer &target, wxWindow *src);
extern void operator+=(wxSizer &target, wxSizer *src);
extern void operator+=(wxSizer &target, wxWindow &src);
extern void operator+=(wxSizer &target, wxSizer &src);
extern void operator+=( wxSizer* target, wxWindow& src );
extern void operator+=( wxSizer* target, wxSizer& src );
extern void operator+=(wxSizer *target, wxWindow &src);
extern void operator+=(wxSizer *target, wxSizer &src);
extern void operator+=( wxSizer& target, int spacer );
extern void operator+=( wxWindow& target, int spacer );
extern void operator+=( wxSizer& target, const pxStretchSpacer& spacer );
extern void operator+=( wxWindow& target, const pxStretchSpacer& spacer );
extern void operator+=(wxSizer &target, int spacer);
extern void operator+=(wxWindow &target, int spacer);
extern void operator+=(wxSizer &target, const pxStretchSpacer &spacer);
extern void operator+=(wxWindow &target, const pxStretchSpacer &spacer);
// ----------------------------------------------------------------------------
// Important: This template is needed in order to retain window type information and
// invoke the proper overloaded version of += (which is used by pxStaticText and other
// classes to perform special actions when added to sizers).
template< typename WinType >
void operator+=( wxWindow& target, WinType* src )
template <typename WinType>
void operator+=(wxWindow &target, WinType *src)
{
if( !pxAssert( target.GetSizer() != NULL ) ) return;
if (!pxAssert(target.GetSizer() != NULL))
return;
*target.GetSizer() += src;
}
template< typename WinType >
void operator+=( wxWindow& target, WinType& src )
template <typename WinType>
void operator+=(wxWindow &target, WinType &src)
{
if( !pxAssert( target.GetSizer() != NULL ) ) return;
if (!pxAssert(target.GetSizer() != NULL))
return;
*target.GetSizer() += src;
}
template< typename WinType >
void operator+=( wxWindow& target, const pxWindowAndFlags<WinType>& src )
template <typename WinType>
void operator+=(wxWindow &target, const pxWindowAndFlags<WinType> &src)
{
if( !pxAssert( target.GetSizer() != NULL ) ) return;
if (!pxAssert(target.GetSizer() != NULL))
return;
*target.GetSizer() += src;
}
template< typename WinType >
void operator+=( wxSizer& target, const pxWindowAndFlags<WinType>& src )
template <typename WinType>
void operator+=(wxSizer &target, const pxWindowAndFlags<WinType> &src)
{
target.Add( src.window, src.flags );
target.Add(src.window, src.flags);
}
wxDECLARE_EVENT(pxEvt_OnDialogCreated, wxCommandEvent);
@ -306,25 +307,25 @@ public:
hasCaption = true;
}
pxDialogCreationFlags& SetSizerOrient( wxOrientation orient )
pxDialogCreationFlags &SetSizerOrient(wxOrientation orient)
{
BoxSizerOrient = orient;
return *this;
}
pxDialogCreationFlags& SetResize( bool enable=true )
pxDialogCreationFlags &SetResize(bool enable = true)
{
isResizable = enable;
return *this;
}
pxDialogCreationFlags& SetMinimize( bool enable=true )
pxDialogCreationFlags &SetMinimize(bool enable = true)
{
hasMinimizeBox = enable;
return *this;
}
pxDialogCreationFlags& SetMaximize( bool enable=true )
pxDialogCreationFlags &SetMaximize(bool enable = true)
{
hasMaximizeBox = enable;
return *this;
@ -332,43 +333,45 @@ public:
// NOTE: Enabling system menu on dialogs usually doesn't work, and might cause
// other unwanted behavior, such as a missing close button.
pxDialogCreationFlags& SetSystemMenu( bool enable=true )
pxDialogCreationFlags &SetSystemMenu(bool enable = true)
{
hasSystemMenu = enable;
return *this;
}
pxDialogCreationFlags& SetCaption( bool enable=true )
pxDialogCreationFlags &SetCaption(bool enable = true)
{
hasCaption = enable;
return *this;
}
pxDialogCreationFlags& SetCloseBox( bool enable=true )
pxDialogCreationFlags &SetCloseBox(bool enable = true)
{
hasCloseBox = enable;
return *this;
}
pxDialogCreationFlags SetContextHelp( bool enabled=true )
pxDialogCreationFlags SetContextHelp(bool enabled = true)
{
hasContextHelp = enabled;
return *this;
}
pxDialogCreationFlags& SetMinWidth( int width )
pxDialogCreationFlags &SetMinWidth(int width)
{
if( width > MinimumSize.x ) MinimumSize.SetWidth( width );
if (width > MinimumSize.x)
MinimumSize.SetWidth(width);
return *this;
}
pxDialogCreationFlags& SetMinHeight( int height )
pxDialogCreationFlags &SetMinHeight(int height)
{
if( height > MinimumSize.y ) MinimumSize.SetHeight( height );
if (height > MinimumSize.y)
MinimumSize.SetHeight(height);
return *this;
}
pxDialogCreationFlags& SetMinSize( const wxSize& size )
pxDialogCreationFlags &SetMinSize(const wxSize &size)
{
return SetMinWidth(size.x).SetMinHeight(size.y);
}
@ -376,110 +379,116 @@ public:
pxDialogCreationFlags Horizontal() const
{
return pxDialogCreationFlags(*this).SetSizerOrient( wxHORIZONTAL );
return pxDialogCreationFlags(*this).SetSizerOrient(wxHORIZONTAL);
}
pxDialogCreationFlags Vertical() const
{
return pxDialogCreationFlags(*this).SetSizerOrient( wxVERTICAL );
return pxDialogCreationFlags(*this).SetSizerOrient(wxVERTICAL);
}
pxDialogCreationFlags NoSizer() const
{
return pxDialogCreationFlags(*this).SetSizerOrient( (wxOrientation)0 );
return pxDialogCreationFlags(*this).SetSizerOrient((wxOrientation)0);
}
pxDialogCreationFlags Resize( bool enable=true ) const
pxDialogCreationFlags Resize(bool enable = true) const
{
return pxDialogCreationFlags(*this).SetResize( enable );
return pxDialogCreationFlags(*this).SetResize(enable);
}
pxDialogCreationFlags Minimize( bool enable=true ) const
pxDialogCreationFlags Minimize(bool enable = true) const
{
return pxDialogCreationFlags(*this).SetMinimize( enable );
return pxDialogCreationFlags(*this).SetMinimize(enable);
}
pxDialogCreationFlags Maximize( bool enable=true ) const
pxDialogCreationFlags Maximize(bool enable = true) const
{
return pxDialogCreationFlags(*this).SetMaximize( enable );
return pxDialogCreationFlags(*this).SetMaximize(enable);
}
// NOTE: Enabling system menu on dialogs usually doesn't work, and might cause
// other unwanted behavior, such as a missing close button.
pxDialogCreationFlags SystemMenu( bool enable=true ) const
pxDialogCreationFlags SystemMenu(bool enable = true) const
{
return pxDialogCreationFlags(*this).SetSystemMenu( false );
return pxDialogCreationFlags(*this).SetSystemMenu(false);
}
pxDialogCreationFlags Caption( bool enable=true ) const
pxDialogCreationFlags Caption(bool enable = true) const
{
return pxDialogCreationFlags(*this).SetCaption( enable );
return pxDialogCreationFlags(*this).SetCaption(enable);
}
pxDialogCreationFlags CloseBox( bool enable=true ) const
pxDialogCreationFlags CloseBox(bool enable = true) const
{
return pxDialogCreationFlags(*this).SetCloseBox( enable );
return pxDialogCreationFlags(*this).SetCloseBox(enable);
}
pxDialogCreationFlags NoResize() const
{
return pxDialogCreationFlags(*this).SetResize( false );
return pxDialogCreationFlags(*this).SetResize(false);
}
pxDialogCreationFlags NoMinimize() const
{
return pxDialogCreationFlags(*this).SetMinimize( false );
return pxDialogCreationFlags(*this).SetMinimize(false);
}
pxDialogCreationFlags NoMaximize() const
{
return pxDialogCreationFlags(*this).SetMaximize( false );
return pxDialogCreationFlags(*this).SetMaximize(false);
}
pxDialogCreationFlags NoSystemMenu() const
{
return pxDialogCreationFlags(*this).SetSystemMenu( false );
return pxDialogCreationFlags(*this).SetSystemMenu(false);
}
pxDialogCreationFlags NoCaption() const
{
return pxDialogCreationFlags(*this).SetCaption( false );
return pxDialogCreationFlags(*this).SetCaption(false);
}
pxDialogCreationFlags NoCloseBox() const
{
return pxDialogCreationFlags(*this).SetCloseBox( false );
return pxDialogCreationFlags(*this).SetCloseBox(false);
}
pxDialogCreationFlags MinWidth( int width ) const
pxDialogCreationFlags MinWidth(int width) const
{
return pxDialogCreationFlags(*this).SetMinWidth( width );
return pxDialogCreationFlags(*this).SetMinWidth(width);
}
pxDialogCreationFlags MinHeight( int height ) const
pxDialogCreationFlags MinHeight(int height) const
{
return pxDialogCreationFlags(*this).SetMinHeight( height );
return pxDialogCreationFlags(*this).SetMinHeight(height);
}
pxDialogCreationFlags MinSize( const wxSize& size ) const
pxDialogCreationFlags MinSize(const wxSize &size) const
{
return pxDialogCreationFlags(*this).SetMinSize( size );
return pxDialogCreationFlags(*this).SetMinSize(size);
}
pxDialogCreationFlags MinSize( int width, int height ) const
pxDialogCreationFlags MinSize(int width, int height) const
{
return pxDialogCreationFlags(*this).SetMinWidth( width ).SetMinHeight( height );
return pxDialogCreationFlags(*this).SetMinWidth(width).SetMinHeight(height);
}
int GetWxWindowFlags() const
{
int retval = 0;
if( isResizable ) retval |= wxRESIZE_BORDER;
if( hasCaption ) retval |= wxCAPTION;
if( hasMaximizeBox ) retval |= wxMAXIMIZE_BOX;
if( hasMinimizeBox ) retval |= wxMINIMIZE_BOX;
if( hasSystemMenu ) retval |= wxSYSTEM_MENU;
if( hasCloseBox ) retval |= wxCLOSE_BOX;
if (isResizable)
retval |= wxRESIZE_BORDER;
if (hasCaption)
retval |= wxCAPTION;
if (hasMaximizeBox)
retval |= wxMAXIMIZE_BOX;
if (hasMinimizeBox)
retval |= wxMINIMIZE_BOX;
if (hasSystemMenu)
retval |= wxSYSTEM_MENU;
if (hasCloseBox)
retval |= wxCLOSE_BOX;
return retval;
}
@ -495,22 +504,22 @@ class wxDialogWithHelpers : public wxDialog
protected:
bool m_hasContextHelp;
wxBoxSizer* m_extraButtonSizer;
wxBoxSizer *m_extraButtonSizer;
wxRect m_CreatedRect;
public:
wxDialogWithHelpers();
wxDialogWithHelpers(wxWindow* parent, const wxString& title, const pxDialogCreationFlags& cflags = pxDialogCreationFlags() );
wxDialogWithHelpers(wxWindow *parent, const wxString &title, const pxDialogCreationFlags &cflags = pxDialogCreationFlags());
virtual ~wxDialogWithHelpers() throw();
void Init( const pxDialogCreationFlags& cflags );
void AddOkCancel( wxSizer& sizer, bool hasApply=false );
void AddOkCancel( wxSizer* sizer=NULL, bool hasApply=false );
void Init(const pxDialogCreationFlags &cflags);
void AddOkCancel(wxSizer &sizer, bool hasApply = false);
void AddOkCancel(wxSizer *sizer = NULL, bool hasApply = false);
void RememberPosition();
virtual void SmartCenterFit();
virtual int ShowModal();
virtual bool Show( bool show=true );
virtual bool Show(bool show = true);
// Must return the same thing as GetNameStatic; a name ideal for use in uniquely
// identifying dialogs. (this version is the 'instance' version, which is called
@ -518,18 +527,18 @@ public:
// screenshots to disk)
virtual wxString GetDialogName() const;
virtual wxStaticText& Label( const wxString& label );
virtual pxStaticText& Text( const wxString& label );
virtual pxStaticText& Heading( const wxString& label );
virtual wxStaticText &Label(const wxString &label);
virtual pxStaticText &Text(const wxString &label);
virtual pxStaticText &Heading(const wxString &label);
wxDialogWithHelpers& SetMinWidth( int newWidth );
wxDialogWithHelpers& SetMinHeight( int newHeight );
wxDialogWithHelpers &SetMinWidth(int newWidth);
wxDialogWithHelpers &SetMinHeight(int newHeight);
int GetCharHeight() const;
protected:
void OnDialogCreated( wxCommandEvent& evt );
void OnOkCancel(wxCommandEvent& evt);
void OnDialogCreated(wxCommandEvent &evt);
void OnOkCancel(wxCommandEvent &evt);
bool ShouldPreventAppExit() const { return false; }
@ -558,18 +567,18 @@ class wxPanelWithHelpers : public wxPanel
DECLARE_DYNAMIC_CLASS_NO_COPY(wxPanelWithHelpers)
public:
wxPanelWithHelpers( wxWindow* parent, wxOrientation orient, const wxString& staticBoxLabel );
wxPanelWithHelpers( wxWindow* parent, wxOrientation orient );
wxPanelWithHelpers( wxWindow* parent, const wxPoint& pos, const wxSize& size=wxDefaultSize );
explicit wxPanelWithHelpers( wxWindow* parent=NULL );
wxPanelWithHelpers(wxWindow *parent, wxOrientation orient, const wxString &staticBoxLabel);
wxPanelWithHelpers(wxWindow *parent, wxOrientation orient);
wxPanelWithHelpers(wxWindow *parent, const wxPoint &pos, const wxSize &size = wxDefaultSize);
explicit wxPanelWithHelpers(wxWindow *parent = NULL);
wxPanelWithHelpers* AddFrame( const wxString& label, wxOrientation orient=wxVERTICAL );
wxPanelWithHelpers *AddFrame(const wxString &label, wxOrientation orient = wxVERTICAL);
wxStaticText& Label( const wxString& label );
pxStaticText& Text( const wxString& label );
pxStaticText& Heading( const wxString& label );
wxStaticText &Label(const wxString &label);
pxStaticText &Text(const wxString &label);
pxStaticText &Heading(const wxString &label);
virtual wxPanelWithHelpers& SetMinWidth( int newWidth );
virtual wxPanelWithHelpers &SetMinWidth(int newWidth);
protected:
void Init();
@ -595,10 +604,10 @@ protected:
wxString m_indent;
public:
virtual ~pxTextWrapperBase() throw() { }
virtual ~pxTextWrapperBase() throw() {}
pxTextWrapperBase( const wxString& indent=wxEmptyString )
: m_indent( indent )
pxTextWrapperBase(const wxString &indent = wxEmptyString)
: m_indent(indent)
{
m_eol = false;
m_linecount = 0;
@ -606,7 +615,7 @@ public:
// win is used for getting the font, text is the text to wrap, width is the
// max line width or -1 to disable wrapping
pxTextWrapperBase& Wrap( const wxWindow& win, const wxString& text, int widthMax );
pxTextWrapperBase &Wrap(const wxWindow &win, const wxString &text, int widthMax);
int GetLineCount() const
{
@ -615,12 +624,12 @@ public:
protected:
// line may be empty
virtual void OnOutputLine(const wxString& line) { }
virtual void OnOutputLine(const wxString &line) {}
// called at the start of every new line (except the very first one)
virtual void OnNewLine() { }
virtual void OnNewLine() {}
void DoOutputLine(const wxString& line);
void DoOutputLine(const wxString &line);
bool IsStartOfNewLine();
};
@ -638,22 +647,23 @@ protected:
wxString m_text;
public:
pxTextWrapper( const wxString& wrapPrefix=wxEmptyString )
: pxTextWrapperBase( wrapPrefix )
{ }
pxTextWrapper(const wxString &wrapPrefix = wxEmptyString)
: pxTextWrapperBase(wrapPrefix)
{
}
virtual ~pxTextWrapper() throw() { }
virtual ~pxTextWrapper() throw() {}
const wxString& GetResult() const
const wxString &GetResult() const
{
return m_text;
}
pxTextWrapper& Wrap( const wxWindow& win, const wxString& text, int widthMax );
pxTextWrapper& Wrap( const wxWindow* win, const wxString& text, int widthMax );
pxTextWrapper &Wrap(const wxWindow &win, const wxString &text, int widthMax);
pxTextWrapper &Wrap(const wxWindow *win, const wxString &text, int widthMax);
protected:
void OnOutputLine(const wxString& line);
void OnOutputLine(const wxString &line);
void OnNewLine();
};
@ -663,64 +673,64 @@ protected:
class pxWindowTextWriter
{
protected:
wxDC& m_dc;
wxDC &m_dc;
wxAlignment m_align;
wxPoint m_curpos;
int m_leading;
virtual void _DoWriteLn( const wxChar* msg );
void _DoWriteLn( const wxString msg );
void _DoWrite( const wxChar* msg );
virtual void _DoWriteLn(const wxChar *msg);
void _DoWriteLn(const wxString msg);
void _DoWrite(const wxChar *msg);
public:
pxWindowTextWriter( wxDC& dc );
virtual ~pxWindowTextWriter() throw() { }
pxWindowTextWriter(wxDC &dc);
virtual ~pxWindowTextWriter() throw() {}
virtual void OnFontChanged();
pxWindowTextWriter& WriteLn();
pxWindowTextWriter& FormatLn( const wxChar* fmt, ... );
pxWindowTextWriter& WriteLn( const wxChar* fmt );
pxWindowTextWriter& SetFont( const wxFont& font );
pxWindowTextWriter& Align( const wxAlignment& align );
pxWindowTextWriter& WriteLn( const wxString fmt );
pxWindowTextWriter &WriteLn();
pxWindowTextWriter &FormatLn(const wxChar *fmt, ...);
pxWindowTextWriter &WriteLn(const wxChar *fmt);
pxWindowTextWriter &SetFont(const wxFont &font);
pxWindowTextWriter &Align(const wxAlignment &align);
pxWindowTextWriter &WriteLn(const wxString fmt);
pxWindowTextWriter& SetLeading( int lead )
pxWindowTextWriter &SetLeading(int lead)
{
m_leading = lead;
return *this;
}
pxWindowTextWriter& SetWeight( wxFontWeight weight );
pxWindowTextWriter& SetStyle( wxFontStyle style );
pxWindowTextWriter& Normal();
pxWindowTextWriter &SetWeight(wxFontWeight weight);
pxWindowTextWriter &SetStyle(wxFontStyle style);
pxWindowTextWriter &Normal();
pxWindowTextWriter& Bold()
pxWindowTextWriter &Bold()
{
return SetWeight(wxFONTWEIGHT_BOLD);
}
pxWindowTextWriter& Italic()
pxWindowTextWriter &Italic()
{
return SetStyle(wxFONTSTYLE_ITALIC);
}
pxWindowTextWriter& SetPos( const wxPoint& pos );
pxWindowTextWriter& MovePos( const wxSize& delta );
pxWindowTextWriter &SetPos(const wxPoint &pos);
pxWindowTextWriter &MovePos(const wxSize &delta);
pxWindowTextWriter& SetPos( int xpos, int ypos )
pxWindowTextWriter &SetPos(int xpos, int ypos)
{
return SetPos( wxPoint(xpos,ypos) );
return SetPos(wxPoint(xpos, ypos));
}
pxWindowTextWriter& MovePos( int xdelta, int ydelta )
pxWindowTextWriter &MovePos(int xdelta, int ydelta)
{
return MovePos( wxSize(xdelta, ydelta) );
return MovePos(wxSize(xdelta, ydelta));
}
pxWindowTextWriter& SetY( int ypos );
pxWindowTextWriter& MoveY( int ydelta );
pxWindowTextWriter &SetY(int ypos);
pxWindowTextWriter &MoveY(int ydelta);
};
// --------------------------------------------------------------------------------------
@ -734,13 +744,12 @@ protected:
std::unique_ptr<wxCursor> m_arrowWait;
public:
MoreStockCursors() { }
virtual ~MoreStockCursors() throw() { }
const wxCursor& GetArrowWait();
MoreStockCursors() {}
virtual ~MoreStockCursors() throw() {}
const wxCursor &GetArrowWait();
};
enum BusyCursorType
{
enum BusyCursorType {
Cursor_NotBusy,
Cursor_KindaBusy,
Cursor_ReallyBusy,
@ -761,11 +770,11 @@ protected:
static BusyCursorType m_defBusyType;
public:
ScopedBusyCursor( BusyCursorType busytype );
ScopedBusyCursor(BusyCursorType busytype);
virtual ~ScopedBusyCursor() throw();
static void SetDefault( BusyCursorType busytype );
static void SetManualBusyCursor( BusyCursorType busytype );
static void SetDefault(BusyCursorType busytype);
static void SetManualBusyCursor(BusyCursorType busytype);
};
// --------------------------------------------------------------------------------------
@ -774,24 +783,24 @@ public:
// Fits a given text or spinner control to the number of digits requested, since by default
// they're usually way over-sized.
extern void pxFitToDigits( wxWindow* win, int digits );
extern void pxFitToDigits( wxSpinCtrl* win, int digits );
extern wxTextCtrl* CreateNumericalTextCtrl( wxWindow* parent, int digits, long flags = wxTE_RIGHT );
extern void pxFitToDigits(wxWindow *win, int digits);
extern void pxFitToDigits(wxSpinCtrl *win, int digits);
extern wxTextCtrl *CreateNumericalTextCtrl(wxWindow *parent, int digits, long flags = wxTE_RIGHT);
//////////////////////////////////////////////////////////////////////////////////////////////
extern bool pxDialogExists( const wxString& name );
extern bool pxIsValidWindowPosition( const wxWindow& window, const wxPoint& windowPos );
extern bool pxDialogExists(const wxString &name);
extern bool pxIsValidWindowPosition(const wxWindow &window, const wxPoint &windowPos);
extern wxRect wxGetDisplayArea();
extern wxString pxGetAppName();
extern int pxGetCharHeight( const wxWindow* wind, int rows=1 );
extern int pxGetCharHeight( const wxWindow& wind, int rows=1 );
extern int pxGetCharHeight(const wxWindow *wind, int rows = 1);
extern int pxGetCharHeight(const wxWindow &wind, int rows = 1);
extern void pxSetToolTip( wxWindow* wind, const wxString& src );
extern void pxSetToolTip( wxWindow& wind, const wxString& src );
extern wxFont pxGetFixedFont( int ptsize = 8, wxFontWeight weight = wxFONTWEIGHT_NORMAL );
extern void pxSetToolTip(wxWindow *wind, const wxString &src);
extern void pxSetToolTip(wxWindow &wind, const wxString &src);
extern wxFont pxGetFixedFont(int ptsize = 8, wxFontWeight weight = wxFONTWEIGHT_NORMAL);
extern pxDialogCreationFlags pxDialogFlags();

133
common/include/api/CDVDApi.h
View File

@ -35,36 +35,57 @@
// Basic functions.
EXPORT_C_(s32) CDVDinit();
EXPORT_C_(s32) CDVDopen(void *pDisplay, const char* pTitleFilename);
EXPORT_C_(void) CDVDclose();
EXPORT_C_(void) CDVDshutdown();
EXPORT_C_(s32) CDVDreadTrack(u32 lsn, int mode);
EXPORT_C_(s32)
CDVDinit();
EXPORT_C_(s32)
CDVDopen(void *pDisplay, const char *pTitleFilename);
EXPORT_C_(void)
CDVDclose();
EXPORT_C_(void)
CDVDshutdown();
EXPORT_C_(s32)
CDVDreadTrack(u32 lsn, int mode);
// return can be NULL (for async modes)
EXPORT_C_(u8*) CDVDgetBuffer();
EXPORT_C_(u8 *)
CDVDgetBuffer();
EXPORT_C_(s32) CDVDreadSubQ(u32 lsn, cdvdSubQ* subq);//read subq from disc (only cds have subq data)
EXPORT_C_(s32) CDVDgetTN(cdvdTN *Buffer); //disk information
EXPORT_C_(s32) CDVDgetTD(u8 Track, cdvdTD *Buffer); //track info: min,sec,frame,type
EXPORT_C_(s32) CDVDgetTOC(void* toc); //gets ps2 style toc from disc
EXPORT_C_(s32) CDVDgetDiskType(); //CDVD_TYPE_xxxx
EXPORT_C_(s32) CDVDgetTrayStatus(); //CDVD_TRAY_xxxx
EXPORT_C_(s32) CDVDctrlTrayOpen(); //open disc tray
EXPORT_C_(s32) CDVDctrlTrayClose(); //close disc tray
EXPORT_C_(s32)
CDVDreadSubQ(u32 lsn, cdvdSubQ *subq); //read subq from disc (only cds have subq data)
EXPORT_C_(s32)
CDVDgetTN(cdvdTN *Buffer); //disk information
EXPORT_C_(s32)
CDVDgetTD(u8 Track, cdvdTD *Buffer); //track info: min,sec,frame,type
EXPORT_C_(s32)
CDVDgetTOC(void *toc); //gets ps2 style toc from disc
EXPORT_C_(s32)
CDVDgetDiskType(); //CDVD_TYPE_xxxx
EXPORT_C_(s32)
CDVDgetTrayStatus(); //CDVD_TRAY_xxxx
EXPORT_C_(s32)
CDVDctrlTrayOpen(); //open disc tray
EXPORT_C_(s32)
CDVDctrlTrayClose(); //close disc tray
// Extended functions
EXPORT_C_(void) CDVDkeyEvent(keyEvent *ev);
EXPORT_C_(void) CDVDconfigure();
EXPORT_C_(s32) CDVDfreeze(u8 mode, freezeData *data);
EXPORT_C_(void) CDVDabout();
EXPORT_C_(s32) CDVDtest();
EXPORT_C_(void) CDVDnewDiskCB(void (*callback)());
EXPORT_C_(void)
CDVDkeyEvent(keyEvent *ev);
EXPORT_C_(void)
CDVDconfigure();
EXPORT_C_(s32)
CDVDfreeze(u8 mode, freezeData *data);
EXPORT_C_(void)
CDVDabout();
EXPORT_C_(s32)
CDVDtest();
EXPORT_C_(void)
CDVDnewDiskCB(void (*callback)());
typedef struct _cdvdSubQ {
u8 ctrl:4; // control and mode bits
u8 mode:4; // control and mode bits
typedef struct _cdvdSubQ
{
u8 ctrl : 4; // control and mode bits
u8 mode : 4; // control and mode bits
u8 trackNum; // current track number (1 to 99)
u8 trackIndex; // current index within track (0 to 99)
u8 trackM; // current minute location on the disc (BCD encoded)
@ -76,60 +97,62 @@ typedef struct _cdvdSubQ {
u8 discF; // current frame offset from first track (BCD encoded)
} cdvdSubQ;
typedef struct _cdvdTD { // NOT bcd coded
typedef struct _cdvdTD
{ // NOT bcd coded
u32 lsn;
u8 type;
} cdvdTD;
typedef struct _cdvdTN {
typedef struct _cdvdTN
{
u8 strack; //number of the first track (usually 1)
u8 etrack; //number of the last track
} cdvdTN;
// CDVDreadTrack mode values:
enum {
CDVD_MODE_2352 0, // full 2352 bytes
CDVD_MODE_2340 1, // skip sync (12) bytes
CDVD_MODE_2328 2, // skip sync+head+sub (24) bytes
CDVD_MODE_2048 3, // skip sync+head+sub (24) bytes
CDVD_MODE_2368 4 // full 2352 bytes + 16 subq
CDVD_MODE_2352 0, // full 2352 bytes
CDVD_MODE_2340 1, // skip sync (12) bytes
CDVD_MODE_2328 2, // skip sync+head+sub (24) bytes
CDVD_MODE_2048 3, // skip sync+head+sub (24) bytes
CDVD_MODE_2368 4 // full 2352 bytes + 16 subq
} TrackModes
// CDVDgetDiskType returns:
enum {
CDVD_TYPE_ILLEGAL = 0xff, // Illegal Disc
CDVD_TYPE_DVDV = 0xfe, // DVD Video
CDVD_TYPE_CDDA = 0xfd, // Audio CD
CDVD_TYPE_PS2DVD = 0x14, // PS2 DVD
CDVD_TYPE_PS2CDDA = 0x13, // PS2 CD (with audio)
CDVD_TYPE_PS2CD = 0x12, // PS2 CD
CDVD_TYPE_PSCDDA = 0x11, // PS CD (with audio)
CDVD_TYPE_PSCD = 0x10, // PS CD
CDVD_TYPE_UNKNOWN = 0x05, // Unknown
CDVD_TYPE_DETCTDVDD = 0x04, // Detecting Dvd Dual Sided
CDVD_TYPE_DETCTDVDS = 0x03, // Detecting Dvd Single Sided
CDVD_TYPE_DETCTCD = 0x02, // Detecting Cd
CDVD_TYPE_DETCT = 0x01, // Detecting
CDVD_TYPE_NODISC = 0x00 // No Disc
} DiskType;
// CDVDgetDiskType returns:
enum {
CDVD_TYPE_ILLEGAL = 0xff, // Illegal Disc
CDVD_TYPE_DVDV = 0xfe, // DVD Video
CDVD_TYPE_CDDA = 0xfd, // Audio CD
CDVD_TYPE_PS2DVD = 0x14, // PS2 DVD
CDVD_TYPE_PS2CDDA = 0x13, // PS2 CD (with audio)
CDVD_TYPE_PS2CD = 0x12, // PS2 CD
CDVD_TYPE_PSCDDA = 0x11, // PS CD (with audio)
CDVD_TYPE_PSCD = 0x10, // PS CD
CDVD_TYPE_UNKNOWN = 0x05, // Unknown
CDVD_TYPE_DETCTDVDD = 0x04, // Detecting Dvd Dual Sided
CDVD_TYPE_DETCTDVDS = 0x03, // Detecting Dvd Single Sided
CDVD_TYPE_DETCTCD = 0x02, // Detecting Cd
CDVD_TYPE_DETCT = 0x01, // Detecting
CDVD_TYPE_NODISC = 0x00 // No Disc
} DiskType;
// CDVDgetTrayStatus returns:
enum {
CDVD_TRAY_CLOSE = 0x00,
CDVD_TRAY_OPEN = 0x01
CDVD_TRAY_CLOSE = 0x00,
CDVD_TRAY_OPEN = 0x01
} TrayStatus;
// cdvdTD.type (track types for cds)
enum {
CDVD_AUDIO_TRACK = 0x01,
CDVD_MODE1_TRACK = 0x41,
CDVD_MODE2_TRACK = 0x61
CDVD_AUDIO_TRACK = 0x01,
CDVD_MODE1_TRACK = 0x41,
CDVD_MODE2_TRACK = 0x61
} CDVDTDType;
enum {
CDVD_AUDIO_MASK = 0x00,
CDVD_DATA_MASK = 0x40
// CDROM_DATA_TRACK 0x04 //do not enable this! (from linux kernel)
CDVD_AUDIO_MASK = 0x00,
CDVD_DATA_MASK = 0x40
// CDROM_DATA_TRACK 0x04 //do not enable this! (from linux kernel)
} CDVD_Masks;
#endif // __CDVDAPI_H__

57
common/include/api/Dev9Api.h
View File

@ -37,32 +37,51 @@ typedef int (*DEV9handler)(void);
// Basic functions.
// NOTE: The read/write functions CANNOT use XMM/MMX regs
// If you want to use them, need to save and restore current ones
EXPORT_C_(s32) DEV9init();
EXPORT_C_(s32)
DEV9init();
// pDisplay normally is passed a handle to the GS plugins window.
EXPORT_C_(s32) DEV9open(void *pDisplay);
EXPORT_C_(void) DEV9close();
EXPORT_C_(void) DEV9shutdown();
EXPORT_C_(u8) DEV9read8(u32 addr);
EXPORT_C_(u16) DEV9read16(u32 addr);
EXPORT_C_(u32) DEV9read32(u32 addr);
EXPORT_C_(void) DEV9write8(u32 addr, u8 value);
EXPORT_C_(void) DEV9write16(u32 addr, u16 value);
EXPORT_C_(void) DEV9write32(u32 addr, u32 value);
EXPORT_C_(void) DEV9readDMA8Mem(u32 *pMem, int size);
EXPORT_C_(void) DEV9writeDMA8Mem(u32 *pMem, int size);
EXPORT_C_(s32)
DEV9open(void *pDisplay);
EXPORT_C_(void)
DEV9close();
EXPORT_C_(void)
DEV9shutdown();
EXPORT_C_(u8)
DEV9read8(u32 addr);
EXPORT_C_(u16)
DEV9read16(u32 addr);
EXPORT_C_(u32)
DEV9read32(u32 addr);
EXPORT_C_(void)
DEV9write8(u32 addr, u8 value);
EXPORT_C_(void)
DEV9write16(u32 addr, u16 value);
EXPORT_C_(void)
DEV9write32(u32 addr, u32 value);
EXPORT_C_(void)
DEV9readDMA8Mem(u32 *pMem, int size);
EXPORT_C_(void)
DEV9writeDMA8Mem(u32 *pMem, int size);
// cycles = IOP cycles before calling callback,
// if callback returns 1 the irq is triggered, else not
EXPORT_C_(void) DEV9irqCallback(DEV9callback callback);
EXPORT_C_(DEV9handler) DEV9irqHandler(void);
EXPORT_C_(void)
DEV9irqCallback(DEV9callback callback);
EXPORT_C_(DEV9handler)
DEV9irqHandler(void);
// Extended functions
EXPORT_C_(void) DEV9keyEvent(keyEvent *ev);
EXPORT_C_(s32) DEV9freeze(u8 mode, freezeData *data);
EXPORT_C_(void) DEV9configure();
EXPORT_C_(void) DEV9about();
EXPORT_C_(s32) DEV9test();
EXPORT_C_(void)
DEV9keyEvent(keyEvent *ev);
EXPORT_C_(s32)
DEV9freeze(u8 mode, freezeData *data);
EXPORT_C_(void)
DEV9configure();
EXPORT_C_(void)
DEV9about();
EXPORT_C_(s32)
DEV9test();
#endif // __DEV9API_H__

36
common/include/api/FWApi.h
View File

@ -37,22 +37,34 @@
// NOTE: The read/write functions CANNOT use XMM/MMX regs
// If you want to use them, need to save and restore current ones
EXPORT_C_(s32) FWinit();
EXPORT_C_(s32)
FWinit();
// pDisplay normally is passed a handle to the GS plugins window.
EXPORT_C_(s32) FWopen(void *pDisplay);
EXPORT_C_(void) FWclose();
EXPORT_C_(void) FWshutdown();
EXPORT_C_(u32) FWread32(u32 addr);
EXPORT_C_(void) FWwrite32(u32 addr, u32 value);
EXPORT_C_(void) FWirqCallback(void (*callback)());
EXPORT_C_(s32)
FWopen(void *pDisplay);
EXPORT_C_(void)
FWclose();
EXPORT_C_(void)
FWshutdown();
EXPORT_C_(u32)
FWread32(u32 addr);
EXPORT_C_(void)
FWwrite32(u32 addr, u32 value);
EXPORT_C_(void)
FWirqCallback(void (*callback)());
// Extended functions
EXPORT_C_(void) FWkeyEvent(keyEvent *ev);
EXPORT_C_(s32) FWfreeze(u8 mode, freezeData *data);
EXPORT_C_(void) FWconfigure();
EXPORT_C_(void) FWabout();
EXPORT_C_(s32) FWtest();
EXPORT_C_(void)
FWkeyEvent(keyEvent *ev);
EXPORT_C_(s32)
FWfreeze(u8 mode, freezeData *data);
EXPORT_C_(void)
FWconfigure();
EXPORT_C_(void)
FWabout();
EXPORT_C_(s32)
FWtest();
#endif
#endif // __USBAPI_H__

93
common/include/api/GSApi.h
View File

@ -31,55 +31,86 @@
#include "Pcsx2Api.h"
typedef struct _GSdriverInfo {
typedef struct _GSdriverInfo
{
char name[8];
void *common;
} GSdriverInfo;
// Basic functions.
EXPORT_C_(s32) GSinit();
EXPORT_C_(s32)
GSinit();
// pDisplay normally is passed a handle to the GS plugins window.
EXPORT_C_(s32) GSopen(void *pDisplay, char *Title, bool multithread);
EXPORT_C_(void) GSclose();
EXPORT_C_(void) GSshutdown();
EXPORT_C_(void) GSvsync(int field);
EXPORT_C_(void) GSgifTransfer1(u32 *pMem, u32 addr);
EXPORT_C_(void) GSgifTransfer2(u32 *pMem, u32 size);
EXPORT_C_(void) GSgifTransfer3(u32 *pMem, u32 size);
EXPORT_C_(void) GSgetLastTag(u64* ptag); // returns the last tag processed (64 bits)
EXPORT_C_(void) GSgifSoftReset(u32 mask);
EXPORT_C_(void) GSreadFIFO(u64 *mem);
EXPORT_C_(void) GSreadFIFO2(u64 *mem, int qwc);
EXPORT_C_(s32)
GSopen(void *pDisplay, char *Title, bool multithread);
EXPORT_C_(void)
GSclose();
EXPORT_C_(void)
GSshutdown();
EXPORT_C_(void)
GSvsync(int field);
EXPORT_C_(void)
GSgifTransfer1(u32 *pMem, u32 addr);
EXPORT_C_(void)
GSgifTransfer2(u32 *pMem, u32 size);
EXPORT_C_(void)
GSgifTransfer3(u32 *pMem, u32 size);
EXPORT_C_(void)
GSgetLastTag(u64 *ptag); // returns the last tag processed (64 bits)
EXPORT_C_(void)
GSgifSoftReset(u32 mask);
EXPORT_C_(void)
GSreadFIFO(u64 *mem);
EXPORT_C_(void)
GSreadFIFO2(u64 *mem, int qwc);
// Extended functions
// GSkeyEvent gets called when there is a keyEvent from the PAD plugin
EXPORT_C_(void) GSkeyEvent(keyEvent *ev);
EXPORT_C_(void) GSchangeSaveState(s32 state, const char* filename);
EXPORT_C_(void) GSmakeSnapshot(char *path);
EXPORT_C_(void) GSmakeSnapshot2(char *pathname, int* snapdone, int savejpg);
EXPORT_C_(void) GSirqCallback(void (*callback)());
EXPORT_C_(void) CALLBACK GSprintf(s32 timeout, char *fmt, ...);
EXPORT_C_(void) GSsetBaseMem(void*);
EXPORT_C_(void) GSsetGameCRC(s32 crc, s32 gameoptions);
EXPORT_C_(void)
GSkeyEvent(keyEvent *ev);
EXPORT_C_(void)
GSchangeSaveState(s32 state, const char *filename);
EXPORT_C_(void)
GSmakeSnapshot(char *path);
EXPORT_C_(void)
GSmakeSnapshot2(char *pathname, int *snapdone, int savejpg);
EXPORT_C_(void)
GSirqCallback(void (*callback)());
EXPORT_C_(void)
CALLBACK GSprintf(s32 timeout, char *fmt, ...);
EXPORT_C_(void)
GSsetBaseMem(void *);
EXPORT_C_(void)
GSsetGameCRC(s32 crc, s32 gameoptions);
// controls frame skipping in the GS, if this routine isn't present, frame skipping won't be done
EXPORT_C_(void) GSsetFrameSkip(int frameskip);
EXPORT_C_(void)
GSsetFrameSkip(int frameskip);
// if start is true, starts recording spu2 data, else stops
// returns true if successful
// for now, pData is not used
EXPORT_C_(bool) GSsetupRecording(bool start);
EXPORT_C_(bool)
GSsetupRecording(bool start);
EXPORT_C_(void) GSreset();
EXPORT_C_(void) GSwriteCSR(u32 value);
EXPORT_C_(void ) GSgetDriverInfo(GSdriverInfo *info);
EXPORT_C_(void)
GSreset();
EXPORT_C_(void)
GSwriteCSR(u32 value);
EXPORT_C_(void)
GSgetDriverInfo(GSdriverInfo *info);
#ifdef _WIN32
EXPORT_C_(s32) CALLBACK GSsetWindowInfo(winInfo *info);
EXPORT_C_(s32)
CALLBACK GSsetWindowInfo(winInfo *info);
#endif
EXPORT_C_(s32) GSfreeze(u8 mode, freezeData *data);
EXPORT_C_(void) GSconfigure();
EXPORT_C_(void) GSabout();
EXPORT_C_(s32) GStest();
EXPORT_C_(s32)
GSfreeze(u8 mode, freezeData *data);
EXPORT_C_(void)
GSconfigure();
EXPORT_C_(void)
GSabout();
EXPORT_C_(s32)
GStest();
#endif // __GSAPI_H__

48
common/include/api/PadApi.h
View File

@ -35,19 +35,27 @@
/* So obsolete that everyone uses it. */
// Basic functions.
EXPORT_C_(s32) PADinit(u32 flags);
EXPORT_C_(s32)
PADinit(u32 flags);
// pDisplay normally is passed a handle to the GS plugins window.
EXPORT_C_(s32) PADopen(void *pDisplay);
EXPORT_C_(void) PADclose();
EXPORT_C_(void) PADshutdown();
EXPORT_C_(s32)
PADopen(void *pDisplay);
EXPORT_C_(void)
PADclose();
EXPORT_C_(void)
PADshutdown();
// PADkeyEvent is called every vsync (return NULL if no event)
EXPORT_C_(keyEvent*) PADkeyEvent();
EXPORT_C_(u8) PADstartPoll(u8 pad);
EXPORT_C_(u8) PADpoll(u8 value);
EXPORT_C_(keyEvent *)
PADkeyEvent();
EXPORT_C_(u8)
PADstartPoll(u8 pad);
EXPORT_C_(u8)
PADpoll(u8 value);
// returns: 1 if supported pad1
// 2 if supported pad2
// 3 if both are supported
EXPORT_C_(u8) PADquery();
EXPORT_C_(u8)
PADquery();
// call to give a hint to the PAD plugin to query for the keyboard state. A
// good plugin will query the OS for keyboard state ONLY in this function.
@ -56,25 +64,33 @@ EXPORT_C_(u8) PADquery();
// the window (and input). Note that PADupdate can be called from a different
// thread than the other functions, so mutex or other multithreading primitives
// have to be added to maintain data integrity.
EXPORT_C_(void) PADupdate(u8 pad);
EXPORT_C_(void)
PADupdate(u8 pad);
// Extended functions
EXPORT_C_(void) PADgsDriverInfo(GSdriverInfo *info);
EXPORT_C_(s32) PADfreeze(u8 mode, freezeData *data);
EXPORT_C_(void)
PADgsDriverInfo(GSdriverInfo *info);
EXPORT_C_(s32)
PADfreeze(u8 mode, freezeData *data);
// Returns 1 if the pad plugin wants a multitap on the specified port.
// 0 otherwise.
EXPORT_C_(s32) PADqueryMtap(u8 port);
EXPORT_C_(s32)
PADqueryMtap(u8 port);
// Sets the active pad slot for the specified port.
// Both numbers are 1-based indices. Should return 0 if there's no
// pad on the specified slot. Even if PADqueryMtap(port) returns 0,
// should handle this properly for slot != 1, so emulator can allow
// Multitap to be enabled/disabled elsewhere.
EXPORT_C_(s32) PADsetSlot(u8 port, u8 slot);
EXPORT_C_(s32)
PADsetSlot(u8 port, u8 slot);
EXPORT_C_(void) PADconfigure();
EXPORT_C_(void) PADabout();
EXPORT_C_(s32) PADtest();
EXPORT_C_(void)
PADconfigure();
EXPORT_C_(void)
PADabout();
EXPORT_C_(s32)
PADtest();
#endif // __PADAPI_H__

46
common/include/api/SIOApi.h
View File

@ -38,49 +38,61 @@
// MTAP SIO plugins should ignore slot values on startPoll, as should RMs (probably).
// Port isn't strictly necessary, but doesn't hurt.
typedef int (CALLBACK * SIOchangeSlotCB)(int port, int slot);
typedef int(CALLBACK *SIOchangeSlotCB)(int port, int slot);
// Basic functions.
// Types is an or-ed combination of SioTypes to initialize. It'd probably be simplest
// just to make each SIO plugin support only one type, for simplicity.
// SIOchangeSlotCB should *only* be called by MTAP plugins.
EXPORT_C_(s32) SIOinit(int types, SIOchangeSlotCB f);
EXPORT_C_(s32)
SIOinit(int types, SIOchangeSlotCB f);
// Single plugin can only be PAD, MTAP, RM, or MC. Only load one plugin of each type,
// but not both a PAD and MTAP. Simplifies plugin selection and interface, as well
// as API.
// pDisplay normally is passed a handle to the GS plugins window.
EXPORT_C_(s32) SIOopen(void *pDisplay);
EXPORT_C_(void) SIOclose();
EXPORT_C_(void) SIOshutdown();
EXPORT_C_(s32)
SIOopen(void *pDisplay);
EXPORT_C_(void)
SIOclose();
EXPORT_C_(void)
SIOshutdown();
// Returns 0 if device doesn't exist. Means old pad plugins can just say nothing
// connected to other slots, and SIOpoll won't be called on those slots, ideally.
EXPORT_C_(s32) SIOstartPoll(u8 deviceType, u32 port, u32 slot, u8 *returnValue);
EXPORT_C_(s32)
SIOstartPoll(u8 deviceType, u32 port, u32 slot, u8 *returnValue);
// Returns 0 on the last output byte.
EXPORT_C_(s32) SIOpoll(u8 value, u8 *returnValue);
EXPORT_C_(s32)
SIOpoll(u8 value, u8 *returnValue);
// returns: SIO_TYPE_{PAD,MTAP,RM,MC}
EXPORT_C_(u32) SIOquery();
EXPORT_C_(u32)
SIOquery();
// extended funcs
EXPORT_C_(void) SIOconfigure();
EXPORT_C_(keyEvent*) CALLBACK SIOkeyEvent();
EXPORT_C_(void)
SIOconfigure();
EXPORT_C_(keyEvent *)
CALLBACK SIOkeyEvent();
// Save one type at a time. If a plugin supports all 4 types,
// should expect 4 calls. Increases savestate compatibility.
EXPORT_C_(s32) SIOfreeze(u8 mode, freezeData *data, int type);
EXPORT_C_(void) SIOabout();
EXPORT_C_(s32) SIOtest();
EXPORT_C_(s32)
SIOfreeze(u8 mode, freezeData *data, int type);
EXPORT_C_(void)
SIOabout();
EXPORT_C_(s32)
SIOtest();
enum {
SIO_TYPE_PAD = 0x00000001,
SIO_TYPE_MTAP = 0x00000004,
SIO_TYPE_RM = 0x00000040,
SIO_TYPE_MC = 0x00000100
SIO_TYPE_PAD = 0x00000001,
SIO_TYPE_MTAP = 0x00000004,
SIO_TYPE_RM = 0x00000040,
SIO_TYPE_MC = 0x00000100
} SioTypes;
#endif // __SIOAPI_H__

81
common/include/api/Spu2Api.h
View File

@ -31,47 +31,74 @@
#include "Pcsx2Api.h"
EXPORT_C_(s32) SPU2init();
EXPORT_C_(s32)
SPU2init();
// pDisplay normally is passed a handle to the GS plugins window.
EXPORT_C_(s32) SPU2open(void *pDisplay);
EXPORT_C_(void) SPU2close();
EXPORT_C_(void) SPU2shutdown();
EXPORT_C_(void) SPU2write(u32 mem, u16 value);
EXPORT_C_(u16) SPU2read(u32 mem);
EXPORT_C_(s32)
SPU2open(void *pDisplay);
EXPORT_C_(void)
SPU2close();
EXPORT_C_(void)
SPU2shutdown();
EXPORT_C_(void)
SPU2write(u32 mem, u16 value);
EXPORT_C_(u16)
SPU2read(u32 mem);
// The following calls are depreciated.
EXPORT_C_(void) SPU2readDMA4Mem(u16 *pMem, u32 size);
EXPORT_C_(void) SPU2readDMA7Mem(u16 *pMem, u32 size);
EXPORT_C_(void) SPU2writeDMA4Mem(u16 *pMem, u32 size);
EXPORT_C_(void) SPU2writeDMA7Mem(u16 *pMem, u32 size);
EXPORT_C_(void) SPU2interruptDMA4();
EXPORT_C_(void) SPU2interruptDMA7();
EXPORT_C_(void)
SPU2readDMA4Mem(u16 *pMem, u32 size);
EXPORT_C_(void)
SPU2readDMA7Mem(u16 *pMem, u32 size);
EXPORT_C_(void)
SPU2writeDMA4Mem(u16 *pMem, u32 size);
EXPORT_C_(void)
SPU2writeDMA7Mem(u16 *pMem, u32 size);
EXPORT_C_(void)
SPU2interruptDMA4();
EXPORT_C_(void)
SPU2interruptDMA7();
// These calls replace the calls above.
EXPORT_C_(void) SPU2readDMAMem(u16 *pMem, u32 size, u8 core);
EXPORT_C_(void) SPU2writeDMAMem(u16 *pMem, u32 size, u8 core);
EXPORT_C_(void) SPU2interruptDMA(u8 core);
EXPORT_C_(void)
SPU2readDMAMem(u16 *pMem, u32 size, u8 core);
EXPORT_C_(void)
SPU2writeDMAMem(u16 *pMem, u32 size, u8 core);
EXPORT_C_(void)
SPU2interruptDMA(u8 core);
// all addresses passed by dma will be pointers to the array starting at baseaddr
// This function is necessary to successfully save and reload the spu2 state
EXPORT_C_(void) SPU2setDMABaseAddr(uptr baseaddr);
EXPORT_C_(void)
SPU2setDMABaseAddr(uptr baseaddr);
EXPORT_C_(u32) SPU2ReadMemAddr(u8 core);
EXPORT_C_(void) SPU2WriteMemAddr(u8 core,u32 value);
EXPORT_C_(void) SPU2irqCallback(void (*SPU2callback)(),void (*DMA4callback)(),void (*DMA7callback)());
EXPORT_C_(u32)
SPU2ReadMemAddr(u8 core);
EXPORT_C_(void)
SPU2WriteMemAddr(u8 core, u32 value);
EXPORT_C_(void)
SPU2irqCallback(void (*SPU2callback)(), void (*DMA4callback)(), void (*DMA7callback)());
// extended funcs
// if start is true, starts recording spu2 data, else stops
// returns true if successful
EXPORT_C_(bool) SPU2setupRecording(bool start);
EXPORT_C_(bool)
SPU2setupRecording(bool start);
EXPORT_C_(void) SPU2keyEvent(keyEvent *ev);
EXPORT_C_(void) SPU2setClockPtr(u32* ptr);
EXPORT_C_(void) SPU2async(u32 cycles);
EXPORT_C_(s32) SPU2freeze(u8 mode, freezeData *data);
EXPORT_C_(void) SPU2configure();
EXPORT_C_(void) SPU2about();
EXPORT_C_(s32) SPU2test();
EXPORT_C_(void)
SPU2keyEvent(keyEvent *ev);
EXPORT_C_(void)
SPU2setClockPtr(u32 *ptr);
EXPORT_C_(void)
SPU2async(u32 cycles);
EXPORT_C_(s32)
SPU2freeze(u8 mode, freezeData *data);
EXPORT_C_(void)
SPU2configure();
EXPORT_C_(void)
SPU2about();
EXPORT_C_(s32)
SPU2test();
#endif

57
common/include/api/USBApi.h
View File

@ -35,31 +35,50 @@ typedef void (*USBcallback)(int cycles);
typedef int (*USBhandler)(void);
// Basic functions.
EXPORT_C_(s32) USBinit();
EXPORT_C_(s32)
USBinit();
// pDisplay normally is passed a handle to the GS plugins window.
EXPORT_C_(s32) USBopen(void *pDisplay);
EXPORT_C_(void) USBclose();
EXPORT_C_(void) USBshutdown();
EXPORT_C_(u8) USBread8(u32 addr);
EXPORT_C_(u16) USBread16(u32 addr);
EXPORT_C_(u32) USBread32(u32 addr);
EXPORT_C_(void) USBwrite8(u32 addr, u8 value);
EXPORT_C_(void) USBwrite16(u32 addr, u16 value);
EXPORT_C_(void) USBwrite32(u32 addr, u32 value);
EXPORT_C_(void) USBasync(u32 cycles);
EXPORT_C_(s32)
USBopen(void *pDisplay);
EXPORT_C_(void)
USBclose();
EXPORT_C_(void)
USBshutdown();
EXPORT_C_(u8)
USBread8(u32 addr);
EXPORT_C_(u16)
USBread16(u32 addr);
EXPORT_C_(u32)
USBread32(u32 addr);
EXPORT_C_(void)
USBwrite8(u32 addr, u8 value);
EXPORT_C_(void)
USBwrite16(u32 addr, u16 value);
EXPORT_C_(void)
USBwrite32(u32 addr, u32 value);
EXPORT_C_(void)
USBasync(u32 cycles);
// cycles = IOP cycles before calling callback,
// if callback returns 1 the irq is triggered, else not
EXPORT_C_(void) USBirqCallback(USBcallback callback);
EXPORT_C_(USBhandler) USBirqHandler(void);
EXPORT_C_(void) USBsetRAM(void *mem);
EXPORT_C_(void)
USBirqCallback(USBcallback callback);
EXPORT_C_(USBhandler)
USBirqHandler(void);
EXPORT_C_(void)
USBsetRAM(void *mem);
// Extended functions
EXPORT_C_(void) USBkeyEvent(keyEvent *ev);
EXPORT_C_(s32) USBfreeze(u8 mode, freezeData *data);
EXPORT_C_(void) USBconfigure();
EXPORT_C_(void) USBabout();
EXPORT_C_(s32) USBtest();
EXPORT_C_(void)
USBkeyEvent(keyEvent *ev);
EXPORT_C_(s32)
USBfreeze(u8 mode, freezeData *data);
EXPORT_C_(void)
USBconfigure();
EXPORT_C_(void)
USBabout();
EXPORT_C_(s32)
USBtest();
#endif // __USBAPI_H__

14
common/include/x86emitter/implement/bmi.h
View File

@ -17,10 +17,11 @@
// Implement BMI1/BMI2 instruction set
namespace x86Emitter {
namespace x86Emitter
{
struct xImplBMI_RVM
{
struct xImplBMI_RVM
{
u8 Prefix;
u8 MbPrefix;
u8 Opcode;
@ -30,8 +31,8 @@ namespace x86Emitter {
// PDEP Parallel bits deposit
// PEXT Parallel bits extract
// ANDN Logical and not ~x & y
void operator()( const xRegisterInt& to, const xRegisterInt& from1, const xRegisterInt& from2) const;
void operator()( const xRegisterInt& to, const xRegisterInt& from1, const xIndirectVoid& from2) const;
void operator()(const xRegisterInt &to, const xRegisterInt &from1, const xRegisterInt &from2) const;
void operator()(const xRegisterInt &to, const xRegisterInt &from1, const xIndirectVoid &from2) const;
#if 0
// RMV
@ -56,6 +57,5 @@ namespace x86Emitter {
void operator()( const xRegisterInt& to, const xRegisterInt& from, u8 imm) const;
void operator()( const xRegisterInt& to, const xIndirectVoid& from, u8 imm) const;
#endif
};
};
}

11
common/include/x86emitter/implement/dwshift.h
View File

@ -15,7 +15,8 @@
#pragma once
namespace x86Emitter {
namespace x86Emitter
{
// Implementations here cover SHLD and SHRD.
@ -32,12 +33,12 @@ struct xImpl_DwordShift
{
u16 OpcodeBase;
void operator()( const xRegister16or32or64& to, const xRegister16or32or64& from, const xRegisterCL& clreg ) const;
void operator()(const xRegister16or32or64 &to, const xRegister16or32or64 &from, const xRegisterCL &clreg) const;
void operator()( const xRegister16or32or64& to, const xRegister16or32or64& from, u8 shiftcnt ) const;
void operator()(const xRegister16or32or64 &to, const xRegister16or32or64 &from, u8 shiftcnt) const;
void operator()( const xIndirectVoid& dest,const xRegister16or32or64& from, const xRegisterCL& clreg ) const;
void operator()( const xIndirectVoid& dest,const xRegister16or32or64& from, u8 shiftcnt ) const;
void operator()(const xIndirectVoid &dest, const xRegister16or32or64 &from, const xRegisterCL &clreg) const;
void operator()(const xIndirectVoid &dest, const xRegister16or32or64 &from, u8 shiftcnt) const;
};
} // End namespace x86Emitter

51
common/include/x86emitter/implement/group1.h
View File

@ -15,11 +15,11 @@
#pragma once
namespace x86Emitter {
enum G1Type
namespace x86Emitter
{
G1Type_ADD=0,
enum G1Type {
G1Type_ADD = 0,
G1Type_OR,
G1Type_ADC,
G1Type_SBB,
@ -29,7 +29,7 @@ enum G1Type
G1Type_CMP
};
extern void _g1_EmitOp( G1Type InstType, const xRegisterInt& to, const xRegisterInt& from );
extern void _g1_EmitOp(G1Type InstType, const xRegisterInt &to, const xRegisterInt &from);
// --------------------------------------------------------------------------------------
// xImpl_Group1
@ -38,12 +38,12 @@ struct xImpl_Group1
{
G1Type InstType;
void operator()( const xRegisterInt& to, const xRegisterInt& from ) const;
void operator()(const xRegisterInt &to, const xRegisterInt &from) const;
void operator()( const xIndirectVoid& to, const xRegisterInt& from ) const;
void operator()( const xRegisterInt& to, const xIndirectVoid& from ) const;
void operator()( const xRegisterInt& to, int imm ) const;
void operator()( const xIndirect64orLess& to, int imm ) const;
void operator()(const xIndirectVoid &to, const xRegisterInt &from) const;
void operator()(const xRegisterInt &to, const xIndirectVoid &from) const;
void operator()(const xRegisterInt &to, int imm) const;
void operator()(const xIndirect64orLess &to, int imm) const;
#if 0
// ------------------------------------------------------------------------
@ -89,13 +89,13 @@ struct xImpl_G1Logic
{
G1Type InstType;
void operator()( const xRegisterInt& to, const xRegisterInt& from ) const;
void operator()(const xRegisterInt &to, const xRegisterInt &from) const;
void operator()( const xIndirectVoid& to, const xRegisterInt& from ) const;
void operator()( const xRegisterInt& to, const xIndirectVoid& from ) const;
void operator()( const xRegisterInt& to, int imm ) const;
void operator()(const xIndirectVoid &to, const xRegisterInt &from) const;
void operator()(const xRegisterInt &to, const xIndirectVoid &from) const;
void operator()(const xRegisterInt &to, int imm) const;
void operator()( const xIndirect64orLess& to, int imm ) const;
void operator()(const xIndirect64orLess &to, int imm) const;
xImplSimd_DestRegSSE PS; // packed single precision
xImplSimd_DestRegSSE PD; // packed double precision
@ -108,13 +108,13 @@ struct xImpl_G1Arith
{
G1Type InstType;
void operator()( const xRegisterInt& to, const xRegisterInt& from ) const;
void operator()(const xRegisterInt &to, const xRegisterInt &from) const;
void operator()( const xIndirectVoid& to, const xRegisterInt& from ) const;
void operator()( const xRegisterInt& to, const xIndirectVoid& from ) const;
void operator()( const xRegisterInt& to, int imm ) const;
void operator()(const xIndirectVoid &to, const xRegisterInt &from) const;
void operator()(const xRegisterInt &to, const xIndirectVoid &from) const;
void operator()(const xRegisterInt &to, int imm) const;
void operator()( const xIndirect64orLess& to, int imm ) const;
void operator()(const xIndirect64orLess &to, int imm) const;
xImplSimd_DestRegSSE PS; // packed single precision
xImplSimd_DestRegSSE PD; // packed double precision
@ -125,13 +125,13 @@ struct xImpl_G1Arith
// ------------------------------------------------------------------------
struct xImpl_G1Compare
{
void operator()( const xRegisterInt& to, const xRegisterInt& from ) const;
void operator()(const xRegisterInt &to, const xRegisterInt &from) const;
void operator()( const xIndirectVoid& to, const xRegisterInt& from ) const;
void operator()( const xRegisterInt& to, const xIndirectVoid& from ) const;
void operator()( const xRegisterInt& to, int imm ) const;
void operator()(const xIndirectVoid &to, const xRegisterInt &from) const;
void operator()(const xRegisterInt &to, const xIndirectVoid &from) const;
void operator()(const xRegisterInt &to, int imm) const;
void operator()( const xIndirect64orLess& to, int imm ) const;
void operator()(const xIndirect64orLess &to, int imm) const;
xImplSimd_DestSSE_CmpImm PS;
xImplSimd_DestSSE_CmpImm PD;
@ -140,4 +140,3 @@ struct xImpl_G1Compare
};
} // End namespace x86Emitter

16
common/include/x86emitter/implement/group2.h
View File

@ -15,11 +15,11 @@
#pragma once
namespace x86Emitter {
enum G2Type
namespace x86Emitter
{
G2Type_ROL=0,
enum G2Type {
G2Type_ROL = 0,
G2Type_ROR,
G2Type_RCL,
G2Type_RCR,
@ -40,10 +40,10 @@ struct xImpl_Group2
{
G2Type InstType;
void operator()( const xRegisterInt& to, const xRegisterCL& from ) const;
void operator()( const xIndirect64orLess& to, const xRegisterCL& from ) const;
void operator()( const xRegisterInt& to, u8 imm ) const;
void operator()( const xIndirect64orLess& to, u8 imm ) const;
void operator()(const xRegisterInt &to, const xRegisterCL &from) const;
void operator()(const xIndirect64orLess &to, const xRegisterCL &from) const;
void operator()(const xRegisterInt &to, u8 imm) const;
void operator()(const xIndirect64orLess &to, u8 imm) const;
#if 0
// ------------------------------------------------------------------------

39
common/include/x86emitter/implement/group3.h
View File

@ -15,10 +15,10 @@
#pragma once
namespace x86Emitter {
enum G3Type
namespace x86Emitter
{
enum G3Type {
G3Type_NOT = 2,
G3Type_NEG = 3,
G3Type_MUL = 4,
@ -34,8 +34,8 @@ struct xImpl_Group3
{
G3Type InstType;
void operator()( const xRegisterInt& from ) const;
void operator()( const xIndirect64orLess& from ) const;
void operator()(const xRegisterInt &from) const;
void operator()(const xIndirect64orLess &from) const;
#if 0
template< typename T >
@ -56,8 +56,8 @@ struct xImpl_MulDivBase
G3Type InstType;
u16 OpcodeSSE;
void operator()( const xRegisterInt& from ) const;
void operator()( const xIndirect64orLess& from ) const;
void operator()(const xRegisterInt &from) const;
void operator()(const xIndirect64orLess &from) const;
const xImplSimd_DestRegSSE PS;
const xImplSimd_DestRegSSE PD;
@ -70,8 +70,8 @@ struct xImpl_MulDivBase
// --------------------------------------------------------------------------------------
struct xImpl_iDiv
{
void operator()( const xRegisterInt& from ) const;
void operator()( const xIndirect64orLess& from ) const;
void operator()(const xRegisterInt &from) const;
void operator()(const xIndirect64orLess &from) const;
const xImplSimd_DestRegSSE PS;
const xImplSimd_DestRegSSE PD;
@ -85,25 +85,24 @@ struct xImpl_iDiv
//
struct xImpl_iMul
{
void operator()( const xRegisterInt& from ) const;
void operator()( const xIndirect64orLess& from ) const;
void operator()(const xRegisterInt &from) const;
void operator()(const xIndirect64orLess &from) const;
// The following iMul-specific forms are valid for 16 and 32 bit register operands only!
void operator()( const xRegister32& to, const xRegister32& from ) const;
void operator()( const xRegister32& to, const xIndirectVoid& src ) const;
void operator()( const xRegister16& to, const xRegister16& from ) const;
void operator()( const xRegister16& to, const xIndirectVoid& src ) const;
void operator()(const xRegister32 &to, const xRegister32 &from) const;
void operator()(const xRegister32 &to, const xIndirectVoid &src) const;
void operator()(const xRegister16 &to, const xRegister16 &from) const;
void operator()(const xRegister16 &to, const xIndirectVoid &src) const;
void operator()( const xRegister32& to, const xRegister32& from, s32 imm ) const;
void operator()( const xRegister32& to, const xIndirectVoid& from, s32 imm ) const;
void operator()( const xRegister16& to, const xRegister16& from, s16 imm ) const;
void operator()( const xRegister16& to, const xIndirectVoid& from, s16 imm ) const;
void operator()(const xRegister32 &to, const xRegister32 &from, s32 imm) const;
void operator()(const xRegister32 &to, const xIndirectVoid &from, s32 imm) const;
void operator()(const xRegister16 &to, const xRegister16 &from, s16 imm) const;
void operator()(const xRegister16 &to, const xIndirectVoid &from, s16 imm) const;
const xImplSimd_DestRegSSE PS;
const xImplSimd_DestRegSSE PD;
const xImplSimd_DestRegSSE SS;
const xImplSimd_DestRegSSE SD;
};
}

3
common/include/x86emitter/implement/helpers.h
View File

@ -15,7 +15,8 @@
#pragma once
namespace x86Emitter {
namespace x86Emitter
{
// helpermess is currently broken >_<

7
common/include/x86emitter/implement/incdec.h
View File

@ -18,7 +18,8 @@
// Implementations found here: Increment and Decrement Instructions!
// (They're soooo lonely... but I dunno where else to stick this class!)
namespace x86Emitter {
namespace x86Emitter
{
// --------------------------------------------------------------------------------------
// xImpl_IncDec
@ -27,8 +28,8 @@ struct xImpl_IncDec
{
bool isDec;
void operator()( const xRegisterInt& to ) const;
void operator()( const xIndirect64orLess& to ) const;
void operator()(const xRegisterInt &to) const;
void operator()(const xIndirect64orLess &to) const;
};
} // End namespace x86Emitter

57
common/include/x86emitter/implement/jmpcall.h
View File

@ -17,32 +17,32 @@
// Implementations found here: CALL and JMP! (unconditional only)
namespace x86Emitter {
namespace x86Emitter
{
extern void xJccKnownTarget( JccComparisonType comparison, const void* target, bool slideForward );
extern void xJccKnownTarget(JccComparisonType comparison, const void *target, bool slideForward);
// ------------------------------------------------------------------------
struct xImpl_JmpCall
{
bool isJmp;
void operator()( const xRegisterInt& absreg ) const;
void operator()( const xIndirect64orLess& src ) const;
void operator()(const xRegisterInt &absreg) const;
void operator()(const xIndirect64orLess &src) const;
// Special form for calling functions. This form automatically resolves the
// correct displacement based on the size of the instruction being generated.
void operator()( void* func ) const
{
if( isJmp )
xJccKnownTarget( Jcc_Unconditional, (void*)(uptr)func, false ); // double cast to/from (uptr) needed to appease GCC
else
void operator()(void *func) const
{
if (isJmp)
xJccKnownTarget(Jcc_Unconditional, (void *)(uptr)func, false); // double cast to/from (uptr) needed to appease GCC
else {
// calls are relative to the instruction after this one, and length is
// always 5 bytes (16 bit calls are bad mojo, so no bother to do special logic).
sptr dest = (sptr)func - ((sptr)xGetPtr() + 5);
xWrite8( 0xe8 );
xWrite32( dest );
xWrite8(0xe8);
xWrite32(dest);
}
}
};
@ -53,11 +53,11 @@ extern const xImpl_JmpCall xCALL;
struct xImpl_FastCall
{
// FIXME: current 64 bits is mostly a copy/past potentially it would require to push/pop
// some registers. But I think it is enough to handle the first call.
// FIXME: current 64 bits is mostly a copy/past potentially it would require to push/pop
// some registers. But I think it is enough to handle the first call.
// Type unsafety is nice
// Type unsafety is nice
#ifdef __x86_64__
#define XFASTCALL \
@ -88,7 +88,7 @@ struct xImpl_FastCall
#endif
void operator()( void* f, const xRegisterLong& a1 = xEmptyReg, const xRegisterLong& a2 = xEmptyReg) const
void operator()(void *f, const xRegisterLong &a1 = xEmptyReg, const xRegisterLong &a2 = xEmptyReg) const
{
#ifdef __x86_64__
if (a1.IsEmpty()) {
@ -109,10 +109,10 @@ struct xImpl_FastCall
#endif
}
template< typename T > __fi
void operator()( T* func, u32 a1, const xRegisterLong& a2) const
template <typename T>
__fi void operator()(T *func, u32 a1, const xRegisterLong &a2) const
{
void* f = (void*)func;
void *f = (void *)func;
#ifdef __x86_64__
XFASTCALL2;
@ -121,10 +121,10 @@ struct xImpl_FastCall
#endif
}
template< typename T > __fi
void operator()( T* func, const xIndirectVoid& a1) const
template <typename T>
__fi void operator()(T *func, const xIndirectVoid &a1) const
{
void* f = (void*)func;
void *f = (void *)func;
#ifdef __x86_64__
XFASTCALL1;
@ -133,10 +133,10 @@ struct xImpl_FastCall
#endif
}
template< typename T > __fi
void operator()( T* func, u32 a1, u32 a2) const
template <typename T>
__fi void operator()(T *func, u32 a1, u32 a2) const
{
void* f = (void*)func;
void *f = (void *)func;
#ifdef __x86_64__
XFASTCALL2;
@ -145,10 +145,10 @@ struct xImpl_FastCall
#endif
}
template< typename T > __fi
void operator()( T* func, u32 a1) const
template <typename T>
__fi void operator()(T *func, u32 a1) const
{
void* f = (void*)func;
void *f = (void *)func;
#ifdef __x86_64__
XFASTCALL1;
@ -157,7 +157,7 @@ struct xImpl_FastCall
#endif
}
void operator()(const xIndirect32& f, const xRegisterLong& a1 = xEmptyReg, const xRegisterLong& a2 = xEmptyReg) const
void operator()(const xIndirect32 &f, const xRegisterLong &a1 = xEmptyReg, const xRegisterLong &a2 = xEmptyReg) const
{
#ifdef __x86_64__
if (a1.IsEmpty()) {
@ -184,4 +184,3 @@ struct xImpl_FastCall
};
} // End namespace x86Emitter

29
common/include/x86emitter/implement/movs.h
View File

@ -18,7 +18,8 @@
// Header: ix86_impl_movs.h -- covers mov, cmov, movsx/movzx, and SETcc (which shares
// with cmov many similarities).
namespace x86Emitter {
namespace x86Emitter
{
// --------------------------------------------------------------------------------------
// MovImplAll
@ -29,11 +30,11 @@ struct xImpl_Mov
{
xImpl_Mov() {} // Satisfy GCC's whims.
void operator()( const xRegisterInt& to, const xRegisterInt& from ) const;
void operator()( const xIndirectVoid& dest, const xRegisterInt& from ) const;
void operator()( const xRegisterInt& to, const xIndirectVoid& src ) const;
void operator()( const xIndirect64orLess& dest, int imm ) const;
void operator()( const xRegisterInt& to, int imm, bool preserve_flags=false ) const;
void operator()(const xRegisterInt &to, const xRegisterInt &from) const;
void operator()(const xIndirectVoid &dest, const xRegisterInt &from) const;
void operator()(const xRegisterInt &to, const xIndirectVoid &src) const;
void operator()(const xIndirect64orLess &dest, int imm) const;
void operator()(const xRegisterInt &to, int imm, bool preserve_flags = false) const;
#if 0
template< typename T > __noinline void operator()( const ModSibBase& to, const xImmReg<T>& immOrReg ) const
@ -85,8 +86,8 @@ struct xImpl_Mov
struct xImpl_CMov
{
JccComparisonType ccType;
void operator()( const xRegister16or32or64& to, const xRegister16or32or64& from ) const;
void operator()( const xRegister16or32or64& to, const xIndirectVoid& sibsrc ) const;
void operator()(const xRegister16or32or64 &to, const xRegister16or32or64 &from) const;
void operator()(const xRegister16or32or64 &to, const xIndirectVoid &sibsrc) const;
//void operator()( const xDirectOrIndirect32& to, const xDirectOrIndirect32& from );
//void operator()( const xDirectOrIndirect16& to, const xDirectOrIndirect16& from ) const;
@ -96,8 +97,8 @@ struct xImpl_Set
{
JccComparisonType ccType;
void operator()( const xRegister8& to ) const;
void operator()( const xIndirect8& dest ) const;
void operator()(const xRegister8 &to) const;
void operator()(const xIndirect8 &dest) const;
//void operator()( const xDirectOrIndirect8& dest ) const;
};
@ -112,10 +113,10 @@ struct xImpl_MovExtend
{
bool SignExtend;
void operator()( const xRegister16or32or64& to, const xRegister8& from ) const;
void operator()( const xRegister16or32or64& to, const xIndirect8& sibsrc ) const;
void operator()( const xRegister32or64& to, const xRegister16& from ) const;
void operator()( const xRegister32or64& to, const xIndirect16& sibsrc ) const;
void operator()(const xRegister16or32or64 &to, const xRegister8 &from) const;
void operator()(const xRegister16or32or64 &to, const xIndirect8 &sibsrc) const;
void operator()(const xRegister32or64 &to, const xRegister16 &from) const;
void operator()(const xRegister32or64 &to, const xIndirect16 &sibsrc) const;
//void operator()( const xRegister32& to, const xDirectOrIndirect16& src ) const;
//void operator()( const xRegister16or32& to, const xDirectOrIndirect8& src ) const;

13
common/include/x86emitter/implement/simd_arithmetic.h
View File

@ -15,7 +15,8 @@
#pragma once
namespace x86Emitter {
namespace x86Emitter
{
// --------------------------------------------------------------------------------------
// _SimdShiftHelper
@ -27,10 +28,10 @@ struct _SimdShiftHelper
u16 OpcodeImm;
u8 Modcode;
void operator()( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void operator()( const xRegisterSSE& to, const xIndirectVoid& from ) const;
void operator()(const xRegisterSSE &to, const xRegisterSSE &from) const;
void operator()(const xRegisterSSE &to, const xIndirectVoid &from) const;
void operator()( const xRegisterSSE& to, u8 imm8 ) const;
void operator()(const xRegisterSSE &to, u8 imm8) const;
};
// --------------------------------------------------------------------------------------
@ -53,7 +54,7 @@ struct xImplSimd_Shift
const _SimdShiftHelper D;
const _SimdShiftHelper Q;
void DQ( const xRegisterSSE& to, u8 imm8 ) const;
void DQ(const xRegisterSSE &to, u8 imm8) const;
};
//////////////////////////////////////////////////////////////////////////////////////////
@ -178,7 +179,6 @@ struct xImplSimd_PSign
// is unchanged. If a data element in src is zero, the corresponding data element in
// dest is set to zero.
const xImplSimd_DestRegEither D;
};
//////////////////////////////////////////////////////////////////////////////////////////
@ -314,4 +314,3 @@ struct xImplSimd_Round
};
} // End namespace x86Emitter

20
common/include/x86emitter/implement/simd_comparisons.h
View File

@ -15,7 +15,8 @@
#pragma once
namespace x86Emitter {
namespace x86Emitter
{
struct xImplSimd_MinMax
{
@ -31,17 +32,17 @@ struct xImplSimd_Compare
{
SSE2_ComparisonType CType;
void PS( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void PS( const xRegisterSSE& to, const xIndirectVoid& from ) const;
void PS(const xRegisterSSE &to, const xRegisterSSE &from) const;
void PS(const xRegisterSSE &to, const xIndirectVoid &from) const;
void PD( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void PD( const xRegisterSSE& to, const xIndirectVoid& from ) const;
void PD(const xRegisterSSE &to, const xRegisterSSE &from) const;
void PD(const xRegisterSSE &to, const xIndirectVoid &from) const;
void SS( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void SS( const xRegisterSSE& to, const xIndirectVoid& from ) const;
void SS(const xRegisterSSE &to, const xRegisterSSE &from) const;
void SS(const xRegisterSSE &to, const xIndirectVoid &from) const;
void SD( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void SD( const xRegisterSSE& to, const xIndirectVoid& from ) const;
void SD(const xRegisterSSE &to, const xRegisterSSE &from) const;
void SD(const xRegisterSSE &to, const xIndirectVoid &from) const;
};
//////////////////////////////////////////////////////////////////////////////////////////
@ -120,4 +121,3 @@ struct xImplSimd_PMinMax
};
} // end namespace x86Emitter

20
common/include/x86emitter/implement/simd_helpers.h
View File

@ -15,7 +15,8 @@
#pragma once
namespace x86Emitter {
namespace x86Emitter
{
// =====================================================================================================
// xImpl_SIMD Types (template free!)
@ -30,8 +31,8 @@ struct xImplSimd_DestRegSSE
u8 Prefix;
u16 Opcode;
void operator()( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void operator()( const xRegisterSSE& to, const xIndirectVoid& from ) const;
void operator()(const xRegisterSSE &to, const xRegisterSSE &from) const;
void operator()(const xRegisterSSE &to, const xIndirectVoid &from) const;
};
// ------------------------------------------------------------------------
@ -43,8 +44,8 @@ struct xImplSimd_DestRegImmSSE
u8 Prefix;
u16 Opcode;
void operator()( const xRegisterSSE& to, const xRegisterSSE& from, u8 imm ) const;
void operator()( const xRegisterSSE& to, const xIndirectVoid& from, u8 imm ) const;
void operator()(const xRegisterSSE &to, const xRegisterSSE &from, u8 imm) const;
void operator()(const xRegisterSSE &to, const xIndirectVoid &from, u8 imm) const;
};
struct xImplSimd_DestSSE_CmpImm
@ -52,8 +53,8 @@ struct xImplSimd_DestSSE_CmpImm
u8 Prefix;
u16 Opcode;
void operator()( const xRegisterSSE& to, const xRegisterSSE& from, SSE2_ComparisonType imm ) const;
void operator()( const xRegisterSSE& to, const xIndirectVoid& from, SSE2_ComparisonType imm ) const;
void operator()(const xRegisterSSE &to, const xRegisterSSE &from, SSE2_ComparisonType imm) const;
void operator()(const xRegisterSSE &to, const xIndirectVoid &from, SSE2_ComparisonType imm) const;
};
// ------------------------------------------------------------------------
@ -65,9 +66,8 @@ struct xImplSimd_DestRegEither
u8 Prefix;
u16 Opcode;
void operator()( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void operator()( const xRegisterSSE& to, const xIndirectVoid& from ) const;
void operator()(const xRegisterSSE &to, const xRegisterSSE &from) const;
void operator()(const xRegisterSSE &to, const xIndirectVoid &from) const;
};
} // end namespace x86Emitter

53
common/include/x86emitter/implement/simd_moremovs.h
View File

@ -15,7 +15,8 @@
#pragma once
namespace x86Emitter {
namespace x86Emitter
{
// --------------------------------------------------------------------------------------
// xImplSimd_MovHL
@ -27,11 +28,11 @@ struct xImplSimd_MovHL
{
u16 Opcode;
void PS( const xRegisterSSE& to, const xIndirectVoid& from ) const;
void PS( const xIndirectVoid& to, const xRegisterSSE& from ) const;
void PS(const xRegisterSSE &to, const xIndirectVoid &from) const;
void PS(const xIndirectVoid &to, const xRegisterSSE &from) const;
void PD( const xRegisterSSE& to, const xIndirectVoid& from ) const;
void PD( const xIndirectVoid& to, const xRegisterSSE& from ) const;
void PD(const xRegisterSSE &to, const xIndirectVoid &from) const;
void PD(const xIndirectVoid &to, const xRegisterSSE &from) const;
};
// --------------------------------------------------------------------------------------
@ -44,8 +45,8 @@ struct xImplSimd_MovHL_RtoR
{
u16 Opcode;
void PS( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void PD( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void PS(const xRegisterSSE &to, const xRegisterSSE &from) const;
void PD(const xRegisterSSE &to, const xRegisterSSE &from) const;
};
// --------------------------------------------------------------------------------------
@ -62,9 +63,9 @@ struct xImplSimd_MoveSSE
u8 Prefix;
bool isAligned;
void operator()( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void operator()( const xRegisterSSE& to, const xIndirectVoid& from ) const;
void operator()( const xIndirectVoid& to, const xRegisterSSE& from ) const;
void operator()(const xRegisterSSE &to, const xRegisterSSE &from) const;
void operator()(const xRegisterSSE &to, const xIndirectVoid &from) const;
void operator()(const xIndirectVoid &to, const xRegisterSSE &from) const;
};
// --------------------------------------------------------------------------------------
@ -81,9 +82,9 @@ struct xImplSimd_MoveDQ
u8 Prefix;
bool isAligned;
void operator()( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void operator()( const xRegisterSSE& to, const xIndirectVoid& from ) const;
void operator()( const xIndirectVoid& to, const xRegisterSSE& from ) const;
void operator()(const xRegisterSSE &to, const xRegisterSSE &from) const;
void operator()(const xRegisterSSE &to, const xIndirectVoid &from) const;
void operator()(const xIndirectVoid &to, const xRegisterSSE &from) const;
};
// --------------------------------------------------------------------------------------
@ -141,34 +142,32 @@ struct xImplSimd_PMove
// [SSE-4.1] Zero/Sign-extend the low byte values in src into word integers
// and store them in dest.
void BW( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void BW( const xRegisterSSE& to, const xIndirect64& from ) const;
void BW(const xRegisterSSE &to, const xRegisterSSE &from) const;
void BW(const xRegisterSSE &to, const xIndirect64 &from) const;
// [SSE-4.1] Zero/Sign-extend the low byte values in src into dword integers
// and store them in dest.
void BD( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void BD( const xRegisterSSE& to, const xIndirect32& from ) const;
void BD(const xRegisterSSE &to, const xRegisterSSE &from) const;
void BD(const xRegisterSSE &to, const xIndirect32 &from) const;
// [SSE-4.1] Zero/Sign-extend the low byte values in src into qword integers
// and store them in dest.
void BQ( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void BQ( const xRegisterSSE& to, const xIndirect16& from ) const;
void BQ(const xRegisterSSE &to, const xRegisterSSE &from) const;
void BQ(const xRegisterSSE &to, const xIndirect16 &from) const;
// [SSE-4.1] Zero/Sign-extend the low word values in src into dword integers
// and store them in dest.
void WD( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void WD( const xRegisterSSE& to, const xIndirect64& from ) const;
void WD(const xRegisterSSE &to, const xRegisterSSE &from) const;
void WD(const xRegisterSSE &to, const xIndirect64 &from) const;
// [SSE-4.1] Zero/Sign-extend the low word values in src into qword integers
// and store them in dest.
void WQ( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void WQ( const xRegisterSSE& to, const xIndirect32& from ) const;
void WQ(const xRegisterSSE &to, const xRegisterSSE &from) const;
void WQ(const xRegisterSSE &to, const xIndirect32 &from) const;
// [SSE-4.1] Zero/Sign-extend the low dword values in src into qword integers
// and store them in dest.
void DQ( const xRegisterSSE& to, const xRegisterSSE& from ) const;
void DQ( const xRegisterSSE& to, const xIndirect64& from ) const;
void DQ(const xRegisterSSE &to, const xRegisterSSE &from) const;
void DQ(const xRegisterSSE &to, const xIndirect64 &from) const;
};
}

34
common/include/x86emitter/implement/simd_shufflepack.h
View File

@ -15,20 +15,21 @@
#pragma once
namespace x86Emitter {
namespace x86Emitter
{
// --------------------------------------------------------------------------------------
// xImplSimd_Shuffle
// --------------------------------------------------------------------------------------
struct xImplSimd_Shuffle
{
inline void _selector_assertion_check( u8 selector ) const;
inline void _selector_assertion_check(u8 selector) const;
void PS( const xRegisterSSE& to, const xRegisterSSE& from, u8 selector ) const;
void PS( const xRegisterSSE& to, const xIndirectVoid& from, u8 selector ) const;
void PS(const xRegisterSSE &to, const xRegisterSSE &from, u8 selector) const;
void PS(const xRegisterSSE &to, const xIndirectVoid &from, u8 selector) const;
void PD( const xRegisterSSE& to, const xRegisterSSE& from, u8 selector ) const;
void PD( const xRegisterSSE& to, const xIndirectVoid& from, u8 selector ) const;
void PD(const xRegisterSSE &to, const xRegisterSSE &from, u8 selector) const;
void PD(const xRegisterSSE &to, const xIndirectVoid &from, u8 selector) const;
};
// --------------------------------------------------------------------------------------
@ -59,10 +60,10 @@ struct xImplSimd_PShuffle
//
const xImplSimd_DestRegEither B;
// below is my test bed for a new system, free of subclasses. Was supposed to improve intellisense
// but it doesn't (makes it worse). Will try again in MSVC 2010. --air
// below is my test bed for a new system, free of subclasses. Was supposed to improve intellisense
// but it doesn't (makes it worse). Will try again in MSVC 2010. --air
#if 0
#if 0
// Copies words from src and inserts them into dest at word locations selected with
// the order operand (8 bit immediate).
@ -92,7 +93,7 @@ struct xImplSimd_PShuffle
//
void B( const xRegisterSSE& to, const xRegisterSSE& from ) const { OpWriteSSE( 0x66, 0x0038 ); }
void B( const xRegisterSSE& to, const xIndirectVoid& from ) const { OpWriteSSE( 0x66, 0x0038 ); }
#endif
#endif
};
// --------------------------------------------------------------------------------------
@ -188,10 +189,10 @@ struct xImplSimd_InsertExtractHelper
u16 Opcode;
// [SSE-4.1] Allowed with SSE registers only (MMX regs are invalid)
void operator()( const xRegisterSSE& to, const xRegister32& from, u8 imm8 ) const;
void operator()(const xRegisterSSE &to, const xRegister32 &from, u8 imm8) const;
// [SSE-4.1] Allowed with SSE registers only (MMX regs are invalid)
void operator()( const xRegisterSSE& to, const xIndirectVoid& from, u8 imm8 ) const;
void operator()(const xRegisterSSE &to, const xIndirectVoid &from, u8 imm8) const;
};
// --------------------------------------------------------------------------------------
@ -201,8 +202,8 @@ struct xImplSimd_InsertExtractHelper
//
struct xImplSimd_PInsert
{
void W( const xRegisterSSE& to, const xRegister32& from, u8 imm8 ) const;
void W( const xRegisterSSE& to, const xIndirectVoid& from, u8 imm8 ) const;
void W(const xRegisterSSE &to, const xRegister32 &from, u8 imm8) const;
void W(const xRegisterSSE &to, const xIndirectVoid &from, u8 imm8) const;
// [SSE-4.1] Allowed with SSE registers only (MMX regs are invalid)
xImplSimd_InsertExtractHelper B;
@ -225,8 +226,8 @@ struct SimdImpl_PExtract
//
// [SSE-4.1] Note: Indirect memory forms of this instruction are an SSE-4.1 extension!
//
void W( const xRegister32& to, const xRegisterSSE& from, u8 imm8 ) const;
void W( const xIndirectVoid& dest, const xRegisterSSE& from, u8 imm8 ) const;
void W(const xRegister32 &to, const xRegisterSSE &from, u8 imm8) const;
void W(const xIndirectVoid &dest, const xRegisterSSE &from, u8 imm8) const;
// [SSE-4.1] Copies the byte element specified by imm8 from src to dest. The upper bits
// of dest are zero-extended (cleared). This can be used to extract any single packed
@ -237,5 +238,4 @@ struct SimdImpl_PExtract
// used to extract any single packed dword value from src into an x86 32 bit register.
const xImplSimd_InsertExtractHelper D;
};
}

10
common/include/x86emitter/implement/simd_templated_helpers.h
View File

@ -22,16 +22,16 @@
// For implementing SSE-only logic operations that have xmmreg,xmmreg/rm forms only,
// like ANDPS/ANDPD
//
template< u8 Prefix, u16 Opcode >
template <u8 Prefix, u16 Opcode>
class SimdImpl_DestRegSSE
{
public:
__forceinline void operator()( const xRegisterSSE& to, const xRegisterSSE& from ) const { xOpWrite0F( Prefix, Opcode, to, from ); }
__forceinline void operator()( const xRegisterSSE& to, const ModSibBase& from ) const
__forceinline void operator()(const xRegisterSSE &to, const xRegisterSSE &from) const { xOpWrite0F(Prefix, Opcode, to, from); }
__forceinline void operator()(const xRegisterSSE &to, const ModSibBase &from) const
{
bool isReallyAligned = ((from.Displacement & 0x0f) == 0) && from.Index.IsEmpty() && from.Base.IsEmpty();
pxAssertDev( isReallyAligned, "Alignment check failed on SSE indirect load." );
xOpWrite0F( Prefix, Opcode, to, from );
pxAssertDev(isReallyAligned, "Alignment check failed on SSE indirect load.");
xOpWrite0F(Prefix, Opcode, to, from);
}
SimdImpl_DestRegSSE() {} //GCWho?

29
common/include/x86emitter/implement/test.h
View File

@ -17,7 +17,8 @@
// Implementations found here: TEST + BTS/BT/BTC/BTR + BSF/BSR! (for lack of better location)
namespace x86Emitter {
namespace x86Emitter
{
// --------------------------------------------------------------------------------------
// xImpl_Test
@ -25,13 +26,12 @@ namespace x86Emitter {
//
struct xImpl_Test
{
void operator()( const xRegisterInt& to, const xRegisterInt& from ) const;
void operator()( const xIndirect64orLess& dest, int imm ) const;
void operator()( const xRegisterInt& to, int imm ) const;
void operator()(const xRegisterInt &to, const xRegisterInt &from) const;
void operator()(const xIndirect64orLess &dest, int imm) const;
void operator()(const xRegisterInt &to, int imm) const;
};
enum G8Type
{
enum G8Type {
G8Type_BT = 4,
G8Type_BTS,
G8Type_BTR,
@ -48,8 +48,8 @@ struct xImpl_BitScan
// 0xbc [fwd] / 0xbd [rev]
u16 Opcode;
void operator()( const xRegister16or32or64& to, const xRegister16or32or64& from ) const;
void operator()( const xRegister16or32or64& to, const xIndirectVoid& sibsrc ) const;
void operator()(const xRegister16or32or64 &to, const xRegister16or32or64 &from) const;
void operator()(const xRegister16or32or64 &to, const xIndirectVoid &sibsrc) const;
};
// --------------------------------------------------------------------------------------
@ -61,15 +61,14 @@ struct xImpl_Group8
{
G8Type InstType;
void operator()( const xRegister16or32or64& bitbase, const xRegister16or32or64& bitoffset ) const;
void operator()( const xRegister16or32or64& bitbase, u8 bitoffset ) const;
void operator()(const xRegister16or32or64 &bitbase, const xRegister16or32or64 &bitoffset) const;
void operator()(const xRegister16or32or64 &bitbase, u8 bitoffset) const;
void operator()( const xIndirectVoid& bitbase, const xRegister16or32or64& bitoffset ) const;
void operator()(const xIndirectVoid &bitbase, const xRegister16or32or64 &bitoffset) const;
void operator()( const xIndirect64& bitbase, u8 bitoffset ) const;
void operator()( const xIndirect32& bitbase, u8 bitoffset ) const;
void operator()( const xIndirect16& bitbase, u8 bitoffset ) const;
void operator()(const xIndirect64 &bitbase, u8 bitoffset) const;
void operator()(const xIndirect32 &bitbase, u8 bitoffset) const;
void operator()(const xIndirect16 &bitbase, u8 bitoffset) const;
};
} // End namespace x86Emitter

3
common/include/x86emitter/implement/xchg.h
View File

@ -18,7 +18,8 @@
// This header file is intended to be the future home of xchg, cmpxchg, xadd, and
// other threading-related exchange instructions.
namespace x86Emitter {
namespace x86Emitter
{
} // End namespace x86Emitter

727
common/include/x86emitter/instructions.h
View File

@ -32,72 +32,71 @@
namespace x86Emitter
{
extern void xStoreReg( const xRegisterSSE& src );
extern void xRestoreReg( const xRegisterSSE& dest );
extern void xStoreReg(const xRegisterSSE &src);
extern void xRestoreReg(const xRegisterSSE &dest);
// ------------------------------------------------------------------------
// Group 1 Instruction Class
// ------------------------------------------------------------------------
// Group 1 Instruction Class
extern const xImpl_Group1 xADC;
extern const xImpl_Group1 xSBB;
extern const xImpl_Group1 xADC;
extern const xImpl_Group1 xSBB;
extern const xImpl_G1Logic xAND;
extern const xImpl_G1Logic xOR;
extern const xImpl_G1Logic xXOR;
extern const xImpl_G1Logic xAND;
extern const xImpl_G1Logic xOR;
extern const xImpl_G1Logic xXOR;
extern const xImpl_G1Arith xADD;
extern const xImpl_G1Arith xSUB;
extern const xImpl_G1Compare xCMP;
extern const xImpl_G1Arith xADD;
extern const xImpl_G1Arith xSUB;
extern const xImpl_G1Compare xCMP;
// ------------------------------------------------------------------------
// Group 2 Instruction Class
//
// Optimization Note: For Imm forms, we ignore the instruction if the shift count is
// zero. This is a safe optimization since any zero-value shift does not affect any
// flags.
// ------------------------------------------------------------------------
// Group 2 Instruction Class
//
// Optimization Note: For Imm forms, we ignore the instruction if the shift count is
// zero. This is a safe optimization since any zero-value shift does not affect any
// flags.
extern const xImpl_Mov xMOV;
extern const xImpl_Test xTEST;
extern const xImpl_Mov xMOV;
extern const xImpl_Test xTEST;
extern const xImpl_Group2 xROL, xROR,
extern const xImpl_Group2 xROL, xROR,
xRCL, xRCR,
xSHL, xSHR,
xSAR;
// ------------------------------------------------------------------------
// Group 3 Instruction Class
// ------------------------------------------------------------------------
// Group 3 Instruction Class
extern const xImpl_Group3 xNOT, xNEG;
extern const xImpl_Group3 xUMUL, xUDIV;
extern const xImpl_iDiv xDIV;
extern const xImpl_iMul xMUL;
extern const xImpl_Group3 xNOT, xNEG;
extern const xImpl_Group3 xUMUL, xUDIV;
extern const xImpl_iDiv xDIV;
extern const xImpl_iMul xMUL;
extern const xImpl_IncDec xINC, xDEC;
extern const xImpl_IncDec xINC, xDEC;
extern const xImpl_MovExtend xMOVZX, xMOVSX;
extern const xImpl_MovExtend xMOVZX, xMOVSX;
extern const xImpl_DwordShift xSHLD, xSHRD;
extern const xImpl_DwordShift xSHLD, xSHRD;
extern const xImpl_Group8 xBT;
extern const xImpl_Group8 xBTR;
extern const xImpl_Group8 xBTS;
extern const xImpl_Group8 xBTC;
extern const xImpl_Group8 xBT;
extern const xImpl_Group8 xBTR;
extern const xImpl_Group8 xBTS;
extern const xImpl_Group8 xBTC;
extern const xImpl_BitScan xBSF, xBSR;
extern const xImpl_BitScan xBSF, xBSR;
extern const xImpl_JmpCall xJMP;
extern const xImpl_JmpCall xJMP;
#ifdef __x86_64__
// 32 bits Call won't be compatible in 64 bits (different ABI)
// Just a reminder to port the code
[[deprecated]] extern const xImpl_JmpCall xCALL;
// 32 bits Call won't be compatible in 64 bits (different ABI)
// Just a reminder to port the code
[[deprecated]] extern const xImpl_JmpCall xCALL;
#else
extern const xImpl_JmpCall xCALL;
extern const xImpl_JmpCall xCALL;
#endif
extern const xImpl_FastCall xFastCall;
extern const xImpl_FastCall xFastCall;
// ------------------------------------------------------------------------
extern const xImpl_CMov
xCMOVA, xCMOVAE,
// ------------------------------------------------------------------------
extern const xImpl_CMov xCMOVA, xCMOVAE,
xCMOVB, xCMOVBE,
xCMOVG, xCMOVGE,
xCMOVL, xCMOVLE,
@ -110,9 +109,8 @@ namespace x86Emitter
xCMOVS, xCMOVNS,
xCMOVPE, xCMOVPO;
// ------------------------------------------------------------------------
extern const xImpl_Set
xSETA, xSETAE,
// ------------------------------------------------------------------------
extern const xImpl_Set xSETA, xSETAE,
xSETB, xSETBE,
xSETG, xSETGE,
xSETL, xSETLE,
@ -125,379 +123,460 @@ namespace x86Emitter
xSETS, xSETNS,
xSETPE, xSETPO;
// ------------------------------------------------------------------------
// BMI extra instruction requires BMI1/BMI2
extern const xImplBMI_RVM xMULX, xPDEP, xPEXT, xANDN_S; // Warning xANDN is already used by SSE
// ------------------------------------------------------------------------
// BMI extra instruction requires BMI1/BMI2
extern const xImplBMI_RVM xMULX, xPDEP, xPEXT, xANDN_S; // Warning xANDN is already used by SSE
//////////////////////////////////////////////////////////////////////////////////////////
// Miscellaneous Instructions
// These are all defined inline or in ix86.cpp.
//
//////////////////////////////////////////////////////////////////////////////////////////
// Miscellaneous Instructions
// These are all defined inline or in ix86.cpp.
//
extern void xBSWAP( const xRegister32or64& to );
extern void xBSWAP(const xRegister32or64 &to);
// ----- Lea Instructions (Load Effective Address) -----
// Note: alternate (void*) forms of these instructions are not provided since those
// forms are functionally equivalent to Mov reg,imm, and thus better written as MOVs
// instead.
// ----- Lea Instructions (Load Effective Address) -----
// Note: alternate (void*) forms of these instructions are not provided since those
// forms are functionally equivalent to Mov reg,imm, and thus better written as MOVs
// instead.
extern void xLEA( xRegister64 to, const xIndirectVoid& src, bool preserve_flags=false );
extern void xLEA( xRegister32 to, const xIndirectVoid& src, bool preserve_flags=false );
extern void xLEA( xRegister16 to, const xIndirectVoid& src, bool preserve_flags=false );
extern void xLEA(xRegister64 to, const xIndirectVoid &src, bool preserve_flags = false);
extern void xLEA(xRegister32 to, const xIndirectVoid &src, bool preserve_flags = false);
extern void xLEA(xRegister16 to, const xIndirectVoid &src, bool preserve_flags = false);
// ----- Push / Pop Instructions -----
// Note: pushad/popad implementations are intentionally left out. The instructions are
// invalid in x64, and are super slow on x32. Use multiple Push/Pop instructions instead.
// ----- Push / Pop Instructions -----
// Note: pushad/popad implementations are intentionally left out. The instructions are
// invalid in x64, and are super slow on x32. Use multiple Push/Pop instructions instead.
extern void xPOP( const xIndirectVoid& from );
extern void xPUSH( const xIndirectVoid& from );
extern void xPOP(const xIndirectVoid &from);
extern void xPUSH(const xIndirectVoid &from);
extern void xPOP( xRegister32or64 from );
extern void xPOP(xRegister32or64 from);
extern void xPUSH( u32 imm );
extern void xPUSH( xRegister32or64 from );
extern void xPUSH(u32 imm);
extern void xPUSH(xRegister32or64 from);
// pushes the EFLAGS register onto the stack
extern void xPUSHFD();
// pops the EFLAGS register from the stack
extern void xPOPFD();
// pushes the EFLAGS register onto the stack
extern void xPUSHFD();
// pops the EFLAGS register from the stack
extern void xPOPFD();
// ----- Miscellaneous Instructions -----
// Various Instructions with no parameter and no special encoding logic.
// ----- Miscellaneous Instructions -----
// Various Instructions with no parameter and no special encoding logic.
extern void xLEAVE();
extern void xRET();
extern void xCBW();
extern void xCWD();
extern void xCDQ();
extern void xCWDE();
extern void xLEAVE();
extern void xRET();
extern void xCBW();
extern void xCWD();
extern void xCDQ();
extern void xCWDE();
extern void xLAHF();
extern void xSAHF();
extern void xLAHF();
extern void xSAHF();
extern void xSTC();
extern void xCLC();
extern void xSTC();
extern void xCLC();
// NOP 1-byte
extern void xNOP();
// NOP 1-byte
extern void xNOP();
extern void xINT( u8 imm );
extern void xINTO();
extern void xINT(u8 imm);
extern void xINTO();
//////////////////////////////////////////////////////////////////////////////////////////
// Helper object to handle the various functions ABI
class xScopedStackFrame
{
//////////////////////////////////////////////////////////////////////////////////////////
// Helper object to handle the various functions ABI
class xScopedStackFrame
{
bool m_base_frame;
bool m_save_base_pointer;
int m_offset;
public:
public:
xScopedStackFrame(bool base_frame, bool save_base_pointer = false, int offset = 0);
~xScopedStackFrame();
};
};
//////////////////////////////////////////////////////////////////////////////////////////
// JMP / Jcc Instructions!
//////////////////////////////////////////////////////////////////////////////////////////
// JMP / Jcc Instructions!
extern void xJcc( JccComparisonType comparison, const void* target );
extern s8* xJcc8( JccComparisonType comparison=Jcc_Unconditional, s8 displacement=0 );
extern s32* xJcc32( JccComparisonType comparison=Jcc_Unconditional, s32 displacement=0 );
extern void xJcc(JccComparisonType comparison, const void *target);
extern s8 *xJcc8(JccComparisonType comparison = Jcc_Unconditional, s8 displacement = 0);
extern s32 *xJcc32(JccComparisonType comparison = Jcc_Unconditional, s32 displacement = 0);
// ------------------------------------------------------------------------
// Conditional jumps to fixed targets.
// Jumps accept any pointer as a valid target (function or data), and will generate either
// 8 or 32 bit displacement versions of the jump, depending on relative displacement of
// the target (efficient!)
//
// ------------------------------------------------------------------------
// Conditional jumps to fixed targets.
// Jumps accept any pointer as a valid target (function or data), and will generate either
// 8 or 32 bit displacement versions of the jump, depending on relative displacement of
// the target (efficient!)
//
template< typename T > __fi void xJE( T* func ) { xJcc( Jcc_Equal, (void*)(uptr)func ); }
template< typename T > __fi void xJZ( T* func ) { xJcc( Jcc_Zero, (void*)(uptr)func ); }
template< typename T > __fi void xJNE( T* func ) { xJcc( Jcc_NotEqual, (void*)(uptr)func ); }
template< typename T > __fi void xJNZ( T* func ) { xJcc( Jcc_NotZero, (void*)(uptr)func ); }
template <typename T>
__fi void xJE(T *func)
{
xJcc(Jcc_Equal, (void *)(uptr)func);
}
template <typename T>
__fi void xJZ(T *func)
{
xJcc(Jcc_Zero, (void *)(uptr)func);
}
template <typename T>
__fi void xJNE(T *func)
{
xJcc(Jcc_NotEqual, (void *)(uptr)func);
}
template <typename T>
__fi void xJNZ(T *func)
{
xJcc(Jcc_NotZero, (void *)(uptr)func);
}
template< typename T > __fi void xJO( T* func ) { xJcc( Jcc_Overflow, (void*)(uptr)func ); }
template< typename T > __fi void xJNO( T* func ) { xJcc( Jcc_NotOverflow, (void*)(uptr)func ); }
template< typename T > __fi void xJC( T* func ) { xJcc( Jcc_Carry, (void*)(uptr)func ); }
template< typename T > __fi void xJNC( T* func ) { xJcc( Jcc_NotCarry, (void*)(uptr)func ); }
template< typename T > __fi void xJS( T* func ) { xJcc( Jcc_Signed, (void*)(uptr)func ); }
template< typename T > __fi void xJNS( T* func ) { xJcc( Jcc_Unsigned, (void*)(uptr)func ); }
template <typename T>
__fi void xJO(T *func)
{
xJcc(Jcc_Overflow, (void *)(uptr)func);
}
template <typename T>
__fi void xJNO(T *func)
{
xJcc(Jcc_NotOverflow, (void *)(uptr)func);
}
template <typename T>
__fi void xJC(T *func)
{
xJcc(Jcc_Carry, (void *)(uptr)func);
}
template <typename T>
__fi void xJNC(T *func)
{
xJcc(Jcc_NotCarry, (void *)(uptr)func);
}
template <typename T>
__fi void xJS(T *func)
{
xJcc(Jcc_Signed, (void *)(uptr)func);
}
template <typename T>
__fi void xJNS(T *func)
{
xJcc(Jcc_Unsigned, (void *)(uptr)func);
}
template< typename T > __fi void xJPE( T* func ) { xJcc( Jcc_ParityEven, (void*)(uptr)func ); }
template< typename T > __fi void xJPO( T* func ) { xJcc( Jcc_ParityOdd, (void*)(uptr)func ); }
template <typename T>
__fi void xJPE(T *func)
{
xJcc(Jcc_ParityEven, (void *)(uptr)func);
}
template <typename T>
__fi void xJPO(T *func)
{
xJcc(Jcc_ParityOdd, (void *)(uptr)func);
}
template< typename T > __fi void xJL( T* func ) { xJcc( Jcc_Less, (void*)(uptr)func ); }
template< typename T > __fi void xJLE( T* func ) { xJcc( Jcc_LessOrEqual, (void*)(uptr)func ); }
template< typename T > __fi void xJG( T* func ) { xJcc( Jcc_Greater, (void*)(uptr)func ); }
template< typename T > __fi void xJGE( T* func ) { xJcc( Jcc_GreaterOrEqual, (void*)(uptr)func ); }
template <typename T>
__fi void xJL(T *func)
{
xJcc(Jcc_Less, (void *)(uptr)func);
}
template <typename T>
__fi void xJLE(T *func)
{
xJcc(Jcc_LessOrEqual, (void *)(uptr)func);
}
template <typename T>
__fi void xJG(T *func)
{
xJcc(Jcc_Greater, (void *)(uptr)func);
}
template <typename T>
__fi void xJGE(T *func)
{
xJcc(Jcc_GreaterOrEqual, (void *)(uptr)func);
}
template< typename T > __fi void xJB( T* func ) { xJcc( Jcc_Below, (void*)(uptr)func ); }
template< typename T > __fi void xJBE( T* func ) { xJcc( Jcc_BelowOrEqual, (void*)(uptr)func ); }
template< typename T > __fi void xJA( T* func ) { xJcc( Jcc_Above, (void*)(uptr)func ); }
template< typename T > __fi void xJAE( T* func ) { xJcc( Jcc_AboveOrEqual, (void*)(uptr)func ); }
template <typename T>
__fi void xJB(T *func)
{
xJcc(Jcc_Below, (void *)(uptr)func);
}
template <typename T>
__fi void xJBE(T *func)
{
xJcc(Jcc_BelowOrEqual, (void *)(uptr)func);
}
template <typename T>
__fi void xJA(T *func)
{
xJcc(Jcc_Above, (void *)(uptr)func);
}
template <typename T>
__fi void xJAE(T *func)
{
xJcc(Jcc_AboveOrEqual, (void *)(uptr)func);
}
// ------------------------------------------------------------------------
// Forward Jump Helpers (act as labels!)
// ------------------------------------------------------------------------
// Forward Jump Helpers (act as labels!)
#define DEFINE_FORWARD_JUMP( label, cond ) \
template< typename OperandType > \
#define DEFINE_FORWARD_JUMP(label, cond) \
template <typename OperandType> \
class xForward##label : public xForwardJump<OperandType> \
{ \
public: \
xForward##label() : xForwardJump<OperandType>( cond ) {} \
xForward##label() \
: xForwardJump<OperandType>(cond) \
{ \
} \
};
// ------------------------------------------------------------------------
// Note: typedefs below are defined individually in order to appease Intellisense
// resolution. Including them into the class definition macro above breaks it.
// ------------------------------------------------------------------------
// Note: typedefs below are defined individually in order to appease Intellisense
// resolution. Including them into the class definition macro above breaks it.
typedef xForwardJump<s8> xForwardJump8;
typedef xForwardJump<s32> xForwardJump32;
typedef xForwardJump<s8> xForwardJump8;
typedef xForwardJump<s32> xForwardJump32;
DEFINE_FORWARD_JUMP( JA, Jcc_Above );
DEFINE_FORWARD_JUMP( JB, Jcc_Below );
DEFINE_FORWARD_JUMP( JAE, Jcc_AboveOrEqual );
DEFINE_FORWARD_JUMP( JBE, Jcc_BelowOrEqual );
DEFINE_FORWARD_JUMP(JA, Jcc_Above);
DEFINE_FORWARD_JUMP(JB, Jcc_Below);
DEFINE_FORWARD_JUMP(JAE, Jcc_AboveOrEqual);
DEFINE_FORWARD_JUMP(JBE, Jcc_BelowOrEqual);
typedef xForwardJA<s8> xForwardJA8;
typedef xForwardJA<s32> xForwardJA32;
typedef xForwardJB<s8> xForwardJB8;
typedef xForwardJB<s32> xForwardJB32;
typedef xForwardJAE<s8> xForwardJAE8;
typedef xForwardJAE<s32> xForwardJAE32;
typedef xForwardJBE<s8> xForwardJBE8;
typedef xForwardJBE<s32> xForwardJBE32;
typedef xForwardJA<s8> xForwardJA8;
typedef xForwardJA<s32> xForwardJA32;
typedef xForwardJB<s8> xForwardJB8;
typedef xForwardJB<s32> xForwardJB32;
typedef xForwardJAE<s8> xForwardJAE8;
typedef xForwardJAE<s32> xForwardJAE32;
typedef xForwardJBE<s8> xForwardJBE8;
typedef xForwardJBE<s32> xForwardJBE32;
DEFINE_FORWARD_JUMP( JG, Jcc_Greater );
DEFINE_FORWARD_JUMP( JL, Jcc_Less );
DEFINE_FORWARD_JUMP( JGE, Jcc_GreaterOrEqual );
DEFINE_FORWARD_JUMP( JLE, Jcc_LessOrEqual );
DEFINE_FORWARD_JUMP(JG, Jcc_Greater);
DEFINE_FORWARD_JUMP(JL, Jcc_Less);
DEFINE_FORWARD_JUMP(JGE, Jcc_GreaterOrEqual);
DEFINE_FORWARD_JUMP(JLE, Jcc_LessOrEqual);
typedef xForwardJG<s8> xForwardJG8;
typedef xForwardJG<s32> xForwardJG32;
typedef xForwardJL<s8> xForwardJL8;
typedef xForwardJL<s32> xForwardJL32;
typedef xForwardJGE<s8> xForwardJGE8;
typedef xForwardJGE<s32> xForwardJGE32;
typedef xForwardJLE<s8> xForwardJLE8;
typedef xForwardJLE<s32> xForwardJLE32;
typedef xForwardJG<s8> xForwardJG8;
typedef xForwardJG<s32> xForwardJG32;
typedef xForwardJL<s8> xForwardJL8;
typedef xForwardJL<s32> xForwardJL32;
typedef xForwardJGE<s8> xForwardJGE8;
typedef xForwardJGE<s32> xForwardJGE32;
typedef xForwardJLE<s8> xForwardJLE8;
typedef xForwardJLE<s32> xForwardJLE32;
DEFINE_FORWARD_JUMP( JZ, Jcc_Zero );
DEFINE_FORWARD_JUMP( JE, Jcc_Equal );
DEFINE_FORWARD_JUMP( JNZ, Jcc_NotZero );
DEFINE_FORWARD_JUMP( JNE, Jcc_NotEqual );
DEFINE_FORWARD_JUMP(JZ, Jcc_Zero);
DEFINE_FORWARD_JUMP(JE, Jcc_Equal);
DEFINE_FORWARD_JUMP(JNZ, Jcc_NotZero);
DEFINE_FORWARD_JUMP(JNE, Jcc_NotEqual);
typedef xForwardJZ<s8> xForwardJZ8;
typedef xForwardJZ<s32> xForwardJZ32;
typedef xForwardJE<s8> xForwardJE8;
typedef xForwardJE<s32> xForwardJE32;
typedef xForwardJNZ<s8> xForwardJNZ8;
typedef xForwardJNZ<s32> xForwardJNZ32;
typedef xForwardJNE<s8> xForwardJNE8;
typedef xForwardJNE<s32> xForwardJNE32;
typedef xForwardJZ<s8> xForwardJZ8;
typedef xForwardJZ<s32> xForwardJZ32;
typedef xForwardJE<s8> xForwardJE8;
typedef xForwardJE<s32> xForwardJE32;
typedef xForwardJNZ<s8> xForwardJNZ8;
typedef xForwardJNZ<s32> xForwardJNZ32;
typedef xForwardJNE<s8> xForwardJNE8;
typedef xForwardJNE<s32> xForwardJNE32;
DEFINE_FORWARD_JUMP( JS, Jcc_Signed );
DEFINE_FORWARD_JUMP( JNS, Jcc_Unsigned );
DEFINE_FORWARD_JUMP(JS, Jcc_Signed);
DEFINE_FORWARD_JUMP(JNS, Jcc_Unsigned);
typedef xForwardJS<s8> xForwardJS8;
typedef xForwardJS<s32> xForwardJS32;
typedef xForwardJNS<s8> xForwardJNS8;
typedef xForwardJNS<s32> xForwardJNS32;
typedef xForwardJS<s8> xForwardJS8;
typedef xForwardJS<s32> xForwardJS32;
typedef xForwardJNS<s8> xForwardJNS8;
typedef xForwardJNS<s32> xForwardJNS32;
DEFINE_FORWARD_JUMP( JO, Jcc_Overflow );
DEFINE_FORWARD_JUMP( JNO, Jcc_NotOverflow );
DEFINE_FORWARD_JUMP(JO, Jcc_Overflow);
DEFINE_FORWARD_JUMP(JNO, Jcc_NotOverflow);
typedef xForwardJO<s8> xForwardJO8;
typedef xForwardJO<s32> xForwardJO32;
typedef xForwardJNO<s8> xForwardJNO8;
typedef xForwardJNO<s32> xForwardJNO32;
typedef xForwardJO<s8> xForwardJO8;
typedef xForwardJO<s32> xForwardJO32;
typedef xForwardJNO<s8> xForwardJNO8;
typedef xForwardJNO<s32> xForwardJNO32;
DEFINE_FORWARD_JUMP( JC, Jcc_Carry );
DEFINE_FORWARD_JUMP( JNC, Jcc_NotCarry );
DEFINE_FORWARD_JUMP(JC, Jcc_Carry);
DEFINE_FORWARD_JUMP(JNC, Jcc_NotCarry);
typedef xForwardJC<s8> xForwardJC8;
typedef xForwardJC<s32> xForwardJC32;
typedef xForwardJNC<s8> xForwardJNC8;
typedef xForwardJNC<s32> xForwardJNC32;
typedef xForwardJC<s8> xForwardJC8;
typedef xForwardJC<s32> xForwardJC32;
typedef xForwardJNC<s8> xForwardJNC8;
typedef xForwardJNC<s32> xForwardJNC32;
DEFINE_FORWARD_JUMP( JPE, Jcc_ParityEven );
DEFINE_FORWARD_JUMP( JPO, Jcc_ParityOdd );
DEFINE_FORWARD_JUMP(JPE, Jcc_ParityEven);
DEFINE_FORWARD_JUMP(JPO, Jcc_ParityOdd);
typedef xForwardJPE<s8> xForwardJPE8;
typedef xForwardJPE<s32> xForwardJPE32;
typedef xForwardJPO<s8> xForwardJPO8;
typedef xForwardJPO<s32> xForwardJPO32;
typedef xForwardJPE<s8> xForwardJPE8;
typedef xForwardJPE<s32> xForwardJPE32;
typedef xForwardJPO<s8> xForwardJPO8;
typedef xForwardJPO<s32> xForwardJPO32;
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
extern void xEMMS();
extern void xSTMXCSR( const xIndirect32& dest );
extern void xLDMXCSR( const xIndirect32& src );
extern void xFXSAVE( const xIndirectVoid& dest );
extern void xFXRSTOR( const xIndirectVoid& src );
extern void xEMMS();
extern void xSTMXCSR(const xIndirect32 &dest);
extern void xLDMXCSR(const xIndirect32 &src);
extern void xFXSAVE(const xIndirectVoid &dest);
extern void xFXRSTOR(const xIndirectVoid &src);
extern void xMOVDZX( const xRegisterSSE& to, const xRegister32or64& from );
extern void xMOVDZX( const xRegisterSSE& to, const xIndirectVoid& src );
extern void xMOVDZX(const xRegisterSSE &to, const xRegister32or64 &from);
extern void xMOVDZX(const xRegisterSSE &to, const xIndirectVoid &src);
extern void xMOVD( const xRegister32or64& to, const xRegisterSSE& from );
extern void xMOVD( const xIndirectVoid& dest, const xRegisterSSE& from );
extern void xMOVD(const xRegister32or64 &to, const xRegisterSSE &from);
extern void xMOVD(const xIndirectVoid &dest, const xRegisterSSE &from);
extern void xMOVQ( const xIndirectVoid& dest, const xRegisterSSE& from );
extern void xMOVQ(const xIndirectVoid &dest, const xRegisterSSE &from);
extern void xMOVQZX( const xRegisterSSE& to, const xIndirectVoid& src );
extern void xMOVQZX( const xRegisterSSE& to, const xRegisterSSE& from );
extern void xMOVQZX(const xRegisterSSE &to, const xIndirectVoid &src);
extern void xMOVQZX(const xRegisterSSE &to, const xRegisterSSE &from);
extern void xMOVSS( const xRegisterSSE& to, const xRegisterSSE& from );
extern void xMOVSS( const xIndirectVoid& to, const xRegisterSSE& from );
extern void xMOVSD( const xRegisterSSE& to, const xRegisterSSE& from );
extern void xMOVSD( const xIndirectVoid& to, const xRegisterSSE& from );
extern void xMOVSS(const xRegisterSSE &to, const xRegisterSSE &from);
extern void xMOVSS(const xIndirectVoid &to, const xRegisterSSE &from);
extern void xMOVSD(const xRegisterSSE &to, const xRegisterSSE &from);
extern void xMOVSD(const xIndirectVoid &to, const xRegisterSSE &from);
extern void xMOVSSZX( const xRegisterSSE& to, const xIndirectVoid& from );
extern void xMOVSDZX( const xRegisterSSE& to, const xIndirectVoid& from );
extern void xMOVSSZX(const xRegisterSSE &to, const xIndirectVoid &from);
extern void xMOVSDZX(const xRegisterSSE &to, const xIndirectVoid &from);
extern void xMOVNTDQA( const xRegisterSSE& to, const xIndirectVoid& from );
extern void xMOVNTDQA( const xIndirectVoid& to, const xRegisterSSE& from );
extern void xMOVNTDQA(const xRegisterSSE &to, const xIndirectVoid &from);
extern void xMOVNTDQA(const xIndirectVoid &to, const xRegisterSSE &from);
extern void xMOVNTPD( const xIndirectVoid& to, const xRegisterSSE& from );
extern void xMOVNTPS( const xIndirectVoid& to, const xRegisterSSE& from );
extern void xMOVNTPD(const xIndirectVoid &to, const xRegisterSSE &from);
extern void xMOVNTPS(const xIndirectVoid &to, const xRegisterSSE &from);
extern void xMOVMSKPS( const xRegister32or64& to, const xRegisterSSE& from );
extern void xMOVMSKPD( const xRegister32or64& to, const xRegisterSSE& from );
extern void xMOVMSKPS(const xRegister32or64 &to, const xRegisterSSE &from);
extern void xMOVMSKPD(const xRegister32or64 &to, const xRegisterSSE &from);
extern void xMASKMOV( const xRegisterSSE& to, const xRegisterSSE& from );
extern void xPMOVMSKB( const xRegister32or64& to, const xRegisterSSE& from );
extern void xPALIGNR( const xRegisterSSE& to, const xRegisterSSE& from, u8 imm8 );
extern void xMASKMOV(const xRegisterSSE &to, const xRegisterSSE &from);
extern void xPMOVMSKB(const xRegister32or64 &to, const xRegisterSSE &from);
extern void xPALIGNR(const xRegisterSSE &to, const xRegisterSSE &from, u8 imm8);
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
extern const xImplSimd_MoveSSE xMOVAPS;
extern const xImplSimd_MoveSSE xMOVUPS;
extern const xImplSimd_MoveSSE xMOVAPD;
extern const xImplSimd_MoveSSE xMOVUPD;
extern const xImplSimd_MoveSSE xMOVAPS;
extern const xImplSimd_MoveSSE xMOVUPS;
extern const xImplSimd_MoveSSE xMOVAPD;
extern const xImplSimd_MoveSSE xMOVUPD;
#ifdef ALWAYS_USE_MOVAPS
extern const xImplSimd_MoveSSE xMOVDQA;
extern const xImplSimd_MoveSSE xMOVDQU;
extern const xImplSimd_MoveSSE xMOVDQA;
extern const xImplSimd_MoveSSE xMOVDQU;
#else
extern const xImplSimd_MoveDQ xMOVDQA;
extern const xImplSimd_MoveDQ xMOVDQU;
extern const xImplSimd_MoveDQ xMOVDQA;
extern const xImplSimd_MoveDQ xMOVDQU;
#endif
extern const xImplSimd_MovHL xMOVH;
extern const xImplSimd_MovHL xMOVL;
extern const xImplSimd_MovHL_RtoR xMOVLH;
extern const xImplSimd_MovHL_RtoR xMOVHL;
extern const xImplSimd_MovHL xMOVH;
extern const xImplSimd_MovHL xMOVL;
extern const xImplSimd_MovHL_RtoR xMOVLH;
extern const xImplSimd_MovHL_RtoR xMOVHL;
extern const xImplSimd_Blend xBLEND;
extern const xImplSimd_PMove xPMOVSX;
extern const xImplSimd_PMove xPMOVZX;
extern const xImplSimd_Blend xBLEND;
extern const xImplSimd_PMove xPMOVSX;
extern const xImplSimd_PMove xPMOVZX;
extern const xImplSimd_DestRegSSE xMOVSLDUP;
extern const xImplSimd_DestRegSSE xMOVSHDUP;
extern const xImplSimd_DestRegSSE xMOVSLDUP;
extern const xImplSimd_DestRegSSE xMOVSHDUP;
extern void xINSERTPS( const xRegisterSSE& to, const xRegisterSSE& from, u8 imm8 );
extern void xINSERTPS( const xRegisterSSE& to, const xIndirect32& from, u8 imm8 );
extern void xINSERTPS(const xRegisterSSE &to, const xRegisterSSE &from, u8 imm8);
extern void xINSERTPS(const xRegisterSSE &to, const xIndirect32 &from, u8 imm8);
extern void xEXTRACTPS( const xRegister32or64& to, const xRegisterSSE& from, u8 imm8 );
extern void xEXTRACTPS( const xIndirect32& dest, const xRegisterSSE& from, u8 imm8 );
extern void xEXTRACTPS(const xRegister32or64 &to, const xRegisterSSE &from, u8 imm8);
extern void xEXTRACTPS(const xIndirect32 &dest, const xRegisterSSE &from, u8 imm8);
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
extern const xImplSimd_DestRegEither xPAND;
extern const xImplSimd_DestRegEither xPANDN;
extern const xImplSimd_DestRegEither xPOR;
extern const xImplSimd_DestRegEither xPXOR;
extern const xImplSimd_DestRegEither xPAND;
extern const xImplSimd_DestRegEither xPANDN;
extern const xImplSimd_DestRegEither xPOR;
extern const xImplSimd_DestRegEither xPXOR;
extern const xImplSimd_Shuffle xSHUF;
extern const xImplSimd_Shuffle xSHUF;
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
extern const xImplSimd_DestRegSSE xPTEST;
extern const xImplSimd_DestRegSSE xPTEST;
extern const xImplSimd_MinMax xMIN;
extern const xImplSimd_MinMax xMAX;
extern const xImplSimd_MinMax xMIN;
extern const xImplSimd_MinMax xMAX;
extern const xImplSimd_Compare xCMPEQ, xCMPLT,
extern const xImplSimd_Compare xCMPEQ, xCMPLT,
xCMPLE, xCMPUNORD,
xCMPNE, xCMPNLT,
xCMPNLE,xCMPORD;
xCMPNLE, xCMPORD;
extern const xImplSimd_COMI xCOMI;
extern const xImplSimd_COMI xUCOMI;
extern const xImplSimd_COMI xCOMI;
extern const xImplSimd_COMI xUCOMI;
extern const xImplSimd_PCompare xPCMP;
extern const xImplSimd_PMinMax xPMIN;
extern const xImplSimd_PMinMax xPMAX;
extern const xImplSimd_PCompare xPCMP;
extern const xImplSimd_PMinMax xPMIN;
extern const xImplSimd_PMinMax xPMAX;
// ------------------------------------------------------------------------
//
//
extern void xCVTDQ2PD( const xRegisterSSE& to, const xRegisterSSE& from );
extern void xCVTDQ2PD( const xRegisterSSE& to, const xIndirect64& from );
extern void xCVTDQ2PS( const xRegisterSSE& to, const xRegisterSSE& from );
extern void xCVTDQ2PS( const xRegisterSSE& to, const xIndirect128& from );
// ------------------------------------------------------------------------
//
//
extern void xCVTDQ2PD(const xRegisterSSE &to, const xRegisterSSE &from);
extern void xCVTDQ2PD(const xRegisterSSE &to, const xIndirect64 &from);
extern void xCVTDQ2PS(const xRegisterSSE &to, const xRegisterSSE &from);
extern void xCVTDQ2PS(const xRegisterSSE &to, const xIndirect128 &from);
extern void xCVTPD2DQ( const xRegisterSSE& to, const xRegisterSSE& from );
extern void xCVTPD2DQ( const xRegisterSSE& to, const xIndirect128& from );
extern void xCVTPD2PS( const xRegisterSSE& to, const xRegisterSSE& from );
extern void xCVTPD2PS( const xRegisterSSE& to, const xIndirect128& from );
extern void xCVTPD2DQ(const xRegisterSSE &to, const xRegisterSSE &from);
extern void xCVTPD2DQ(const xRegisterSSE &to, const xIndirect128 &from);
extern void xCVTPD2PS(const xRegisterSSE &to, const xRegisterSSE &from);
extern void xCVTPD2PS(const xRegisterSSE &to, const xIndirect128 &from);
extern void xCVTPI2PD( const xRegisterSSE& to, const xIndirect64& from );
extern void xCVTPI2PS( const xRegisterSSE& to, const xIndirect64& from );
extern void xCVTPI2PD(const xRegisterSSE &to, const xIndirect64 &from);
extern void xCVTPI2PS(const xRegisterSSE &to, const xIndirect64 &from);
extern void xCVTPS2DQ( const xRegisterSSE& to, const xRegisterSSE& from );
extern void xCVTPS2DQ( const xRegisterSSE& to, const xIndirect128& from );
extern void xCVTPS2PD( const xRegisterSSE& to, const xRegisterSSE& from );
extern void xCVTPS2PD( const xRegisterSSE& to, const xIndirect64& from );
extern void xCVTPS2DQ(const xRegisterSSE &to, const xRegisterSSE &from);
extern void xCVTPS2DQ(const xRegisterSSE &to, const xIndirect128 &from);
extern void xCVTPS2PD(const xRegisterSSE &to, const xRegisterSSE &from);
extern void xCVTPS2PD(const xRegisterSSE &to, const xIndirect64 &from);
extern void xCVTSD2SI( const xRegister32or64& to, const xRegisterSSE& from );
extern void xCVTSD2SI( const xRegister32or64& to, const xIndirect64& from );
extern void xCVTSD2SS( const xRegisterSSE& to, const xRegisterSSE& from );
extern void xCVTSD2SS( const xRegisterSSE& to, const xIndirect64& from );
extern void xCVTSI2SS( const xRegisterSSE& to, const xRegister32or64& from );
extern void xCVTSI2SS( const xRegisterSSE& to, const xIndirect32& from );
extern void xCVTSD2SI(const xRegister32or64 &to, const xRegisterSSE &from);
extern void xCVTSD2SI(const xRegister32or64 &to, const xIndirect64 &from);
extern void xCVTSD2SS(const xRegisterSSE &to, const xRegisterSSE &from);
extern void xCVTSD2SS(const xRegisterSSE &to, const xIndirect64 &from);
extern void xCVTSI2SS(const xRegisterSSE &to, const xRegister32or64 &from);
extern void xCVTSI2SS(const xRegisterSSE &to, const xIndirect32 &from);
extern void xCVTSS2SD( const xRegisterSSE& to, const xRegisterSSE& from );
extern void xCVTSS2SD( const xRegisterSSE& to, const xIndirect32& from );
extern void xCVTSS2SI( const xRegister32or64& to, const xRegisterSSE& from );
extern void xCVTSS2SI( const xRegister32or64& to, const xIndirect32& from );
extern void xCVTSS2SD(const xRegisterSSE &to, const xRegisterSSE &from);
extern void xCVTSS2SD(const xRegisterSSE &to, const xIndirect32 &from);
extern void xCVTSS2SI(const xRegister32or64 &to, const xRegisterSSE &from);
extern void xCVTSS2SI(const xRegister32or64 &to, const xIndirect32 &from);
extern void xCVTTPD2DQ( const xRegisterSSE& to, const xRegisterSSE& from );
extern void xCVTTPD2DQ( const xRegisterSSE& to, const xIndirect128& from );
extern void xCVTTPS2DQ( const xRegisterSSE& to, const xRegisterSSE& from );
extern void xCVTTPS2DQ( const xRegisterSSE& to, const xIndirect128& from );
extern void xCVTTPD2DQ(const xRegisterSSE &to, const xRegisterSSE &from);
extern void xCVTTPD2DQ(const xRegisterSSE &to, const xIndirect128 &from);
extern void xCVTTPS2DQ(const xRegisterSSE &to, const xRegisterSSE &from);
extern void xCVTTPS2DQ(const xRegisterSSE &to, const xIndirect128 &from);
extern void xCVTTSD2SI( const xRegister32or64& to, const xRegisterSSE& from );
extern void xCVTTSD2SI( const xRegister32or64& to, const xIndirect64& from );
extern void xCVTTSS2SI( const xRegister32or64& to, const xRegisterSSE& from );
extern void xCVTTSS2SI( const xRegister32or64& to, const xIndirect32& from );
extern void xCVTTSD2SI(const xRegister32or64 &to, const xRegisterSSE &from);
extern void xCVTTSD2SI(const xRegister32or64 &to, const xIndirect64 &from);
extern void xCVTTSS2SI(const xRegister32or64 &to, const xRegisterSSE &from);
extern void xCVTTSS2SI(const xRegister32or64 &to, const xIndirect32 &from);
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
extern const xImplSimd_AndNot xANDN;
extern const xImplSimd_rSqrt xRCP;
extern const xImplSimd_rSqrt xRSQRT;
extern const xImplSimd_Sqrt xSQRT;
extern const xImplSimd_AndNot xANDN;
extern const xImplSimd_rSqrt xRCP;
extern const xImplSimd_rSqrt xRSQRT;
extern const xImplSimd_Sqrt xSQRT;
extern const xImplSimd_Shift xPSLL;
extern const xImplSimd_Shift xPSRL;
extern const xImplSimd_ShiftWithoutQ xPSRA;
extern const xImplSimd_AddSub xPADD;
extern const xImplSimd_AddSub xPSUB;
extern const xImplSimd_PMul xPMUL;
extern const xImplSimd_PAbsolute xPABS;
extern const xImplSimd_PSign xPSIGN;
extern const xImplSimd_PMultAdd xPMADD;
extern const xImplSimd_HorizAdd xHADD;
extern const xImplSimd_DotProduct xDP;
extern const xImplSimd_Round xROUND;
extern const xImplSimd_PShuffle xPSHUF;
extern const SimdImpl_PUnpack xPUNPCK;
extern const xImplSimd_Unpack xUNPCK;
extern const SimdImpl_Pack xPACK;
extern const xImplSimd_PInsert xPINSR;
extern const SimdImpl_PExtract xPEXTR;
extern const xImplSimd_Shift xPSLL;
extern const xImplSimd_Shift xPSRL;
extern const xImplSimd_ShiftWithoutQ xPSRA;
extern const xImplSimd_AddSub xPADD;
extern const xImplSimd_AddSub xPSUB;
extern const xImplSimd_PMul xPMUL;
extern const xImplSimd_PAbsolute xPABS;
extern const xImplSimd_PSign xPSIGN;
extern const xImplSimd_PMultAdd xPMADD;
extern const xImplSimd_HorizAdd xHADD;
extern const xImplSimd_DotProduct xDP;
extern const xImplSimd_Round xROUND;
extern const xImplSimd_PShuffle xPSHUF;
extern const SimdImpl_PUnpack xPUNPCK;
extern const xImplSimd_Unpack xUNPCK;
extern const SimdImpl_Pack xPACK;
extern const xImplSimd_PInsert xPINSR;
extern const SimdImpl_PExtract xPEXTR;
}

188
common/include/x86emitter/internal.h
View File

@ -19,96 +19,106 @@
#include "instructions.h"
namespace x86Emitter {
namespace x86Emitter
{
#define OpWriteSSE( pre, op ) xOpWrite0F( pre, op, to, from )
#define OpWriteSSE(pre, op) xOpWrite0F(pre, op, to, from)
extern void SimdPrefix( u8 prefix, u16 opcode );
extern void EmitSibMagic( uint regfield, const void* address );
extern void EmitSibMagic( uint regfield, const xIndirectVoid& info );
extern void EmitSibMagic( uint reg1, const xRegisterBase& reg2 );
extern void EmitSibMagic( const xRegisterBase& reg1, const xRegisterBase& reg2 );
extern void EmitSibMagic( const xRegisterBase& reg1, const void* src );
extern void EmitSibMagic( const xRegisterBase& reg1, const xIndirectVoid& sib );
extern void SimdPrefix(u8 prefix, u16 opcode);
extern void EmitSibMagic(uint regfield, const void *address);
extern void EmitSibMagic(uint regfield, const xIndirectVoid &info);
extern void EmitSibMagic(uint reg1, const xRegisterBase &reg2);
extern void EmitSibMagic(const xRegisterBase &reg1, const xRegisterBase &reg2);
extern void EmitSibMagic(const xRegisterBase &reg1, const void *src);
extern void EmitSibMagic(const xRegisterBase &reg1, const xIndirectVoid &sib);
extern void EmitRex( uint regfield, const void* address );
extern void EmitRex( uint regfield, const xIndirectVoid& info );
extern void EmitRex( uint reg1, const xRegisterBase& reg2 );
extern void EmitRex( const xRegisterBase& reg1, const xRegisterBase& reg2 );
extern void EmitRex( const xRegisterBase& reg1, const void* src );
extern void EmitRex( const xRegisterBase& reg1, const xIndirectVoid& sib );
extern void EmitRex(uint regfield, const void *address);
extern void EmitRex(uint regfield, const xIndirectVoid &info);
extern void EmitRex(uint reg1, const xRegisterBase &reg2);
extern void EmitRex(const xRegisterBase &reg1, const xRegisterBase &reg2);
extern void EmitRex(const xRegisterBase &reg1, const void *src);
extern void EmitRex(const xRegisterBase &reg1, const xIndirectVoid &sib);
extern void _xMovRtoR( const xRegisterInt& to, const xRegisterInt& from );
extern void _xMovRtoR(const xRegisterInt &to, const xRegisterInt &from);
template< typename T > inline
void xWrite( T val )
{
*(T*)x86Ptr = val;
template <typename T>
inline void xWrite(T val)
{
*(T *)x86Ptr = val;
x86Ptr += sizeof(T);
}
}
template< typename T1, typename T2 > __emitinline
void xOpWrite( u8 prefix, u8 opcode, const T1& param1, const T2& param2 )
{
if( prefix != 0 ) xWrite8( prefix );
EmitRex( param1, param2 );
template <typename T1, typename T2>
__emitinline void xOpWrite(u8 prefix, u8 opcode, const T1 &param1, const T2 &param2)
{
if (prefix != 0)
xWrite8(prefix);
EmitRex(param1, param2);
xWrite8( opcode );
xWrite8(opcode);
EmitSibMagic( param1, param2 );
}
EmitSibMagic(param1, param2);
}
template< typename T1, typename T2 > __emitinline
void xOpAccWrite( u8 prefix, u8 opcode, const T1& param1, const T2& param2 )
{
if( prefix != 0 ) xWrite8( prefix );
EmitRex( param1, param2 );
template <typename T1, typename T2>
__emitinline void xOpAccWrite(u8 prefix, u8 opcode, const T1 &param1, const T2 &param2)
{
if (prefix != 0)
xWrite8(prefix);
EmitRex(param1, param2);
xWrite8( opcode );
}
xWrite8(opcode);
}
//////////////////////////////////////////////////////////////////////////////////////////
// emitter helpers for xmm instruction with prefixes, most of which are using
// the basic opcode format (items inside braces denote optional or conditional
// emission):
//
// [Prefix] / 0x0f / [OpcodePrefix] / Opcode / ModRM+[SibSB]
//
// Prefixes are typically 0x66, 0xf2, or 0xf3. OpcodePrefixes are either 0x38 or
// 0x3a [and other value will result in assertion failue].
//
template< typename T1, typename T2 > __emitinline
void xOpWrite0F( u8 prefix, u16 opcode, const T1& param1, const T2& param2 )
{
if( prefix != 0 ) xWrite8( prefix );
EmitRex( param1, param2 );
//////////////////////////////////////////////////////////////////////////////////////////
// emitter helpers for xmm instruction with prefixes, most of which are using
// the basic opcode format (items inside braces denote optional or conditional
// emission):
//
// [Prefix] / 0x0f / [OpcodePrefix] / Opcode / ModRM+[SibSB]
//
// Prefixes are typically 0x66, 0xf2, or 0xf3. OpcodePrefixes are either 0x38 or
// 0x3a [and other value will result in assertion failue].
//
template <typename T1, typename T2>
__emitinline void xOpWrite0F(u8 prefix, u16 opcode, const T1 &param1, const T2 &param2)
{
if (prefix != 0)
xWrite8(prefix);
EmitRex(param1, param2);
SimdPrefix( 0, opcode );
SimdPrefix(0, opcode);
EmitSibMagic( param1, param2 );
}
EmitSibMagic(param1, param2);
}
template< typename T1, typename T2 > __emitinline
void xOpWrite0F( u8 prefix, u16 opcode, const T1& param1, const T2& param2, u8 imm8 )
{
xOpWrite0F( prefix, opcode, param1, param2 );
xWrite8( imm8 );
}
template <typename T1, typename T2>
__emitinline void xOpWrite0F(u8 prefix, u16 opcode, const T1 &param1, const T2 &param2, u8 imm8)
{
xOpWrite0F(prefix, opcode, param1, param2);
xWrite8(imm8);
}
template< typename T1, typename T2 > __emitinline
void xOpWrite0F( u16 opcode, const T1& param1, const T2& param2 ) { xOpWrite0F( 0, opcode, param1, param2 ); }
template <typename T1, typename T2>
__emitinline void xOpWrite0F(u16 opcode, const T1 &param1, const T2 &param2)
{
xOpWrite0F(0, opcode, param1, param2);
}
template< typename T1, typename T2 > __emitinline
void xOpWrite0F( u16 opcode, const T1& param1, const T2& param2, u8 imm8 ) { xOpWrite0F( 0, opcode, param1, param2, imm8 ); }
template <typename T1, typename T2>
__emitinline void xOpWrite0F(u16 opcode, const T1 &param1, const T2 &param2, u8 imm8)
{
xOpWrite0F(0, opcode, param1, param2, imm8);
}
// VEX 2 Bytes Prefix
template< typename T1, typename T2, typename T3 > __emitinline
void xOpWriteC5( u8 prefix, u8 opcode, const T1& param1, const T2& param2, const T3& param3 )
{
pxAssert( prefix == 0 || prefix == 0x66 || prefix == 0xF3 || prefix == 0xF2 );
// VEX 2 Bytes Prefix
template <typename T1, typename T2, typename T3>
__emitinline void xOpWriteC5(u8 prefix, u8 opcode, const T1 &param1, const T2 &param2, const T3 &param3)
{
pxAssert(prefix == 0 || prefix == 0x66 || prefix == 0xF3 || prefix == 0xF2);
const xRegisterInt& reg = param1.IsReg() ? param1 : param2;
const xRegisterInt &reg = param1.IsReg() ? param1 : param2;
#ifdef __x86_64__
u8 nR = reg.IsExtended() ? 0x00 : 0x80;
@ -124,20 +134,20 @@ namespace x86Emitter {
prefix == 0xF3 ? 2 :
prefix == 0x66 ? 1 : 0;
xWrite8( 0xC5 );
xWrite8( nR | nv | L | p );
xWrite8( opcode );
EmitSibMagic( param1, param3 );
}
xWrite8(0xC5);
xWrite8(nR | nv | L | p);
xWrite8(opcode);
EmitSibMagic(param1, param3);
}
// VEX 3 Bytes Prefix
template< typename T1, typename T2, typename T3 > __emitinline
void xOpWriteC4( u8 prefix, u8 mb_prefix, u8 opcode, const T1& param1, const T2& param2, const T3& param3, int w = -1 )
{
pxAssert( prefix == 0 || prefix == 0x66 || prefix == 0xF3 || prefix == 0xF2 );
pxAssert( mb_prefix == 0x0F || mb_prefix == 0x38 || mb_prefix == 0x3A );
// VEX 3 Bytes Prefix
template <typename T1, typename T2, typename T3>
__emitinline void xOpWriteC4(u8 prefix, u8 mb_prefix, u8 opcode, const T1 &param1, const T2 &param2, const T3 &param3, int w = -1)
{
pxAssert(prefix == 0 || prefix == 0x66 || prefix == 0xF3 || prefix == 0xF2);
pxAssert(mb_prefix == 0x0F || mb_prefix == 0x38 || mb_prefix == 0x3A);
const xRegisterInt& reg = param1.IsReg() ? param1 : param2;
const xRegisterInt &reg = param1.IsReg() ? param1 : param2;
#ifdef __x86_64__
u8 nR = reg.IsExtended() ? 0x00 : 0x80;
@ -163,12 +173,10 @@ namespace x86Emitter {
mb_prefix == 0x3A ? 3 :
mb_prefix == 0x38 ? 2 : 1;
xWrite8( 0xC4 );
xWrite8( nR | nX | nB | m );
xWrite8( W | nv | L | p );
xWrite8( opcode );
EmitSibMagic( param1, param3 );
}
xWrite8(0xC4);
xWrite8(nR | nX | nB | m);
xWrite8(W | nv | L | p);
xWrite8(opcode);
EmitSibMagic(param1, param3);
}
}

136
common/include/x86emitter/legacy_instructions.h
View File

@ -25,15 +25,15 @@
//------------------------------------------------------------------
// legacy jump/align functions
//------------------------------------------------------------------
ATTR_DEP extern void x86SetPtr( u8 *ptr );
ATTR_DEP extern void x86SetJ8( u8 *j8 );
ATTR_DEP extern void x86SetJ8A( u8 *j8 );
ATTR_DEP extern void x86SetJ16( u16 *j16 );
ATTR_DEP extern void x86SetJ16A( u16 *j16 );
ATTR_DEP extern void x86SetJ32( u32 *j32 );
ATTR_DEP extern void x86SetJ32A( u32 *j32 );
ATTR_DEP extern void x86Align( int bytes );
ATTR_DEP extern void x86AlignExecutable( int align );
ATTR_DEP extern void x86SetPtr(u8 *ptr);
ATTR_DEP extern void x86SetJ8(u8 *j8);
ATTR_DEP extern void x86SetJ8A(u8 *j8);
ATTR_DEP extern void x86SetJ16(u16 *j16);
ATTR_DEP extern void x86SetJ16A(u16 *j16);
ATTR_DEP extern void x86SetJ32(u32 *j32);
ATTR_DEP extern void x86SetJ32A(u32 *j32);
ATTR_DEP extern void x86Align(int bytes);
ATTR_DEP extern void x86AlignExecutable(int align);
//------------------------------------------------------------------
////////////////////////////////////
@ -41,55 +41,55 @@ ATTR_DEP extern void x86AlignExecutable( int align );
////////////////////////////////////
// jmp rel8
ATTR_DEP extern u8* JMP8( u8 to );
ATTR_DEP extern u8 *JMP8(u8 to);
// jmp rel32
ATTR_DEP extern u32* JMP32( uptr to );
ATTR_DEP extern u32 *JMP32(uptr to);
// jp rel8
ATTR_DEP extern u8* JP8( u8 to );
ATTR_DEP extern u8 *JP8(u8 to);
// jnp rel8
ATTR_DEP extern u8* JNP8( u8 to );
ATTR_DEP extern u8 *JNP8(u8 to);
// je rel8
ATTR_DEP extern u8* JE8( u8 to );
ATTR_DEP extern u8 *JE8(u8 to);
// jz rel8
ATTR_DEP extern u8* JZ8( u8 to );
ATTR_DEP extern u8 *JZ8(u8 to);
// jg rel8
ATTR_DEP extern u8* JG8( u8 to );
ATTR_DEP extern u8 *JG8(u8 to);
// jge rel8
ATTR_DEP extern u8* JGE8( u8 to );
ATTR_DEP extern u8 *JGE8(u8 to);
// js rel8
ATTR_DEP extern u8* JS8( u8 to );
ATTR_DEP extern u8 *JS8(u8 to);
// jns rel8
ATTR_DEP extern u8* JNS8( u8 to );
ATTR_DEP extern u8 *JNS8(u8 to);
// jl rel8
ATTR_DEP extern u8* JL8( u8 to );
ATTR_DEP extern u8 *JL8(u8 to);
// ja rel8
ATTR_DEP extern u8* JA8( u8 to );
ATTR_DEP extern u8 *JA8(u8 to);
// jae rel8
ATTR_DEP extern u8* JAE8( u8 to );
ATTR_DEP extern u8 *JAE8(u8 to);
// jb rel8
ATTR_DEP extern u8* JB8( u8 to );
ATTR_DEP extern u8 *JB8(u8 to);
// jbe rel8
ATTR_DEP extern u8* JBE8( u8 to );
ATTR_DEP extern u8 *JBE8(u8 to);
// jle rel8
ATTR_DEP extern u8* JLE8( u8 to );
ATTR_DEP extern u8 *JLE8(u8 to);
// jne rel8
ATTR_DEP extern u8* JNE8( u8 to );
ATTR_DEP extern u8 *JNE8(u8 to);
// jnz rel8
ATTR_DEP extern u8* JNZ8( u8 to );
ATTR_DEP extern u8 *JNZ8(u8 to);
// jng rel8
ATTR_DEP extern u8* JNG8( u8 to );
ATTR_DEP extern u8 *JNG8(u8 to);
// jnge rel8
ATTR_DEP extern u8* JNGE8( u8 to );
ATTR_DEP extern u8 *JNGE8(u8 to);
// jnl rel8
ATTR_DEP extern u8* JNL8( u8 to );
ATTR_DEP extern u8 *JNL8(u8 to);
// jnle rel8
ATTR_DEP extern u8* JNLE8( u8 to );
ATTR_DEP extern u8 *JNLE8(u8 to);
// jo rel8
ATTR_DEP extern u8* JO8( u8 to );
ATTR_DEP extern u8 *JO8(u8 to);
// jno rel8
ATTR_DEP extern u8* JNO8( u8 to );
ATTR_DEP extern u8 *JNO8(u8 to);
/*
// jb rel16
@ -103,51 +103,51 @@ ATTR_DEP extern u16* JZ16( u16 to );
*/
// jns rel32
ATTR_DEP extern u32* JNS32( u32 to );
ATTR_DEP extern u32 *JNS32(u32 to);
// js rel32
ATTR_DEP extern u32* JS32( u32 to );
ATTR_DEP extern u32 *JS32(u32 to);
// jb rel32
ATTR_DEP extern u32* JB32( u32 to );
ATTR_DEP extern u32 *JB32(u32 to);
// je rel32
ATTR_DEP extern u32* JE32( u32 to );
ATTR_DEP extern u32 *JE32(u32 to);
// jz rel32
ATTR_DEP extern u32* JZ32( u32 to );
ATTR_DEP extern u32 *JZ32(u32 to);
// jg rel32
ATTR_DEP extern u32* JG32( u32 to );
ATTR_DEP extern u32 *JG32(u32 to);
// jge rel32
ATTR_DEP extern u32* JGE32( u32 to );
ATTR_DEP extern u32 *JGE32(u32 to);
// jl rel32
ATTR_DEP extern u32* JL32( u32 to );
ATTR_DEP extern u32 *JL32(u32 to);
// jle rel32
ATTR_DEP extern u32* JLE32( u32 to );
ATTR_DEP extern u32 *JLE32(u32 to);
// jae rel32
ATTR_DEP extern u32* JAE32( u32 to );
ATTR_DEP extern u32 *JAE32(u32 to);
// jne rel32
ATTR_DEP extern u32* JNE32( u32 to );
ATTR_DEP extern u32 *JNE32(u32 to);
// jnz rel32
ATTR_DEP extern u32* JNZ32( u32 to );
ATTR_DEP extern u32 *JNZ32(u32 to);
// jng rel32
ATTR_DEP extern u32* JNG32( u32 to );
ATTR_DEP extern u32 *JNG32(u32 to);
// jnge rel32
ATTR_DEP extern u32* JNGE32( u32 to );
ATTR_DEP extern u32 *JNGE32(u32 to);
// jnl rel32
ATTR_DEP extern u32* JNL32( u32 to );
ATTR_DEP extern u32 *JNL32(u32 to);
// jnle rel32
ATTR_DEP extern u32* JNLE32( u32 to );
ATTR_DEP extern u32 *JNLE32(u32 to);
// jo rel32
ATTR_DEP extern u32* JO32( u32 to );
ATTR_DEP extern u32 *JO32(u32 to);
// jno rel32
ATTR_DEP extern u32* JNO32( u32 to );
ATTR_DEP extern u32 *JNO32(u32 to);
// js rel32
ATTR_DEP extern u32* JS32( u32 to );
ATTR_DEP extern u32 *JS32(u32 to);
//******************
// FPU instructions
//******************
// fld m32 to fpu reg stack
ATTR_DEP extern void FLD32( u32 from );
ATTR_DEP extern void FLD32(u32 from);
// fld st(i)
ATTR_DEP extern void FLD(int st);
// fld1 (push +1.0f on the stack)
@ -155,7 +155,7 @@ ATTR_DEP extern void FLD1();
// fld1 (push log_2 e on the stack)
ATTR_DEP extern void FLDL2E();
// fstp m32 from fpu reg stack
ATTR_DEP extern void FSTP32( u32 to );
ATTR_DEP extern void FSTP32(u32 to);
// fstp st(i)
ATTR_DEP extern void FSTP(int st);
@ -166,32 +166,32 @@ ATTR_DEP extern void F2XM1();
ATTR_DEP extern void FSCALE();
// fadd ST(0) to fpu reg stack ST(src)
ATTR_DEP extern void FADD320toR( x86IntRegType src );
ATTR_DEP extern void FADD320toR(x86IntRegType src);
// fsub ST(src) to fpu reg stack ST(0)
ATTR_DEP extern void FSUB32Rto0( x86IntRegType src );
ATTR_DEP extern void FSUB32Rto0(x86IntRegType src);
// fmul m32 to fpu reg stack
ATTR_DEP extern void FMUL32( u32 from );
ATTR_DEP extern void FMUL32(u32 from);
// fdiv m32 to fpu reg stack
ATTR_DEP extern void FDIV32( u32 from );
ATTR_DEP extern void FDIV32(u32 from);
// ftan fpu reg stack
ATTR_DEP extern void FPATAN( void );
ATTR_DEP extern void FPATAN(void);
// fsin fpu reg stack
ATTR_DEP extern void FSIN( void );
ATTR_DEP extern void FSIN(void);
//*********************
// SSE instructions *
//*********************
ATTR_DEP extern void SSE_MAXSS_XMM_to_XMM( x86SSERegType to, x86SSERegType from );
ATTR_DEP extern void SSE_MINSS_XMM_to_XMM( x86SSERegType to, x86SSERegType from );
ATTR_DEP extern void SSE_ADDSS_XMM_to_XMM( x86SSERegType to, x86SSERegType from );
ATTR_DEP extern void SSE_SUBSS_XMM_to_XMM( x86SSERegType to, x86SSERegType from );
ATTR_DEP extern void SSE_MAXSS_XMM_to_XMM(x86SSERegType to, x86SSERegType from);
ATTR_DEP extern void SSE_MINSS_XMM_to_XMM(x86SSERegType to, x86SSERegType from);
ATTR_DEP extern void SSE_ADDSS_XMM_to_XMM(x86SSERegType to, x86SSERegType from);
ATTR_DEP extern void SSE_SUBSS_XMM_to_XMM(x86SSERegType to, x86SSERegType from);
//*********************
// SSE 2 Instructions*
//*********************
ATTR_DEP extern void SSE2_MAXSD_XMM_to_XMM( x86SSERegType to, x86SSERegType from );
ATTR_DEP extern void SSE2_MINSD_XMM_to_XMM( x86SSERegType to, x86SSERegType from );
ATTR_DEP extern void SSE2_ADDSD_XMM_to_XMM( x86SSERegType to, x86SSERegType from );
ATTR_DEP extern void SSE2_SUBSD_XMM_to_XMM( x86SSERegType to, x86SSERegType from );
ATTR_DEP extern void SSE2_MAXSD_XMM_to_XMM(x86SSERegType to, x86SSERegType from);
ATTR_DEP extern void SSE2_MINSD_XMM_to_XMM(x86SSERegType to, x86SSERegType from);
ATTR_DEP extern void SSE2_ADDSD_XMM_to_XMM(x86SSERegType to, x86SSERegType from);
ATTR_DEP extern void SSE2_SUBSD_XMM_to_XMM(x86SSERegType to, x86SSERegType from);

11
common/include/x86emitter/legacy_internal.h
View File

@ -33,9 +33,8 @@ using x86Emitter::xWrite64;
#define MEMADDR(addr, oplen) (addr)
extern void ModRM( uint mod, uint reg, uint rm );
extern void SibSB( uint ss, uint index, uint base );
extern void SET8R( int cc, int to );
extern u8* J8Rel( int cc, int to );
extern u32* J32Rel( int cc, u32 to );
extern void ModRM(uint mod, uint reg, uint rm);
extern void SibSB(uint ss, uint index, uint base);
extern void SET8R(int cc, int to);
extern u8 *J8Rel(int cc, int to);
extern u32 *J32Rel(int cc, u32 to);

137
common/include/x86emitter/tools.h
View File

@ -17,8 +17,7 @@
#include "x86emitter.h"
enum x86VendorType
{
enum x86VendorType {
x86Vendor_Intel = 0,
x86Vendor_AMD = 1,
x86Vendor_Unknown = 2
@ -53,51 +52,53 @@ public:
// x86 CPU Capabilities Section (all boolean flags!)
// ----------------------------------------------------------------------------
union {
struct {
u32 hasFloatingPointUnit :1;
u32 hasVirtual8086ModeEnhancements :1;
u32 hasDebuggingExtensions :1;
u32 hasPageSizeExtensions :1;
u32 hasTimeStampCounter :1;
u32 hasModelSpecificRegisters :1;
u32 hasPhysicalAddressExtension :1;
u32 hasCOMPXCHG8BInstruction :1;
u32 hasAdvancedProgrammableInterruptController :1;
u32 hasSEPFastSystemCall :1;
u32 hasMemoryTypeRangeRegisters :1;
u32 hasPTEGlobalFlag :1;
u32 hasMachineCheckArchitecture :1;
u32 hasConditionalMoveAndCompareInstructions :1;
u32 hasFGPageAttributeTable :1;
u32 has36bitPageSizeExtension :1;
u32 hasProcessorSerialNumber :1;
u32 hasCFLUSHInstruction :1;
u32 hasDebugStore :1;
u32 hasACPIThermalMonitorAndClockControl :1;
u32 hasFastStreamingSIMDExtensionsSaveRestore :1;
u32 hasStreamingSIMDExtensions :1;
u32 hasStreamingSIMD2Extensions :1;
u32 hasSelfSnoop :1;
union
{
struct
{
u32 hasFloatingPointUnit : 1;
u32 hasVirtual8086ModeEnhancements : 1;
u32 hasDebuggingExtensions : 1;
u32 hasPageSizeExtensions : 1;
u32 hasTimeStampCounter : 1;
u32 hasModelSpecificRegisters : 1;
u32 hasPhysicalAddressExtension : 1;
u32 hasCOMPXCHG8BInstruction : 1;
u32 hasAdvancedProgrammableInterruptController : 1;
u32 hasSEPFastSystemCall : 1;
u32 hasMemoryTypeRangeRegisters : 1;
u32 hasPTEGlobalFlag : 1;
u32 hasMachineCheckArchitecture : 1;
u32 hasConditionalMoveAndCompareInstructions : 1;
u32 hasFGPageAttributeTable : 1;
u32 has36bitPageSizeExtension : 1;
u32 hasProcessorSerialNumber : 1;
u32 hasCFLUSHInstruction : 1;
u32 hasDebugStore : 1;
u32 hasACPIThermalMonitorAndClockControl : 1;
u32 hasFastStreamingSIMDExtensionsSaveRestore : 1;
u32 hasStreamingSIMDExtensions : 1;
u32 hasStreamingSIMD2Extensions : 1;
u32 hasSelfSnoop : 1;
// is TRUE for both multi-core and Hyperthreaded CPUs.
u32 hasMultiThreading :1;
u32 hasMultiThreading : 1;
u32 hasThermalMonitor :1;
u32 hasIntel64BitArchitecture :1;
u32 hasStreamingSIMD3Extensions :1;
u32 hasSupplementalStreamingSIMD3Extensions :1;
u32 hasStreamingSIMD4Extensions :1;
u32 hasStreamingSIMD4Extensions2 :1;
u32 hasAVX :1;
u32 hasAVX2 :1;
u32 hasBMI1 :1;
u32 hasBMI2 :1;
u32 hasFMA :1;
u32 hasThermalMonitor : 1;
u32 hasIntel64BitArchitecture : 1;
u32 hasStreamingSIMD3Extensions : 1;
u32 hasSupplementalStreamingSIMD3Extensions : 1;
u32 hasStreamingSIMD4Extensions : 1;
u32 hasStreamingSIMD4Extensions2 : 1;
u32 hasAVX : 1;
u32 hasAVX2 : 1;
u32 hasBMI1 : 1;
u32 hasBMI2 : 1;
u32 hasFMA : 1;
// AMD-specific CPU Features
u32 hasAMD64BitArchitecture :1;
u32 hasStreamingSIMD4ExtensionsA :1;
u32 hasAMD64BitArchitecture : 1;
u32 hasStreamingSIMD4ExtensionsA : 1;
};
u64 AllCapabilities;
@ -119,12 +120,11 @@ public:
void SIMD_EstablishMXCSRmask();
protected:
s64 _CPUSpeedHz( u64 time ) const;
s64 _CPUSpeedHz(u64 time) const;
void CountLogicalCores();
};
enum SSE_RoundMode
{
enum SSE_RoundMode {
SSE_RoundMode_FIRST = 0,
SSEround_Nearest = 0,
SSEround_NegInf,
@ -133,7 +133,7 @@ enum SSE_RoundMode
SSE_RoundMode_COUNT
};
ImplementEnumOperators( SSE_RoundMode );
ImplementEnumOperators(SSE_RoundMode);
// --------------------------------------------------------------------------------------
// SSE_MXCSR - Control/Status Register (bitfield)
@ -151,43 +151,43 @@ union SSE_MXCSR
struct
{
u32
InvalidOpFlag :1,
DenormalFlag :1,
DivideByZeroFlag :1,
OverflowFlag :1,
UnderflowFlag :1,
PrecisionFlag :1,
InvalidOpFlag : 1,
DenormalFlag : 1,
DivideByZeroFlag : 1,
OverflowFlag : 1,
UnderflowFlag : 1,
PrecisionFlag : 1,
// This bit is supported only on SSE2 or better CPUs. Setting it to 1 on
// SSE1 cpus will result in an invalid instruction exception when executing
// LDMXSCR.
DenormalsAreZero :1,
DenormalsAreZero : 1,
InvalidOpMask :1,
DenormalMask :1,
DivideByZeroMask :1,
OverflowMask :1,
UnderflowMask :1,
PrecisionMask :1,
InvalidOpMask : 1,
DenormalMask : 1,
DivideByZeroMask : 1,
OverflowMask : 1,
UnderflowMask : 1,
PrecisionMask : 1,
RoundingControl :2,
FlushToZero :1;
RoundingControl : 2,
FlushToZero : 1;
};
SSE_RoundMode GetRoundMode() const;
SSE_MXCSR& SetRoundMode( SSE_RoundMode mode );
SSE_MXCSR& ClearExceptionFlags();
SSE_MXCSR& EnableExceptions();
SSE_MXCSR& DisableExceptions();
SSE_MXCSR &SetRoundMode(SSE_RoundMode mode);
SSE_MXCSR &ClearExceptionFlags();
SSE_MXCSR &EnableExceptions();
SSE_MXCSR &DisableExceptions();
SSE_MXCSR& ApplyReserveMask();
SSE_MXCSR &ApplyReserveMask();
bool operator ==( const SSE_MXCSR& right ) const
bool operator==(const SSE_MXCSR &right) const
{
return bitmask == right.bitmask;
}
bool operator !=( const SSE_MXCSR& right ) const
bool operator!=(const SSE_MXCSR &right) const
{
return bitmask != right.bitmask;
}
@ -199,4 +199,3 @@ extern SSE_MXCSR MXCSR_Mask;
extern __aligned16 x86capabilities x86caps;

12
common/include/x86emitter/x86_intrin.h
View File

@ -39,18 +39,22 @@
#include <cpuid.h>
static __inline__ __attribute__((always_inline)) void cpuidex(int CPUInfo[], const int InfoType, const int count) {
static __inline__ __attribute__((always_inline)) void cpuidex(int CPUInfo[], const int InfoType, const int count)
{
__cpuid_count(InfoType, count, CPUInfo[0], CPUInfo[1], CPUInfo[2], CPUInfo[3]);
}
static __inline__ __attribute__((always_inline)) void cpuid(int CPUInfo[], const int InfoType) {
static __inline__ __attribute__((always_inline)) void cpuid(int CPUInfo[], const int InfoType)
{
__cpuid(InfoType, CPUInfo[0], CPUInfo[1], CPUInfo[2], CPUInfo[3]);
}
static __inline__ __attribute__((always_inline)) unsigned long long _xgetbv(unsigned int index)
{
unsigned int eax, edx;
__asm__ __volatile__("xgetbv" : "=a"(eax), "=d"(edx) : "c"(index));
__asm__ __volatile__("xgetbv"
: "=a"(eax), "=d"(edx)
: "c"(index));
return ((unsigned long long)edx << 32) | eax;
}
@ -72,5 +76,5 @@ static unsigned int _rotl(unsigned int x, int s)
// Not correctly defined in GCC4.8 and below ! (dunno for VS)
#ifndef _MM_MK_INSERTPS_NDX
#define _MM_MK_INSERTPS_NDX(srcField, dstField, zeroMask) (((srcField)<<6) | ((dstField)<<4) | (zeroMask))
#define _MM_MK_INSERTPS_NDX(srcField, dstField, zeroMask) (((srcField) << 6) | ((dstField) << 4) | (zeroMask))
#endif

1160
common/include/x86emitter/x86types.h
View File

File diff suppressed because it is too large Load Diff

12
common/src/Utilities/AlignedMalloc.cpp
View File

@ -18,9 +18,9 @@
#include "PrecompiledHeader.h"
void* __fastcall _aligned_malloc(size_t size, size_t align)
void *__fastcall _aligned_malloc(size_t size, size_t align)
{
pxAssert( align < 0x10000 );
pxAssert(align < 0x10000);
#if defined(__USE_ISOC11) && !defined(ASAN_WORKAROUND) // not supported yet on gcc 4.9
return aligned_alloc(align, size);
#else
@ -30,11 +30,11 @@ void* __fastcall _aligned_malloc(size_t size, size_t align)
#endif
}
void* __fastcall pcsx2_aligned_realloc(void* handle, size_t new_size, size_t align, size_t old_size)
void *__fastcall pcsx2_aligned_realloc(void *handle, size_t new_size, size_t align, size_t old_size)
{
pxAssert( align < 0x10000 );
pxAssert(align < 0x10000);
void* newbuf = _aligned_malloc(new_size, align);
void *newbuf = _aligned_malloc(new_size, align);
if (newbuf != NULL && handle != NULL) {
memcpy(newbuf, handle, std::min(old_size, new_size));
@ -43,7 +43,7 @@ void* __fastcall pcsx2_aligned_realloc(void* handle, size_t new_size, size_t ali
return newbuf;
}
__fi void _aligned_free(void* pmem)
__fi void _aligned_free(void *pmem)
{
free(pmem);
}

41
common/src/Utilities/CheckedStaticBox.cpp
View File

@ -16,40 +16,39 @@
#include "PrecompiledHeader.h"
#include "CheckedStaticBox.h"
CheckedStaticBox::CheckedStaticBox( wxWindow* parent, int orientation, const wxString& title )
: wxPanelWithHelpers( parent, wxVERTICAL )
, ThisSizer( *new wxStaticBoxSizer( orientation, this ) )
, ThisToggle( *new wxCheckBox( this, wxID_ANY, title, wxPoint( 8, 0 ) ) )
CheckedStaticBox::CheckedStaticBox(wxWindow *parent, int orientation, const wxString &title)
: wxPanelWithHelpers(parent, wxVERTICAL)
, ThisSizer(*new wxStaticBoxSizer(orientation, this))
, ThisToggle(*new wxCheckBox(this, wxID_ANY, title, wxPoint(8, 0)))
{
*this += ThisToggle;
*this += ThisSizer | pxExpand;
// Ensure that the right-side of the static group box isn't too cozy:
SetMinWidth( ThisToggle.GetSize().GetWidth() + 32 );
SetMinWidth(ThisToggle.GetSize().GetWidth() + 32);
Bind(wxEVT_CHECKBOX, &CheckedStaticBox::MainToggle_Click, this, ThisToggle.GetId());
}
// Event handler for click events for the main checkbox (default behavior: enables/disables all child controls)
// This function can be overridden to implement custom handling of check enable/disable behavior.
void CheckedStaticBox::MainToggle_Click( wxCommandEvent& evt )
void CheckedStaticBox::MainToggle_Click(wxCommandEvent &evt)
{
SetValue( evt.IsChecked() );
SetValue(evt.IsChecked());
}
// Sets the main checkbox status, and enables/disables all child controls
// bound to the StaticBox accordingly.
void CheckedStaticBox::SetValue( bool val )
void CheckedStaticBox::SetValue(bool val)
{
wxWindowList& list = GetChildren();
wxWindowList &list = GetChildren();
for( wxWindowList::iterator iter = list.begin(); iter != list.end(); ++iter)
{
for (wxWindowList::iterator iter = list.begin(); iter != list.end(); ++iter) {
wxWindow *current = *iter;
if( current != &ThisToggle )
current->Enable( val );
if (current != &ThisToggle)
current->Enable(val);
}
ThisToggle.SetValue( val );
ThisToggle.SetValue(val);
}
bool CheckedStaticBox::GetValue() const
@ -59,18 +58,18 @@ bool CheckedStaticBox::GetValue() const
// This override is here so to only enable the children if both the main toggle and
// the enable request are true. If not, disable them!
bool CheckedStaticBox::Enable( bool enable )
bool CheckedStaticBox::Enable(bool enable)
{
if (!_parent::Enable(enable)) return false;
if (!_parent::Enable(enable))
return false;
bool val = enable && ThisToggle.GetValue();
wxWindowList& list = GetChildren();
wxWindowList &list = GetChildren();
for( wxWindowList::iterator iter = list.begin(); iter != list.end(); ++iter)
{
for (wxWindowList::iterator iter = list.begin(); iter != list.end(); ++iter) {
wxWindow *current = *iter;
if( current != &ThisToggle )
current->Enable( val );
if (current != &ThisToggle)
current->Enable(val);
}
return true;

268
common/src/Utilities/Console.cpp
View File

@ -23,10 +23,10 @@
using namespace Threading;
// thread-local console indentation setting.
static DeclareTls(int) conlog_Indent( 0 );
static DeclareTls(int) conlog_Indent(0);
// thread-local console color storage.
static DeclareTls(ConsoleColors) conlog_Color( DefaultConsoleColor );
static DeclareTls(ConsoleColors) conlog_Color(DefaultConsoleColor);
#ifdef __POSIX__
static FILE *stdout_fp = stdout;
@ -44,14 +44,13 @@ void Console_SetStdout(FILE *fp)
// Important! Only Assert and Null console loggers are allowed during C++ startup init (when
// the program or DLL first loads). Other log targets rely on the static buffer and a
// threaded mutex lock, which are only valid after C++ initialization has finished.
void Console_SetActiveHandler( const IConsoleWriter& writer, FILE* flushfp )
void Console_SetActiveHandler(const IConsoleWriter &writer, FILE *flushfp)
{
pxAssertDev(
(writer.WriteRaw != NULL) && (writer.DoWriteLn != NULL) &&
(writer.Newline != NULL) && (writer.SetTitle != NULL) &&
(writer.DoSetColor != NULL),
"Invalid IConsoleWriter object! All function pointer interfaces must be implemented."
);
"Invalid IConsoleWriter object! All function pointer interfaces must be implemented.");
Console = writer;
DevConWriter = writer;
@ -63,11 +62,12 @@ void Console_SetActiveHandler( const IConsoleWriter& writer, FILE* flushfp )
// Writes text to the Visual Studio Output window (Microsoft Windows only).
// On all other platforms this pipes to Stdout instead.
void MSW_OutputDebugString( const wxString& text )
void MSW_OutputDebugString(const wxString &text)
{
#if defined(__WXMSW__) && !defined(__WXMICROWIN__)
static bool hasDebugger = wxIsDebuggerRunning();
if( hasDebugger ) OutputDebugString( text );
if (hasDebugger)
OutputDebugString(text);
#else
fputs(text.utf8_str(), stdout_fp);
fflush(stdout_fp);
@ -79,14 +79,14 @@ void MSW_OutputDebugString( const wxString& text )
// ConsoleNull
// --------------------------------------------------------------------------------------
static void __concall ConsoleNull_SetTitle( const wxString& title ) {}
static void __concall ConsoleNull_DoSetColor( ConsoleColors color ) {}
static void __concall ConsoleNull_SetTitle(const wxString &title) {}
static void __concall ConsoleNull_DoSetColor(ConsoleColors color) {}
static void __concall ConsoleNull_Newline() {}
static void __concall ConsoleNull_DoWrite( const wxString& fmt ) {}
static void __concall ConsoleNull_DoWriteLn( const wxString& fmt ) {}
static void __concall ConsoleNull_DoWrite(const wxString &fmt) {}
static void __concall ConsoleNull_DoWriteLn(const wxString &fmt) {}
const IConsoleWriter ConsoleWriter_Null =
{
{
ConsoleNull_DoWrite,
ConsoleNull_DoWriteLn,
ConsoleNull_DoSetColor,
@ -103,65 +103,80 @@ const IConsoleWriter ConsoleWriter_Null =
// --------------------------------------------------------------------------------------
#if defined(__unix__)
static __fi const char* GetLinuxConsoleColor(ConsoleColors color)
static __fi const char *GetLinuxConsoleColor(ConsoleColors color)
{
switch(color)
{
switch (color) {
case Color_Black:
case Color_StrongBlack: return "\033[30m\033[1m";
case Color_StrongBlack:
return "\033[30m\033[1m";
case Color_Red: return "\033[31m";
case Color_StrongRed: return "\033[31m\033[1m";
case Color_Red:
return "\033[31m";
case Color_StrongRed:
return "\033[31m\033[1m";
case Color_Green: return "\033[32m";
case Color_StrongGreen: return "\033[32m\033[1m";
case Color_Green:
return "\033[32m";
case Color_StrongGreen:
return "\033[32m\033[1m";
case Color_Yellow: return "\033[33m";
case Color_StrongYellow: return "\033[33m\033[1m";
case Color_Yellow:
return "\033[33m";
case Color_StrongYellow:
return "\033[33m\033[1m";
case Color_Blue: return "\033[34m";
case Color_StrongBlue: return "\033[34m\033[1m";
case Color_Blue:
return "\033[34m";
case Color_StrongBlue:
return "\033[34m\033[1m";
// No orange, so use magenta.
case Color_Orange:
case Color_Magenta: return "\033[35m";
case Color_Magenta:
return "\033[35m";
case Color_StrongOrange:
case Color_StrongMagenta: return "\033[35m\033[1m";
case Color_StrongMagenta:
return "\033[35m\033[1m";
case Color_Cyan: return "\033[36m";
case Color_StrongCyan: return "\033[36m\033[1m";
case Color_Cyan:
return "\033[36m";
case Color_StrongCyan:
return "\033[36m\033[1m";
// Use 'white' instead of grey.
case Color_Gray:
case Color_White: return "\033[37m";
case Color_White:
return "\033[37m";
case Color_StrongGray:
case Color_StrongWhite: return "\033[37m\033[1m";
case Color_StrongWhite:
return "\033[37m\033[1m";
// On some other value being passed, clear any formatting.
case Color_Default:
default: return "\033[0m";
default:
return "\033[0m";
}
}
#endif
// One possible default write action at startup and shutdown is to use the stdout.
static void __concall ConsoleStdout_DoWrite( const wxString& fmt )
static void __concall ConsoleStdout_DoWrite(const wxString &fmt)
{
MSW_OutputDebugString( fmt );
MSW_OutputDebugString(fmt);
}
// Default write action at startup and shutdown is to use the stdout.
static void __concall ConsoleStdout_DoWriteLn( const wxString& fmt )
static void __concall ConsoleStdout_DoWriteLn(const wxString &fmt)
{
MSW_OutputDebugString( fmt + L"\n" );
MSW_OutputDebugString(fmt + L"\n");
}
static void __concall ConsoleStdout_Newline()
{
MSW_OutputDebugString( L"\n" );
MSW_OutputDebugString(L"\n");
}
static void __concall ConsoleStdout_DoSetColor( ConsoleColors color )
static void __concall ConsoleStdout_DoSetColor(ConsoleColors color)
{
#if defined(__unix__)
fprintf(stdout_fp, "\033[0m%s", GetLinuxConsoleColor(color));
@ -169,7 +184,7 @@ static void __concall ConsoleStdout_DoSetColor( ConsoleColors color )
#endif
}
static void __concall ConsoleStdout_SetTitle( const wxString& title )
static void __concall ConsoleStdout_SetTitle(const wxString &title)
{
#if defined(__unix__)
fputs("\033]0;", stdout_fp);
@ -179,7 +194,7 @@ static void __concall ConsoleStdout_SetTitle( const wxString& title )
}
const IConsoleWriter ConsoleWriter_Stdout =
{
{
ConsoleStdout_DoWrite, // Writes without newlines go to buffer to avoid error log spam.
ConsoleStdout_DoWriteLn,
ConsoleStdout_DoSetColor,
@ -194,18 +209,18 @@ const IConsoleWriter ConsoleWriter_Stdout =
// ConsoleAssert
// --------------------------------------------------------------------------------------
static void __concall ConsoleAssert_DoWrite( const wxString& fmt )
static void __concall ConsoleAssert_DoWrite(const wxString &fmt)
{
pxFail( L"Console class has not been initialized; Message written:\n\t" + fmt );
pxFail(L"Console class has not been initialized; Message written:\n\t" + fmt);
}
static void __concall ConsoleAssert_DoWriteLn( const wxString& fmt )
static void __concall ConsoleAssert_DoWriteLn(const wxString &fmt)
{
pxFail( L"Console class has not been initialized; Message written:\n\t" + fmt );
pxFail(L"Console class has not been initialized; Message written:\n\t" + fmt);
}
const IConsoleWriter ConsoleWriter_Assert =
{
{
ConsoleAssert_DoWrite,
ConsoleAssert_DoWriteLn,
ConsoleNull_DoSetColor,
@ -227,28 +242,29 @@ const IConsoleWriter ConsoleWriter_Assert =
// glob_indent - this parameter is used to specify a global indentation setting. It is used by
// WriteLn function, but defaults to 0 for Warning and Error calls. Local indentation always
// applies to all writes.
wxString IConsoleWriter::_addIndentation( const wxString& src, int glob_indent=0 ) const
wxString IConsoleWriter::_addIndentation(const wxString &src, int glob_indent = 0) const
{
const int indent = glob_indent + _imm_indentation;
if( indent == 0 ) return src;
if (indent == 0)
return src;
wxString result( src );
const wxString indentStr( L'\t', indent );
result.Replace( L"\n", L"\n" + indentStr );
wxString result(src);
const wxString indentStr(L'\t', indent);
result.Replace(L"\n", L"\n" + indentStr);
return indentStr + result;
}
// Sets the indentation to be applied to all WriteLn's. The indentation is added to the
// primary write, and to any newlines specified within the write. Note that this applies
// to calls to WriteLn *only* -- calls to Write bypass the indentation parser.
const IConsoleWriter& IConsoleWriter::SetIndent( int tabcount ) const
const IConsoleWriter &IConsoleWriter::SetIndent(int tabcount) const
{
conlog_Indent += tabcount;
pxAssert( conlog_Indent >= 0 );
pxAssert(conlog_Indent >= 0);
return *this;
}
IConsoleWriter IConsoleWriter::Indent( int tabcount ) const
IConsoleWriter IConsoleWriter::Indent(int tabcount) const
{
IConsoleWriter retval = *this;
retval._imm_indentation = tabcount;
@ -258,15 +274,16 @@ IConsoleWriter IConsoleWriter::Indent( int tabcount ) const
// Changes the active console color.
// This color will be unset by calls to colored text methods
// such as ErrorMsg and Notice.
const IConsoleWriter& IConsoleWriter::SetColor( ConsoleColors color ) const
const IConsoleWriter &IConsoleWriter::SetColor(ConsoleColors color) const
{
// Ignore current color requests since, well, the current color is already set. ;)
if( color == Color_Current ) return *this;
if (color == Color_Current)
return *this;
pxAssertMsg( (color > Color_Current) && (color < ConsoleColors_Count), "Invalid ConsoleColor specified." );
pxAssertMsg((color > Color_Current) && (color < ConsoleColors_Count), "Invalid ConsoleColor specified.");
if( conlog_Color != color )
DoSetColor( conlog_Color = color );
if (conlog_Color != color)
DoSetColor(conlog_Color = color);
return *this;
}
@ -277,10 +294,10 @@ ConsoleColors IConsoleWriter::GetColor() const
}
// Restores the console color to default (usually black, or low-intensity white if the console uses a black background)
const IConsoleWriter& IConsoleWriter::ClearColor() const
const IConsoleWriter &IConsoleWriter::ClearColor() const
{
if( conlog_Color != DefaultConsoleColor )
DoSetColor( conlog_Color = DefaultConsoleColor );
if (conlog_Color != DefaultConsoleColor)
DoSetColor(conlog_Color = DefaultConsoleColor);
return *this;
}
@ -289,49 +306,49 @@ const IConsoleWriter& IConsoleWriter::ClearColor() const
// ASCII/UTF8 (char*)
// --------------------------------------------------------------------------------------
bool IConsoleWriter::FormatV( const char* fmt, va_list args ) const
bool IConsoleWriter::FormatV(const char *fmt, va_list args) const
{
DoWriteLn( _addIndentation( pxsFmtV(fmt,args), conlog_Indent ) );
DoWriteLn(_addIndentation(pxsFmtV(fmt, args), conlog_Indent));
return false;
}
bool IConsoleWriter::WriteLn( const char* fmt, ... ) const
bool IConsoleWriter::WriteLn(const char *fmt, ...) const
{
va_list args;
va_start(args,fmt);
va_start(args, fmt);
FormatV(fmt, args);
va_end(args);
return false;
}
bool IConsoleWriter::WriteLn( ConsoleColors color, const char* fmt, ... ) const
bool IConsoleWriter::WriteLn(ConsoleColors color, const char *fmt, ...) const
{
va_list args;
va_start(args,fmt);
ConsoleColorScope cs( color );
va_start(args, fmt);
ConsoleColorScope cs(color);
FormatV(fmt, args);
va_end(args);
return false;
}
bool IConsoleWriter::Error( const char* fmt, ... ) const
bool IConsoleWriter::Error(const char *fmt, ...) const
{
va_list args;
va_start(args,fmt);
ConsoleColorScope cs( Color_StrongRed );
va_start(args, fmt);
ConsoleColorScope cs(Color_StrongRed);
FormatV(fmt, args);
va_end(args);
return false;
}
bool IConsoleWriter::Warning( const char* fmt, ... ) const
bool IConsoleWriter::Warning(const char *fmt, ...) const
{
va_list args;
va_start(args,fmt);
ConsoleColorScope cs( Color_StrongOrange );
va_start(args, fmt);
ConsoleColorScope cs(Color_StrongOrange);
FormatV(fmt, args);
va_end(args);
@ -342,50 +359,50 @@ bool IConsoleWriter::Warning( const char* fmt, ... ) const
// Write Variants - Unicode/UTF16 style
// --------------------------------------------------------------------------------------
bool IConsoleWriter::FormatV( const wxChar* fmt, va_list args ) const
bool IConsoleWriter::FormatV(const wxChar *fmt, va_list args) const
{
DoWriteLn( _addIndentation( pxsFmtV( fmt, args ), conlog_Indent ) );
DoWriteLn(_addIndentation(pxsFmtV(fmt, args), conlog_Indent));
return false;
}
bool IConsoleWriter::WriteLn( const wxChar* fmt, ... ) const
bool IConsoleWriter::WriteLn(const wxChar *fmt, ...) const
{
va_list args;
va_start(args,fmt);
FormatV(fmt,args);
va_start(args, fmt);
FormatV(fmt, args);
va_end(args);
return false;
}
bool IConsoleWriter::WriteLn( ConsoleColors color, const wxChar* fmt, ... ) const
bool IConsoleWriter::WriteLn(ConsoleColors color, const wxChar *fmt, ...) const
{
va_list args;
va_start(args,fmt);
ConsoleColorScope cs( color );
FormatV(fmt,args);
va_start(args, fmt);
ConsoleColorScope cs(color);
FormatV(fmt, args);
va_end(args);
return false;
}
bool IConsoleWriter::Error( const wxChar* fmt, ... ) const
bool IConsoleWriter::Error(const wxChar *fmt, ...) const
{
va_list args;
va_start(args,fmt);
ConsoleColorScope cs( Color_StrongRed );
FormatV(fmt,args);
va_start(args, fmt);
ConsoleColorScope cs(Color_StrongRed);
FormatV(fmt, args);
va_end(args);
return false;
}
bool IConsoleWriter::Warning( const wxChar* fmt, ... ) const
bool IConsoleWriter::Warning(const wxChar *fmt, ...) const
{
va_list args;
va_start(args,fmt);
ConsoleColorScope cs( Color_StrongOrange );
FormatV(fmt,args);
va_start(args, fmt);
ConsoleColorScope cs(Color_StrongOrange);
FormatV(fmt, args);
va_end(args);
return false;
@ -394,44 +411,44 @@ bool IConsoleWriter::Warning( const wxChar* fmt, ... ) const
// --------------------------------------------------------------------------------------
// Write Variants - Unknown style
// --------------------------------------------------------------------------------------
bool IConsoleWriter::WriteLn( const wxString fmt, ... ) const
bool IConsoleWriter::WriteLn(const wxString fmt, ...) const
{
va_list args;
va_start(args,fmt);
FormatV(fmt.wx_str(),args);
va_start(args, fmt);
FormatV(fmt.wx_str(), args);
va_end(args);
return false;
}
bool IConsoleWriter::WriteLn( ConsoleColors color, const wxString fmt, ... ) const
bool IConsoleWriter::WriteLn(ConsoleColors color, const wxString fmt, ...) const
{
va_list args;
va_start(args,fmt);
ConsoleColorScope cs( color );
FormatV(fmt.wx_str(),args);
va_start(args, fmt);
ConsoleColorScope cs(color);
FormatV(fmt.wx_str(), args);
va_end(args);
return false;
}
bool IConsoleWriter::Error( const wxString fmt, ... ) const
bool IConsoleWriter::Error(const wxString fmt, ...) const
{
va_list args;
va_start(args,fmt);
ConsoleColorScope cs( Color_StrongRed );
FormatV(fmt.wx_str(),args);
va_start(args, fmt);
ConsoleColorScope cs(Color_StrongRed);
FormatV(fmt.wx_str(), args);
va_end(args);
return false;
}
bool IConsoleWriter::Warning( const wxString fmt, ... ) const
bool IConsoleWriter::Warning(const wxString fmt, ...) const
{
va_list args;
va_start(args,fmt);
ConsoleColorScope cs( Color_StrongOrange );
FormatV(fmt.wx_str(),args);
va_start(args, fmt);
ConsoleColorScope cs(Color_StrongOrange);
FormatV(fmt.wx_str(), args);
va_end(args);
return false;
@ -442,7 +459,7 @@ bool IConsoleWriter::Warning( const wxString fmt, ... ) const
// ConsoleColorScope / ConsoleIndentScope
// --------------------------------------------------------------------------------------
ConsoleColorScope::ConsoleColorScope( ConsoleColors newcolor )
ConsoleColorScope::ConsoleColorScope(ConsoleColors newcolor)
{
m_IsScoped = false;
m_newcolor = newcolor;
@ -456,20 +473,19 @@ ConsoleColorScope::~ConsoleColorScope() throw()
void ConsoleColorScope::EnterScope()
{
if (!m_IsScoped)
{
if (!m_IsScoped) {
m_old_color = Console.GetColor();
Console.SetColor( m_newcolor );
Console.SetColor(m_newcolor);
m_IsScoped = true;
}
}
void ConsoleColorScope::LeaveScope()
{
m_IsScoped = m_IsScoped && (Console.SetColor( m_old_color ), false);
m_IsScoped = m_IsScoped && (Console.SetColor(m_old_color), false);
}
ConsoleIndentScope::ConsoleIndentScope( int tabs )
ConsoleIndentScope::ConsoleIndentScope(int tabs)
{
m_IsScoped = false;
m_amount = tabs;
@ -486,27 +502,27 @@ ConsoleIndentScope::~ConsoleIndentScope() throw()
void ConsoleIndentScope::EnterScope()
{
m_IsScoped = m_IsScoped || (Console.SetIndent( m_amount ),true);
m_IsScoped = m_IsScoped || (Console.SetIndent(m_amount), true);
}
void ConsoleIndentScope::LeaveScope()
{
m_IsScoped = m_IsScoped && (Console.SetIndent( -m_amount ),false);
m_IsScoped = m_IsScoped && (Console.SetIndent(-m_amount), false);
}
ConsoleAttrScope::ConsoleAttrScope( ConsoleColors newcolor, int indent )
ConsoleAttrScope::ConsoleAttrScope(ConsoleColors newcolor, int indent)
{
m_old_color = Console.GetColor();
Console.SetIndent( m_tabsize = indent );
Console.SetColor( newcolor );
Console.SetIndent(m_tabsize = indent);
Console.SetColor(newcolor);
}
ConsoleAttrScope::~ConsoleAttrScope() throw()
{
try {
Console.SetColor( m_old_color );
Console.SetIndent( -m_tabsize );
Console.SetColor(m_old_color);
Console.SetIndent(-m_tabsize);
}
DESTRUCTOR_CATCHALL
}
@ -539,31 +555,31 @@ NullConsoleWriter NullCon = {};
// Writes to the console using the specified color. This overrides the default color setting
// for this log.
bool ConsoleLogSource::WriteV( ConsoleColors color, const char *fmt, va_list list ) const
bool ConsoleLogSource::WriteV(ConsoleColors color, const char *fmt, va_list list) const
{
ConsoleColorScope cs(color);
DoWrite( pxsFmtV(fmt,list).c_str() );
DoWrite(pxsFmtV(fmt, list).c_str());
return false;
}
bool ConsoleLogSource::WriteV( ConsoleColors color, const wxChar *fmt, va_list list ) const
bool ConsoleLogSource::WriteV(ConsoleColors color, const wxChar *fmt, va_list list) const
{
ConsoleColorScope cs(color);
DoWrite( pxsFmtV(fmt,list).c_str() );
DoWrite(pxsFmtV(fmt, list).c_str());
return false;
}
// Writes to the console using the source's default color. Note that the source's default
// color will always be used, thus ConsoleColorScope() will not be effectual unless the
// console's default color is Color_Default.
bool ConsoleLogSource::WriteV( const char *fmt, va_list list ) const
bool ConsoleLogSource::WriteV(const char *fmt, va_list list) const
{
WriteV( DefaultColor, fmt, list );
WriteV(DefaultColor, fmt, list);
return false;
}
bool ConsoleLogSource::WriteV( const wxChar *fmt, va_list list ) const
bool ConsoleLogSource::WriteV(const wxChar *fmt, va_list list) const
{
WriteV( DefaultColor, fmt, list );
WriteV(DefaultColor, fmt, list);
return false;
}

8
common/src/Utilities/Darwin/DarwinMisc.cpp
View File

@ -24,7 +24,7 @@
#include <mach/mach_time.h>
#define NELEM(x) \
((sizeof(x)/sizeof(0[x])) / ((size_t)(!(sizeof(x) % sizeof(0[x])))))
((sizeof(x) / sizeof(0 [x])) / ((size_t)(!(sizeof(x) % sizeof(0 [x])))))
// Darwin (OSX) is a bit different from Linux when requesting properties of
// the OS because of its BSD/Mach heritage. Helpfully, most of this code
@ -47,7 +47,7 @@ u64 GetPhysicalMemory()
if (__atomic_load_n(&mem, __ATOMIC_SEQ_CST) == 0) {
u64 getmem = 0;
size_t len = sizeof(getmem);
int mib[] = { CTL_HW, HW_MEMSIZE };
int mib[] = {CTL_HW, HW_MEMSIZE};
if (sysctl(mib, NELEM(mib), &getmem, &len, NULL, 0) < 0) {
perror("sysctl:");
}
@ -87,7 +87,7 @@ u64 GetTickFrequency()
}
// store the calculated value atomically
__atomic_store_n(&freq, (u64) 1e9 * (u64) info.denom / (u64) info.numer, __ATOMIC_SEQ_CST);
__atomic_store_n(&freq, (u64)1e9 * (u64)info.denom / (u64)info.numer, __ATOMIC_SEQ_CST);
}
return freq;
@ -115,7 +115,7 @@ wxString GetOSVersionString()
#define SYSCTL_GET(var, base, name) \
do { \
int mib[] = { base, name }; \
int mib[] = {base, name}; \
size_t len = sizeof(var); \
sysctl(mib, NELEM(mib), NULL, &len, NULL, 0); \
sysctl(mib, NELEM(mib), var, &len, NULL, 0); \

33
common/src/Utilities/Darwin/DarwinSemaphore.cpp
View File

@ -66,14 +66,14 @@ Threading::Semaphore::Semaphore()
Threading::Semaphore::~Semaphore() throw()
{
MACH_CHECK(semaphore_destroy(mach_task_self(), (semaphore_t) m_sema));
MACH_CHECK(semaphore_destroy(mach_task_self(), (semaphore_t)m_sema));
__atomic_store_n(&m_counter, 0, __ATOMIC_SEQ_CST);
}
void Threading::Semaphore::Reset()
{
MACH_CHECK(semaphore_destroy(mach_task_self(), (semaphore_t) m_sema));
MACH_CHECK(semaphore_create(mach_task_self(), (semaphore_t *) &m_sema, SYNC_POLICY_FIFO, 0));
MACH_CHECK(semaphore_destroy(mach_task_self(), (semaphore_t)m_sema));
MACH_CHECK(semaphore_create(mach_task_self(), (semaphore_t *)&m_sema, SYNC_POLICY_FIFO, 0));
__atomic_store_n(&m_counter, 0, __ATOMIC_SEQ_CST);
}
@ -98,7 +98,7 @@ void Threading::Semaphore::WaitWithoutYield()
__atomic_sub_fetch(&m_counter, 1, __ATOMIC_SEQ_CST);
}
bool Threading::Semaphore::WaitWithoutYield(const wxTimeSpan& timeout)
bool Threading::Semaphore::WaitWithoutYield(const wxTimeSpan &timeout)
{
// This method is the reason why there has to be a special Darwin
// implementation of Semaphore. Note that semaphore_timedwait() is prone
@ -155,14 +155,12 @@ bool Threading::Semaphore::WaitWithoutYield(const wxTimeSpan& timeout)
void Threading::Semaphore::Wait()
{
#if wxUSE_GUI
if(!wxThread::IsMain() || (wxTheApp == NULL)) {
if (!wxThread::IsMain() || (wxTheApp == NULL)) {
WaitWithoutYield();
}
else if(_WaitGui_RecursionGuard( L"Semaphore::Wait" )) {
ScopedBusyCursor hourglass( Cursor_ReallyBusy );
} else if (_WaitGui_RecursionGuard(L"Semaphore::Wait")) {
ScopedBusyCursor hourglass(Cursor_ReallyBusy);
WaitWithoutYield();
}
else {
} else {
while (!WaitWithoutYield(def_yieldgui_interval)) {
YieldToMain();
}
@ -181,22 +179,21 @@ void Threading::Semaphore::Wait()
// false if the wait timed out before the semaphore was signaled, or true if the signal was
// reached prior to timeout.
//
bool Threading::Semaphore::Wait(const wxTimeSpan& timeout)
bool Threading::Semaphore::Wait(const wxTimeSpan &timeout)
{
#if wxUSE_GUI
if(!wxThread::IsMain() || (wxTheApp == NULL)) {
if (!wxThread::IsMain() || (wxTheApp == NULL)) {
return WaitWithoutYield(timeout);
}
else if (_WaitGui_RecursionGuard( L"Semaphore::TimedWait")) {
} else if (_WaitGui_RecursionGuard(L"Semaphore::TimedWait")) {
ScopedBusyCursor hourglass(Cursor_ReallyBusy);
return WaitWithoutYield(timeout);
}
else {
} else {
//ScopedBusyCursor hourglass( Cursor_KindaBusy );
wxTimeSpan countdown((timeout));
do {
if (WaitWithoutYield(def_yieldgui_interval)) break;
if (WaitWithoutYield(def_yieldgui_interval))
break;
YieldToMain();
countdown -= def_yieldgui_interval;
} while (countdown.GetMilliseconds() > 0);
@ -229,7 +226,7 @@ void Threading::Semaphore::WaitNoCancel()
pthread_setcancelstate(oldstate, NULL);
}
void Threading::Semaphore::WaitNoCancel(const wxTimeSpan& timeout)
void Threading::Semaphore::WaitNoCancel(const wxTimeSpan &timeout)
{
int oldstate;
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate);

25
common/src/Utilities/Darwin/DarwinThreads.cpp
View File

@ -19,7 +19,7 @@
#include <unistd.h>
#if !defined(__APPLE__)
# error "DarwinThreads.cpp should only be compiled by projects or makefiles targeted at OSX."
#error "DarwinThreads.cpp should only be compiled by projects or makefiles targeted at OSX."
#else
#include <mach/mach_init.h>
@ -30,7 +30,7 @@
// the LOCK prefix. The prefix works on single core CPUs fine (but is slow), but not
// having the LOCK prefix is very bad indeed.
__forceinline void Threading::Sleep( int ms )
__forceinline void Threading::Sleep(int ms)
{
usleep(1000 * ms);
}
@ -41,7 +41,7 @@ __forceinline void Threading::SpinWait()
{
// If this doesn't compile you can just comment it out (it only serves as a
// performance hint and isn't required).
__asm__ ( "pause" );
__asm__("pause");
}
__forceinline void Threading::EnableHiresScheduler()
@ -66,21 +66,22 @@ u64 Threading::GetThreadTicksPerSecond()
// gets the CPU time used by the current thread (both system and user), in
// microseconds, returns 0 on failure
static u64 getthreadtime(thread_port_t thread) {
static u64 getthreadtime(thread_port_t thread)
{
mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
thread_basic_info_data_t info;
kern_return_t kr = thread_info(thread, THREAD_BASIC_INFO,
(thread_info_t) &info, &count);
(thread_info_t)&info, &count);
if (kr != KERN_SUCCESS) {
return 0;
}
// add system and user time
return (u64) info.user_time.seconds * (u64) 1e6 +
(u64) info.user_time.microseconds +
(u64) info.system_time.seconds * (u64) 1e6 +
(u64) info.system_time.microseconds;
return (u64)info.user_time.seconds * (u64)1e6 +
(u64)info.user_time.microseconds +
(u64)info.system_time.seconds * (u64)1e6 +
(u64)info.system_time.microseconds;
}
// Returns the current timestamp (not relative to a real world clock) in
@ -109,19 +110,19 @@ u64 Threading::pxThread::GetCpuTime() const
return 0;
}
return getthreadtime((thread_port_t) m_native_id) * 10ULL;
return getthreadtime((thread_port_t)m_native_id) * 10ULL;
}
void Threading::pxThread::_platform_specific_OnStartInThread()
{
m_native_id = (uptr) mach_thread_self();
m_native_id = (uptr)mach_thread_self();
}
void Threading::pxThread::_platform_specific_OnCleanupInThread()
{
// cleanup of handles that were upened in
// _platform_specific_OnStartInThread
mach_port_deallocate(mach_task_self(), (thread_port_t) m_native_id);
mach_port_deallocate(mach_task_self(), (thread_port_t)m_native_id);
}
// name can be up to 16 bytes

146
common/src/Utilities/Exceptions.cpp
View File

@ -43,34 +43,34 @@ Fnptr_OutOfMemory pxDoOutOfMemory = NULL;
// const false).
//
#ifdef PCSX2_DEVBUILD
# define DEVASSERT_INLINE __noinline
#define DEVASSERT_INLINE __noinline
#else
# define DEVASSERT_INLINE __fi
#define DEVASSERT_INLINE __fi
#endif
// Using a threadlocal assertion guard. Separate threads can assert at the same time.
// That's ok. What we don't want is the *same* thread recurse-asserting.
static DeclareTls(int) s_assert_guard( 0 );
static DeclareTls(int) s_assert_guard(0);
pxDoAssertFnType* pxDoAssert = pxAssertImpl_LogIt;
pxDoAssertFnType *pxDoAssert = pxAssertImpl_LogIt;
// make life easier for people using VC++ IDE by using this format, which allows double-click
// response times from the Output window...
wxString DiagnosticOrigin::ToString( const wxChar* msg ) const
wxString DiagnosticOrigin::ToString(const wxChar *msg) const
{
FastFormatUnicode message;
message.Write( L"%ls(%d) : assertion failed:\n", srcfile, line );
message.Write(L"%ls(%d) : assertion failed:\n", srcfile, line);
if( function != NULL )
message.Write( " Function: %s\n", function );
if (function != NULL)
message.Write(" Function: %s\n", function);
message.Write(L" Thread: %s\n", WX_STR(Threading::pxGetCurrentThreadName()) );
message.Write(L" Thread: %s\n", WX_STR(Threading::pxGetCurrentThreadName()));
if( condition != NULL )
if (condition != NULL)
message.Write(L" Condition: %ls\n", condition);
if( msg != NULL )
if (msg != NULL)
message.Write(L" Message: %ls\n", msg);
return message;
@ -83,37 +83,39 @@ void pxTrap()
#if defined(__WXMSW__) && !defined(__WXMICROWIN__)
__debugbreak();
#elif defined(__WXMAC__) && !defined(__DARWIN__)
#if __powerc
#if __powerc
Debugger();
#else
#else
SysBreak();
#endif
#endif
#elif defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
Debugger();
#elif defined(__UNIX__)
raise(SIGTRAP);
#else
// TODO
// TODO
#endif // Win/Unix
}
bool pxAssertImpl_LogIt( const DiagnosticOrigin& origin, const wxChar *msg )
bool pxAssertImpl_LogIt(const DiagnosticOrigin &origin, const wxChar *msg)
{
//wxLogError( L"%s", origin.ToString( msg ).c_str() );
wxMessageOutputDebug().Printf( L"%s", origin.ToString( msg ).c_str() );
wxMessageOutputDebug().Printf(L"%s", origin.ToString(msg).c_str());
pxTrap();
return false;
}
DEVASSERT_INLINE void pxOnAssert( const DiagnosticOrigin& origin, const wxChar* msg )
DEVASSERT_INLINE void pxOnAssert(const DiagnosticOrigin &origin, const wxChar *msg)
{
// Recursion guard: Allow at least one recursive call. This is useful because sometimes
// we get meaningless assertions while unwinding stack traces after exceptions have occurred.
RecursionGuard guard( s_assert_guard );
if (guard.Counter > 2) { return pxTrap(); }
RecursionGuard guard(s_assert_guard);
if (guard.Counter > 2) {
return pxTrap();
}
// wxWidgets doesn't come with debug builds on some Linux distros, and other distros make
// it difficult to use the debug build (compilation failures). To handle these I've had to
@ -122,32 +124,31 @@ DEVASSERT_INLINE void pxOnAssert( const DiagnosticOrigin& origin, const wxChar*
bool trapit;
if( pxDoAssert == NULL )
{
if (pxDoAssert == NULL) {
// Note: Format uses MSVC's syntax for output window hotlinking.
trapit = pxAssertImpl_LogIt( origin, msg );
}
else
{
trapit = pxDoAssert( origin, msg );
trapit = pxAssertImpl_LogIt(origin, msg);
} else {
trapit = pxDoAssert(origin, msg);
}
if( trapit ) { pxTrap(); }
if (trapit) {
pxTrap();
}
}
__fi void pxOnAssert( const DiagnosticOrigin& origin, const char* msg)
__fi void pxOnAssert(const DiagnosticOrigin &origin, const char *msg)
{
pxOnAssert( origin, fromUTF8(msg) );
pxOnAssert(origin, fromUTF8(msg));
}
__fi void pxOnAssert( const DiagnosticOrigin& origin, const wxString& msg)
__fi void pxOnAssert(const DiagnosticOrigin &origin, const wxString &msg)
{
pxOnAssert( origin, msg.wc_str() );
pxOnAssert(origin, msg.wc_str());
}
__fi void pxOnAssert( const DiagnosticOrigin& origin, const FastFormatUnicode& msg)
__fi void pxOnAssert(const DiagnosticOrigin &origin, const FastFormatUnicode &msg)
{
pxOnAssert( origin, msg.c_str());
pxOnAssert(origin, msg.c_str());
}
// --------------------------------------------------------------------------------------
@ -156,19 +157,19 @@ __fi void pxOnAssert( const DiagnosticOrigin& origin, const FastFormatUnicode& m
BaseException::~BaseException() throw() {}
BaseException& BaseException::SetBothMsgs( const wxChar* msg_diag )
BaseException &BaseException::SetBothMsgs(const wxChar *msg_diag)
{
m_message_user = msg_diag ? wxString(wxGetTranslation( msg_diag )) : wxString("");
return SetDiagMsg( msg_diag );
m_message_user = msg_diag ? wxString(wxGetTranslation(msg_diag)) : wxString("");
return SetDiagMsg(msg_diag);
}
BaseException& BaseException::SetDiagMsg( const wxString& msg_diag )
BaseException &BaseException::SetDiagMsg(const wxString &msg_diag)
{
m_message_diag = msg_diag;
return *this;
}
BaseException& BaseException::SetUserMsg( const wxString& msg_user )
BaseException &BaseException::SetUserMsg(const wxString &msg_user)
{
m_message_user = msg_user;
return *this;
@ -187,30 +188,28 @@ wxString BaseException::FormatDisplayMessage() const
// --------------------------------------------------------------------------------------
// Exception::RuntimeError (implementations)
// --------------------------------------------------------------------------------------
Exception::RuntimeError::RuntimeError( const std::runtime_error& ex, const wxString& prefix )
Exception::RuntimeError::RuntimeError(const std::runtime_error &ex, const wxString &prefix)
{
IsSilent = false;
SetDiagMsg( pxsFmt( L"STL Runtime Error%s: %s",
SetDiagMsg(pxsFmt(L"STL Runtime Error%s: %s",
(prefix.IsEmpty() ? L"" : pxsFmt(L" (%s)", WX_STR(prefix)).c_str()),
WX_STR(fromUTF8( ex.what() ))
) );
WX_STR(fromUTF8(ex.what()))));
}
Exception::RuntimeError::RuntimeError( const std::exception& ex, const wxString& prefix )
Exception::RuntimeError::RuntimeError(const std::exception &ex, const wxString &prefix)
{
IsSilent = false;
SetDiagMsg( pxsFmt( L"STL Exception%s: %s",
SetDiagMsg(pxsFmt(L"STL Exception%s: %s",
(prefix.IsEmpty() ? L"" : pxsFmt(L" (%s)", WX_STR(prefix)).c_str()),
WX_STR(fromUTF8( ex.what() ))
) );
WX_STR(fromUTF8(ex.what()))));
}
// --------------------------------------------------------------------------------------
// Exception::OutOfMemory (implementations)
// --------------------------------------------------------------------------------------
Exception::OutOfMemory::OutOfMemory( const wxString& allocdesc )
Exception::OutOfMemory::OutOfMemory(const wxString &allocdesc)
{
AllocDescription = allocdesc;
}
@ -231,7 +230,7 @@ wxString Exception::OutOfMemory::FormatDiagnosticMessage() const
wxString Exception::OutOfMemory::FormatDisplayMessage() const
{
FastFormatUnicode retmsg;
retmsg.Write( L"%s", _("Oh noes! Out of memory!") );
retmsg.Write(L"%s", _("Oh noes! Out of memory!"));
if (!m_message_user.IsEmpty())
retmsg.Write(L"\n\n%s", WX_STR(m_message_user));
@ -243,7 +242,7 @@ wxString Exception::OutOfMemory::FormatDisplayMessage() const
// --------------------------------------------------------------------------------------
// Exception::VirtualMemoryMapConflict (implementations)
// --------------------------------------------------------------------------------------
Exception::VirtualMemoryMapConflict::VirtualMemoryMapConflict( const wxString& allocdesc )
Exception::VirtualMemoryMapConflict::VirtualMemoryMapConflict(const wxString &allocdesc)
{
AllocDescription = allocdesc;
m_message_user = _("Virtual memory mapping failure! Your system may have conflicting device drivers, services, or may simply have insufficient memory or resources to meet PCSX2's lofty needs.");
@ -265,10 +264,8 @@ wxString Exception::VirtualMemoryMapConflict::FormatDiagnosticMessage() const
wxString Exception::VirtualMemoryMapConflict::FormatDisplayMessage() const
{
FastFormatUnicode retmsg;
retmsg.Write( L"%s",
pxE( L"There is not enough virtual memory available, or necessary virtual memory mappings have already been reserved by other processes, services, or DLLs."
)
);
retmsg.Write(L"%s",
pxE(L"There is not enough virtual memory available, or necessary virtual memory mappings have already been reserved by other processes, services, or DLLs."));
if (!m_message_diag.IsEmpty())
retmsg.Write(L"\n\n%s", WX_STR(m_message_diag));
@ -305,25 +302,25 @@ wxString Exception::BadStream::FormatDisplayMessage() const
return retval;
}
void Exception::BadStream::_formatDiagMsg( FastFormatUnicode& dest ) const
void Exception::BadStream::_formatDiagMsg(FastFormatUnicode &dest) const
{
dest.Write( L"Path: " );
dest.Write(L"Path: ");
if (!StreamName.IsEmpty())
dest.Write( L"%s", WX_STR(StreamName) );
dest.Write(L"%s", WX_STR(StreamName));
else
dest.Write( L"[Unnamed or unknown]" );
dest.Write(L"[Unnamed or unknown]");
if (!m_message_diag.IsEmpty())
dest.Write(L"\n%s", WX_STR(m_message_diag));
}
void Exception::BadStream::_formatUserMsg( FastFormatUnicode& dest ) const
void Exception::BadStream::_formatUserMsg(FastFormatUnicode &dest) const
{
dest.Write( _("Path: ") );
dest.Write(_("Path: "));
if (!StreamName.IsEmpty())
dest.Write( L"%s", WX_STR(StreamName) );
dest.Write(L"%s", WX_STR(StreamName));
else
dest.Write( _("[Unnamed or unknown]") );
dest.Write(_("[Unnamed or unknown]"));
if (!m_message_user.IsEmpty())
dest.Write(L"\n%s", WX_STR(m_message_user));
@ -415,35 +412,34 @@ wxString Exception::EndOfStream::FormatDisplayMessage() const
// Translates an Errno code into an exception.
// Throws an exception based on the given error code (usually taken from ANSI C's errno)
BaseException* Exception::FromErrno( const wxString& streamname, int errcode )
BaseException *Exception::FromErrno(const wxString &streamname, int errcode)
{
pxAssumeDev( errcode != 0, "Invalid NULL error code? (errno)" );
pxAssumeDev(errcode != 0, "Invalid NULL error code? (errno)");
switch( errcode )
{
switch (errcode) {
case EINVAL:
pxFailDev( L"Invalid argument" );
return &(new Exception::BadStream( streamname ))->SetDiagMsg(L"Invalid argument? (likely caused by an unforgivable programmer error!)" );
pxFailDev(L"Invalid argument");
return &(new Exception::BadStream(streamname))->SetDiagMsg(L"Invalid argument? (likely caused by an unforgivable programmer error!)");
case EACCES: // Access denied!
return new Exception::AccessDenied( streamname );
return new Exception::AccessDenied(streamname);
case EMFILE: // Too many open files!
return &(new Exception::CannotCreateStream( streamname ))->SetDiagMsg(L"Too many open files"); // File handle allocation failure
return &(new Exception::CannotCreateStream(streamname))->SetDiagMsg(L"Too many open files"); // File handle allocation failure
case EEXIST:
return &(new Exception::CannotCreateStream( streamname ))->SetDiagMsg(L"File already exists");
return &(new Exception::CannotCreateStream(streamname))->SetDiagMsg(L"File already exists");
case ENOENT: // File not found!
return new Exception::FileNotFound( streamname );
return new Exception::FileNotFound(streamname);
case EPIPE:
return &(new Exception::BadStream( streamname ))->SetDiagMsg(L"Broken pipe");
return &(new Exception::BadStream(streamname))->SetDiagMsg(L"Broken pipe");
case EBADF:
return &(new Exception::BadStream( streamname ))->SetDiagMsg(L"Bad file number");
return &(new Exception::BadStream(streamname))->SetDiagMsg(L"Bad file number");
default:
return &(new Exception::BadStream( streamname ))->SetDiagMsg(pxsFmt( L"General file/stream error [errno: %d]", errcode ));
return &(new Exception::BadStream(streamname))->SetDiagMsg(pxsFmt(L"General file/stream error [errno: %d]", errcode));
}
}

112
common/src/Utilities/FastFormatString.cpp
View File

@ -24,9 +24,9 @@ template class SafeArray<char>;
template class SafeArray<wchar_t>;
template class SafeArray<u8>;
template class SafeAlignedArray<char,16>;
template class SafeAlignedArray<wchar_t,16>;
template class SafeAlignedArray<u8,16>;
template class SafeAlignedArray<char, 16>;
template class SafeAlignedArray<wchar_t, 16>;
template class SafeAlignedArray<u8, 16>;
// Sanity check: truncate strings if they exceed 512k in length. Anything like that
// is either a bug or really horrible code that needs to be stopped before it causes
@ -35,36 +35,38 @@ static const int MaxFormattedStringLength = 0x80000;
static
#ifndef __linux__
__ri
__ri
#endif
void format_that_ascii_mess( CharBufferType& buffer, uint writepos, const char* fmt, va_list argptr )
void
format_that_ascii_mess(CharBufferType &buffer, uint writepos, const char *fmt, va_list argptr)
{
va_list args;
while( true )
{
while (true) {
int size = buffer.GetLength();
va_copy(args, argptr);
int len = vsnprintf(buffer.GetPtr(writepos), size-writepos, fmt, args);
int len = vsnprintf(buffer.GetPtr(writepos), size - writepos, fmt, args);
va_end(args);
// some implementations of vsnprintf() don't NUL terminate
// the string if there is not enough space for it so
// always do it manually
buffer[size-1] = '\0';
buffer[size - 1] = '\0';
if (size >= MaxFormattedStringLength) break;
if (size >= MaxFormattedStringLength)
break;
// vsnprintf() may return either -1 (traditional Unix behavior) or the
// total number of characters which would have been written if the
// buffer were large enough (newer standards such as Unix98)
if (len < 0)
len = size + (size/4);
len = size + (size / 4);
len += writepos;
if (len < size) break;
buffer.Resize( len + 128 );
if (len < size)
break;
buffer.Resize(len + 128);
};
// performing an assertion or log of a truncated string is unsafe, so let's not; even
@ -74,42 +76,44 @@ void format_that_ascii_mess( CharBufferType& buffer, uint writepos, const char*
// returns the length of the formatted string, in characters (wxChars).
static
#ifndef __linux__
__ri
__ri
#endif
uint format_that_unicode_mess( CharBufferType& buffer, uint writepos, const wxChar* fmt, va_list argptr)
uint
format_that_unicode_mess(CharBufferType &buffer, uint writepos, const wxChar *fmt, va_list argptr)
{
va_list args;
while( true )
{
while (true) {
int size = buffer.GetLength() / sizeof(wxChar);
va_copy(args, argptr);
int len = wxVsnprintf((wxChar*)buffer.GetPtr(writepos*sizeof(wxChar)), size-writepos, fmt, args);
int len = wxVsnprintf((wxChar *)buffer.GetPtr(writepos * sizeof(wxChar)), size - writepos, fmt, args);
va_end(args);
// some implementations of vsnprintf() don't NUL terminate
// the string if there is not enough space for it so
// always do it manually
((wxChar*)buffer.GetPtr())[size-1] = L'\0';
((wxChar *)buffer.GetPtr())[size - 1] = L'\0';
if( size >= MaxFormattedStringLength ) return size-1;
if (size >= MaxFormattedStringLength)
return size - 1;
// vsnprintf() may return either -1 (traditional Unix behavior) or the
// total number of characters which would have been written if the
// buffer were large enough (newer standards such as Unix98)
if (len < 0)
len = size + (size/4);
len = size + (size / 4);
len += writepos;
if (len < size) return len;
buffer.Resize( (len + 128) * sizeof(wxChar) );
if (len < size)
return len;
buffer.Resize((len + 128) * sizeof(wxChar));
};
// performing an assertion or log of a truncated string is unsafe, so let's not; even
// though it'd be kinda nice if we did.
pxAssume( false );
pxAssume(false);
return 0; // unreachable.
}
@ -135,112 +139,112 @@ FastFormatUnicode::~FastFormatUnicode() throw()
void FastFormatUnicode::Clear()
{
m_Length = 0;
((wxChar*)m_dest.GetPtr())[0] = 0;
((wxChar *)m_dest.GetPtr())[0] = 0;
}
FastFormatUnicode& FastFormatUnicode::WriteV( const char* fmt, va_list argptr )
FastFormatUnicode &FastFormatUnicode::WriteV(const char *fmt, va_list argptr)
{
wxString converted( fromUTF8(FastFormatAscii().WriteV( fmt, argptr )) );
wxString converted(fromUTF8(FastFormatAscii().WriteV(fmt, argptr)));
const uint inspos = m_Length;
const uint convLen = converted.Length();
m_dest.MakeRoomFor((inspos + convLen + 64) * sizeof(wxChar));
memcpy( &((wxChar*)m_dest.GetPtr())[inspos], converted.wc_str(), (convLen+1)*sizeof(wxChar) );
memcpy(&((wxChar *)m_dest.GetPtr())[inspos], converted.wc_str(), (convLen + 1) * sizeof(wxChar));
m_Length += convLen;
return *this;
}
FastFormatUnicode& FastFormatUnicode::WriteV( const wxChar* fmt, va_list argptr )
FastFormatUnicode &FastFormatUnicode::WriteV(const wxChar *fmt, va_list argptr)
{
m_Length = format_that_unicode_mess( m_dest, m_Length, fmt, argptr );
m_Length = format_that_unicode_mess(m_dest, m_Length, fmt, argptr);
return *this;
}
FastFormatUnicode& FastFormatUnicode::Write( const char* fmt, ... )
FastFormatUnicode &FastFormatUnicode::Write(const char *fmt, ...)
{
va_list list;
va_start(list, fmt);
WriteV(fmt,list);
WriteV(fmt, list);
va_end(list);
return *this;
}
FastFormatUnicode& FastFormatUnicode::Write( const wxChar* fmt, ... )
FastFormatUnicode &FastFormatUnicode::Write(const wxChar *fmt, ...)
{
va_list list;
va_start(list, fmt);
WriteV(fmt,list);
WriteV(fmt, list);
va_end(list);
return *this;
}
FastFormatUnicode& FastFormatUnicode::Write( const wxString fmt, ... )
FastFormatUnicode &FastFormatUnicode::Write(const wxString fmt, ...)
{
va_list list;
va_start(list, fmt);
WriteV(fmt.wx_str(),list);
WriteV(fmt.wx_str(), list);
va_end(list);
return *this;
}
bool FastFormatUnicode::IsEmpty() const
{
return ((wxChar&)m_dest[0]) == 0;
return ((wxChar &)m_dest[0]) == 0;
}
FastFormatUnicode& FastFormatUnicode::ToUpper()
FastFormatUnicode &FastFormatUnicode::ToUpper()
{
wxChar* ch = (wxChar*)m_dest.GetPtr();
for ( uint i=0; i<m_Length; ++i, ++ch )
wxChar *ch = (wxChar *)m_dest.GetPtr();
for (uint i = 0; i < m_Length; ++i, ++ch)
*ch = (wxChar)wxToupper(*ch);
return *this;
}
FastFormatUnicode& FastFormatUnicode::ToLower()
FastFormatUnicode &FastFormatUnicode::ToLower()
{
wxChar* ch = (wxChar*)m_dest.GetPtr();
for ( uint i=0; i<m_Length; ++i, ++ch )
wxChar *ch = (wxChar *)m_dest.GetPtr();
for (uint i = 0; i < m_Length; ++i, ++ch)
*ch = (wxChar)wxTolower(*ch);
return *this;
}
FastFormatUnicode& FastFormatUnicode::operator+=(const char* psz )
FastFormatUnicode &FastFormatUnicode::operator+=(const char *psz)
{
Write( L"%s", WX_STR(fromUTF8(psz)) );
Write(L"%s", WX_STR(fromUTF8(psz)));
return *this;
}
wxString& operator+=(wxString& str1, const FastFormatUnicode& str2)
wxString &operator+=(wxString &str1, const FastFormatUnicode &str2)
{
str1.Append(str2.c_str(), str2.Length());
return str1;
}
wxString operator+(const wxString& str1, const FastFormatUnicode& str2)
wxString operator+(const wxString &str1, const FastFormatUnicode &str2)
{
wxString s = str1;
s += str2;
return s;
}
wxString operator+(const wxChar* str1, const FastFormatUnicode& str2)
wxString operator+(const wxChar *str1, const FastFormatUnicode &str2)
{
wxString s = str1;
s += str2;
return s;
}
wxString operator+(const FastFormatUnicode& str1, const wxString& str2)
wxString operator+(const FastFormatUnicode &str1, const wxString &str2)
{
wxString s = str1;
s += str2;
return s;
}
wxString operator+(const FastFormatUnicode& str1, const wxChar* str2)
wxString operator+(const FastFormatUnicode &str1, const wxChar *str2)
{
wxString s = str1;
s += str2;
@ -271,17 +275,17 @@ const wxString FastFormatAscii::GetString() const
return fromAscii(m_dest.GetPtr());
}
FastFormatAscii& FastFormatAscii::WriteV( const char* fmt, va_list argptr )
FastFormatAscii &FastFormatAscii::WriteV(const char *fmt, va_list argptr)
{
format_that_ascii_mess( m_dest, strlen(m_dest.GetPtr()), fmt, argptr );
format_that_ascii_mess(m_dest, strlen(m_dest.GetPtr()), fmt, argptr);
return *this;
}
FastFormatAscii& FastFormatAscii::Write( const char* fmt, ... )
FastFormatAscii &FastFormatAscii::Write(const char *fmt, ...)
{
va_list list;
va_start(list, fmt);
WriteV(fmt,list);
WriteV(fmt, list);
va_end(list);
return *this;
}

33
common/src/Utilities/HashTools.cpp
View File

@ -16,9 +16,10 @@
#include "PrecompiledHeader.h"
#include "HashMap.h"
namespace HashTools {
namespace HashTools
{
#define get16bits(d) (*((const u16 *) (d)))
#define get16bits(d) (*((const u16 *)(d)))
/// <summary>
/// Calculates a hash value for an arbitrary set of binary data.
@ -52,39 +53,41 @@ namespace HashTools {
/// uint32 hashval = Hash( (const char*)&data, sizeof( data ) );
/// </code>
/// </example>
u32 Hash(const s8 * data, int len)
u32 Hash(const s8 *data, int len)
{
u32 hash = len;
int rem;
if (len <= 0 || data == NULL) return 0;
if (len <= 0 || data == NULL)
return 0;
rem = len & 3;
len >>= 2;
/* Main loop */
for (;len > 0; --len)
{
hash += get16bits (data);
u32 tmp = (get16bits (data+2) << 11) ^ hash;
for (; len > 0; --len) {
hash += get16bits(data);
u32 tmp = (get16bits(data + 2) << 11) ^ hash;
hash = (hash << 16) ^ tmp;
data += 2*sizeof (u16);
data += 2 * sizeof(u16);
hash += hash >> 11;
}
/* Handle end cases */
switch (rem)
{
case 3: hash += get16bits (data);
switch (rem) {
case 3:
hash += get16bits(data);
hash ^= hash << 16;
hash ^= data[sizeof (u16)] << 18;
hash ^= data[sizeof(u16)] << 18;
hash += hash >> 11;
break;
case 2: hash += get16bits (data);
case 2:
hash += get16bits(data);
hash ^= hash << 11;
hash += hash >> 17;
break;
case 1: hash += *data;
case 1:
hash += *data;
hash ^= hash << 10;
hash += hash >> 1;
}

313
common/src/Utilities/IniInterface.cpp
View File

@ -18,7 +18,7 @@
#include <wx/gdicmn.h>
const wxRect wxDefaultRect( wxDefaultCoord, wxDefaultCoord, wxDefaultCoord, wxDefaultCoord );
const wxRect wxDefaultRect(wxDefaultCoord, wxDefaultCoord, wxDefaultCoord, wxDefaultCoord);
// Implement FixedPointTypes (for lack of a better location, for now)
@ -27,16 +27,15 @@ template struct FixedInt<100>;
template struct FixedInt<256>;
wxDirName g_fullBaseDirName = wxDirName(L"");
void SetFullBaseDir( wxDirName appRoot )
void SetFullBaseDir(wxDirName appRoot)
{
g_fullBaseDirName = appRoot;
}
static int _calcEnumLength( const wxChar* const* enumArray )
static int _calcEnumLength(const wxChar *const *enumArray)
{
int cnt = 0;
while( *enumArray != NULL )
{
while (*enumArray != NULL) {
enumArray++;
cnt++;
}
@ -44,34 +43,34 @@ static int _calcEnumLength( const wxChar* const* enumArray )
return cnt;
}
ScopedIniGroup::ScopedIniGroup( IniInterface& mommy, const wxString& group )
: m_mom( mommy )
ScopedIniGroup::ScopedIniGroup(IniInterface &mommy, const wxString &group)
: m_mom(mommy)
{
pxAssertDev( wxStringTokenize( group, L"/" ).Count() <= 1, L"Cannot nest more than one group deep per instance of ScopedIniGroup." );
m_mom.SetPath( group );
pxAssertDev(wxStringTokenize(group, L"/").Count() <= 1, L"Cannot nest more than one group deep per instance of ScopedIniGroup.");
m_mom.SetPath(group);
}
ScopedIniGroup::~ScopedIniGroup()
{
m_mom.SetPath( L".." );
m_mom.SetPath(L"..");
}
// --------------------------------------------------------------------------------------
// IniInterface (implementations)
// --------------------------------------------------------------------------------------
IniInterface::IniInterface( wxConfigBase& config )
IniInterface::IniInterface(wxConfigBase &config)
{
m_Config = &config;
}
IniInterface::IniInterface( wxConfigBase* config )
IniInterface::IniInterface(wxConfigBase *config)
{
m_Config = config;
}
IniInterface::IniInterface()
{
m_Config = wxConfigBase::Get( false );
m_Config = wxConfigBase::Get(false);
}
IniInterface::~IniInterface()
@ -79,178 +78,188 @@ IniInterface::~IniInterface()
Flush();
}
void IniInterface::SetPath( const wxString& path )
void IniInterface::SetPath(const wxString &path)
{
if( m_Config ) m_Config->SetPath( path );
if (m_Config)
m_Config->SetPath(path);
}
void IniInterface::Flush()
{
if( m_Config ) m_Config->Flush();
if (m_Config)
m_Config->Flush();
}
// --------------------------------------------------------------------------------------
// IniLoader (implementations)
// --------------------------------------------------------------------------------------
IniLoader::IniLoader( wxConfigBase& config ) : IniInterface( config ) { }
IniLoader::IniLoader( wxConfigBase* config ) : IniInterface( config ) { }
IniLoader::IniLoader(wxConfigBase &config)
: IniInterface(config)
{
}
IniLoader::IniLoader(wxConfigBase *config)
: IniInterface(config)
{
}
IniLoader::IniLoader() : IniInterface() {}
IniLoader::IniLoader()
: IniInterface()
{
}
IniLoader::~IniLoader() throw() {}
void IniLoader::Entry( const wxString& var, wxString& value, const wxString defvalue )
void IniLoader::Entry(const wxString &var, wxString &value, const wxString defvalue)
{
if( m_Config )
m_Config->Read( var, &value, defvalue );
if (m_Config)
m_Config->Read(var, &value, defvalue);
else
value = defvalue;
}
void IniLoader::Entry( const wxString& var, wxDirName& value, const wxDirName defvalue, bool isAllowRelative )
void IniLoader::Entry(const wxString &var, wxDirName &value, const wxDirName defvalue, bool isAllowRelative)
{
wxString dest;
if( m_Config ) m_Config->Read( var, &dest, wxEmptyString );
if (m_Config)
m_Config->Read(var, &dest, wxEmptyString);
if( dest.IsEmpty() )
if (dest.IsEmpty())
value = defvalue;
else
{
else {
value = dest;
if( isAllowRelative )
if (isAllowRelative)
value = g_fullBaseDirName + value;
if( value.IsAbsolute() )
if (value.IsAbsolute())
value.Normalize();
}
}
void IniLoader::Entry( const wxString& var, wxFileName& value, const wxFileName defvalue, bool isAllowRelative )
void IniLoader::Entry(const wxString &var, wxFileName &value, const wxFileName defvalue, bool isAllowRelative)
{
wxString dest( defvalue.GetFullPath() );
if( m_Config ) m_Config->Read( var, &dest, defvalue.GetFullPath() );
wxString dest(defvalue.GetFullPath());
if (m_Config)
m_Config->Read(var, &dest, defvalue.GetFullPath());
value = dest;
if( isAllowRelative )
if (isAllowRelative)
value = g_fullBaseDirName + value;
if( value.IsAbsolute() )
if (value.IsAbsolute())
value.Normalize();
if (value.HasVolume())
value.SetVolume(value.GetVolume().Upper());
}
void IniLoader::Entry( const wxString& var, int& value, const int defvalue )
void IniLoader::Entry(const wxString &var, int &value, const int defvalue)
{
if( m_Config )
m_Config->Read( var, &value, defvalue );
if (m_Config)
m_Config->Read(var, &value, defvalue);
else
value = defvalue;
}
void IniLoader::Entry( const wxString& var, uint& value, const uint defvalue )
void IniLoader::Entry(const wxString &var, uint &value, const uint defvalue)
{
if( m_Config )
m_Config->Read( var, (int*)&value, (int)defvalue );
if (m_Config)
m_Config->Read(var, (int *)&value, (int)defvalue);
else
value = defvalue;
}
void IniLoader::Entry( const wxString& var, bool& value, const bool defvalue )
void IniLoader::Entry(const wxString &var, bool &value, const bool defvalue)
{
// TODO : Stricter value checking on enabled/disabled?
wxString dest(defvalue ? L"enabled" : L"disabled");
if( m_Config ) m_Config->Read( var, &dest, dest );
if (m_Config)
m_Config->Read(var, &dest, dest);
value = (dest == L"enabled") || (dest == L"1");
}
bool IniLoader::EntryBitBool( const wxString& var, bool value, const bool defvalue )
bool IniLoader::EntryBitBool(const wxString &var, bool value, const bool defvalue)
{
// Note: 'value' param is used by inisaver only.
bool result;
Entry( var, result, defvalue );
Entry(var, result, defvalue);
return result;
}
int IniLoader::EntryBitfield( const wxString& var, int value, const int defvalue )
int IniLoader::EntryBitfield(const wxString &var, int value, const int defvalue)
{
int result;
Entry( var, result, defvalue );
Entry(var, result, defvalue);
return result;
}
void IniLoader::Entry( const wxString& var, Fixed100& value, const Fixed100 defvalue )
void IniLoader::Entry(const wxString &var, Fixed100 &value, const Fixed100 defvalue)
{
// Note: the "easy" way would be to convert to double and load/save that, but floating point
// has way too much rounding error so we really need to do things out manually.. >_<
wxString readval( value.ToString() );
if( m_Config ) m_Config->Read( var, &readval );
value = Fixed100::FromString( readval, value );
wxString readval(value.ToString());
if (m_Config)
m_Config->Read(var, &readval);
value = Fixed100::FromString(readval, value);
}
void IniLoader::Entry( const wxString& var, wxPoint& value, const wxPoint defvalue )
void IniLoader::Entry(const wxString &var, wxPoint &value, const wxPoint defvalue)
{
if( !m_Config )
{
value = defvalue; return;
if (!m_Config) {
value = defvalue;
return;
}
TryParse( value, m_Config->Read( var, ToString( defvalue ) ), defvalue );
TryParse(value, m_Config->Read(var, ToString(defvalue)), defvalue);
}
void IniLoader::Entry( const wxString& var, wxSize& value, const wxSize defvalue )
void IniLoader::Entry(const wxString &var, wxSize &value, const wxSize defvalue)
{
if( !m_Config )
{
value = defvalue; return;
if (!m_Config) {
value = defvalue;
return;
}
TryParse( value, m_Config->Read( var, ToString( defvalue ) ), defvalue );
TryParse(value, m_Config->Read(var, ToString(defvalue)), defvalue);
}
void IniLoader::Entry( const wxString& var, wxRect& value, const wxRect defvalue )
void IniLoader::Entry(const wxString &var, wxRect &value, const wxRect defvalue)
{
if( !m_Config )
{
value = defvalue; return;
if (!m_Config) {
value = defvalue;
return;
}
TryParse( value, m_Config->Read( var, ToString( defvalue ) ), defvalue );
TryParse(value, m_Config->Read(var, ToString(defvalue)), defvalue);
}
void IniLoader::_EnumEntry( const wxString& var, int& value, const wxChar* const* enumArray, int defvalue )
void IniLoader::_EnumEntry(const wxString &var, int &value, const wxChar *const *enumArray, int defvalue)
{
// Confirm default value sanity...
const int cnt = _calcEnumLength( enumArray );
if( !IndexBoundsCheck( L"IniLoader EnumDefaultValue", defvalue, cnt ) )
{
Console.Error( "(LoadSettings) Default enumeration index is out of bounds. Truncating." );
defvalue = cnt-1;
const int cnt = _calcEnumLength(enumArray);
if (!IndexBoundsCheck(L"IniLoader EnumDefaultValue", defvalue, cnt)) {
Console.Error("(LoadSettings) Default enumeration index is out of bounds. Truncating.");
defvalue = cnt - 1;
}
// Sanity confirmed, proceed with craziness!
if( !m_Config )
{
if (!m_Config) {
value = defvalue;
return;
}
wxString retval;
m_Config->Read( var, &retval, enumArray[defvalue] );
m_Config->Read(var, &retval, enumArray[defvalue]);
int i=0;
while( enumArray[i] != NULL && ( retval != enumArray[i] ) ) i++;
int i = 0;
while (enumArray[i] != NULL && (retval != enumArray[i]))
i++;
if( enumArray[i] == NULL )
{
Console.Warning( L"(LoadSettings) Warning: Unrecognized value '%s' on key '%s'\n\tUsing the default setting of '%s'.",
WX_STR(retval), WX_STR(var), enumArray[defvalue]
);
if (enumArray[i] == NULL) {
Console.Warning(L"(LoadSettings) Warning: Unrecognized value '%s' on key '%s'\n\tUsing the default setting of '%s'.",
WX_STR(retval), WX_STR(var), enumArray[defvalue]);
value = defvalue;
}
else
} else
value = i;
}
@ -258,138 +267,156 @@ void IniLoader::_EnumEntry( const wxString& var, int& value, const wxChar* const
// IniSaver (implementations)
// --------------------------------------------------------------------------------------
IniSaver::IniSaver( wxConfigBase& config ) : IniInterface( config ) { }
IniSaver::IniSaver( wxConfigBase* config ) : IniInterface( config ) { }
IniSaver::IniSaver() : IniInterface() {}
IniSaver::~IniSaver() {}
void IniSaver::Entry( const wxString& var, wxString& value, const wxString defvalue )
IniSaver::IniSaver(wxConfigBase &config)
: IniInterface(config)
{
}
IniSaver::IniSaver(wxConfigBase *config)
: IniInterface(config)
{
if( !m_Config ) return;
m_Config->Write( var, value );
}
void IniSaver::Entry( const wxString& var, wxDirName& value, const wxDirName defvalue, bool isAllowRelative )
IniSaver::IniSaver()
: IniInterface()
{
if( !m_Config ) return;
}
IniSaver::~IniSaver() {}
void IniSaver::Entry(const wxString &var, wxString &value, const wxString defvalue)
{
if (!m_Config)
return;
m_Config->Write(var, value);
}
void IniSaver::Entry(const wxString &var, wxDirName &value, const wxDirName defvalue, bool isAllowRelative)
{
if (!m_Config)
return;
wxDirName res(value);
if ( res.IsAbsolute() )
if (res.IsAbsolute())
res.Normalize();
if (isAllowRelative)
res = wxDirName::MakeAutoRelativeTo( res, g_fullBaseDirName.ToString() );
res = wxDirName::MakeAutoRelativeTo(res, g_fullBaseDirName.ToString());
/*if( value == defvalue )
m_Config->Write( var, wxString() );
else*/
m_Config->Write( var, res.ToString() );
m_Config->Write(var, res.ToString());
}
void IniSaver::Entry( const wxString& var, wxFileName& value, const wxFileName defvalue, bool isAllowRelative )
void IniSaver::Entry(const wxString &var, wxFileName &value, const wxFileName defvalue, bool isAllowRelative)
{
if( !m_Config ) return;
if (!m_Config)
return;
wxFileName res(value);
if ( res.IsAbsolute() )
if (res.IsAbsolute())
res.Normalize();
if (isAllowRelative)
res = wxDirName::MakeAutoRelativeTo( res, g_fullBaseDirName.ToString() );
res = wxDirName::MakeAutoRelativeTo(res, g_fullBaseDirName.ToString());
m_Config->Write( var, res.GetFullPath() );
m_Config->Write(var, res.GetFullPath());
}
void IniSaver::Entry( const wxString& var, int& value, const int defvalue )
void IniSaver::Entry(const wxString &var, int &value, const int defvalue)
{
if( !m_Config ) return;
m_Config->Write( var, value );
if (!m_Config)
return;
m_Config->Write(var, value);
}
void IniSaver::Entry( const wxString& var, uint& value, const uint defvalue )
void IniSaver::Entry(const wxString &var, uint &value, const uint defvalue)
{
if( !m_Config ) return;
m_Config->Write( var, (int)value );
if (!m_Config)
return;
m_Config->Write(var, (int)value);
}
void IniSaver::Entry( const wxString& var, bool& value, const bool defvalue )
void IniSaver::Entry(const wxString &var, bool &value, const bool defvalue)
{
if( !m_Config ) return;
m_Config->Write( var, value ? L"enabled" : L"disabled" );
if (!m_Config)
return;
m_Config->Write(var, value ? L"enabled" : L"disabled");
}
bool IniSaver::EntryBitBool( const wxString& var, bool value, const bool defvalue )
bool IniSaver::EntryBitBool(const wxString &var, bool value, const bool defvalue)
{
if( m_Config ) m_Config->Write( var, value ? L"enabled" : L"disabled" );
if (m_Config)
m_Config->Write(var, value ? L"enabled" : L"disabled");
return value;
}
int IniSaver::EntryBitfield( const wxString& var, int value, const int defvalue )
int IniSaver::EntryBitfield(const wxString &var, int value, const int defvalue)
{
if( m_Config ) m_Config->Write( var, value );
if (m_Config)
m_Config->Write(var, value);
return value;
}
void IniSaver::Entry( const wxString& var, Fixed100& value, const Fixed100 defvalue )
void IniSaver::Entry(const wxString &var, Fixed100 &value, const Fixed100 defvalue)
{
if( !m_Config ) return;
if (!m_Config)
return;
// Note: the "easy" way would be to convert to double and load/save that, but floating point
// has way too much rounding error so we really need to do things out manually, using strings.
m_Config->Write( var, value.ToString() );
m_Config->Write(var, value.ToString());
}
void IniSaver::Entry( const wxString& var, wxPoint& value, const wxPoint defvalue )
void IniSaver::Entry(const wxString &var, wxPoint &value, const wxPoint defvalue)
{
if( !m_Config ) return;
m_Config->Write( var, ToString( value ) );
if (!m_Config)
return;
m_Config->Write(var, ToString(value));
}
void IniSaver::Entry( const wxString& var, wxSize& value, const wxSize defvalue )
void IniSaver::Entry(const wxString &var, wxSize &value, const wxSize defvalue)
{
if( !m_Config ) return;
m_Config->Write( var, ToString( value ) );
if (!m_Config)
return;
m_Config->Write(var, ToString(value));
}
void IniSaver::Entry( const wxString& var, wxRect& value, const wxRect defvalue )
void IniSaver::Entry(const wxString &var, wxRect &value, const wxRect defvalue)
{
if( !m_Config ) return;
m_Config->Write( var, ToString( value ) );
if (!m_Config)
return;
m_Config->Write(var, ToString(value));
}
void IniSaver::_EnumEntry( const wxString& var, int& value, const wxChar* const* enumArray, int defvalue )
void IniSaver::_EnumEntry(const wxString &var, int &value, const wxChar *const *enumArray, int defvalue)
{
const int cnt = _calcEnumLength( enumArray );
const int cnt = _calcEnumLength(enumArray);
// Confirm default value sanity...
if( !IndexBoundsCheck( L"IniSaver EnumDefaultValue", defvalue, cnt ) )
{
Console.Error( "(SaveSettings) Default enumeration index is out of bounds. Truncating." );
defvalue = cnt-1;
if (!IndexBoundsCheck(L"IniSaver EnumDefaultValue", defvalue, cnt)) {
Console.Error("(SaveSettings) Default enumeration index is out of bounds. Truncating.");
defvalue = cnt - 1;
}
if( !m_Config ) return;
if (!m_Config)
return;
if( value >= cnt )
{
Console.Warning( L"(SaveSettings) An illegal enumerated index was detected when saving '%s'", WX_STR(var) );
if (value >= cnt) {
Console.Warning(L"(SaveSettings) An illegal enumerated index was detected when saving '%s'", WX_STR(var));
Console.Indent().Warning(
L"Illegal Value: %d\n"
L"Using Default: %d (%s)\n",
value, defvalue, enumArray[defvalue]
);
value, defvalue, enumArray[defvalue]);
// Cause a debug assertion, since this is a fully recoverable error.
pxAssert( value < cnt );
pxAssert(value < cnt);
value = defvalue;
}
m_Config->Write( var, enumArray[value] );
m_Config->Write(var, enumArray[value]);
}

111
common/src/Utilities/Linux/LnxHostSys.cpp
View File

@ -27,15 +27,15 @@
// Apple uses the MAP_ANON define instead of MAP_ANONYMOUS, but they mean
// the same thing.
#if defined(__APPLE__) && !defined(MAP_ANONYMOUS)
# define MAP_ANONYMOUS MAP_ANON
#define MAP_ANONYMOUS MAP_ANON
#endif
extern void SignalExit(int sig);
static const uptr m_pagemask = getpagesize()-1;
static const uptr m_pagemask = getpagesize() - 1;
// Linux implementation of SIGSEGV handler. Bind it using sigaction().
static void SysPageFaultSignalFilter( int signal, siginfo_t *siginfo, void * )
static void SysPageFaultSignalFilter(int signal, siginfo_t *siginfo, void *)
{
// [TODO] : Add a thread ID filter to the Linux Signal handler here.
// Rationale: On windows, the __try/__except model allows per-thread specific behavior
@ -59,14 +59,14 @@ static void SysPageFaultSignalFilter( int signal, siginfo_t *siginfo, void * )
// so for now we lock this exception code unless someone can fix this better...
Threading::ScopedLock lock(PageFault_Mutex);
Source_PageFault->Dispatch( PageFaultInfo( (uptr)siginfo->si_addr & ~m_pagemask ) );
Source_PageFault->Dispatch(PageFaultInfo((uptr)siginfo->si_addr & ~m_pagemask));
// resumes execution right where we left off (re-executes instruction that
// caused the SIGSEGV).
if (Source_PageFault->WasHandled()) return;
if (Source_PageFault->WasHandled())
return;
if (!wxThread::IsMain())
{
if (!wxThread::IsMain()) {
pxFailRel(pxsFmt("Unhandled page fault @ 0x%08x", siginfo->si_addr));
}
@ -74,7 +74,8 @@ static void SysPageFaultSignalFilter( int signal, siginfo_t *siginfo, void * )
// Instigate a trap if we're in a debugger, and if not then do a SIGKILL.
pxTrap();
if (!IsDebugBuild) raise( SIGKILL );
if (!IsDebugBuild)
raise(SIGKILL);
}
void _platform_InstallSignalHandler()
@ -88,50 +89,49 @@ void _platform_InstallSignalHandler()
sigaction(SIGSEGV, &sa, NULL);
}
static __ri void PageSizeAssertionTest( size_t size )
static __ri void PageSizeAssertionTest(size_t size)
{
pxAssertMsg( (__pagesize == getpagesize()), pxsFmt(
pxAssertMsg((__pagesize == getpagesize()), pxsFmt(
"Internal system error: Operating system pagesize does not match compiled pagesize.\n\t"
L"\tOS Page Size: 0x%x (%d), Compiled Page Size: 0x%x (%u)",
getpagesize(), getpagesize(), __pagesize, __pagesize )
);
getpagesize(), getpagesize(), __pagesize, __pagesize));
pxAssertDev( (size & (__pagesize-1)) == 0, pxsFmt(
pxAssertDev((size & (__pagesize - 1)) == 0, pxsFmt(
L"Memory block size must be a multiple of the target platform's page size.\n"
L"\tPage Size: 0x%x (%u), Block Size: 0x%x (%u)",
__pagesize, __pagesize, size, size )
);
__pagesize, __pagesize, size, size));
}
// returns FALSE if the mprotect call fails with an ENOMEM.
// Raises assertions on other types of POSIX errors (since those typically reflect invalid object
// or memory states).
static bool _memprotect( void* baseaddr, size_t size, const PageProtectionMode& mode )
static bool _memprotect(void *baseaddr, size_t size, const PageProtectionMode &mode)
{
PageSizeAssertionTest(size);
uint lnxmode = 0;
if (mode.CanWrite()) lnxmode |= PROT_WRITE;
if (mode.CanRead()) lnxmode |= PROT_READ;
if (mode.CanExecute()) lnxmode |= PROT_EXEC | PROT_READ;
if (mode.CanWrite())
lnxmode |= PROT_WRITE;
if (mode.CanRead())
lnxmode |= PROT_READ;
if (mode.CanExecute())
lnxmode |= PROT_EXEC | PROT_READ;
const int result = mprotect( baseaddr, size, lnxmode );
const int result = mprotect(baseaddr, size, lnxmode);
if (result == 0) return true;
if (result == 0)
return true;
switch(errno)
{
switch (errno) {
case EINVAL:
pxFailDev(pxsFmt(L"mprotect returned EINVAL @ 0x%08X -> 0x%08X (mode=%s)",
baseaddr, (uptr)baseaddr+size, WX_STR(mode.ToString()))
);
baseaddr, (uptr)baseaddr + size, WX_STR(mode.ToString())));
break;
case EACCES:
pxFailDev(pxsFmt(L"mprotect returned EACCES @ 0x%08X -> 0x%08X (mode=%s)",
baseaddr, (uptr)baseaddr+size, WX_STR(mode.ToString()))
);
baseaddr, (uptr)baseaddr + size, WX_STR(mode.ToString())));
break;
case ENOMEM:
@ -141,7 +141,7 @@ static bool _memprotect( void* baseaddr, size_t size, const PageProtectionMode&
return false;
}
void* HostSys::MmapReservePtr(void* base, size_t size)
void *HostSys::MmapReservePtr(void *base, size_t size)
{
PageSizeAssertionTest(size);
@ -152,23 +152,26 @@ void* HostSys::MmapReservePtr(void* base, size_t size)
return mmap(base, size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
}
bool HostSys::MmapCommitPtr(void* base, size_t size, const PageProtectionMode& mode)
bool HostSys::MmapCommitPtr(void *base, size_t size, const PageProtectionMode &mode)
{
// In linux, reserved memory is automatically committed when its permissions are
// changed to something other than PROT_NONE. If the user is committing memory
// as PROT_NONE, then just ignore this call (memory will be committed automatically
// later when the user changes permissions to something useful via calls to MemProtect).
if (mode.IsNone()) return false;
if (mode.IsNone())
return false;
if (_memprotect( base, size, mode )) return true;
if (_memprotect(base, size, mode))
return true;
if (!pxDoOutOfMemory) return false;
if (!pxDoOutOfMemory)
return false;
pxDoOutOfMemory(size);
return _memprotect( base, size, mode );
return _memprotect(base, size, mode);
}
void HostSys::MmapResetPtr(void* base, size_t size)
void HostSys::MmapResetPtr(void *base, size_t size)
{
// On linux the only way to reset the memory is to unmap and remap it as PROT_NONE.
// That forces linux to unload all committed pages and start from scratch.
@ -180,52 +183,50 @@ void HostSys::MmapResetPtr(void* base, size_t size)
// pretty well stops all PCSX2 threads anyway).
Munmap(base, size);
void* result = MmapReservePtr(base, size);
void *result = MmapReservePtr(base, size);
pxAssertRel ((uptr)result == (uptr)base, pxsFmt(
pxAssertRel((uptr)result == (uptr)base, pxsFmt(
"Virtual memory decommit failed: memory at 0x%08X -> 0x%08X could not be remapped. "
"This is likely caused by multi-thread memory contention.", base, (uptr)base+size
));
"This is likely caused by multi-thread memory contention.",
base, (uptr)base + size));
}
void* HostSys::MmapReserve(uptr base, size_t size)
void *HostSys::MmapReserve(uptr base, size_t size)
{
return MmapReservePtr((void*)base, size);
return MmapReservePtr((void *)base, size);
}
bool HostSys::MmapCommit(uptr base, size_t size, const PageProtectionMode& mode)
bool HostSys::MmapCommit(uptr base, size_t size, const PageProtectionMode &mode)
{
return MmapCommitPtr( (void*)base, size, mode );
return MmapCommitPtr((void *)base, size, mode);
}
void HostSys::MmapReset(uptr base, size_t size)
{
MmapResetPtr((void*)base, size);
MmapResetPtr((void *)base, size);
}
void* HostSys::Mmap(uptr base, size_t size)
void *HostSys::Mmap(uptr base, size_t size)
{
PageSizeAssertionTest(size);
// MAP_ANONYMOUS - means we have no associated file handle (or device).
return mmap((void*)base, size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
return mmap((void *)base, size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
}
void HostSys::Munmap(uptr base, size_t size)
{
if (!base) return;
munmap((void*)base, size);
if (!base)
return;
munmap((void *)base, size);
}
void HostSys::MemProtect( void* baseaddr, size_t size, const PageProtectionMode& mode )
void HostSys::MemProtect(void *baseaddr, size_t size, const PageProtectionMode &mode)
{
if (!_memprotect(baseaddr, size, mode))
{
throw Exception::OutOfMemory( L"MemProtect" )
.SetDiagMsg(pxsFmt( L"mprotect failed @ 0x%08X -> 0x%08X (mode=%s)",
baseaddr, (uptr)baseaddr+size, WX_STR(mode.ToString())
)
);
if (!_memprotect(baseaddr, size, mode)) {
throw Exception::OutOfMemory(L"MemProtect")
.SetDiagMsg(pxsFmt(L"mprotect failed @ 0x%08X -> 0x%08X (mode=%s)",
baseaddr, (uptr)baseaddr + size, WX_STR(mode.ToString())));
}
}

2
common/src/Utilities/Linux/LnxMisc.cpp
View File

@ -47,7 +47,7 @@ u64 GetCPUTicks()
{
struct timeval t;
gettimeofday(&t, NULL);
return ((u64)t.tv_sec*GetTickFrequency())+t.tv_usec;
return ((u64)t.tv_sec * GetTickFrequency()) + t.tv_usec;
}
wxString GetOSVersionString()

23
common/src/Utilities/Linux/LnxThreads.cpp
View File

@ -29,7 +29,7 @@
#if !defined(__unix__)
# pragma message( "LnxThreads.cpp should only be compiled by projects or makefiles targeted at Linux/BSD distros.")
#pragma message("LnxThreads.cpp should only be compiled by projects or makefiles targeted at Linux/BSD distros.")
#else
@ -37,9 +37,9 @@
// the LOCK prefix. The prefix works on single core CPUs fine (but is slow), but not
// having the LOCK prefix is very bad indeed.
__forceinline void Threading::Sleep( int ms )
__forceinline void Threading::Sleep(int ms)
{
usleep( 1000*ms );
usleep(1000 * ms);
}
// For use in spin/wait loops, Acts as a hint to Intel CPUs and should, in theory
@ -48,7 +48,7 @@ __forceinline void Threading::SpinWait()
{
// If this doesn't compile you can just comment it out (it only serves as a
// performance hint and isn't required).
__asm__ ( "pause" );
__asm__("pause");
}
__forceinline void Threading::EnableHiresScheduler()
@ -73,16 +73,18 @@ static u64 get_thread_time(uptr id = 0)
clockid_t cid;
if (id) {
int err = pthread_getcpuclockid((pthread_t)id, &cid);
if (err) return 0;
if (err)
return 0;
} else {
cid = CLOCK_THREAD_CPUTIME_ID;
}
struct timespec ts;
int err = clock_gettime(cid, &ts);
if (err) return 0;
if (err)
return 0;
return (u64) ts.tv_sec * (u64) 1e6 + (u64) ts.tv_nsec / (u64) 1e3;
return (u64)ts.tv_sec * (u64)1e6 + (u64)ts.tv_nsec / (u64)1e3;
}
// Returns the current timestamp (not relative to a real world clock)
@ -98,7 +100,8 @@ u64 Threading::pxThread::GetCpuTime() const
// thread has used on the CPU (scaled by the value returned by GetThreadTicksPerSecond(),
// which typically would be an OS-provided scalar or some sort).
if (!m_native_id) return 0;
if (!m_native_id)
return 0;
return get_thread_time(m_native_id);
}
@ -107,7 +110,7 @@ void Threading::pxThread::_platform_specific_OnStartInThread()
{
// Obtain linux-specific thread IDs or Handles here, which can be used to query
// kernel scheduler performance information.
m_native_id = (uptr) pthread_self();
m_native_id = (uptr)pthread_self();
}
void Threading::pxThread::_platform_specific_OnCleanupInThread()
@ -115,7 +118,7 @@ void Threading::pxThread::_platform_specific_OnCleanupInThread()
// Cleanup handles here, which were opened above.
}
void Threading::pxThread::_DoSetThreadName( const char* name )
void Threading::pxThread::_DoSetThreadName(const char *name)
{
#if defined(__linux__)
// Extract of manpage: "The name can be up to 16 bytes long, and should be

175
common/src/Utilities/Mutex.cpp
View File

@ -23,8 +23,8 @@
namespace Threading
{
static std::atomic<int> _attr_refcount(0);
static pthread_mutexattr_t _attr_recursive;
static std::atomic<int> _attr_refcount(0);
static pthread_mutexattr_t _attr_recursive;
}
// --------------------------------------------------------------------------------------
@ -66,14 +66,15 @@ static int xpthread_mutex_timedlock(
ts.tv_sec = 0;
ts.tv_nsec = TIMEDLOCK_EMU_SLEEP_NS;
int status;
while ((status = nanosleep(&ts, &ts)) == -1);
while ((status = nanosleep(&ts, &ts)) == -1)
;
// check if the timeout has expired, gettimeofday() is implemented
// efficiently (in userspace) on OSX
struct timeval now;
int res = gettimeofday(&now, NULL);
if (abs_timeout->tv_sec == 0 || now.tv_sec > abs_timeout->tv_sec ||
(u64) now.tv_usec * 1000ULL > (u64) abs_timeout->tv_nsec) {
(u64)now.tv_usec * 1000ULL > (u64)abs_timeout->tv_nsec) {
return ETIMEDOUT;
}
}
@ -84,58 +85,61 @@ static int xpthread_mutex_timedlock(
Threading::Mutex::Mutex()
{
pthread_mutex_init( &m_mutex, NULL );
pthread_mutex_init(&m_mutex, NULL);
}
static wxTimeSpan def_detach_timeout( 0, 0, 6, 0 );
static wxTimeSpan def_detach_timeout(0, 0, 6, 0);
void Threading::Mutex::Detach()
{
if( EBUSY != pthread_mutex_destroy(&m_mutex) ) return;
if (EBUSY != pthread_mutex_destroy(&m_mutex))
return;
if( IsRecursive() )
{
if (IsRecursive()) {
// Sanity check: Recursive locks could be held by our own thread, which would
// be considered an assertion failure, but can also be handled gracefully.
// (note: if the mutex is locked recursively more than twice then this assert won't
// detect it)
Release(); Release(); // in case of double recursion.
int result = pthread_mutex_destroy( &m_mutex );
if( pxAssertDev( result != EBUSY, "Detachment of a recursively-locked mutex (self-locked!)." ) ) return;
Release();
Release(); // in case of double recursion.
int result = pthread_mutex_destroy(&m_mutex);
if (pxAssertDev(result != EBUSY, "Detachment of a recursively-locked mutex (self-locked!)."))
return;
}
if( Wait(def_detach_timeout) )
pthread_mutex_destroy( &m_mutex );
if (Wait(def_detach_timeout))
pthread_mutex_destroy(&m_mutex);
else
Console.Error( "(Thread Log) Mutex cleanup failed due to possible deadlock.");
Console.Error("(Thread Log) Mutex cleanup failed due to possible deadlock.");
}
Threading::Mutex::~Mutex() throw()
{
try {
Mutex::Detach();
} DESTRUCTOR_CATCHALL;
}
DESTRUCTOR_CATCHALL;
}
Threading::MutexRecursive::MutexRecursive() : Mutex( false )
Threading::MutexRecursive::MutexRecursive()
: Mutex(false)
{
if( ++_attr_refcount == 1 )
{
if( 0 != pthread_mutexattr_init( &_attr_recursive ) )
if (++_attr_refcount == 1) {
if (0 != pthread_mutexattr_init(&_attr_recursive))
throw Exception::OutOfMemory(L"Recursive mutexing attributes");
pthread_mutexattr_settype( &_attr_recursive, PTHREAD_MUTEX_RECURSIVE );
pthread_mutexattr_settype(&_attr_recursive, PTHREAD_MUTEX_RECURSIVE);
}
if (pthread_mutex_init( &m_mutex, &_attr_recursive ))
Console.Error( "(Thread Log) Failed to initialize mutex.");
if (pthread_mutex_init(&m_mutex, &_attr_recursive))
Console.Error("(Thread Log) Failed to initialize mutex.");
}
Threading::MutexRecursive::~MutexRecursive() throw()
{
if( --_attr_refcount == 0 )
pthread_mutexattr_destroy( &_attr_recursive );
if (--_attr_refcount == 0)
pthread_mutexattr_destroy(&_attr_recursive);
}
// This is a bit of a hackish function, which is technically unsafe, but can be useful for allowing
@ -145,7 +149,7 @@ Threading::MutexRecursive::~MutexRecursive() throw()
void Threading::Mutex::Recreate()
{
Detach();
pthread_mutex_init( &m_mutex, NULL );
pthread_mutex_init(&m_mutex, NULL);
}
// Returns:
@ -153,8 +157,7 @@ void Threading::Mutex::Recreate()
// unlocked.
bool Threading::Mutex::RecreateIfLocked()
{
if( !Wait(def_detach_timeout) )
{
if (!Wait(def_detach_timeout)) {
Recreate();
return true;
}
@ -168,25 +171,25 @@ bool Threading::Mutex::RecreateIfLocked()
// other than the main thread.
void Threading::Mutex::AcquireWithoutYield()
{
pxAssertMsg( !wxThread::IsMain(), "Unyielding mutex acquire issued from the main/gui thread. Please use Acquire() instead." );
pthread_mutex_lock( &m_mutex );
pxAssertMsg(!wxThread::IsMain(), "Unyielding mutex acquire issued from the main/gui thread. Please use Acquire() instead.");
pthread_mutex_lock(&m_mutex);
}
bool Threading::Mutex::AcquireWithoutYield( const wxTimeSpan& timeout )
bool Threading::Mutex::AcquireWithoutYield(const wxTimeSpan &timeout)
{
wxDateTime megafail( wxDateTime::UNow() + timeout );
const timespec fail = { megafail.GetTicks(), megafail.GetMillisecond() * 1000000 };
return xpthread_mutex_timedlock( &m_mutex, &fail ) == 0;
wxDateTime megafail(wxDateTime::UNow() + timeout);
const timespec fail = {megafail.GetTicks(), megafail.GetMillisecond() * 1000000};
return xpthread_mutex_timedlock(&m_mutex, &fail) == 0;
}
void Threading::Mutex::Release()
{
pthread_mutex_unlock( &m_mutex );
pthread_mutex_unlock(&m_mutex);
}
bool Threading::Mutex::TryAcquire()
{
return EBUSY != pthread_mutex_trylock( &m_mutex );
return EBUSY != pthread_mutex_trylock(&m_mutex);
}
// This is a wxApp-safe rendition of AcquireWithoutYield, which makes sure to execute pending app events
@ -195,48 +198,39 @@ bool Threading::Mutex::TryAcquire()
void Threading::Mutex::Acquire()
{
#if wxUSE_GUI
if( !wxThread::IsMain() || (wxTheApp == NULL) )
{
pthread_mutex_lock( &m_mutex );
}
else if( _WaitGui_RecursionGuard( L"Mutex::Acquire" ) )
{
ScopedBusyCursor hourglass( Cursor_ReallyBusy );
pthread_mutex_lock( &m_mutex );
}
else
{
if (!wxThread::IsMain() || (wxTheApp == NULL)) {
pthread_mutex_lock(&m_mutex);
} else if (_WaitGui_RecursionGuard(L"Mutex::Acquire")) {
ScopedBusyCursor hourglass(Cursor_ReallyBusy);
pthread_mutex_lock(&m_mutex);
} else {
//ScopedBusyCursor hourglass( Cursor_KindaBusy );
while( !AcquireWithoutYield(def_yieldgui_interval) )
while (!AcquireWithoutYield(def_yieldgui_interval))
YieldToMain();
}
#else
pthread_mutex_lock( &m_mutex );
pthread_mutex_lock(&m_mutex);
#endif
}
bool Threading::Mutex::Acquire( const wxTimeSpan& timeout )
bool Threading::Mutex::Acquire(const wxTimeSpan &timeout)
{
#if wxUSE_GUI
if( !wxThread::IsMain() || (wxTheApp == NULL) )
{
if (!wxThread::IsMain() || (wxTheApp == NULL)) {
return AcquireWithoutYield(timeout);
}
else if( _WaitGui_RecursionGuard( L"Mutex::TimedAcquire" ) )
{
ScopedBusyCursor hourglass( Cursor_ReallyBusy );
return AcquireWithoutYield( timeout );
}
else
{
} else if (_WaitGui_RecursionGuard(L"Mutex::TimedAcquire")) {
ScopedBusyCursor hourglass(Cursor_ReallyBusy);
return AcquireWithoutYield(timeout);
} else {
//ScopedBusyCursor hourglass( Cursor_KindaBusy );
wxTimeSpan countdown( (timeout) );
wxTimeSpan countdown((timeout));
do {
if( AcquireWithoutYield( def_yieldgui_interval ) ) break;
if (AcquireWithoutYield(def_yieldgui_interval))
break;
YieldToMain();
countdown -= def_yieldgui_interval;
} while( countdown.GetMilliseconds() > 0 );
} while (countdown.GetMilliseconds() > 0);
return countdown.GetMilliseconds() > 0;
}
@ -272,20 +266,18 @@ void Threading::Mutex::WaitWithoutYield()
// true if the mutex was freed and is in an unlocked state; or false if the wait timed out
// and the mutex is still locked by another thread.
//
bool Threading::Mutex::Wait( const wxTimeSpan& timeout )
bool Threading::Mutex::Wait(const wxTimeSpan &timeout)
{
if( Acquire(timeout) )
{
if (Acquire(timeout)) {
Release();
return true;
}
return false;
}
bool Threading::Mutex::WaitWithoutYield( const wxTimeSpan& timeout )
bool Threading::Mutex::WaitWithoutYield(const wxTimeSpan &timeout)
{
if( AcquireWithoutYield(timeout) )
{
if (AcquireWithoutYield(timeout)) {
Release();
return true;
}
@ -298,67 +290,72 @@ bool Threading::Mutex::WaitWithoutYield( const wxTimeSpan& timeout )
Threading::ScopedLock::~ScopedLock() throw()
{
if( m_IsLocked && m_lock )
if (m_IsLocked && m_lock)
m_lock->Release();
}
Threading::ScopedLock::ScopedLock( const Mutex* locker )
Threading::ScopedLock::ScopedLock(const Mutex *locker)
{
m_IsLocked = false;
AssignAndLock( locker );
AssignAndLock(locker);
}
Threading::ScopedLock::ScopedLock( const Mutex& locker )
Threading::ScopedLock::ScopedLock(const Mutex &locker)
{
m_IsLocked = false;
AssignAndLock( locker );
AssignAndLock(locker);
}
void Threading::ScopedLock::AssignAndLock( const Mutex& locker )
void Threading::ScopedLock::AssignAndLock(const Mutex &locker)
{
AssignAndLock( &locker );
AssignAndLock(&locker);
}
void Threading::ScopedLock::AssignAndLock( const Mutex* locker )
void Threading::ScopedLock::AssignAndLock(const Mutex *locker)
{
pxAssert(!m_IsLocked); // if we're already locked, changing the lock is bad mojo.
m_lock = const_cast<Mutex*>(locker);
if( !m_lock ) return;
m_lock = const_cast<Mutex *>(locker);
if (!m_lock)
return;
m_IsLocked = true;
m_lock->Acquire();
}
void Threading::ScopedLock::Assign( const Mutex& locker )
void Threading::ScopedLock::Assign(const Mutex &locker)
{
m_lock = const_cast<Mutex*>(&locker);
m_lock = const_cast<Mutex *>(&locker);
}
void Threading::ScopedLock::Assign( const Mutex* locker )
void Threading::ScopedLock::Assign(const Mutex *locker)
{
m_lock = const_cast<Mutex*>(locker);
m_lock = const_cast<Mutex *>(locker);
}
// Provides manual unlocking of a scoped lock prior to object destruction.
void Threading::ScopedLock::Release()
{
if( !m_IsLocked ) return;
if (!m_IsLocked)
return;
m_IsLocked = false;
if( m_lock ) m_lock->Release();
if (m_lock)
m_lock->Release();
}
// provides manual locking of a scoped lock, to re-lock after a manual unlocking.
void Threading::ScopedLock::Acquire()
{
if( m_IsLocked || !m_lock ) return;
if (m_IsLocked || !m_lock)
return;
m_lock->Acquire();
m_IsLocked = true;
}
Threading::ScopedLock::ScopedLock( const Mutex& locker, bool isTryLock )
Threading::ScopedLock::ScopedLock(const Mutex &locker, bool isTryLock)
{
m_lock = const_cast<Mutex*>(&locker);
if( !m_lock ) return;
m_lock = const_cast<Mutex *>(&locker);
if (!m_lock)
return;
m_IsLocked = isTryLock ? m_lock->TryAcquire() : false;
}

121
common/src/Utilities/PathUtils.cpp
View File

@ -23,71 +23,73 @@
// wxDirName (implementations)
// ---------------------------------------------------------------------------------
wxFileName wxDirName::Combine( const wxFileName& right ) const
wxFileName wxDirName::Combine(const wxFileName &right) const
{
pxAssertMsg( IsDir(), L"Warning: Malformed directory name detected during wxDirName concatenation." );
if( right.IsAbsolute() )
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wxDirName concatenation.");
if (right.IsAbsolute())
return right;
// Append any directory parts from right, and then set the filename.
// Except we can't do that because our m_members are private (argh!) and there is no API
// for getting each component of the path. So instead let's use Normalize:
wxFileName result( right );
result.Normalize( wxPATH_NORM_ENV_VARS | wxPATH_NORM_DOTS | wxPATH_NORM_ABSOLUTE, GetPath() );
wxFileName result(right);
result.Normalize(wxPATH_NORM_ENV_VARS | wxPATH_NORM_DOTS | wxPATH_NORM_ABSOLUTE, GetPath());
return result;
}
wxDirName wxDirName::Combine( const wxDirName& right ) const
wxDirName wxDirName::Combine(const wxDirName &right) const
{
pxAssertMsg( IsDir() && right.IsDir(), L"Warning: Malformed directory name detected during wDirName concatenation." );
pxAssertMsg(IsDir() && right.IsDir(), L"Warning: Malformed directory name detected during wDirName concatenation.");
wxDirName result( right );
result.Normalize( wxPATH_NORM_ENV_VARS | wxPATH_NORM_DOTS | wxPATH_NORM_ABSOLUTE, GetPath() );
wxDirName result(right);
result.Normalize(wxPATH_NORM_ENV_VARS | wxPATH_NORM_DOTS | wxPATH_NORM_ABSOLUTE, GetPath());
return result;
}
wxDirName& wxDirName::Normalize( int flags, const wxString& cwd )
wxDirName &wxDirName::Normalize(int flags, const wxString &cwd)
{
pxAssertMsg( IsDir(), L"Warning: Malformed directory name detected during wDirName normalization." );
if( !wxFileName::Normalize( flags, cwd ) )
throw Exception::ParseError().SetDiagMsg( L"wxDirName::Normalize operation failed." );
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wDirName normalization.");
if (!wxFileName::Normalize(flags, cwd))
throw Exception::ParseError().SetDiagMsg(L"wxDirName::Normalize operation failed.");
return *this;
}
wxDirName& wxDirName::MakeRelativeTo( const wxString& pathBase )
wxDirName &wxDirName::MakeRelativeTo(const wxString &pathBase)
{
pxAssertMsg( IsDir(), L"Warning: Malformed directory name detected during wDirName normalization." );
if( !wxFileName::MakeRelativeTo( pathBase ) )
throw Exception::ParseError().SetDiagMsg( L"wxDirName::MakeRelativeTo operation failed." );
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wDirName normalization.");
if (!wxFileName::MakeRelativeTo(pathBase))
throw Exception::ParseError().SetDiagMsg(L"wxDirName::MakeRelativeTo operation failed.");
return *this;
}
wxDirName& wxDirName::MakeAbsolute( const wxString& cwd )
wxDirName &wxDirName::MakeAbsolute(const wxString &cwd)
{
pxAssertMsg( IsDir(), L"Warning: Malformed directory name detected during wDirName normalization." );
if( !wxFileName::MakeAbsolute( cwd ) )
throw Exception::ParseError().SetDiagMsg( L"wxDirName::MakeAbsolute operation failed." );
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wDirName normalization.");
if (!wxFileName::MakeAbsolute(cwd))
throw Exception::ParseError().SetDiagMsg(L"wxDirName::MakeAbsolute operation failed.");
return *this;
}
void wxDirName::Rmdir()
{
if( !Exists() ) return;
if (!Exists())
return;
wxFileName::Rmdir();
// TODO : Throw exception if operation failed? Do we care?
}
bool wxDirName::Mkdir()
{
// wxWidgets recurses directory creation for us.
// wxWidgets recurses directory creation for us.
// only exist in wx2.9 and above
// only exist in wx2.9 and above
#ifndef wxS_DIR_DEFAULT
#define wxS_DIR_DEFAULT 0777
#endif
if( Exists() ) return true;
if (Exists())
return true;
return wxFileName::Mkdir(wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
}
@ -97,34 +99,35 @@ bool wxDirName::Mkdir()
// ---------------------------------------------------------------------------------
bool Path::IsRelative( const wxString& path )
bool Path::IsRelative(const wxString &path)
{
return wxDirName( path ).IsRelative();
return wxDirName(path).IsRelative();
}
// Returns -1 if the file does not exist.
s64 Path::GetFileSize( const wxString& path )
s64 Path::GetFileSize(const wxString &path)
{
if( !wxFile::Exists( path.c_str() ) ) return -1;
return (s64)wxFileName::GetSize( path ).GetValue();
if (!wxFile::Exists(path.c_str()))
return -1;
return (s64)wxFileName::GetSize(path).GetValue();
}
wxString Path::Normalize( const wxString& src )
wxString Path::Normalize(const wxString &src)
{
wxFileName normalize( src );
wxFileName normalize(src);
normalize.Normalize();
return normalize.GetFullPath();
}
wxString Path::Normalize( const wxDirName& src )
wxString Path::Normalize(const wxDirName &src)
{
return wxDirName(src).Normalize().ToString();
}
wxString Path::MakeAbsolute( const wxString& src )
wxString Path::MakeAbsolute(const wxString &src)
{
wxFileName absolute( src );
wxFileName absolute(src);
absolute.MakeAbsolute();
return absolute.GetFullPath();
}
@ -132,48 +135,48 @@ wxString Path::MakeAbsolute( const wxString& src )
// Concatenates two pathnames together, inserting delimiters (backslash on win32)
// as needed! Assumes the 'dest' is allocated to at least g_MaxPath length.
//
wxString Path::Combine( const wxString& srcPath, const wxString& srcFile )
wxString Path::Combine(const wxString &srcPath, const wxString &srcFile)
{
return (wxDirName( srcPath ) + srcFile).GetFullPath();
return (wxDirName(srcPath) + srcFile).GetFullPath();
}
wxString Path::Combine( const wxDirName& srcPath, const wxFileName& srcFile )
wxString Path::Combine(const wxDirName &srcPath, const wxFileName &srcFile)
{
return (srcPath + srcFile).GetFullPath();
}
wxString Path::Combine( const wxString& srcPath, const wxDirName& srcFile )
wxString Path::Combine(const wxString &srcPath, const wxDirName &srcFile)
{
return (wxDirName( srcPath ) + srcFile).ToString();
return (wxDirName(srcPath) + srcFile).ToString();
}
// Replaces the extension of the file with the one given.
// This function works for path names as well as file names.
wxString Path::ReplaceExtension( const wxString& src, const wxString& ext )
wxString Path::ReplaceExtension(const wxString &src, const wxString &ext)
{
wxFileName jojo( src );
jojo.SetExt( ext );
wxFileName jojo(src);
jojo.SetExt(ext);
return jojo.GetFullPath();
}
wxString Path::ReplaceFilename( const wxString& src, const wxString& newfilename )
wxString Path::ReplaceFilename(const wxString &src, const wxString &newfilename)
{
wxFileName jojo( src );
jojo.SetFullName( newfilename );
wxFileName jojo(src);
jojo.SetFullName(newfilename);
return jojo.GetFullPath();
}
wxString Path::GetFilename( const wxString& src )
wxString Path::GetFilename(const wxString &src)
{
return wxFileName(src).GetFullName();
}
wxString Path::GetFilenameWithoutExt( const wxString& src )
wxString Path::GetFilenameWithoutExt(const wxString &src)
{
return wxFileName(src).GetName();
}
wxString Path::GetDirectory( const wxString& src )
wxString Path::GetDirectory(const wxString &src)
{
return wxFileName(src).GetPath();
}
@ -181,26 +184,26 @@ wxString Path::GetDirectory( const wxString& src )
// returns the base/root directory of the given path.
// Example /this/that/something.txt -> dest == "/"
wxString Path::GetRootDirectory( const wxString& src )
wxString Path::GetRootDirectory(const wxString &src)
{
size_t pos = src.find_first_of( wxFileName::GetPathSeparators() );
if( pos == wxString::npos )
size_t pos = src.find_first_of(wxFileName::GetPathSeparators());
if (pos == wxString::npos)
return wxString();
else
return wxString( src.begin(), src.begin()+pos );
return wxString(src.begin(), src.begin() + pos);
}
// ------------------------------------------------------------------------
// Launches the specified file according to its mime type
//
void pxLaunch( const wxString& filename )
void pxLaunch(const wxString &filename)
{
wxLaunchDefaultBrowser( filename );
wxLaunchDefaultBrowser(filename);
}
void pxLaunch(const char *filename)
{
pxLaunch( fromUTF8(filename) );
pxLaunch(fromUTF8(filename));
}
// ------------------------------------------------------------------------
@ -209,12 +212,12 @@ void pxLaunch(const char *filename)
// bypasses wxWidgets internal filename checking, which can end up launching things
// through browser more often than desired.
//
void pxExplore( const wxString& path )
void pxExplore(const wxString &path)
{
wxLaunchDefaultBrowser( !path.Contains( L"://") ? L"file://" + path : path );
wxLaunchDefaultBrowser(!path.Contains(L"://") ? L"file://" + path : path);
}
void pxExplore(const char *path)
{
pxExplore( fromUTF8(path) );
pxExplore(fromUTF8(path));
}

129
common/src/Utilities/Perf.cpp
View File

@ -23,84 +23,92 @@
namespace Perf
{
// Warning object aren't thread safe
InfoVector any("");
InfoVector ee("EE");
InfoVector iop("IOP");
InfoVector vu("VU");
// Warning object aren't thread safe
InfoVector any("");
InfoVector ee("EE");
InfoVector iop("IOP");
InfoVector vu("VU");
// Perf is only supported on linux
#if defined(__linux__) && defined(ProfileWithPerf)
////////////////////////////////////////////////////////////////////////////////
// Implementation of the Info object
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Implementation of the Info object
////////////////////////////////////////////////////////////////////////////////
Info::Info(uptr x86, u32 size, const char* symbol) : m_x86(x86), m_size(size), m_dynamic(false)
{
Info::Info(uptr x86, u32 size, const char *symbol)
: m_x86(x86)
, m_size(size)
, m_dynamic(false)
{
strncpy(m_symbol, symbol, sizeof(m_symbol));
}
}
Info::Info(uptr x86, u32 size, const char* symbol, u32 pc) : m_x86(x86), m_size(size), m_dynamic(true)
{
Info::Info(uptr x86, u32 size, const char *symbol, u32 pc)
: m_x86(x86)
, m_size(size)
, m_dynamic(true)
{
snprintf(m_symbol, sizeof(m_symbol), "%s_0x%08x", symbol, pc);
}
}
void Info::Print(FILE* fp)
{
void Info::Print(FILE *fp)
{
fprintf(fp, "%x %x %s\n", m_x86, m_size, m_symbol);
}
}
////////////////////////////////////////////////////////////////////////////////
// Implementation of the InfoVector object
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Implementation of the InfoVector object
////////////////////////////////////////////////////////////////////////////////
InfoVector::InfoVector(const char* prefix)
{
InfoVector::InfoVector(const char *prefix)
{
strncpy(m_prefix, prefix, sizeof(m_prefix));
}
}
void InfoVector::print(FILE* fp)
{
for(auto&& it : m_v) it.Print(fp);
}
void InfoVector::print(FILE *fp)
{
for (auto &&it : m_v)
it.Print(fp);
}
void InfoVector::map(uptr x86, u32 size, const char* symbol)
{
// This function is typically used for dispatcher and recompiler.
// Dispatchers are on a page and must always be kept.
// Recompilers are much bigger (TODO check VIF) and are only
// useful when MERGE_BLOCK_RESULT is defined
void InfoVector::map(uptr x86, u32 size, const char *symbol)
{
// This function is typically used for dispatcher and recompiler.
// Dispatchers are on a page and must always be kept.
// Recompilers are much bigger (TODO check VIF) and are only
// useful when MERGE_BLOCK_RESULT is defined
#ifdef MERGE_BLOCK_RESULT
m_v.emplace_back(x86, size, symbol);
#else
if (size < 8 * _1kb) m_v.emplace_back(x86, size, symbol);
if (size < 8 * _1kb)
m_v.emplace_back(x86, size, symbol);
#endif
}
}
void InfoVector::map(uptr x86, u32 size, u32 pc)
{
void InfoVector::map(uptr x86, u32 size, u32 pc)
{
#ifndef MERGE_BLOCK_RESULT
m_v.emplace_back(x86, size, m_prefix, pc);
#endif
}
}
void InfoVector::reset()
{
void InfoVector::reset()
{
auto dynamic = std::remove_if(m_v.begin(), m_v.end(), [](Info i) { return i.m_dynamic; });
m_v.erase(dynamic, m_v.end());
}
}
////////////////////////////////////////////////////////////////////////////////
// Global function
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Global function
////////////////////////////////////////////////////////////////////////////////
void dump()
{
void dump()
{
char file[256];
snprintf(file, 250, "/tmp/perf-%d.map", getpid());
FILE* fp = fopen(file, "w");
FILE *fp = fopen(file, "w");
any.print(fp);
ee.print(fp);
@ -109,32 +117,31 @@ namespace Perf
if (fp)
fclose(fp);
}
}
void dump_and_reset()
{
void dump_and_reset()
{
dump();
any.reset();
ee.reset();
iop.reset();
vu.reset();
}
}
#else
////////////////////////////////////////////////////////////////////////////////
// Dummy implementation
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Dummy implementation
////////////////////////////////////////////////////////////////////////////////
InfoVector::InfoVector(const char* prefix) {}
void InfoVector::map(uptr x86, u32 size, const char* symbol) {}
void InfoVector::map(uptr x86, u32 size, u32 pc) {}
void InfoVector::reset() {}
InfoVector::InfoVector(const char *prefix) {}
void InfoVector::map(uptr x86, u32 size, const char *symbol) {}
void InfoVector::map(uptr x86, u32 size, u32 pc) {}
void InfoVector::reset() {}
void dump() {}
void dump_and_reset() {}
void dump() {}
void dump_and_reset() {}
#endif
}

1
common/src/Utilities/PrecompiledHeader.h
View File

@ -28,4 +28,3 @@
#include "General.h"
#endif

37
common/src/Utilities/RwMutex.cpp
View File

@ -21,37 +21,37 @@
// --------------------------------------------------------------------------------------
Threading::RwMutex::RwMutex()
{
pthread_rwlock_init( &m_rwlock, NULL );
pthread_rwlock_init(&m_rwlock, NULL);
}
Threading::RwMutex::~RwMutex() throw()
{
pthread_rwlock_destroy( &m_rwlock );
pthread_rwlock_destroy(&m_rwlock);
}
void Threading::RwMutex::AcquireRead()
{
pthread_rwlock_rdlock( &m_rwlock );
pthread_rwlock_rdlock(&m_rwlock);
}
void Threading::RwMutex::AcquireWrite()
{
pthread_rwlock_wrlock( &m_rwlock );
pthread_rwlock_wrlock(&m_rwlock);
}
bool Threading::RwMutex::TryAcquireRead()
{
return pthread_rwlock_tryrdlock( &m_rwlock ) != EBUSY;
return pthread_rwlock_tryrdlock(&m_rwlock) != EBUSY;
}
bool Threading::RwMutex::TryAcquireWrite()
{
return pthread_rwlock_trywrlock( &m_rwlock ) != EBUSY;
return pthread_rwlock_trywrlock(&m_rwlock) != EBUSY;
}
void Threading::RwMutex::Release()
{
pthread_rwlock_unlock( &m_rwlock );
pthread_rwlock_unlock(&m_rwlock);
}
// --------------------------------------------------------------------------------------
@ -59,14 +59,15 @@ void Threading::RwMutex::Release()
// --------------------------------------------------------------------------------------
Threading::BaseScopedReadWriteLock::~BaseScopedReadWriteLock() throw()
{
if( m_IsLocked )
if (m_IsLocked)
m_lock.Release();
}
// Provides manual unlocking of a scoped lock prior to object destruction.
void Threading::BaseScopedReadWriteLock::Release()
{
if( !m_IsLocked ) return;
if (!m_IsLocked)
return;
m_IsLocked = false;
m_lock.Release();
}
@ -74,8 +75,8 @@ void Threading::BaseScopedReadWriteLock::Release()
// --------------------------------------------------------------------------------------
// ScopedReadLock / ScopedWriteLock
// --------------------------------------------------------------------------------------
Threading::ScopedReadLock::ScopedReadLock( RwMutex& locker )
: BaseScopedReadWriteLock( locker )
Threading::ScopedReadLock::ScopedReadLock(RwMutex &locker)
: BaseScopedReadWriteLock(locker)
{
m_IsLocked = true;
m_lock.AcquireRead();
@ -84,13 +85,14 @@ Threading::ScopedReadLock::ScopedReadLock( RwMutex& locker )
// provides manual locking of a scoped lock, to re-lock after a manual unlocking.
void Threading::ScopedReadLock::Acquire()
{
if( m_IsLocked ) return;
if (m_IsLocked)
return;
m_lock.AcquireRead();
m_IsLocked = true;
}
Threading::ScopedWriteLock::ScopedWriteLock( RwMutex& locker )
: BaseScopedReadWriteLock( locker )
Threading::ScopedWriteLock::ScopedWriteLock(RwMutex &locker)
: BaseScopedReadWriteLock(locker)
{
m_IsLocked = true;
m_lock.AcquireWrite();
@ -99,14 +101,15 @@ Threading::ScopedWriteLock::ScopedWriteLock( RwMutex& locker )
// provides manual locking of a scoped lock, to re-lock after a manual unlocking.
void Threading::ScopedWriteLock::Acquire()
{
if( m_IsLocked ) return;
if (m_IsLocked)
return;
m_lock.AcquireWrite();
m_IsLocked = true;
}
// Special constructor used by ScopedTryLock
Threading::ScopedWriteLock::ScopedWriteLock( RwMutex& locker, bool isTryLock )
: BaseScopedReadWriteLock( locker )
Threading::ScopedWriteLock::ScopedWriteLock(RwMutex &locker, bool isTryLock)
: BaseScopedReadWriteLock(locker)
{
//m_IsLocked = isTryLock ? m_lock.TryAcquireWrite() : false;
}

Some files were not shown because too many files have changed in this diff Show More