/*
We do not do any buffer override checks here because we are sure
that the function is called *only* from within our library.
*/
void eph_error (eph_iob *iob,int err,char *fmt,...) {
va_list ap;
char *msg=NULL;
char msgbuf[512];
va_start(ap,fmt);
if (fmt) {
wvsprintf(msgbuf,fmt,ap);
} else {
if ((err >= ERR_BASE) && (err < ERR_MAX)) {
msg=eph_errmsg[err-ERR_BASE];
} else {
msg=strerror(err);
}
strcpy(msgbuf,msg);
}
va_end(ap);
(iob->errorcb)(err,msgbuf);
}
void TPrinter::ReportError(PTPrintout Printout)
{
char ErrorMsg[80];
char ErrorCaption[80];
char ErrorTemplate[40];
char ErrorStr[40];
WORD ErrorId;
Pchar Title;
switch (Error) {
case SP_APPABORT:
ErrorId = SR_PRNCANCEL;
break;
case SP_ERROR:
ErrorId = SR_GENERROR;
break;
case SP_OUTOFDISK:
ErrorId = SR_OUTOFDISK;
break;
case SP_OUTOFMEMORY:
ErrorId = SR_OUTOFMEMORY;
break;
case SP_USERABORT:
ErrorId = SR_PRNMGRABORT;
break;
default:
return;
}
HINSTANCE hInstance = GetApplicationObject()->hInstance;
LoadString(hInstance, SR_ERRORTEMPLATE, ErrorTemplate,
sizeof(ErrorTemplate));
LoadString(hInstance, ErrorId, ErrorStr, sizeof(ErrorStr));
Title = Printout->Title;
LPSTR C[1];
C[0] = Title;
wvsprintf(ErrorMsg, ErrorTemplate, (LPSTR) C);
LoadString(hInstance, SR_ERRORCAPTION, ErrorCaption,
sizeof(ErrorCaption));
MessageBox(0, ErrorMsg, ErrorCaption, MB_OK | MB_ICONSTOP);
}
void cdecl dDbgOut(int iLevel, LPSTR lpszFormat, ...)
{
char buf[256];
int iLogLevel;
char far *lpcLogLevel;
// Get the external logging level from the emulated ROM
iLogLevel = 0;
(LONG)lpcLogLevel = 0x00400042;
if (*lpcLogLevel >= '0' && *lpcLogLevel <= '9')
iLogLevel = (*lpcLogLevel-'0')*10+(*(lpcLogLevel+1)-'0');
if (iLevel==iLogLevel && (iLogLevel&1) || iLevel<=iLogLevel && !(iLogLevel&1)) {
OutputDebugString(" W16USER:"******"\r\n");
}
}
void far_ods( char const * const Fmt, ... )
{
// здесь не используется create/delete, на случай, если
// захочется попользовать в CDbgReportInit::AllocHook(),
// иначе, по понятным причинам, получим переполнение стека :)
HANDLE Heap = GetProcessHeap();
char * Tmp = (char*)HeapAlloc( Heap, 0, 1024 );
va_list argPtr;
va_start( argPtr, Fmt );
wvsprintf( Tmp, Fmt, argPtr );
va_end( argPtr );
OutputDebugString( Tmp );
HeapFree( Heap, 0, Tmp );
}
void Log ( char *fmt, ... )
{
SYSTEMTIME time;
va_list ap;
if ( flLog == NULL )
{
flLog = fopen( "RakSAMPClient.log", "a" );
if ( flLog == NULL )
return;
}
GetLocalTime( &time );
fprintf( flLog, "[%02d:%02d:%02d.%03d] ", time.wHour, time.wMinute, time.wSecond, time.wMilliseconds );
if(settings.iPrintTimestamps)
{
if(settings.iConsole)
printf("[%02d:%02d:%02d.%03d] ", time.wHour, time.wMinute, time.wSecond, time.wMilliseconds );
}
va_start( ap, fmt );
vfprintf( flLog, fmt, ap );
if(settings.iConsole)
vprintf(fmt, ap);
else
{
int lbCount = SendMessage(loghwnd, LB_GETCOUNT, 0, 0);
LPTSTR buf = new TCHAR[512];
wvsprintf(buf, fmt, ap);
WPARAM idx = SendMessage(loghwnd, LB_ADDSTRING, 0, (LPARAM)buf);
SendMessage(loghwnd, LB_SETCURSEL, lbCount - 1, 0);
SendMessage(loghwnd, LB_SETTOPINDEX, idx, 0);
}
va_end( ap );
fprintf( flLog, "\n" );
if(settings.iConsole)
printf("\n");
fflush( flLog );
}
int __cdecl getDebugString(char *szFormat, ...)
{
char szDebugString[1024];
va_list argList;
va_start(argList, szFormat);
int iLength = wvsprintf(szDebugString, szFormat, argList);
va_end(argList);
//\n\0 ---> \r\n\0
szDebugString[iLength-1] = '\r';
szDebugString[iLength] = '\n';
szDebugString[iLength+1] = '\0';
WriteDebugFile(szDebugString);
setDebugString(szDebugString);
return 1;
}
void CNPServer::Log (char *pszLine, ...)
// Log
//
// Logs a message to the debug log
{
if (m_bLog)
{
char *pArgs;
char szBuffer[1024];
pArgs = (char *)&pszLine + sizeof(pszLine);
wvsprintf(szBuffer, pszLine, pArgs);
kernelDebugLogMessage(szBuffer);
#ifdef _DEBUG
printf("%s\n", szBuffer);
#endif
}
}
///////////////////////////////////////////////////////////////////////////////
// Formatierfunktionen
os_string __cdecl FakeTRiASName (UINT resID, ...)
{
CString strText;
VERIFY(strText.LoadString (resID));
COM_TRY {
CString strOut;
LPTSTR pcOut = strOut.GetBufferSetLength(_MAX_PATH*4);
va_list params;
va_start (params, resID);
//lint --e(534)
wvsprintf (pcOut, strText, params);
va_end (params);
return os_string(pcOut);
} COM_CATCH_IGNORE; // irgendein Fehler
return os_string((LPCSTR)strText);
}
// Because thunk program can not debug.
// So this function use to write debug message to file.
// And use for debug version.
void DbgPrintf(LPSTR fmt, ...)
{
va_list marker;
char szBuf[4096];
int len;
#ifdef _WIN16_DEBUG_
FILE* fp;
#endif
va_start(marker, fmt);
wvsprintf(szBuf, fmt, marker);
va_end(marker);
len = strlen(szBuf);
szBuf[len] = 0x0d;
szBuf[len + 1] = 0x0a;
szBuf[len + 2] = 0;
if (bDebugBegin)
{
// Delete old debug file.
bDebugBegin = FALSE;
#ifdef _WIN16_DEBUG_
fp = fopen(_DEBUG_FILE_NAME_, "w");
fprintf(fp, "Debug Message:\n");
fclose(fp);
#endif
#ifdef _WIN32_DEBUG_
WriteWin32File("Debug Message:\n");
#endif
}
#ifdef _WIN32_DEBUG_
WriteWin32File(szBuf);
#endif
#ifdef _WIN16_DEBUG_
fp = fopen(_DEBUG_FILE_NAME_, "a");
fprintf(fp, "%s", szBuf);
fclose(fp);
#endif
}
//*=================================================================================
//*原型: void WriteLog(const char *format, ...)
//*功能: 写系统日志
//*参数:
//* format, 格式串信息
//*返回:
//* 无
//*====================================================================================
void WriteLog(const char *format, ...)
{
TCHAR sBuffer[256],szTemp[MAX_PATH];
char szFile[256];
va_list ptr;
SYSTEMTIME SysTime;
GetLocalTime(&SysTime);
long nTick = GetTickCount();
wsprintf(szTemp,"%s\\%04d%02d%2d",szTempPath,SysTime.wYear,SysTime.wMonth,
SysTime.wDay);
CreateDirectory(szTemp,NULL);
va_start(ptr, format);
wvsprintf(sBuffer, format, ptr);
va_end(ptr);
sprintf(szFile,"%s\\Application.log",szTemp);
FILE *fp;
if( (fp=fopen(szFile, "a+")) != NULL )
{
TCHAR szLog[512];
SYSTEMTIME SysTime;
GetLocalTime(&SysTime);
wsprintf(szLog, "%04d-%02d-%02d %02d:%02d:%02d:%06d [%d] %s\n",
SysTime.wYear, SysTime.wMonth, SysTime.wDay,
SysTime.wHour, SysTime.wMinute, SysTime.wSecond,
SysTime.wMilliseconds, GetTickCount() - nTick, sBuffer);
fwrite(szLog, lstrlen(szLog), sizeof(TCHAR), fp);
fclose(fp);
}
}
// Call GetLastError() and show the message to the user. The function can be
// called like printf, except each percent sign must be doubled ("%%s") as
// it goes through FormatMessage() first. A "%0" (no double-percent) will be
// replaced with a description of the last error, as returned by GetLastError()
void showSystemError(const char *message, ...)
{
// Get the system message
char *sysMsg;
if (FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, GetLastError(), 0, (LPTSTR) &sysMsg, 0, NULL
) == 0) {
MessageBox(NULL, "There was an error, and it was not possible to get a "
"description of the error.", "Error", MB_OK | MB_ICONERROR);
return;
}
// Replace %1 in the user message with the system one
char *buffer;
if (FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING |
FORMAT_MESSAGE_ARGUMENT_ARRAY,
message, 0, 0, (LPTSTR) &buffer, 0,
&sysMsg
) == 0) {
MessageBox(NULL, sysMsg, "Error (couldn't get accurate error description)", MB_OK | MB_ICONERROR);
return;
}
LocalFree(sysMsg);
// Run it all through sprintf
va_list argptr;
va_start(argptr, message);
char finalMessage[512];
wvsprintf(finalMessage, buffer, argptr);
va_end(argptr);
LocalFree(buffer);
MessageBox(NULL, finalMessage, "Error", MB_OK | MB_ICONERROR);
return;
}
INT Message(
INT idMsg,
...)
{
va_list marker;
INT RetCode;
TCHAR szT[CCHTEXTMAX];
BOOL fDisabledSave;
va_start(marker, idMsg);
wvsprintf(szT, ids(gamdMessages[idMsg].ids), marker);
fDisabledSave = gfDisabled;
gfDisabled = TRUE;
RetCode = MessageBox(NULL, szT, ids(IDS_DLGEDIT),
(WORD)(gamdMessages[idMsg].fMessageBox | MB_TASKMODAL));
gfDisabled = fDisabledSave;
va_end(marker);
return RetCode;
}
BOOL AstralAffirm( int idStr, ... )
/***********************************************************************/
{
char szBuffer[512];
LPTR lpArguments;
LPSTR lpString;
int retc;
HWND hFocusWindow;
/* Put up a modal message box with arguments specified exactly like printf */
/* The caller passes stringtable ID's, and not hardcoded strings */
/* Used to confirm any user operation */
if ( !AstralStr( idStr, &lpString ) )
return( NO );
lpArguments = (LPTR)&idStr + sizeof(idStr);
wvsprintf( szBuffer, lpString, (LPSTR)lpArguments );
hFocusWindow = GetFocus();
retc = MessageBox( MessageParent(), szBuffer, szAppName,
MB_ICONQUESTION | MB_YESNO | MB_TASKMODAL );
SetFocus( hFocusWindow );
return( retc == IDYES );
}
//------------------------------------------------------------------------
void CLogFile::LogTextRt(const TCHAR * pszString, ...)
{
if (NULL == pszString)
return;
SYSTEMTIME st;
GetLocalTime(&st);
TCHAR buf[256];
wsprintf(buf, L"%04d-%02d-%02d %02d:%02d:%02d ", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
LogText(buf);
THREAD_PROTECT;
if (m_fpLog == NULL)
return;
va_list vl;
va_start(vl, pszString);
wvsprintf(m_szCache, pszString, vl);
va_end(vl);
fputws(m_szCache, m_fpLog);
fputws(L"\n", m_fpLog);
fflush(m_fpLog);
}
int NEAR cdecl MyMessageBox(HWND hWnd, WORD wText, WORD wType, WORD wExtra, ...)
{
HANDLE hText, hRText;
PSTR pText, pRText;
WORD wSize;
int result = 0;
if(wText == IDS_OUTOFMEMORY)
goto Error1;
if(!(hText=MyLoadString(wText, &wSize, LMEM_MOVEABLE)))
goto Error1;
/* We allocate enough room for a bunch of numbers and the strings
*/
if(!(hRText=LocalAlloc(LMEM_MOVEABLE, 2*wSize + wExtra)))
goto Error2;
if(!(pRText=LocalLock(hRText)))
goto Error3;
pText = LocalLock(hText);
wvsprintf(pRText, pText, (LPSTR)(&wExtra+1));
result = MessageBox(hWnd, pRText, pszLongName, wType);
LocalUnlock(hText);
LocalUnlock(hRText);
Error3:
LocalFree(hRText);
Error2:
LocalFree(hText);
Error1:
if(!result) {
MessageBox(hWnd, pszOutOfMemory, pszLongName,
MB_ICONHAND | MB_SYSTEMMODAL | MB_OK);
}
return(result);
}
static int smtp_issue(SOCKET sock, int timeout, LPCTSTR lpFormat, ...)
{
char buf[1024], *p;
int code;
if (lpFormat != NULL) {
va_list arglist;
va_start(arglist, lpFormat);
wvsprintf(buf, lpFormat, arglist);
va_end(arglist);
send(sock, buf, lstrlen(buf), 0);
}
for (;;) {
if (recvline(sock, buf, sizeof(buf), timeout) <= 0) return 0;
for (p=buf, code=0; *p == ' ' || *p == '\t'; p++);
while (*p >= '0' && *p <= '9') code = code * 10 + *p++ - '0';
if (*p == '-') continue;
break;
}
return code;
}
int __cdecl VMessageBox (LPCSTR pcCaption, UINT uiType, UINT uiText, ...)
{
CString strText;
VERIFY(strText.LoadString (uiText));
CWnd Wnd;
CString strOut;
LPTSTR pcOut = NULL;
ATLTRY(pcOut = strOut.GetBufferSetLength(_MAX_PATH*4));
if (NULL != pcOut) {
va_list params;
va_start (params, uiText);
//lint --e(534)
wvsprintf (pcOut, strText, params);
va_end (params);
return Wnd.MessageBox (pcOut, pcCaption, uiType);
}
return Wnd.MessageBox (strText, pcCaption, uiType);
}
/////////////////////////////////////////////////////////////////////////
// A wrapper using a printf-like syntax
/////////////////////////////////////////////////////////////////////////
int __cdecl CMsgBox(
HWND hWnd, // handle of owner window
LPCTSTR lpText, // address of text in message box
LPCTSTR lpCaption, // address of title of message box
UINT uType, // style of message box
... // follow lpText
)
{
char szBuf [512];
va_list marker;
va_start (marker, uType); // Initialize variable arguments.
wvsprintf (szBuf, lpText, marker);
va_end ( marker);
// install a hook
if (hWnd!=NULL && hHook==NULL)
hHook = SetWindowsHookEx (WH_CBT,
CBTMyHookProc,
GetWindowInstance (hWnd),
GetCurrentThreadId() );
// Display the message box
return MessageBox (hWnd, szBuf, lpCaption, uType);
} // CMsgBox
int BadEndOfTransfer (const char *szFmt, ...)
{
char szBuf [512];
va_list marker;
struct tftphdr *tp;
// send NAK to server
tp = (struct tftphdr *) sTC.BufSnd;
tp->th_opcode = htons((u_short)TFTP_ERROR);
tp->th_code = htons(EUNDEF);
send (sTC.s, (char *) tp, TFTP_DATA_HEADERSIZE, 0);
StopTransfer ();
// display message
va_start( marker, szFmt ); /* Initialize variable arguments. */
wvsprintf (szBuf, szFmt, marker);
CMsgBox (hTftpClientWnd, szBuf, APPLICATION, MB_OK | MB_ICONERROR);
// Semaphore released
ReleaseSemaphore (hTftpClientSemaphore, 1, NULL);
if (sTC.opcode==TFTP_RRQ && sTC.nRcvd!=0) DeleteFile (sTC.szFile);
return FALSE;
} // BadEndOfTransfer
int MessageEx( WORD wStyle, int idStr, ... )
/***********************************************************************/
{
char szBuffer[512];
LPTR lpArguments;
LPSTR lpString;
int retc;
HWND hFocusWindow;
if (!bMessageEnable)
return(IDCANCEL);
/* Put up a modal message box with arguments specified exactly like printf */
/* The caller passes stringtable ID's, and not hardcoded strings */
/* Used to display error message and warnings */
if ( !AstralStr( idStr, &lpString ) )
return( IDCANCEL );
lpArguments = (LPTR)&idStr + sizeof(idStr);
wvsprintf( szBuffer, lpString, (LPSTR)lpArguments );
hFocusWindow = GetFocus();
retc = MessageBox( MessageParent(), szBuffer, szAppName,
(wStyle ? wStyle : MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL) );
SetFocus( hFocusWindow );
return( retc );
}
VOID DbgPrintf(
LPTSTR fmt,
...
)
{
static HANDLE mutex;
va_list marker;
TCHAR szBuf[256];
DWORD t;
HANDLE gDbgOut;
va_start(marker, fmt);
wvsprintf(szBuf, fmt, marker);
va_end(marker);
if (!mutex)
mutex = CreateMutex(NULL, FALSE, "Win9xConHookDbgOut");
WaitForSingleObject(mutex, INFINITE);
gDbgOut = CreateFile("COM1", GENERIC_READ | GENERIC_WRITE, 0,
NULL, OPEN_EXISTING, FILE_FLAG_WRITE_THROUGH, NULL);
WriteFile(gDbgOut, szBuf, strlen(szBuf), &t, NULL);
CloseHandle(gDbgOut);
ReleaseMutex(mutex);
}
/*----------------------------------------------------------------------------*\
\*----------------------------------------------------------------------------*/
void AppPrint(LPTSTR sz,...)
{
HWND hwndE = GetWindow(hwndApp, GW_CHILD);
TCHAR ach[128];
va_list marker;
va_start( marker, sz );
if (hwndE == NULL)
{
RECT rc;
GetClientRect(hwndApp, &rc);
hwndE = CreateWindow (TEXT("Edit"), TEXT(""),
WS_VISIBLE | WS_CHILD | ES_MULTILINE | ES_READONLY | WS_VSCROLL | ES_AUTOVSCROLL,
0, 0, rc.right, rc.bottom,
hwndApp, (HMENU)-1, hInstApp, NULL);
SetWindowFont(hwndE, GetStockObject(ANSI_FIXED_FONT), TRUE);
}
if (sz == NULL)
{
Edit_SetSel(hwndE, 0, (UINT)-1);
Edit_ReplaceSel(hwndE, TEXT(""));
}
else
{
wvsprintf (ach,(LPCTSTR)sz,marker); /* Format the string */
lstrcat(ach, TEXT("\r\n"));
Edit_SetSel(hwndE, (UINT)-1, (UINT)-1);
Edit_ReplaceSel(hwndE, ach);
}
va_end(marker);
}
void UpdateConsole( char *szMessage, ... )
{
char szBuffer[1024];
va_list valMaker;
va_start( valMaker, szMessage );
wvsprintf( (char *)szBuffer, (const char *)szMessage, valMaker );
int iLength = SendMessage( g_hWndConsole, WM_GETTEXTLENGTH, 0, 0 );
if(iLength < 5000){
SendMessage( g_hWndConsole, EM_SETSEL, iLength, iLength );
SendMessage( g_hWndConsole, EM_REPLACESEL, FALSE, (LPARAM)szBuffer );
}
else
{
iLength = 0;
SendMessage( g_hWndConsole, WM_SETTEXT, iLength, iLength );
SendMessage( g_hWndConsole, EM_SETSEL, iLength, iLength );
SendMessage( g_hWndConsole, EM_REPLACESEL, FALSE, (LPARAM)szBuffer );
}
}
WORD MessageStatusEx( int idStr, ... )
/***********************************************************************/
{
BOOL bShow = Control.Hints && fAppActive;
char szBuffer[256];
LPTR lpArguments;
LPSTR lpString;
// Used to paint the hint bubble with a string.
// Arguments specified exactly like printf.
// Caller passes stringtable ID's, not hardcoded strings.
*szBuffer = 0;
switch (idStr)
{
case IDS_READY:
idStr = 0;
break;
case HS_HORN:
idStr = SoundIsOn() ? IDS_SOUND_ON : IDS_SOUND_OFF;
bShow = fAppActive;
break;
case HS_TOUR:
idStr = Control.Hints ? IDS_TOUR_GUIDE_ON : IDS_TOUR_GUIDE_OFF;
bShow = fAppActive;
break;
case HS_BACKSHOW:
idStr = (idPreviousRoom == RM_SLIDE) ? HS_BACKSHOW : HS_BACKART;
break;
}
if ( AnimateIsOn() )
{
bShow = NO;
}
else if (idStr && AstralStr (idStr,&lpString))
{
lpArguments = (LPTR)&idStr + sizeof idStr;
wvsprintf (szBuffer,lpString,(LPSTR)lpArguments);
}
//SMS - this didn't work when set to Audio hints only since there is no
//way to throttle starting the sounds, they started like a machine gun....
//#ifdef CDBUILD
// if (bShow)
// {
// if (Control.bBubbleHints)
// {
// if (Status (0,bShow ? szBuffer : NULL))
// {
// if (Control.bAudioHints)
// SoundStartResource ((LPSTR)MAKEINTRESOURCE(idStr), FALSE, 0);
// }
// }
// else if (Control.bAudioHints)
// SoundStartResource ((LPSTR)MAKEINTRESOURCE(idStr), FALSE, 0);
// else
// Status ((HWND)-1, NULL);
// }
// else
// Status ((HWND)-1, NULL);
//#else
if (Status (0,bShow ? szBuffer : NULL))
SoundStartResource ((LPSTR) MAKEINTRESOURCE (idStr),FALSE,0);
//#endif
return NULL;
}
static void MyFailErrorBox (BOOL pmFatal, int pmReason, char *pmFile,
int pmLine, int pmErrorCode, va_list pmArgs)
{
int myTitleStringRsrc;
char myWindowTitle [80];
char myFinalMessage [4096], *myFinalPtr;
char myString [1024], myPartialString [1024];
char myFullString [1024];
int myResult;
ErrorBuffer myErrorBuffer;
FilePath myPanicLogName;
FileEntryPtr myPanicFile;
int myErrorCode;
// char myDateTimeString [256];
char *myPtr, *myNewPtr, *myPtr1, *myPtr2;
#ifndef TPROLOG
StackDumpThreadInfo myStackDumpThreadInfo;
HANDLE myStackDumpThread;
DWORD myThreadID;
#endif // #ifndef TPROLOG
if (pmFatal)
{
myTitleStringRsrc = IDS_FATALWINDOWTITLE;
}
else
{
myTitleStringRsrc = IDS_WARNWINDOWTITLE;
}
// Get file name. If EdProp has not been initialized, this will be
// an empty directory, in which case, use the current directory (which
// will be the correct one about 90% of the time.
strcpy (myPanicLogName, EdProp_GetStartupDirectory ());
if (myPanicLogName [0] == 0)
{
EdFile_GetCurrentDirectory (myPanicLogName);
}
MyLoadString (IDS_PANIC_LOG_FILE, &myPanicLogName [strlen (myPanicLogName)],
sizeof (myPanicLogName), PANIC_LOG_FILE_REPL);
// Get the window title (e.g. "Turing Internal Error")
strcpy (myWindowTitle, gProgram.environmentName);
strcat (myWindowTitle, " ");
MyLoadString (myTitleStringRsrc, &myWindowTitle [strlen (myWindowTitle)],
sizeof (myWindowTitle) - strlen (myWindowTitle),
WINDOW_TITLE_REPL);
// Get the preamble (e.g. "An unexpected error... Please record...")
MyLoadString (IDS_FAILPREAMBLE1, myFinalMessage, sizeof (myFinalMessage),
FAIL_PREAMBLE_REPL1);
strcat (myFinalMessage, myPanicLogName);
myFinalPtr = myFinalMessage + strlen (myFinalMessage);
MyLoadString (IDS_FAILPREAMBLE2, myFinalPtr,
sizeof (myFinalMessage) - strlen (myFinalMessage),
FAIL_PREAMBLE_REPL2);
// Get the error message (e.g. "LoadAccelerators failed (%d)")
myResult = LoadString (gProgram.applicationInstance, pmReason,
myString, sizeof (myString));
// Compose the error message
if (myResult == 0)
{
// Get the reason not found error message (e.g. "Error code = %d")
MyLoadString (IDS_FAILREASONNOTFOUND, myString, sizeof (myString),
FAIL_REASON_NOT_FOUND_REPL);
wsprintf (myFullString, myString, pmReason);
}
else
{
wvsprintf (myPartialString, myString, pmArgs);
// Get the reason found error message (e.g. "Error code = %s (%d)")
MyLoadString (IDS_FAILREASONFOUND, myString, sizeof (myString),
FAIL_REASON_FOUND_REPL);
wsprintf (myFullString, myString, myPartialString, pmReason);
}
strcat (myFinalMessage, myFullString);
// Compose the Windows error message
if (pmErrorCode != 0)
{
// Get the line/file part (e.g. "Windows error = %s (%d)\n")
MyLoadString (IDS_FAILWINDOWSERROR, myString, sizeof (myString),
FAIL_WINDOWS_ERROR_REPL);
EdFail_GetErrorMessage1 (myErrorBuffer, pmErrorCode);
if (myErrorBuffer [0] == 0)
{
MyLoadString (IDS_FAILWINDOWSUNKNOWNERROR, myString,
sizeof (myString), FAIL_WINDOWS_UNKNOWN_ERROR_REPL);
wsprintf (myFullString, myString, pmErrorCode);
}
else
{
wsprintf (myFullString, myString, myErrorBuffer, pmErrorCode);
}
strcat (myFinalMessage, myFullString);
}
// Get the line/file part (e.g. "File=%s\nLine=%s\n")
MyLoadString (IDS_FAILFILELINE, myString, sizeof (myString),
FAIL_FILE_LINE_REPL);
wsprintf (myFullString, myString, pmFile, pmLine);
strcat (myFinalMessage, myFullString);
if (pmFatal)
{
MyLoadString (IDS_FAILSAVEFILE, myString, sizeof (myString),
FAIL_SAVE_FILE_REPL);
strcat (myFinalMessage, myString);
}
// Display the error message
MessageBox (NULL, myFinalMessage, myWindowTitle,
MB_OK | MB_ICONERROR | MB_TASKMODAL);
//
// Write to panic.log
//
myPanicFile = EdFile_OpenFileForWrite (myPanicLogName, &myErrorCode,
BUFFER_OUTPUT, APPEND_TO_FILE);
if (myPanicFile == NULL)
{
// Write to log
EdGUI_Message ("Panic log failure",
"Unable to open panic log file (\"%s\") for writing.\n"
"Error = %d", myPanicLogName, myErrorCode);
return;
}
// Write preamble
// *** Fatal Error in Ready 0.98 at Date:Time
// Message
// ----
if (pmFatal)
{
EdFile_WriteString (myPanicFile, "*** FATAL INTERNAL ERROR");
}
else
{
EdFile_WriteString (myPanicFile, "*** NON-FATAL INTERNAL ERROR");
}
EdFile_WriteString (myPanicFile, " in ");
EdFile_WriteString (myPanicFile, gProgram.environmentName);
EdFile_WritelnString (myPanicFile, " ***");
// Get information about the application and save it to the crash buffer
stCrashBufferPtr = stCrashBuffer;
stCrashBufferLeft = CRASH_BUFFER_SIZE - 10;
MyGetEnvironmentInfo ();
#ifndef TPROLOG
// Add previous operations
MyAddPreviousCommandsToBuffer ();
#endif // #ifndef TPROLOG
/* GetDateFormat (LOCALE_USER_DEFAULT, 0, NULL, "MMM d yyyy",
myDateTimeString, sizeof (myDateTimeString));
EdFile_WriteString (myPanicFile, myDateTimeString);
GetTimeFormat (LOCALE_USER_DEFAULT, TIME_NOSECONDS, NULL, NULL,
myDateTimeString, sizeof (myDateTimeString));
EdFile_WriteString (myPanicFile, " ");
EdFile_WriteString (myPanicFile, myDateTimeString);
*/
EdFile_WritelnString (myPanicFile, stCrashBuffer);
// Write the message, writing each line seperately
myPtr = myFinalMessage;
myPtr1 = strchr (myPtr, '\n');
myPtr2 = strchr (myPtr, '\r');
while ((myPtr1 != NULL) || (myPtr2 != NULL))
{
if (myPtr2 < myPtr1 - 1)
{
*myPtr2 = 0;
myNewPtr = myPtr2 + 1;
}
else if (myPtr2 == myPtr1 - 1)
{
*myPtr2 = 0;
myNewPtr = myPtr1 + 1;
}
else
{
*myPtr1 = 0;
myNewPtr = myPtr1 + 1;
}
EdFile_WritelnString (myPanicFile, myPtr);
myPtr = myNewPtr;
myPtr1 = strchr (myPtr, '\n');
myPtr2 = strchr (myPtr, '\r');
}
if (*myPtr != 0)
{
EdFile_WritelnString (myPanicFile, myPtr);
}
#ifndef TPROLOG
//
// Add a stack dump
//
// First, we need to get the context of the current thread. To do this,
// we must suspend the current thread and have another thread actually
// do the stack dump.
DuplicateHandle (GetCurrentProcess(), GetCurrentThread (),
GetCurrentProcess(), &myStackDumpThreadInfo.thread, 0, FALSE,
DUPLICATE_SAME_ACCESS);
myStackDumpThreadInfo.file = myPanicFile;
myStackDumpThread = CreateThread (NULL, 0,
(LPTHREAD_START_ROUTINE) MyStackDump, &myStackDumpThreadInfo, 0,
&myThreadID);
if (myStackDumpThread != NULL)
{
// Sleep for two seconds while the stack dump is taking place.
WaitForSingleObject (myStackDumpThread, 15000);
}
#endif // #ifndef TPROLOG
EdFile_WritelnString (myPanicFile, LINE_OF_DASHES);
EdFile_CloseFile (myPanicFile);
} // MyFailErrorBox
void EdFail_AddMessage (int pmMsgType, const char *pmMessage, ...)
{
static int stLastMessage = NORMAL;
static int stLastProgessMessageHead = 0;
static int stCount = 0;
static char stLineOfText [1024];
va_list myArgList;
char myLetter [10];
if (stCrashing) return;
switch (pmMsgType)
{
case NORMAL:
stLastMessage = pmMsgType;
break;
case LETTER_MESSAGE:
if ((stLastMessage == LETTER_MESSAGE) && (stCount < 1000))
{
stProgressMessageHead = stLastProgessMessageHead;
stCount++;
}
else
{
stLastProgessMessageHead = stProgressMessageHead;
stCount = 1;
stLineOfText [0] = 0;
}
stLastMessage = pmMsgType;
// Get letter being added and add it to the list.
va_start (myArgList, pmMessage);
wvsprintf (myLetter, "%c", myArgList);
va_end (myArgList);
strcat (stLineOfText, myLetter);
break;
case MOUSE_MESSAGE:
if (stLastMessage == MOUSE_MESSAGE)
{
stProgressMessageHead = stLastProgessMessageHead;
stCount++;
}
else
{
stLastProgessMessageHead = stProgressMessageHead;
stCount = 1;
}
stLastMessage = pmMsgType;
break;
case EXTRA_MESSAGE:
break;
}
va_start (myArgList, pmMessage);
wvsprintf (stProgressMessage [stProgressMessageHead], pmMessage, myArgList);
va_end (myArgList);
if ((pmMsgType == MOUSE_MESSAGE) || (pmMsgType == LETTER_MESSAGE))
{
char myTempStr [20];
wsprintf (myTempStr, " (x%d)", stCount);
strcat (stProgressMessage [stProgressMessageHead], myTempStr);
}
if (pmMsgType == LETTER_MESSAGE)
{
char myTempStr [1028];
wsprintf (myTempStr, " [%s]", stLineOfText);
strcat (stProgressMessage [stProgressMessageHead], myTempStr);
}
stProgressMessageHead = (stProgressMessageHead + 1) % NUM_PROGRESS_MESSAGES;
} // EdFail_AddMessage
void DebugBox( HWND hwnd, char *mes, ... )
{
char buf[512];
wvsprintf( buf, mes, (char *)(&mes+1) );
MessageBox2( hwnd, MB_OK, "�x��", buf );
}
// the same, but who insert a line return
void log_file::printlr(const char * format, ...)
{ va_list va;
va_start(va, format);
wvsprintf(dbg,format,va);
log(dbg,1);
}
//-----------------------------------------------------------------------------
// swTraceWriteBuffer()
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void swTraceWriteBuffer(int iLevel,char *szFunction,unsigned char *pBuffer,int lenBuffer,const char *szTrace, ...)
{
int len;
int i,iBinOffset,iCharOffset;
SYSTEMTIME horodate;
char *psz=gszTraceBuf;
DWORD dw;
if (ghfTrace==INVALID_HANDLE_VALUE) goto end;
if (iLevel>giTraceLevel) goto end;
// fait tourner le fichier si nécessaire
if (GetFileSize(ghfTrace,NULL)>gdwTraceFileSize)
{
SetFilePointer(ghfTrace,0,NULL,FILE_BEGIN);
SetEndOfFile(ghfTrace);
}
// en-tête : horodate + niveau + nom de la fonction
GetLocalTime(&horodate);
len=wsprintf(psz,"%02d/%02d-%02d:%02d:%02d:%03d %s %s ",
(int)horodate.wDay,(int)horodate.wMonth,
(int)horodate.wHour,(int)horodate.wMinute,(int)horodate.wSecond,(int)horodate.wMilliseconds,
swGetTraceLevelLabel(iLevel),szFunction);
// trace
len+=wvsprintf(gszTraceBuf+len,szTrace,(char *)(&szTrace+1));
// retour chariot
memcpy(gszTraceBuf+len,"\r\n\0",3);
len+=2;
WriteFile(ghfTrace,gszTraceBuf,len,&dw,NULL);
// vérif buffer pas NULL
if (pBuffer==NULL)
{
strcpy_s(gszTraceBuf,sizeof(gszTraceBuf),"NULL\r\n");
len=strlen(gszTraceBuf);
WriteFile(ghfTrace,gszTraceBuf,len,&dw,NULL);
goto end;
}
// trace de la longueur
len=wsprintf(gszTraceBuf,"lenBuffer=%d\r\n",lenBuffer);
WriteFile(ghfTrace,gszTraceBuf,len,&dw,NULL);
// préformatage
strcpy_s(gszTraceBuf,sizeof(gszTraceBuf)," | \r\n");
len=strlen(gszTraceBuf);
// trace le contenu du buffer
iBinOffset=0;
iCharOffset=50;
for (i=0;i<lenBuffer;i++)
{
if (i!=0 && (i%16)==0)
{
WriteFile(ghfTrace,gszTraceBuf,len,&dw,NULL);
iBinOffset=0;
iCharOffset=50;
memset(gszTraceBuf,' ',len-2);
}
wsprintf(gszTraceBuf+iBinOffset,"%02x",(unsigned char)(pBuffer[i]));
iBinOffset+=2;
gszTraceBuf[iBinOffset]=' '; // a été écrasé par le 0 du wsprintf
if (pBuffer[i]>=32 && pBuffer[i]<=127)
gszTraceBuf[iCharOffset]=pBuffer[i];
else
gszTraceBuf[iCharOffset]='.';
iBinOffset++;
iCharOffset++;
}
//if ((i%16)!=0) 0.93B6 : visiblement empechait de voir la dernière ligne des buffers multiples de 16 octets !
{
WriteFile(ghfTrace,gszTraceBuf,len,&dw,NULL);
}
end:;
}
/*-----------------------------------------------------------------------
* Function :
* Prototype : void CDebug::printf (const char *fmt, ... )
* Description : Prints formatted string to log-file
* Parameters : const char *fmt - format string
... - list of parameters
* Return : void
* History :
*/
void CDebug::printf (int nLevel, const char* strMod, const char *fmt, ... )
{
DWORD x;
char buf[256];
SYSTEMTIME time;
char buffer[MSG_BUFFER_SIZE];
char buffer2[MSG_BUFFER_SIZE];
va_list arglist;
DWORD dwDiffTime;
if((nLevel < m_nLogLevel) || (nLevel < 0) || !m_bEnabled)
return;
memset(buffer, 0, sizeof(buffer));
memset(buffer2, 0, sizeof(buffer2));
memset(buf, 0, sizeof(buf));
EnterCriticalSection(&m_hLock );
// Do this inside the section in case we have to delete
// the file
CheckFileSize();
// Format string
va_start(arglist, fmt);
wvsprintf(buffer, fmt, arglist);
va_end(arglist);
// Format time stamp
GetLocalTime(&time);
dwDiffTime = GetTickCount() - m_dwStartTime;
SetFilePointer(m_hFile, 0, 0, FILE_END );
// XML Version
if( m_bUseXML )
{
ReplaceXMLChars(buffer, strlen(buffer), buffer2);
wsprintf(buf, "<LINE><ELAPSED>%d.%03d</ELAPSED><DATE>%02d/%02d/%02d</DATE><TIME>%02d:%02d:%02d</TIME>",
dwDiffTime/1000, dwDiffTime%1000,
time.wMonth, time.wDay, time.wYear,
time.wHour, time.wMinute, time.wSecond);
WriteFile(m_hFile, buf, lstrlen(buf), &x, 0 );
wsprintf(buf, "<MODULE>%s</MODULE><MESSAGE>", strMod);
WriteFile(m_hFile, buf, lstrlen(buf), &x, 0 );
if(nLevel == DEBUG_ERROR)
WriteFile(m_hFile, "ERROR - ", 8, &x, 0 );
WriteFile(m_hFile, buffer2, lstrlen(buffer2), &x, 0 );
WriteFile(m_hFile, "</MESSAGE></LINE>", 17, &x, 0 );
}
else
{
wsprintf(buf, "%d.%03d\t%02d/%02d/%02d %02d:%02d:%02d\t%s\t\t",
dwDiffTime/1000, dwDiffTime%1000,
time.wMonth, time.wDay, time.wYear,
time.wHour, time.wMinute, time.wSecond, strMod);
// Write time stamp and formatted string to log-file
WriteFile(m_hFile, buf, lstrlen(buf), &x, 0 );
if(nLevel == DEBUG_ERROR)
WriteFile(m_hFile, "ERROR - ", 8, &x, 0 );
WriteFile(m_hFile, buffer, lstrlen(buffer), &x, 0 );
WriteFile(m_hFile, CrLf, lstrlen(CrLf), &x, 0 );
}
FlushFileBuffers(m_hFile);
LeaveCriticalSection(&m_hLock );
}
