mirror of
https://github.com/spiffcode/hostile-takeover.git
synced 2025-12-16 12:08:36 +00:00
442 lines
7.6 KiB
C++
442 lines
7.6 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
// rip.cpp
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// This module contains support for communicating errors or messages to a
|
|
// developer or tester.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#if defined(_DEBUG) || defined(DEBUG)
|
|
|
|
namespace wi {
|
|
char *gpszRipFile;
|
|
int giRipLine;
|
|
}
|
|
|
|
#if defined(WIN) && !defined(CE)
|
|
|
|
#include "windows.h"
|
|
#include "rip.h"
|
|
#ifdef USE_PALM_UNIX_HEADERS
|
|
#include <unix\unix_stdio.h>
|
|
#else
|
|
#include <stdio.h>
|
|
#endif
|
|
|
|
#define RIP_DEFINED
|
|
|
|
namespace wi {
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// DoRip
|
|
//
|
|
// Gets called to output a message to a developer or tester.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Turn off c++ exception handler unwind semantics not enabled warning
|
|
|
|
#pragma warning(disable : 4530)
|
|
|
|
void DoRip(TCHAR *pszTitle, TCHAR *psz, va_list va)
|
|
{
|
|
int idT;
|
|
static bool gfRipActive = FALSE;
|
|
|
|
// If gpszRipFile is not NULL, Format the string
|
|
// "File: name.cpp, Line: nnn, ..."
|
|
// Otherwise, format the string without the File/Line info.
|
|
|
|
TCHAR szT[256];
|
|
TCHAR szT1[128];
|
|
wvsprintf(szT1, psz, va);
|
|
|
|
if (gpszRipFile != NULL)
|
|
wsprintf(szT, TEXT("\n%s: File: %s, Line: %d. %s\n"), pszTitle, gpszRipFile, giRipLine, szT1);
|
|
else
|
|
wsprintf(szT, TEXT("%s: %s"), pszTitle, szT1);
|
|
|
|
// This'll break into the debugger if the debugger is present,
|
|
// otherwise it'll fall through to the message box case.
|
|
|
|
OutputDebugString(szT);
|
|
|
|
#if 0
|
|
bool fBeingDebugged = TRUE;
|
|
#if defined(WIN) && !defined(CE)
|
|
try {
|
|
DebugBreak();
|
|
} catch (...) {
|
|
fBeingDebugged = FALSE;
|
|
}
|
|
#else
|
|
DebugBreak();
|
|
#endif
|
|
|
|
// If we are not being debugged, bring up the message box
|
|
|
|
if (fBeingDebugged)
|
|
return;
|
|
#endif
|
|
|
|
// Bring up a message box with these options:
|
|
// Abort: terminate app
|
|
// Retry: break
|
|
// Ignore: keep running
|
|
|
|
// We don't want to recurse, which may happen when this message
|
|
// box comes up due to WM_ACTIVATE messages and other being
|
|
// sent back to the app
|
|
|
|
if (gfRipActive)
|
|
return;
|
|
|
|
gfRipActive = TRUE;
|
|
idT = MessageBox(NULL, szT, pszTitle,
|
|
MB_ABORTRETRYIGNORE | MB_SETFOREGROUND);
|
|
gfRipActive = FALSE;
|
|
|
|
switch (idT) {
|
|
case IDABORT:
|
|
// The process should exit now
|
|
// Terminate the process so we don't go through all that
|
|
// .dll cleanup code. This'll avoid mfc dumping heap
|
|
// allocation info to the debugger, making termination
|
|
// faster.
|
|
|
|
TerminateProcess(GetCurrentProcess(), 0);
|
|
return;
|
|
|
|
case IDRETRY:
|
|
// This'll break into the debugger or cause the just
|
|
// in time debugger to load. If neither are present, the app
|
|
// will terminate.
|
|
|
|
OutputDebugString(szT);
|
|
|
|
DebugBreak();
|
|
|
|
// Just continue and hope things get better
|
|
|
|
return;
|
|
|
|
case IDIGNORE:
|
|
// Output assertion string. Can also be used to ignore
|
|
// asserts.
|
|
|
|
OutputDebugString(szT);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void DoAssertRip(int fNoAssert, TCHAR *psz, ...)
|
|
{
|
|
if (fNoAssert)
|
|
return;
|
|
|
|
va_list va;
|
|
va_start(va, psz);
|
|
DoRip(TEXT("Assertion failed!"), psz, va);
|
|
va_end(va);
|
|
}
|
|
|
|
void DoAssertRip(int fNoAssert)
|
|
{
|
|
if (fNoAssert)
|
|
return;
|
|
|
|
DoRip(TEXT("Assertion failed!"), TEXT(""), NULL);
|
|
}
|
|
|
|
void DoAssertRip(TCHAR *psz, ...)
|
|
{
|
|
va_list va;
|
|
va_start(va, psz);
|
|
DoRip(TEXT("Assert!"), psz, va);
|
|
va_end(va);
|
|
}
|
|
|
|
void dvprintf(TCHAR *psz, va_list va)
|
|
{
|
|
TCHAR szT1[2048];
|
|
wvsprintf(szT1, psz, va);
|
|
OutputDebugString(szT1);
|
|
}
|
|
|
|
void dprintf(TCHAR *psz, ...)
|
|
{
|
|
va_list va;
|
|
va_start(va, psz);
|
|
dvprintf(psz, va);
|
|
va_end(va);
|
|
}
|
|
|
|
void DoAssertRip()
|
|
{
|
|
DoAssertRip(TEXT("Unknown error"));
|
|
}
|
|
|
|
} // namespace wi
|
|
|
|
#endif // WIN
|
|
|
|
#ifdef PIL
|
|
|
|
#define RIP_DEFINED
|
|
|
|
#include <palmos.h>
|
|
#include "rip.h"
|
|
|
|
namespace wi {
|
|
|
|
#ifdef PNO
|
|
void DebugBreak()
|
|
{
|
|
}
|
|
#else
|
|
extern "C" void DebugBreak() secCode14;
|
|
#endif
|
|
|
|
void Break()
|
|
{
|
|
ErrDisplayFileLineMsg(gpszRipFile, giRipLine, "Assert!");
|
|
// DebugBreak();
|
|
}
|
|
|
|
void DoAssertRip(int fNoAssert, char *psz, ...)
|
|
{
|
|
if (fNoAssert)
|
|
return;
|
|
Break();
|
|
}
|
|
|
|
void DoAssertRip(int fNoAssert)
|
|
{
|
|
if (!fNoAssert)
|
|
Break();
|
|
}
|
|
|
|
void DoAssertRip(char *psz, ...)
|
|
{
|
|
Break();
|
|
}
|
|
|
|
void DoAssertRip()
|
|
{
|
|
Break();
|
|
}
|
|
|
|
} // namespace wi
|
|
|
|
#endif // PIL
|
|
|
|
#ifdef CE
|
|
|
|
#define RIP_DEFINED
|
|
|
|
#include "windows.h"
|
|
|
|
#include "rip.h"
|
|
|
|
namespace wi {
|
|
|
|
void Break()
|
|
{
|
|
WCHAR wszT[300];
|
|
WCHAR wszT2[300];
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, gpszRipFile, -1, wszT2, sizeof(wszT) - 1);
|
|
wsprintf(wszT, TEXT("File: %s, Line: %d"), wszT2, giRipLine);
|
|
MessageBox(NULL, wszT, TEXT("Assert"), MB_OK);
|
|
DebugBreak();
|
|
}
|
|
|
|
void DoRip(char *psz, va_list va)
|
|
{
|
|
char szT[300];
|
|
sprintf(szT, "File: %s, Line: %d. ", gpszRipFile, giRipLine);
|
|
vsprintf(szT + strlen(szT), psz, va);
|
|
|
|
WCHAR wszT[300];
|
|
MultiByteToWideChar(CP_ACP, 0, szT, -1, wszT, sizeof(wszT) - 1);
|
|
MessageBox(NULL, wszT, TEXT("Assert"), MB_OK);
|
|
|
|
DebugBreak();
|
|
}
|
|
|
|
void DoAssertRip(int fNoAssert, char *psz, ...)
|
|
{
|
|
if (fNoAssert)
|
|
return;
|
|
va_list va;
|
|
va_start(va, psz);
|
|
DoRip(psz, va);
|
|
va_end(va);
|
|
}
|
|
|
|
void DoAssertRip(int fNoAssert)
|
|
{
|
|
if (fNoAssert)
|
|
return;
|
|
DoRip("", NULL);
|
|
}
|
|
|
|
void DoAssertRip(char *psz, ...)
|
|
{
|
|
va_list va;
|
|
va_start(va, psz);
|
|
DoRip(psz, va);
|
|
va_end(va);
|
|
}
|
|
|
|
void DoAssertRip()
|
|
{
|
|
Break();
|
|
}
|
|
|
|
} // namespace wi
|
|
|
|
#endif // CE
|
|
|
|
#ifdef IPHONE
|
|
|
|
#define RIP_DEFINED
|
|
|
|
#include <stdarg.h>
|
|
#include "rip.h"
|
|
#include "iphone.h"
|
|
|
|
namespace wi {
|
|
|
|
void Break()
|
|
{
|
|
IPhone::Log("Break:");
|
|
IPhone::Log("File: %s, Line: %d", gpszRipFile, giRipLine);
|
|
IPhone::Break();
|
|
}
|
|
|
|
void DoRip(char *psz, va_list va)
|
|
{
|
|
IPhone::Log("Assert:");
|
|
IPhone::Log("File: %s, Line: %d", gpszRipFile, giRipLine);
|
|
IPhone::Log(psz, va);
|
|
IPhone::Break();
|
|
}
|
|
|
|
void DoAssertRip(int fNoAssert, char *psz, ...)
|
|
{
|
|
if (fNoAssert)
|
|
return;
|
|
va_list va;
|
|
va_start(va, psz);
|
|
DoRip(psz, va);
|
|
va_end(va);
|
|
}
|
|
|
|
void DoAssertRip(int fNoAssert)
|
|
{
|
|
if (fNoAssert)
|
|
return;
|
|
DoRip("", 0);
|
|
}
|
|
|
|
void DoAssertRip(char *psz, ...)
|
|
{
|
|
va_list va;
|
|
va_start(va, psz);
|
|
DoRip(psz, va);
|
|
va_end(va);
|
|
}
|
|
|
|
void DoAssertRip()
|
|
{
|
|
Break();
|
|
}
|
|
|
|
void dprintf(const char *psz, ...)
|
|
{
|
|
va_list va;
|
|
va_start(va, psz);
|
|
vprintf(psz, va);
|
|
va_end(va);
|
|
}
|
|
|
|
} // namespace wi
|
|
|
|
#endif // IPHONE
|
|
|
|
#ifndef RIP_DEFINED
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include "inc/rip.h"
|
|
|
|
namespace wi {
|
|
|
|
void Break()
|
|
{
|
|
printf("Break:\n");
|
|
printf("File: %s, Line: %d\n", gpszRipFile, giRipLine);
|
|
abort();
|
|
}
|
|
|
|
void DoRip(char *psz, va_list va)
|
|
{
|
|
printf("Assert:\n");
|
|
printf("File: %s, Line: %d\n", gpszRipFile, giRipLine);
|
|
#ifdef __ANDROID__
|
|
printf("%s", psz);
|
|
#else
|
|
if (va == NULL) {
|
|
printf("%s", psz);
|
|
} else {
|
|
vprintf(psz, va);
|
|
}
|
|
#endif
|
|
Break();
|
|
}
|
|
|
|
void DoAssertRip(int fNoAssert, char *psz, ...)
|
|
{
|
|
if (fNoAssert)
|
|
return;
|
|
va_list va;
|
|
va_start(va, psz);
|
|
DoRip(psz, va);
|
|
va_end(va);
|
|
}
|
|
|
|
void DoAssertRip(int fNoAssert)
|
|
{
|
|
if (fNoAssert)
|
|
return;
|
|
va_list empty_va_list;
|
|
DoRip("", empty_va_list);
|
|
}
|
|
|
|
void DoAssertRip(char *psz, ...)
|
|
{
|
|
va_list va;
|
|
va_start(va, psz);
|
|
DoRip(psz, va);
|
|
va_end(va);
|
|
}
|
|
|
|
void DoAssertRip()
|
|
{
|
|
Break();
|
|
}
|
|
|
|
void dprintf(const char *psz, ...)
|
|
{
|
|
va_list va;
|
|
va_start(va, psz);
|
|
vprintf(psz, va);
|
|
va_end(va);
|
|
}
|
|
|
|
} // namespace wi
|
|
|
|
#endif // !RIP_DEFINED
|
|
|
|
#endif // defined(_DEBUG) || defined(DEBUG)
|