Windows2003-3790/multimedia/directx/dmusic/dmusic16/debug.c
2020-09-30 16:53:55 +02:00

1106 lines
26 KiB
C

//==========================================================================;
//
// Copyright (c) 1991-1999 Microsoft Corporation
//
// You have a royalty-free right to use, modify, reproduce and
// distribute the Sample Files (and/or any modified version) in
// any way you find useful, provided that you agree that
// Microsoft has no warranty obligations or liability for any
// Sample Application Files which are modified.
//
//--------------------------------------------------------------------------;
//
// debug.c
//
// Description:
// This file contains code yanked from several places to provide debug
// support that works in win 16 and win 32.
//
// History:
// 11/23/92 cjp [curtisp]
//
//==========================================================================;
#ifdef DEBUG
#include <windows.h>
#include <windowsx.h>
#include <mmsystem.h>
#include <stdarg.h>
#include "debug.h"
#ifdef WIN32
#define BCODE
#else
#define BCODE __based(__segname("_TEXT"))
#endif
#define WSPRINTF_LIMIT 1024
typedef struct tagLOG
{
LPBYTE lpbQueue;
UINT cbBuffer;
UINT idxRead;
UINT idxWrite;
} LOG, FAR *LPLOG;
#define LOG_INCIDX(pl,x) ((++(x) >= pl->cbBuffer) ? x = 0 : x)
VOID FAR CDECL DbgVPrintF(LPSTR szFmt, LPSTR va) ;
BOOL NEAR PASCAL LogInit(LPLOG lpLog, UINT ckBuffer);
VOID NEAR PASCAL LogWrite(LPLOG lpLog, LPSTR lpstrEvent);
BOOL NEAR PASCAL LogRead(LPLOG lpLog, LPSTR lpstrBuffer, UINT cbBuffer);
#ifdef ISRDEBUG
int wivsprintf(LPSTR lpOut, LPCSTR lpFmt, VOID FAR* lpParms) ;
LPCSTR NEAR PASCAL SP_GetFmtValue(LPCSTR lpch, LPWORD lpw) ;
UINT NEAR PASCAL SP_PutNumber(LPSTR lpb, DWORD n, UINT limit, UINT radix, UINT icase) ;
VOID NEAR PASCAL SP_Reverse(LPSTR lpFirst, LPSTR lpLast) ;
UINT NEAR PASCAL ilstrlen(LPSTR lpstr) ;
VOID NEAR PASCAL ilstrcat(LPSTR lpstrDest, LPSTR lpstrSrc) ;
#endif
//
// since we don't UNICODE our debugging messages, use the ASCII entry
// points regardless of how we are compiled.
//
#define wvsprintfA wvsprintf
#define GetProfileIntA GetProfileInt
#define OutputDebugStringA OutputDebugString
#ifdef ISRDEBUG
#define wvsprintf wivsprintf
#define lstrcatA ilstrcat
#define lstrlenA ilstrlen
#else
#define lstrcatA lstrcat
#define lstrlenA lstrlen
#endif
//
//
//
BOOL __gfDbgEnabled = TRUE; // master enable
UINT __guDbgLevel = 0; // current debug level
BOOL __gfLogging = 0; // Are we logging as well?
BOOL __gfAssertBreak = 0; // Break on assert?
HWND ghWndCB = (HWND)NULL;
LOG gLog;
WORD wDebugLevel = 0;
//************************************************************************
//**
//** DbgAssert();
//**
//** DESCRIPTION:
//**
//**
//** ARGUMENTS:
//** LPSTR lpstrExp
//** LPSTR lpstrFile
//** DWORD dwLine
//**
//** RETURNS:
//** VOID
//**
//** HISTORY:
//**
//************************************************************************
VOID WINAPI DbgAssert(
LPSTR lpstrExp,
LPSTR lpstrFile,
DWORD dwLine)
{
static char BCODE szFormat[] =
"Assert:%s@%lu %s";
dprintf(0, szFormat, lpstrFile, dwLine, lpstrExp);
if (__gfAssertBreak)
DebugBreak();
}
//************************************************************************
//**
//** DbgVPrintF();
//**
//** DESCRIPTION:
//**
//**
//** ARGUMENTS:
//** LPSTR szFmt
//** LPSTR va
//**
//** RETURNS:
//** VOID
//**
//** HISTORY:
//**
//************************************************************************
VOID FAR CDECL DbgVPrintF(
LPSTR szFmt,
LPSTR va)
{
char ach[DEBUG_MAX_LINE_LEN];
BOOL fDebugBreak = FALSE;
BOOL fPrefix = TRUE;
BOOL fCRLF = TRUE;
ach[0] = '\0';
for (;;)
{
switch(*szFmt)
{
case '!':
fDebugBreak = TRUE;
szFmt++;
continue;
case '`':
fPrefix = FALSE;
szFmt++;
continue;
case '~':
fCRLF = FALSE;
szFmt++;
continue;
}
break;
}
if (fDebugBreak)
{
ach[0] = '\007';
ach[1] = '\0';
}
if (fPrefix)
lstrcatA(ach, DEBUG_MODULE_NAME ": ");
wvsprintfA(ach + lstrlenA(ach), szFmt, (LPSTR)va);
if (fCRLF)
lstrcatA(ach, "\r\n");
if (__gfLogging)
{
LogWrite(&gLog, ach);
if (ghWndCB)
PostMessage(ghWndCB, WM_DEBUGUPDATE, 0, 0);
}
OutputDebugStringA(ach);
if (fDebugBreak)
DebugBreak();
} //** DbgVPrintF()
//************************************************************************
//**
//** dprintf();
//**
//** DESCRIPTION:
//** dprintf() is called by the DPF macro if DEBUG is defined at compile
//** time.
//**
//** The messages will be send to COM1: like any debug message. To
//** enable debug output, add the following to WIN.INI :
//**
//** [debug]
//** ICSAMPLE=1
//**
//**
//** ARGUMENTS:
//** UINT uDbgLevel
//** LPCSTR szFmt
//** ...
//**
//** RETURNS:
//** VOID
//**
//** HISTORY:
//** 06/12/93 [t-kyleb]
//**
//************************************************************************
VOID FAR CDECL dprintf(
UINT uDbgLevel,
LPSTR szFmt,
...)
{
va_list va;
if (!__gfDbgEnabled || (__guDbgLevel < uDbgLevel))
return;
va_start(va, szFmt);
DbgVPrintF(szFmt, (LPSTR)va);
va_end(va);
} //** dprintf()
//************************************************************************
//**
//** DbgEnable();
//**
//** DESCRIPTION:
//**
//**
//** ARGUMENTS:
//** BOOL fEnable
//**
//** RETURNS:
//** BOOL
//**
//** HISTORY:
//** 06/12/93 [t-kyleb]
//**
//************************************************************************
BOOL WINAPI DbgEnable(
BOOL fEnable)
{
BOOL fOldState;
fOldState = __gfDbgEnabled;
__gfDbgEnabled = fEnable;
return (fOldState);
} //** DbgEnable()
//************************************************************************
//**
//** DbgSetLevel();
//**
//** DESCRIPTION:
//**
//**
//** ARGUMENTS:
//** UINT uLevel
//**
//** RETURNS:
//** UINT
//**
//** HISTORY:
//** 06/12/93 [t-kyleb]
//**
//************************************************************************
UINT WINAPI DbgSetLevel(
UINT uLevel)
{
UINT uOldLevel;
uOldLevel = __guDbgLevel;
__guDbgLevel = wDebugLevel = uLevel;
return (uOldLevel);
} //** DbgSetLevel()
//--------------------------------------------------------------------------;
//
// UINT DbgInitialize(VOID)
//
// Description:
//
//
// Arguments:
//
// Return (UINT):
//
//
// History:
// 11/24/92 cjp [curtisp]
//
//--------------------------------------------------------------------------;
UINT WINAPI DbgInitialize(BOOL fEnable)
{
char szTemp[64];
LPSTR pstr;
UINT uLevel;
UINT uLogMem;
__gfAssertBreak = GetProfileInt(DEBUG_SECTION, ASSERT_BREAK, 0);
GetProfileString(DEBUG_SECTION, DEBUG_MODULE_NAME, "", szTemp, sizeof(szTemp));
pstr = szTemp;
uLevel = 0;
while (*pstr >= '0' && *pstr <= '9')
{
uLevel = uLevel*10 + (UINT)(*pstr - '0');
pstr++;
}
__gfLogging = FALSE;
if (*pstr == ',')
{
pstr++;
uLogMem = 0;
while (*pstr >= '0' && *pstr <= '9')
{
uLogMem = uLogMem*10 + (UINT)(*pstr - '0');
pstr++;
}
if (0 == uLogMem) uLogMem = K_DEFAULT_LOGMEM;
if (uLogMem > K_MAX_LOGMEM) uLogMem = K_MAX_LOGMEM;
__gfLogging = TRUE;
}
if (__gfLogging)
__gfLogging = LogInit(&gLog, uLogMem);
DbgSetLevel(GetProfileIntA(DEBUG_SECTION, DEBUG_MODULE_NAME, 0));
DbgEnable(fEnable);
return (__guDbgLevel);
} // DbgInitialize()
VOID WINAPI DbgRegisterCallback(HWND hWnd)
{
ghWndCB = hWnd;
}
BOOL WINAPI DbgGetNextLogEntry(LPSTR lpstrBuffer, UINT cbBuffer)
{
if (!__gfLogging)
return FALSE;
return LogRead(&gLog, lpstrBuffer, cbBuffer);
}
BOOL NEAR PASCAL LogInit(LPLOG lpLog, UINT ckMem)
{
DWORD cbMem;
cbMem = 1024L * ckMem;
lpLog->lpbQueue = GlobalAllocPtr(GPTR, cbMem);
if (NULL == lpLog->lpbQueue)
return FALSE;
if (!GlobalSmartPageLock(HIWORD(lpLog->lpbQueue)))
{
GlobalFreePtr(lpLog->lpbQueue);
return FALSE;
}
lpLog->cbBuffer = (UINT)cbMem;
lpLog->idxRead = 0;
lpLog->idxWrite = 0;
return TRUE;
}
VOID NEAR PASCAL LogWrite(LPLOG lpLog, LPSTR lpstrEvent)
{
if (!*lpstrEvent)
return;
while (*lpstrEvent)
{
lpLog->lpbQueue[lpLog->idxWrite] = *lpstrEvent++;
LOG_INCIDX(lpLog,lpLog->idxWrite);
}
lpLog->idxRead = lpLog->idxWrite;
while (lpLog->lpbQueue[lpLog->idxRead])
{
lpLog->lpbQueue[lpLog->idxRead] = '\0';
LOG_INCIDX(lpLog,lpLog->idxRead);
}
LOG_INCIDX(lpLog,lpLog->idxRead);
LOG_INCIDX(lpLog,lpLog->idxWrite);
}
BOOL NEAR PASCAL LogRead(LPLOG lpLog, LPSTR lpstrBuffer, UINT cbBuffer)
{
BYTE c;
UINT idx;
if (!cbBuffer)
return FALSE;
idx = lpLog->idxRead;
while ('\0' == lpLog->lpbQueue[idx])
{
LOG_INCIDX(lpLog,idx);
if (idx == lpLog->idxRead)
return FALSE;
}
cbBuffer--;
while (0 != (c = lpLog->lpbQueue[idx]))
{
if (cbBuffer)
{
*lpstrBuffer++ = c;
cbBuffer--;
}
lpLog->lpbQueue[idx] = '\0';
LOG_INCIDX(lpLog,idx);
}
*lpstrBuffer = '\0';
LOG_INCIDX(lpLog,idx);
lpLog->idxRead = idx;
return TRUE;
}
//--------------------------------------------------------------------------;
//
// The rest of the code is only needed if we're in Win16 and need to be
// interrupt callable.
//
//--------------------------------------------------------------------------;
#ifdef ISRDEBUG
#define OUT(ch) if (--cchLimit) *lpOut++=(ch); else goto error_Out
//************************************************************************
//**
//** wivsprintf();
//**
//** DESCRIPTION:
//** Interrupt callable version of wvsprintf()
//**
//**
//** ARGUMENTS:
//** LPSTR lpOut - Buffer to format into.
//** LPCSTR lpFmt - Format string.
//** VOID FAR* lpParms - Points to the first of args
//** described by lpFmt.
//**
//** RETURNS:
//** int - Number of characters stored.
//**
//** HISTORY:
//** 3/28/93 jfg [jimge]
//**
//************************************************************************
int wivsprintf(
LPSTR lpOut,
LPCSTR lpFmt,
VOID FAR* lpParms)
{
int left ;
char prefix ;
int width ;
int prec ;
char fillch ;
int size ;
int sign ;
int radix ;
int upper ;
int cchLimit = WSPRINTF_LIMIT;
int cch ;
LPSTR lpT ;
union
{
long l ;
unsigned long ul ;
char sz[sizeof(long)] ;
} val;
while (*lpFmt)
{
if (*lpFmt=='%')
{
//
// Read the format flags.
//
left = 0 ;
prefix = 0 ;
while (*++lpFmt)
{
if (*lpFmt=='-')
{
left++;
}
else if (*lpFmt=='#')
{
prefix++;
}
else
{
break;
}
}
//
// Find the fill character (either '0' or ' ')
//
if (*lpFmt=='0')
{
fillch = '0' ;
lpFmt++ ;
}
else
{
fillch = ' ' ;
}
//
// Now parse [width[.precision]]
//
lpFmt = SP_GetFmtValue(lpFmt,&cch);
width = cch;
if (*lpFmt=='.')
{
lpFmt = SP_GetFmtValue(++lpFmt,&cch);
prec = cch;
}
else
{
prec = (UINT)-1 ;
}
//
// Get the operand size modifier
//
if (*lpFmt=='l')
{
size = 1 ;
lpFmt++ ;
}
else
{
size = 0 ;
if (*lpFmt=='h')
{
lpFmt++ ;
}
}
//
// We've gotten all the modifier; now format the output
// based on the type (which should now be pointed at
// by lpFmt).
//
upper = 0 ;
sign = 0 ;
radix = 10 ;
switch (*lpFmt)
{
case 0:
goto error_Out ;
case 'i' :
case 'd' :
sign++ ;
case 'u':
//
// Don't show a prefix for decimal formats
//
prefix=0 ;
do_Numeric:
//
// Special cases to act like MSC v5.10
//
if (left || prec>=0)
{
fillch = ' ';
}
//
// Get value from parm list into val union
//
if (size)
{
val.l=*((long far *)lpParms)++;
}
else
{
if (sign)
{
val.l=(long)*((short far *)lpParms)++;
}
else
{
val.ul=(unsigned long)*((unsigned far *)lpParms)++;
}
}
//
// Save sign of val.l in sign and set val.l positive.
//
if (sign && val.l<0L)
{
val.l=-val.l;
}
else
{
sign=0;
}
//
// Save start of output stream for later reverse
//
lpT = lpOut;
//
// Blast the number backwards into the user buffer
//
cch = SP_PutNumber(lpOut,val.l,cchLimit,radix,upper) ;
if (!(cchLimit-=cch))
goto error_Out ;
lpOut += cch ;
width -= cch ;
prec -= cch ;
if (prec>0)
{
width -= prec ;
}
//
// Fill in up to precision
//
while (prec-- > 0)
{
OUT('0') ;
}
if (width>0 && !left)
{
//
// If we're filling with spaces, put sign first
//
if (fillch != '0')
{
if (sign)
{
sign = 0 ;
OUT('-') ;
width-- ;
}
if (prefix)
{
OUT(prefix) ;
OUT('0') ;
prefix = 0 ;
}
}
if (sign)
{
width-- ;
}
//
// Now fill to width
//
while (width-- > 0)
{
OUT(fillch) ;
}
//
// Still have a sign?
//
if (sign)
{
OUT('-') ;
}
if (prefix)
{
OUT(prefix) ;
OUT('0') ;
}
//
// Now reverse the string in place
//
SP_Reverse(lpT,lpOut-1);
}
else
{
//
// Add the sign character
//
if (sign)
{
OUT('-') ;
width-- ;
}
if (prefix)
{
OUT(prefix);
OUT('0');
}
//
// Now reverse the string in place
//
SP_Reverse(lpT,lpOut-1);
//
// Pad to the right of the string in case left aligned
//
while (width-- > 0)
{
OUT(fillch) ;
}
}
break ;
case 'X':
upper++ ;
//
// Falling through...
//
case 'x':
radix=16 ;
if (prefix)
{
prefix = upper ? 'X' : 'x' ;
}
goto do_Numeric ;
case 'c':
//
// Save as one character string and join common code
//
val.sz[0] = *((char far*)lpParms) ;
val.sz[1]=0 ;
lpT = val.sz ;
cch = 1 ;
(BYTE far*)lpParms += sizeof(WORD) ;
goto put_String ;
case 's':
lpT = *((LPSTR FAR *)lpParms)++ ;
cch = ilstrlen(lpT) ;
put_String:
if (prec>=0 && cch>prec)
{
cch = prec ;
}
width -= cch ;
if (left)
{
while (cch--)
{
OUT(*lpT++) ;
}
while (width-->0)
{
OUT(fillch) ;
}
}
else
{
while (width-- > 0)
{
OUT(fillch) ;
}
while (cch--)
{
OUT(*lpT++) ;
}
}
break ;
default:
//
// An unsupported type character was given. We just
// print the character and go on.
//
OUT(*lpFmt) ;
break ;
} // switch(*lpfmt)
} // if (*lpfmt == '%')
else
{
//
// Normal not-format character
//
OUT(*lpFmt) ;
}
lpFmt++ ;
} // while (*lpFmt)
error_Out:
*lpOut = 0 ;
return WSPRINTF_LIMIT-cchLimit ;
} //** wivsprintf()
//************************************************************************
//**
//** SP_GetFmtValue();
//**
//** DESCRIPTION:
//** Parse a decimal integer forming part of a format string.
//**
//**
//** ARGUMENTS:
//** LPCSTR lpch - Points to the string to parse.
//** LPWORD lpw - Points to a word where the value will be
//** returned.
//**
//** RETURNS:
//** LPCSTR - Pointer of first character past the format value.
//**
//** HISTORY:
//** 3/28/93 jfg [jimge]
//**
//************************************************************************
LPCSTR NEAR PASCAL SP_GetFmtValue(
LPCSTR lpch,
LPWORD lpw)
{
WORD i = 0 ;
while (*lpch>='0' && *lpch<='9')
{
i *= 10;
i += (UINT)(*lpch++-'0');
}
*lpw = i;
return(lpch);
} //** SP_GetFmtValue()
//************************************************************************
//**
//** SP_PutNumber();
//**
//** DESCRIPTION:
//** Formats the given number in the given radix into the buffer
//** *backwards*. The entire string will be reversed after printf
//** has added sign, prefix, etc. to it.
//**
//**
//** ARGUMENTS:
//** LPSTR lpb - Points to the output buffer.
//** DWORD n - Number to convert.
//** UINT limit - Maximum number of characters to store.
//** UINT radix - Base to format in.
//** UINT icase - Non-zero if the string should be upper case (hex).
//**
//** RETURNS:
//** UINT - Number of characters output.
//**
//** HISTORY:
//**
//************************************************************************
UINT NEAR PASCAL SP_PutNumber(
LPSTR lpb,
DWORD n,
UINT limit,
UINT radix,
UINT icase)
{
BYTE bTemp;
UINT cchStored = 0;
//
// Set icase to the offset to add to the character if it
// represents a value > 10
//
icase = (icase ? 'A' : 'a') - '0' - 10 ;
while (limit--)
{
//
// AVOID a call to __aFulrem
// This code words because radix is only a word
//
// bTemp = '0' + (BYTE)(n%radix) ;
//
_asm
{
mov cx, radix
mov ax, word ptr n+2
xor dx, dx
div cx
mov ax, word ptr n
div cx
add dl, '0'
mov bTemp, dl
}
if (bTemp > '9')
{
bTemp += icase ;
}
*lpb++ = bTemp ;
++cchStored ;
//
// AVOID a call to __aFFauldiv
// This code words because radix is only a word
//
// n /= radix
//
_asm
{
push bx
mov cx, radix
mov ax, word ptr n+2
xor dx, dx
div cx
mov bx, ax
mov ax, word ptr n
div cx
mov word ptr n+2, bx
mov word ptr n, ax
pop bx
}
if (n == 0)
{
break ;
}
}
return cchStored ;
} //** SP_PutNumber()
//************************************************************************
//**
//** SP_Reverse();
//**
//** DESCRIPTION:
//** Reverse string in place.
//**
//** ARGUMENTS:
//** LPSTR pFirst
//** LPSTR pLast
//**
//** RETURNS:
//** VOID
//**
//** HISTORY:
//**
//************************************************************************
VOID NEAR PASCAL SP_Reverse(
LPSTR pFirst,
LPSTR pLast)
{
UINT uSwaps = (pLast - pFirst + 1) / 2;
BYTE bTemp;
while (uSwaps--)
{
bTemp = *pFirst;
*pFirst = *pLast;
*pLast = bTemp;
pFirst++, pLast--;
}
} //** SP_Reverse()
//************************************************************************
//**
//** ilstrlen();
//**
//** DESCRIPTION:
//** Interrupt callable version of strlen().
//**
//** ARGUMENTS:
//** LPSTR pstr
//**
//** RETURNS:
//** UINT
//**
//** HISTORY:
//**
//************************************************************************
UINT NEAR PASCAL ilstrlen(
LPSTR pstr)
{
UINT cch = 0 ;
while (*pstr++)
++cch;
return(cch);
} //** ilstrlen()
//************************************************************************
//**
//** ilstrcat();
//**
//** DESCRIPTION:
//** Interrupt callable version of lstrcat().
//**
//** ARGUMENTS:
//** LPSTR pstrDest
//** LPSTR pstrSrc
//**
//** RETURNS:
//** VOID
//**
//** HISTORY:
//**
//************************************************************************
VOID NEAR PASCAL ilstrcat(
LPSTR pstrDest,
LPSTR pstrSrc)
{
while (*pstrDest)
pstrDest++;
while (*pstrDest++ = *pstrSrc++)
;
} //** ilstrcat()
#endif // #ifdef ISRDEBUG
#endif // #ifdef DEBUG