vwemirror/TeslaRel410
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
110ecec2ca3edc135e260e0f3ee07e7945cbf4ec
TeslaRel410/BORLAND/BC45/SOURCE/OCF/BOCOLE/OLEDEBUG.CPP
T
CydandClaude Fable 5 63312e07f9 source410: literal 4.10 source reconstruction + BC++ 4.52 fleet toolchain archived 
- BORLAND/: Borland C++ 4.52 (chosen over 4.5 by byte-match: CODE/RP/CW32.LIB
  is identical to 4.52's install lib). BCC32/TLINK32/TLIB/MAKE run natively on
  Win11; CODE/BT/OPT.MAK is the shipped BTL4OPT.EXE's exact flag recipe
  (extender = Borland PowerPack DPMI32, not Phar Lap TNT).
- restoration/source410/: the literal 1995-form reconstruction of the missing
  BT game source (never mixed into CODE/). Round 1-3 state:
  * 6 of 10 surviving original TUs COMPILE CLEAN under the period toolchain
    (BTMSSN, BTCNSL, BTSCNRL, BTTEAM, BTL4MODE, BTL4ARND) - first builds
    since 1996.
  * BT_L4/BTL4APP.CPP pilot reconstruction: 12/12 functions, Fail() lands on
    its binary-recorded line 400 exactly.
  * BT/BTCNSL.HPP: console wire IDs recovered from the binary's ctors
    (Killed=9, Damaged=10, ScoreUpdate=13, DeathWithoutHonor=15 [T1];
    TeamScore=12 flagged [T4]).
  * MUNGA/: 8 engine-header backfills back-dated from the BT412 WinTesla tree
    (VDATA numbering decomp-verified; AUDREND's OpenAL-era virtual removed -
    the period compiler is the drift detector).
  * Tooling: backdate.py (WinTesla->1995 header transform), compile410.sh
    (per-TU verification sweep under authentic OPT.MAK flags).
  * README: corrected roadmap - MECH.HPP is the capstone grown with the mech
    TU reconstructions; BTREG.CPP green = the header-family milestone.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-19 07:33:26 -05:00

1490 lines
41 KiB
C++
Raw Blame History

//
//**************************************************************************
//
// OleDebug.cpp -- Some debugging utilities for getting symbolic output
// from the OLE2 error codes and enums
//
// Copyright (c) 1993,94 by Borland International, Inc. All rights reserved
//
//**************************************************************************
#include <BOle.h>
#include <Olestd.h>
#include <OleDebug.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
OLEDBGDATA;
#undef OleDbgOutHResult(lpsz, hr)
#define OleDbgOutHResult(lpsz,hr) \
OleDbgPrintScodeAlways(g_szDbgPrefix,lpsz,GetScode(hr))
#define BUFFERSIZE 200
STDAPI_(void) OleDbgPrintScodeAlways(LPSTR lpszPrefix, LPSTR lpszMsg, SCODE sc);
#ifdef OLEDBG
static WORD level = 0;
char * cDebug::prepareBuf (char * pB)
{
for (int i=0;i<level;i++) {
*pB++ = '-';
*pB++ = '-';
}
return pB;
}
void cDebug::DebugEnter(char * dc, char * df, LPOLESTR s)
{
if (DebugMode) {
char buf [BUFFERSIZE];
if (s)
wsprintf (prepareBuf(buf),"Enter %s::%s of object %s\n\r", dc, df, s);
else
wsprintf (prepareBuf(buf),"Enter %s::%s\n\r", dc, df);
OleDbgOut (buf);
}
level++;
}
SCODE cDebug::DebugReturn(char * dc, char * df, SCODE sc)
{
if (level)
level--;
if (DebugMode) {
char buf [BUFFERSIZE];
wsprintf (prepareBuf(buf),"Leave %s::%s with ", dc, df);
OleDbgOutScode (buf, sc);
}
return sc;
}
HRESULT cDebug::DebugReturn(char * dc, char * df, HRESULT hrErr)
{
if (level)
level--;
if (DebugMode) {
char buf [BUFFERSIZE];
wsprintf (prepareBuf(buf),"Leave %s::%s with ", dc, df);
OleDbgOutHResult (buf, hrErr);
}
return hrErr;
}
BOOL cDebug::DebugReturn(char * dc, char * df, BOOL f)
{
if (level)
level--;
if (DebugMode) {
char buf [BUFFERSIZE];
wsprintf (prepareBuf(buf),"Leave %s::%s with %s", dc, df, f ? "TRUE" : "FALSE");
OleDbgOut (buf);
}
return f;
}
void cDebug::DebugReturn(char * dc, char * df, REFIID iid, void * P)
{
if (level)
level--;
if (DebugMode) {
char buf [BUFFERSIZE];
wsprintf (prepareBuf(buf),"Leave %s::%s with pointer %08lX", dc, df, P);
OleDbgOut (buf);
}
}
ULONG cDebug::DebugReturn (char * dc, char * df, LPOLESTR s, ULONG r)
{
if (level)
level--;
if (DebugMode) {
char buf [BUFFERSIZE];
wsprintf (prepareBuf(buf),"Refcount in %s::%s for object %s - %ld\n\r", dc, df, s, r);
OleDbgOut (buf);
}
return r;
}
void cDebug::DebugExit (char * dc, char * df)
{
if (level)
level--;
if (DebugMode) {
char buf [BUFFERSIZE];
wsprintf (prepareBuf(buf),"Exit %s:%s\n\r", dc, df);
OleDbgOut (buf);
}
}
HRESULT cDebug::DebugHResult (LPOLESTR s, HRESULT hrErr)
{
if (DebugMode) {
char buf [BUFFERSIZE];
wsprintf (prepareBuf(buf),"%s ", s);
OleDbgOutHResult (buf, hrErr);
}
return hrErr;
}
ULONG cDebug::DebugRefCnt (LPOLESTR s, ULONG r)
{
if (DebugMode) {
char buf [BUFFERSIZE];
wsprintf (prepareBuf(buf),"Refcount for object %s - %ld\n\r", s, r);
OleDbgOut (buf);
}
return r;
}
void cdecl cDebug::DebugPrintf (LPOLESTR s, ...)
{
va_list paramList;
va_start (paramList, s);
if (DebugMode) {
char buf1 [BUFFERSIZE];
vsprintf (buf1, s, paramList);
char buf [BUFFERSIZE];
wsprintf (prepareBuf(buf), "%s\n\r", buf1);
OleDbgOut (buf);
}
va_end (paramList);
}
void cDebug::DebugPrint (LPOLESTR pS, const RECT FAR * pR)
{
if (DebugMode) {
char buf [BUFFERSIZE];
if (pR) {
if (pS)
wsprintf (prepareBuf(buf), "%s %04X %04X %04X %04X\n\r", pS, pR->left, pR->top, pR->right, pR->bottom);
else
wsprintf (prepareBuf(buf), "%04X %04X %04X %04X\n\r", pR->left, pR->top, pR->right, pR->bottom);
}
else {
if (pS)
wsprintf (prepareBuf(buf), "%s\n\r", pS);
else
wsprintf (prepareBuf(buf), "\n\r");
}
OleDbgOut (buf);
}
}
void cDebug::DebugPrint (LPOLESTR pS, const SIZEL FAR * pL)
{
if (DebugMode) {
char buf [BUFFERSIZE];
if (pS)
wsprintf (prepareBuf(buf), "%s %08lX %08lX\n\r", pS, pL->cx, pL->cy);
else
wsprintf (prepareBuf(buf), "%08lX %08lX\n\r", pL->cx, pL->cy);
OleDbgOut (buf);
}
}
void cDebug::DebugPrint (LPOLESTR pS, BOOL f)
{
if (DebugMode) {
char buf [BUFFERSIZE];
if (pS)
wsprintf (prepareBuf(buf), "%s %s\n\r", pS, f ? "TRUE" : "FALSE");
else
wsprintf (prepareBuf(buf), "%s\n\r", f ? "TRUE" : "FALSE");
OleDbgOut (buf);
}
}
void cDebug::DebugPrint (REFIID riid)
{
#if 0
if (DebugMode) {
char buf [BUFFERSIZE];
char * P = prepareBuf (buf);
LPOLESTR * ppC = 0;
if (StringFromIID(riid, ppC) == NOERROR)
strcpy (P, *ppC);
else if (StringFromCLSID(riid, ppC) != NOERROR)
strcpy (P, *ppC);
else
wsprintf (P, "IID not recog 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2, riid.Data3);
OleDbgOut (buf);
}
#else
if (DebugMode) {
char buf [BUFFERSIZE];
if (riid == IID_IUnknown)
{
wsprintf (prepareBuf(buf), "IID = IID_IUnknown 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IClassFactory)
{
wsprintf (prepareBuf(buf), "IID = IID_IClassFactory 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IMalloc)
{
wsprintf (prepareBuf(buf), "IID = IID_IMalloc 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IMarshal)
{
wsprintf (prepareBuf(buf), "IID = IID_IMarshal 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IRpcChannel)
{
wsprintf (prepareBuf(buf), "IID = IID_IRpcChannel 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IRpcStub)
{
wsprintf (prepareBuf(buf), "IID = IID_IRpcStub 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IStubManager)
{
wsprintf (prepareBuf(buf), "IID = IID_IStubManager 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IRpcProxy)
{
wsprintf (prepareBuf(buf), "IID = IID_IRpcProxy 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IProxyManager)
{
wsprintf (prepareBuf(buf), "IID = IID_IProxyManager 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IPSFactory)
{
wsprintf (prepareBuf(buf), "IID = IID_IPSFactory 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_ILockBytes)
{
wsprintf (prepareBuf(buf), "IID = IID_ILockBytes 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IStorage)
{
wsprintf (prepareBuf(buf), "IID = IID_IStorage 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IStream)
{
wsprintf (prepareBuf(buf), "IID = IID_IStream 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IEnumSTATSTG)
{
wsprintf (prepareBuf(buf), "IID = IID_IEnumSTATSTG 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IBindCtx)
{
wsprintf (prepareBuf(buf), "IID = IID_IBindCtx 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IMoniker)
{
wsprintf (prepareBuf(buf), "IID = IID_IMoniker 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IRunningObjectTable)
{
wsprintf (prepareBuf(buf), "IID = IID_IRunningObjectTable 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IInternalMoniker)
{
wsprintf (prepareBuf(buf), "IID = IID_IInternalMoniker 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IRootStorage)
{
wsprintf (prepareBuf(buf), "IID = IID_IRootStorage 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IDfReserved1)
{
wsprintf (prepareBuf(buf), "IID = IID_IDfReserved1 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IDfReserved2)
{
wsprintf (prepareBuf(buf), "IID = IID_IDfReserved2 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IDfReserved3)
{
wsprintf (prepareBuf(buf), "IID = IID_IDfReserved3 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IMessageFilter)
{
wsprintf (prepareBuf(buf), "IID = IID_IMessageFilter 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
#ifdef INCLUDE_IDISPATCH
if (riid == IID_IDispatch)
{
wsprintf (prepareBuf(buf), "IID = IID_IDispatch 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_ITypeInfo)
{
wsprintf (prepareBuf(buf), "IID = IID_ITypeInfo 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_ITypeLib)
{
wsprintf (prepareBuf(buf), "IID = IID_ITypeLib 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_ITypeComp)
{
wsprintf (prepareBuf(buf), "IID = IID_ITypeComp 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IEnumVARIANT)
{
wsprintf (prepareBuf(buf), "IID = IID_IEnumVARIANT 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
#endif // INCLUDE_IDISPATCH
if (riid == IID_IEnumUnknown)
{
wsprintf (prepareBuf(buf), "IID = IID_IEnumUnknown 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IEnumString)
{
wsprintf (prepareBuf(buf), "IID = IID_IEnumString 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IEnumMoniker)
{
wsprintf (prepareBuf(buf), "IID = IID_IEnumMoniker 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IEnumFORMATETC)
{
wsprintf (prepareBuf(buf), "IID = IID_IEnumFORMATETC 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IEnumOLEVERB)
{
wsprintf (prepareBuf(buf), "IID = IID_IEnumOLEVERB 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IEnumSTATDATA)
{
wsprintf (prepareBuf(buf), "IID = IID_IEnumSTATDATA 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IEnumGeneric)
{
wsprintf (prepareBuf(buf), "IID = IID_IEnumGeneric 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IEnumHolder)
{
wsprintf (prepareBuf(buf), "IID = IID_IEnumHolder 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IEnumCallback)
{
wsprintf (prepareBuf(buf), "IID = IID_IEnumCallback 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IPersistStream)
{
wsprintf (prepareBuf(buf), "IID = IID_IPersistStream 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IPersistStorage)
{
wsprintf (prepareBuf(buf), "IID = IID_IPersistStorage 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IPersistFile)
{
wsprintf (prepareBuf(buf), "IID = IID_IPersistFile 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IPersist)
{
wsprintf (prepareBuf(buf), "IID = IID_IPersist 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IViewObject)
{
wsprintf (prepareBuf(buf), "IID = IID_IViewObject 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IDataObject)
{
wsprintf (prepareBuf(buf), "IID = IID_IDataObject 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IAdviseSink)
{
wsprintf (prepareBuf(buf), "IID = IID_IAdviseSink 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IDataAdviseHolder)
{
wsprintf (prepareBuf(buf), "IID = IID_IDataAdviseHolder 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IOleAdviseHolder)
{
wsprintf (prepareBuf(buf), "IID = IID_IOleAdviseHolder 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IOleObject)
{
wsprintf (prepareBuf(buf), "IID = IID_IOleObject 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IOleInPlaceObject)
{
wsprintf (prepareBuf(buf), "IID = IID_IOleInPlaceObject 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IOleWindow)
{
wsprintf (prepareBuf(buf), "IID = IID_IOleWindow 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IOleInPlaceUIWindow)
{
wsprintf (prepareBuf(buf), "IID = IID_IOleInPlaceUIWindow 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IOleInPlaceFrame)
{
wsprintf (prepareBuf(buf), "IID = IID_IOleInPlaceFrame 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IOleInPlaceActiveObject)
{
wsprintf (prepareBuf(buf), "IID = IID_IOleInPlaceActiveObject 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IOleClientSite)
{
wsprintf (prepareBuf(buf), "IID = IID_IOleClientSite 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IOleInPlaceSite)
{
wsprintf (prepareBuf(buf), "IID = IID_IOleInPlaceSite 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IParseDisplayName)
{
wsprintf (prepareBuf(buf), "IID = IID_IParseDisplayName 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IOleContainer)
{
wsprintf (prepareBuf(buf), "IID = IID_IOleContainer 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IOleItemContainer)
{
wsprintf (prepareBuf(buf), "IID = IID_IOleItemContainer 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IOleLink)
{
wsprintf (prepareBuf(buf), "IID = IID_IOleLink 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IOleCache)
{
wsprintf (prepareBuf(buf), "IID = IID_IOleCache 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IOleManager)
{
wsprintf (prepareBuf(buf), "IID = IID_IOleManager 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IOlePresObj)
{
wsprintf (prepareBuf(buf), "IID = IID_IOlePresObj 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IDropSource)
{
wsprintf (prepareBuf(buf), "IID = IID_IDropSource 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IDropTarget)
{
wsprintf (prepareBuf(buf), "IID = IID_IDropTarget 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IDebug)
{
wsprintf (prepareBuf(buf), "IID = IID_IDebug 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
if (riid == IID_IDebugStream)
{
wsprintf (prepareBuf(buf), "IID = IID_IDebugStream 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
goto ll_return;
}
wsprintf (prepareBuf(buf), " IID not recog 0x%lx.%x.%x\n\r", riid.Data1, riid.Data2,
riid.Data3);
ll_return:
OleDbgOut (buf);
}
#endif
}
#define CASE_SCODE(sc) \
case sc: \
lstrcpy((LPSTR)szErrName, (LPSTR)#sc); \
break;
STDAPI_(void) OleDbgPrintScodeAlways(LPSTR lpszPrefix, LPSTR lpszMsg, SCODE sc)
{
char szBuf[256];
char szErrName[40];
switch (sc) {
/* SCODE's defined in SCODE.H */
CASE_SCODE(S_OK)
CASE_SCODE(S_FALSE)
CASE_SCODE(E_UNEXPECTED)
CASE_SCODE(E_OUTOFMEMORY)
CASE_SCODE(E_INVALIDARG)
CASE_SCODE(E_NOINTERFACE)
CASE_SCODE(E_POINTER)
CASE_SCODE(E_HANDLE)
CASE_SCODE(E_ABORT)
CASE_SCODE(E_FAIL)
CASE_SCODE(E_ACCESSDENIED)
/* SCODE's defined in OLE2.H */
CASE_SCODE(OLE_E_OLEVERB)
CASE_SCODE(OLE_E_ADVF)
CASE_SCODE(OLE_E_ENUM_NOMORE)
CASE_SCODE(OLE_E_ADVISENOTSUPPORTED)
CASE_SCODE(OLE_E_NOCONNECTION)
CASE_SCODE(OLE_E_NOTRUNNING)
CASE_SCODE(OLE_E_NOCACHE)
CASE_SCODE(OLE_E_BLANK)
CASE_SCODE(OLE_E_CLASSDIFF)
CASE_SCODE(OLE_E_CANT_GETMONIKER)
CASE_SCODE(OLE_E_CANT_BINDTOSOURCE)
CASE_SCODE(OLE_E_STATIC)
CASE_SCODE(OLE_E_PROMPTSAVECANCELLED)
CASE_SCODE(OLE_E_INVALIDRECT)
CASE_SCODE(OLE_E_WRONGCOMPOBJ)
CASE_SCODE(OLE_E_INVALIDHWND)
CASE_SCODE(OLE_E_NOT_INPLACEACTIVE)
CASE_SCODE(OLE_E_CANTCONVERT)
CASE_SCODE(OLE_E_NOSTORAGE)
CASE_SCODE(DV_E_FORMATETC)
CASE_SCODE(DV_E_DVTARGETDEVICE)
CASE_SCODE(DV_E_STGMEDIUM)
CASE_SCODE(DV_E_STATDATA)
CASE_SCODE(DV_E_LINDEX)
CASE_SCODE(DV_E_TYMED)
CASE_SCODE(DV_E_CLIPFORMAT)
CASE_SCODE(DV_E_DVASPECT)
CASE_SCODE(DV_E_DVTARGETDEVICE_SIZE)
CASE_SCODE(DV_E_NOIVIEWOBJECT)
CASE_SCODE(OLE_S_USEREG)
CASE_SCODE(OLE_S_STATIC)
CASE_SCODE(OLE_S_MAC_CLIPFORMAT)
CASE_SCODE(CONVERT10_E_OLESTREAM_GET)
CASE_SCODE(CONVERT10_E_OLESTREAM_PUT)
CASE_SCODE(CONVERT10_E_OLESTREAM_FMT)
CASE_SCODE(CONVERT10_E_OLESTREAM_BITMAP_TO_DIB)
CASE_SCODE(CONVERT10_E_STG_FMT)
CASE_SCODE(CONVERT10_E_STG_NO_STD_STREAM)
CASE_SCODE(CONVERT10_E_STG_DIB_TO_BITMAP)
CASE_SCODE(CONVERT10_S_NO_PRESENTATION)
CASE_SCODE(CLIPBRD_E_CANT_OPEN)
CASE_SCODE(CLIPBRD_E_CANT_EMPTY)
CASE_SCODE(CLIPBRD_E_CANT_SET)
CASE_SCODE(CLIPBRD_E_BAD_DATA)
CASE_SCODE(CLIPBRD_E_CANT_CLOSE)
CASE_SCODE(DRAGDROP_E_NOTREGISTERED)
CASE_SCODE(DRAGDROP_E_ALREADYREGISTERED)
CASE_SCODE(DRAGDROP_E_INVALIDHWND)
CASE_SCODE(DRAGDROP_S_DROP)
CASE_SCODE(DRAGDROP_S_CANCEL)
CASE_SCODE(DRAGDROP_S_USEDEFAULTCURSORS)
CASE_SCODE(OLEOBJ_E_NOVERBS)
CASE_SCODE(OLEOBJ_E_INVALIDVERB)
CASE_SCODE(OLEOBJ_S_INVALIDVERB)
CASE_SCODE(OLEOBJ_S_CANNOT_DOVERB_NOW)
CASE_SCODE(OLEOBJ_S_INVALIDHWND)
CASE_SCODE(INPLACE_E_NOTUNDOABLE)
CASE_SCODE(INPLACE_E_NOTOOLSPACE)
CASE_SCODE(INPLACE_S_TRUNCATED)
/* SCODE's defined in COMPOBJ.H */
CASE_SCODE(CO_E_NOTINITIALIZED)
CASE_SCODE(CO_E_ALREADYINITIALIZED)
CASE_SCODE(CO_E_CANTDETERMINECLASS)
CASE_SCODE(CO_E_CLASSSTRING)
CASE_SCODE(CO_E_IIDSTRING)
CASE_SCODE(CO_E_APPNOTFOUND)
CASE_SCODE(CO_E_APPSINGLEUSE)
CASE_SCODE(CO_E_ERRORINAPP)
CASE_SCODE(CO_E_DLLNOTFOUND)
CASE_SCODE(CO_E_ERRORINDLL)
CASE_SCODE(CO_E_WRONGOSFORAPP)
CASE_SCODE(CO_E_OBJNOTREG)
CASE_SCODE(CO_E_OBJISREG)
CASE_SCODE(CO_E_OBJNOTCONNECTED)
CASE_SCODE(CO_E_APPDIDNTREG)
CASE_SCODE(CLASS_E_NOAGGREGATION)
CASE_SCODE(CLASS_E_CLASSNOTAVAILABLE)
CASE_SCODE(REGDB_E_READREGDB)
CASE_SCODE(REGDB_E_WRITEREGDB)
CASE_SCODE(REGDB_E_KEYMISSING)
CASE_SCODE(REGDB_E_INVALIDVALUE)
CASE_SCODE(REGDB_E_CLASSNOTREG)
CASE_SCODE(REGDB_E_IIDNOTREG)
CASE_SCODE(RPC_E_CALL_REJECTED)
CASE_SCODE(RPC_E_CALL_CANCELED)
CASE_SCODE(RPC_E_CANTPOST_INSENDCALL)
CASE_SCODE(RPC_E_CANTCALLOUT_INASYNCCALL)
CASE_SCODE(RPC_E_CANTCALLOUT_INEXTERNALCALL)
CASE_SCODE(RPC_E_CONNECTION_TERMINATED)
CASE_SCODE(RPC_E_SERVER_DIED)
CASE_SCODE(RPC_E_CLIENT_DIED)
CASE_SCODE(RPC_E_INVALID_DATAPACKET)
CASE_SCODE(RPC_E_CANTTRANSMIT_CALL)
CASE_SCODE(RPC_E_CLIENT_CANTMARSHAL_DATA)
CASE_SCODE(RPC_E_CLIENT_CANTUNMARSHAL_DATA)
CASE_SCODE(RPC_E_SERVER_CANTMARSHAL_DATA)
CASE_SCODE(RPC_E_SERVER_CANTUNMARSHAL_DATA)
CASE_SCODE(RPC_E_INVALID_DATA)
CASE_SCODE(RPC_E_INVALID_PARAMETER)
CASE_SCODE(RPC_E_CANTCALLOUT_AGAIN)
CASE_SCODE(RPC_E_UNEXPECTED)
/* SCODE's defined in DVOBJ.H */
CASE_SCODE(DATA_S_SAMEFORMATETC)
CASE_SCODE(VIEW_E_DRAW)
CASE_SCODE(VIEW_S_ALREADY_FROZEN)
CASE_SCODE(CACHE_E_NOCACHE_UPDATED)
CASE_SCODE(CACHE_S_FORMATETC_NOTSUPPORTED)
CASE_SCODE(CACHE_S_SAMECACHE)
CASE_SCODE(CACHE_S_SOMECACHES_NOTUPDATED)
/* SCODE's defined in STORAGE.H */
CASE_SCODE(STG_E_INVALIDFUNCTION)
CASE_SCODE(STG_E_FILENOTFOUND)
CASE_SCODE(STG_E_PATHNOTFOUND)
CASE_SCODE(STG_E_TOOMANYOPENFILES)
CASE_SCODE(STG_E_ACCESSDENIED)
CASE_SCODE(STG_E_INVALIDHANDLE)
CASE_SCODE(STG_E_INSUFFICIENTMEMORY)
CASE_SCODE(STG_E_INVALIDPOINTER)
CASE_SCODE(STG_E_NOMOREFILES)
CASE_SCODE(STG_E_DISKISWRITEPROTECTED)
CASE_SCODE(STG_E_SEEKERROR)
CASE_SCODE(STG_E_WRITEFAULT)
CASE_SCODE(STG_E_READFAULT)
CASE_SCODE(STG_E_SHAREVIOLATION)
CASE_SCODE(STG_E_LOCKVIOLATION)
CASE_SCODE(STG_E_FILEALREADYEXISTS)
CASE_SCODE(STG_E_INVALIDPARAMETER)
CASE_SCODE(STG_E_MEDIUMFULL)
CASE_SCODE(STG_E_ABNORMALAPIEXIT)
CASE_SCODE(STG_E_INVALIDHEADER)
CASE_SCODE(STG_E_INVALIDNAME)
CASE_SCODE(STG_E_UNKNOWN)
CASE_SCODE(STG_E_UNIMPLEMENTEDFUNCTION)
CASE_SCODE(STG_E_INVALIDFLAG)
CASE_SCODE(STG_E_INUSE)
CASE_SCODE(STG_E_NOTCURRENT)
CASE_SCODE(STG_E_REVERTED)
CASE_SCODE(STG_E_CANTSAVE)
CASE_SCODE(STG_E_OLDFORMAT)
CASE_SCODE(STG_E_OLDDLL)
CASE_SCODE(STG_E_SHAREREQUIRED)
CASE_SCODE(STG_E_NOTFILEBASEDSTORAGE)
CASE_SCODE(STG_E_EXTANTMARSHALLINGS)
CASE_SCODE(STG_S_CONVERTED)
/* SCODE's defined in STORAGE.H */
CASE_SCODE(MK_E_CONNECTMANUALLY)
CASE_SCODE(MK_E_EXCEEDEDDEADLINE)
CASE_SCODE(MK_E_NEEDGENERIC)
CASE_SCODE(MK_E_UNAVAILABLE)
CASE_SCODE(MK_E_SYNTAX)
CASE_SCODE(MK_E_NOOBJECT)
CASE_SCODE(MK_E_INVALIDEXTENSION)
CASE_SCODE(MK_E_INTERMEDIATEINTERFACENOTSUPPORTED)
CASE_SCODE(MK_E_NOTBINDABLE)
CASE_SCODE(MK_E_NOTBOUND)
CASE_SCODE(MK_E_CANTOPENFILE)
CASE_SCODE(MK_E_MUSTBOTHERUSER)
CASE_SCODE(MK_E_NOINVERSE)
CASE_SCODE(MK_E_NOSTORAGE)
CASE_SCODE(MK_E_NOPREFIX)
CASE_SCODE(MK_S_REDUCED_TO_SELF)
CASE_SCODE(MK_S_ME)
CASE_SCODE(MK_S_HIM)
CASE_SCODE(MK_S_US)
CASE_SCODE(MK_S_MONIKERALREADYREGISTERED)
default:
lstrcpy(szErrName, "UNKNOWN SCODE");
}
wsprintf(szBuf, "%s %s (0x%lx)\n", lpszMsg, (LPSTR)szErrName, sc);
OleDbgPrintAlways(lpszPrefix, szBuf, 0);
}
char cDebugEnum::enumBuf [200];
void cDebugEnum::Print (DWORD e)
{
for (WORD w = 0; w < count; w++)
if (pEnumRecs [w].eValue == (WORD)e) {
wsprintf (enumBuf, "%s:%s", pEnumName, pEnumRecs [w].pEnumS);
return;
}
wsprintf (enumBuf, "%s:%s", pEnumName, "**INVALID**");
}
cDebugEnumRecord rOLERENDER [] =
{
{"OLERENDER_NONE", OLERENDER_NONE},
{"OLERENDER_DRAW", OLERENDER_DRAW},
{"OLERENDER_FORMAT", OLERENDER_FORMAT},
{"OLERENDER_ASIS", OLERENDER_ASIS}
};
cDebugEnum cOLERENDER ("OLERENDER", rOLERENDER, sizeof (rOLERENDER) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rOLEVERBATTRIB [] =
{
{"OLEVERBATTRIB_NEVERDIRTIES", OLEVERBATTRIB_NEVERDIRTIES},
{"OLEVERBATTRIB_ONCONTAINERMENU", OLEVERBATTRIB_ONCONTAINERMENU}
};
cDebugEnum cOLEVERBATTRIB ("OLEVERBATTRIB", rOLEVERBATTRIB, sizeof (rOLEVERBATTRIB) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rUSERCLASSTYPE [] =
{
{"USERCLASSTYPE_FULL", USERCLASSTYPE_FULL},
{"USERCLASSTYPE_SHORT", USERCLASSTYPE_SHORT},
{"USERCLASSTYPE_APPNAME", USERCLASSTYPE_APPNAME},
};
cDebugEnum cUSERCLASSTYPE ("USERCLASSTYPE", rUSERCLASSTYPE, sizeof (rUSERCLASSTYPE) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rOLEMISC [] =
{
{"OLEMISC_RECOMPOSEONRESIZE", OLEMISC_RECOMPOSEONRESIZE},
{"OLEMISC_ONLYICONIC", OLEMISC_ONLYICONIC},
{"OLEMISC_INSERTNOTREPLACE", OLEMISC_INSERTNOTREPLACE},
{"OLEMISC_STATIC", OLEMISC_STATIC},
{"OLEMISC_CANTLINKINSIDE", OLEMISC_CANTLINKINSIDE},
{"OLEMISC_CANLINKBYOLE1", OLEMISC_CANLINKBYOLE1},
{"OLEMISC_ISLINKOBJECT", OLEMISC_ISLINKOBJECT},
{"OLEMISC_INSIDEOUT", OLEMISC_INSIDEOUT},
{"OLEMISC_ACTIVATEWHENVISIBLE", OLEMISC_ACTIVATEWHENVISIBLE}
};
cDebugEnum cOLEMISC ("OLEMISC", rOLEMISC, sizeof (rOLEMISC) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rOLECLOSE [] =
{
{"OLECLOSE_SAVEIFDIRTY", OLECLOSE_SAVEIFDIRTY},
{"OLECLOSE_NOSAVE", OLECLOSE_NOSAVE},
{"OLECLOSE_PROMPTSAVE", OLECLOSE_PROMPTSAVE}
};
cDebugEnum cOLECLOSE ("OLECLOSE", rOLECLOSE, sizeof (rOLECLOSE) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rOLEGETMONIKER [] =
{
{"OLEGETMONIKER_ONLYIFTHERE", OLEGETMONIKER_ONLYIFTHERE},
{"OLEGETMONIKER_FORCEASSIGN", OLEGETMONIKER_FORCEASSIGN},
{"OLEGETMONIKER_UNASSIGN", OLEGETMONIKER_UNASSIGN},
{"OLEGETMONIKER_TEMPFORUSER", OLEGETMONIKER_TEMPFORUSER}
};
cDebugEnum cOLEGETMONIKER ("OLEGETMONIKER", rOLEGETMONIKER, sizeof (rOLEGETMONIKER) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rOLEWHICHMK [] =
{
{"OLEWHICHMK_CONTAINER", OLEWHICHMK_CONTAINER},
{"OLEWHICHMK_OBJREL", OLEWHICHMK_OBJREL},
{"OLEWHICHMK_OBJFULL", OLEWHICHMK_OBJFULL}
};
cDebugEnum cOLEWHICHMK ("OLEWHICHMK", rOLEWHICHMK, sizeof (rOLEWHICHMK) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rBINDSPEED [] =
{
{"BINDSPEED_INDEFINITE", BINDSPEED_INDEFINITE},
{"BINDSPEED_MODERATE", BINDSPEED_MODERATE},
{"BINDSPEED_IMMEDIATE", BINDSPEED_IMMEDIATE}
};
cDebugEnum cBINDSPEED ("BINDSPEED", rBINDSPEED, sizeof (rBINDSPEED) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rOLECONTF [] =
{
{"OLECONTF_EMBEDDINGS", OLECONTF_EMBEDDINGS},
{"OLECONTF_LINKS", OLECONTF_LINKS},
{"OLECONTF_OTHERS", OLECONTF_OTHERS},
{"OLECONTF_ONLYUSER", OLECONTF_ONLYUSER},
{"OLECONTF_ONLYIFRUNNING", OLECONTF_ONLYIFRUNNING}
};
cDebugEnum cOLECONTF ("OLECONTF", rOLECONTF, sizeof (rOLECONTF) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rOLEUPDATE [] =
{
{"OLEUPDATE_ALWAYS", OLEUPDATE_ALWAYS},
{"OLEUPDATE_ONCALL", OLEUPDATE_ONCALL}
};
cDebugEnum cOLEUPDATE ("OLEUPDATE", rOLEUPDATE, sizeof (rOLEUPDATE) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rOLELINKBIND [] =
{
{"OLELINKBIND_EVENIFCLASSDIFF", OLELINKBIND_EVENIFCLASSDIFF},
};
cDebugEnum cOLELINKBIND ("OLELINKBIND", rOLELINKBIND, sizeof (rOLELINKBIND) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rDVASPECT [] =
{
{"DVASPECT_CONTENT", DVASPECT_CONTENT},
{"DVASPECT_THUMBNAIL", DVASPECT_THUMBNAIL},
{"DVASPECT_ICON", DVASPECT_ICON},
{"DVASPECT_DOCPRINT", DVASPECT_DOCPRINT}
};
cDebugEnum cDVASPECT ("DVASPECT", rDVASPECT, sizeof (rDVASPECT) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rTYMED [] =
{
{"TYMED_HGLOBAL", TYMED_HGLOBAL},
{"TYMED_FILE", TYMED_FILE},
{"TYMED_ISTREAM", TYMED_ISTREAM},
{"TYMED_ISTORAGE", TYMED_ISTORAGE},
{"TYMED_GDI", TYMED_GDI},
{"TYMED_MFPICT", TYMED_MFPICT},
{"TYMED_NULL", TYMED_NULL}
};
cDebugEnum cTYMED ("TYMED", rTYMED, sizeof (rTYMED) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rDATADIR [] =
{
{"DATADIR_GET", DATADIR_GET},
{"DATADIR_SET", DATADIR_SET},
};
cDebugEnum cDATADIR ("DATADIR", rDATADIR, sizeof (rDATADIR) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rADVF [] =
{
{"ADVF_NODATA", ADVF_NODATA},
{"ADVF_PRIMEFIRST", ADVF_PRIMEFIRST},
{"ADVF_ONLYONCE", ADVF_ONLYONCE},
{"ADVF_DATAONSTOP", ADVF_DATAONSTOP},
{"ADVFCACHE_NOHANDLER", ADVFCACHE_NOHANDLER},
{"ADVFCACHE_FORCEBUILTIN", ADVFCACHE_FORCEBUILTIN},
{"ADVFCACHE_ONSAVE", ADVFCACHE_ONSAVE}
};
cDebugEnum cADVF ("ADVF", rADVF, sizeof (rADVF) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rMEMCTX [] =
{
{"MEMCTX_TASK", MEMCTX_TASK},
{"MEMCTX_SHARED", MEMCTX_SHARED},
#ifdef _MAC
{"MEMCTX_MACSYSTEM", MEMCTX_MACSYSTEM},
#endif
{"MEMCTX_UNKNOWN", MEMCTX_UNKNOWN},
{"MEMCTX_SAME", MEMCTX_SAME},
};
cDebugEnum cMEMCTX ("MEMCTX", rMEMCTX, sizeof (rMEMCTX) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rCLSCTX [] =
{
{"CLSCTX_INPROC_SERVER", CLSCTX_INPROC_SERVER},
{"CLSCTX_INPROC_HANDLER", CLSCTX_INPROC_HANDLER},
{"CLSCTX_LOCAL_SERVER", CLSCTX_LOCAL_SERVER}
};
cDebugEnum cCLSCTX ("CLSCTX", rCLSCTX, sizeof (rCLSCTX) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rREGCLS [] =
{
{"REGCLS_SINGLEUSE", REGCLS_SINGLEUSE},
{"REGCLS_MULTIPLEUSE", REGCLS_MULTIPLEUSE}
};
cDebugEnum cREGCLS ("REGCLS", rREGCLS, sizeof (rREGCLS) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rMSHLFLAGS [] =
{
{"MSHLFLAGS_NORMAL", MSHLFLAGS_NORMAL},
{"MSHLFLAGS_TABLESTRONG", MSHLFLAGS_TABLESTRONG},
{"MSHLFLAGS_TABLEWEAK", MSHLFLAGS_TABLEWEAK}
};
cDebugEnum cMSHLFLAGS ("MSHLFLAGS", rMSHLFLAGS, sizeof (rMSHLFLAGS) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rMSHCTX [] =
{
{"MSHCTX_LOCAL", MSHCTX_LOCAL},
{"MSHCTX_NOSHAREDMEM", MSHCTX_NOSHAREDMEM},
};
cDebugEnum cMSHCTX ("MSHCTX", rMSHCTX, sizeof (rMSHCTX) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rCALLTYPE [] =
{
{"CALLTYPE_TOPLEVEL", CALLTYPE_TOPLEVEL},
{"CALLTYPE_NESTED", CALLTYPE_NESTED},
{"CALLTYPE_ASYNC", CALLTYPE_ASYNC},
{"CALLTYPE_TOPLEVEL_CALLPENDING", CALLTYPE_TOPLEVEL_CALLPENDING},
{"CALLTYPE_ASYNC_CALLPENDING", CALLTYPE_ASYNC_CALLPENDING}
};
cDebugEnum cCALLTYPE ("CALLTYPE", rCALLTYPE, sizeof (rCALLTYPE) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rSERVERCALL [] =
{
{"SERVERCALL_ISHANDLED", SERVERCALL_ISHANDLED},
{"SERVERCALL_REJECTED", SERVERCALL_REJECTED},
{"SERVERCALL_RETRYLATER", SERVERCALL_RETRYLATER}
};
cDebugEnum cSERVERCALL ("SERVERCALL", rSERVERCALL, sizeof (rSERVERCALL) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rPENDINGTYPE [] =
{
{"PENDINGTYPE_TOPLEVEL", PENDINGTYPE_TOPLEVEL},
{"PENDINGTYPE_NESTED", PENDINGTYPE_NESTED}
};
cDebugEnum cPENDINGTYPE ("PENDINGTYPE", rPENDINGTYPE, sizeof (rPENDINGTYPE) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rPENDINGMSG [] =
{
{"PENDINGMSG_CANCELCALL", PENDINGMSG_CANCELCALL},
{"PENDINGMSG_WAITNOPROCESS", PENDINGMSG_WAITNOPROCESS},
{"PENDINGMSG_WAITDEFPROCESS", PENDINGMSG_WAITDEFPROCESS}
};
cDebugEnum cPENDINGMSG ("PENDINGMSG", rPENDINGMSG, sizeof (rPENDINGMSG) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rBIND_FLAGS [] =
{
{"BIND_MAYBOTHERUSER", BIND_MAYBOTHERUSER},
{"BIND_JUSTTESTEXISTENCE", BIND_JUSTTESTEXISTENCE}
};
cDebugEnum cBIND_FLAGS ("BIND_FLAGS", rBIND_FLAGS, sizeof (rBIND_FLAGS) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rKSYS [] =
{
{"MKSYS_NONE", MKSYS_NONE},
{"MKSYS_GENERICCOMPOSITE", MKSYS_GENERICCOMPOSITE},
{"MKSYS_FILEMONIKER", MKSYS_FILEMONIKER},
{"MKSYS_ANTIMONIKER", MKSYS_ANTIMONIKER},
{"MKSYS_ITEMMONIKER", MKSYS_ITEMMONIKER},
{"MKSYS_POINTERMONIKER", MKSYS_POINTERMONIKER}
};
cDebugEnum cKSYS ("KSYS", rKSYS, sizeof (rKSYS) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rMKRREDUCE [] =
{
{"MKRREDUCE_ONE", MKRREDUCE_ONE},
{"MKRREDUCE_TOUSER", MKRREDUCE_TOUSER},
{"MKRREDUCE_THROUGHUSER", MKRREDUCE_THROUGHUSER},
{"MKRREDUCE_ALL", MKRREDUCE_ALL}
};
cDebugEnum cMKRREDUCE ("MKRREDUCE", rMKRREDUCE, sizeof (rMKRREDUCE) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rSTGC [] =
{
{"STGC_DEFAULT", STGC_DEFAULT},
{"STGC_OVERWRITE", STGC_OVERWRITE},
{"STGC_ONLYIFCURRENT", STGC_ONLYIFCURRENT},
{"STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE", STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE}
};
cDebugEnum cSTGC ("STGC", rSTGC, sizeof (rSTGC) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rSTGTY [] =
{
{"STGTY_STORAGE", STGTY_STORAGE},
{"STGTY_STREAM", STGTY_STREAM},
{"STGTY_LOCKBYTES", STGTY_LOCKBYTES},
{"STGTY_PROPERTY", STGTY_PROPERTY}
};
cDebugEnum cSTGTY ("STGTY", rSTGTY, sizeof (rSTGTY) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rSTREAM_SEEK [] =
{
{"STREAM_SEEK_SET", STREAM_SEEK_SET},
{"STREAM_SEEK_CUR", STREAM_SEEK_CUR},
{"STREAM_SEEK_END", STREAM_SEEK_END}
};
cDebugEnum cSTREAM_SEEK ("STREAM_SEEK", rSTREAM_SEEK, sizeof (rSTREAM_SEEK) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rLOCKTYPE [] =
{
{"LOCK_WRITE", LOCK_WRITE},
{"LOCK_EXCLUSIVE", LOCK_EXCLUSIVE},
{"LOCK_ONLYONCE", LOCK_ONLYONCE}
};
cDebugEnum cLOCKTYPE ("LOCKTYPE", rLOCKTYPE, sizeof (rLOCKTYPE) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rSTGMOVE [] =
{
{"STGMOVE_MOVE", STGMOVE_MOVE},
{"STGMOVE_COPY", STGMOVE_COPY}
};
cDebugEnum cSTGMOVE ("STGMOVE", rSTGMOVE, sizeof (rSTGMOVE) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rSTATFLAG [] =
{
{"STATFLAG_DEFAULT", STATFLAG_DEFAULT},
{"STATFLAG_NONAME", STATFLAG_NONAME}
};
cDebugEnum cSTATFLAG ("STATFLAG", rSTATFLAG, sizeof (rSTATFLAG) / sizeof (cDebugEnumRecord));
cDebugEnumRecord rOLEUIPASTEFLAG [] =
{
{"OLEUIPASTE_PASTEONLY", OLEUIPASTE_PASTEONLY},
{"OLEUIPASTE_PASTE", OLEUIPASTE_PASTE},
{"OLEUIPASTE_LINKANYTYPE", OLEUIPASTE_LINKANYTYPE},
{"OLEUIPASTE_LINKTYPE1", OLEUIPASTE_LINKTYPE1},
{"OLEUIPASTE_LINKTYPE2", OLEUIPASTE_LINKTYPE2},
{"OLEUIPASTE_LINKTYPE3", OLEUIPASTE_LINKTYPE3},
{"OLEUIPASTE_LINKTYPE4", OLEUIPASTE_LINKTYPE4},
{"OLEUIPASTE_LINKTYPE5", OLEUIPASTE_LINKTYPE5},
{"OLEUIPASTE_LINKTYPE6", OLEUIPASTE_LINKTYPE6},
{"OLEUIPASTE_LINKTYPE7", OLEUIPASTE_LINKTYPE7},
{"OLEUIPASTE_LINKTYPE8", OLEUIPASTE_LINKTYPE8}
};
cDebugEnum cOLEUIPASTEFLAG ("OLEUIPASTEFLAG", rOLEUIPASTEFLAG, sizeof (rOLEUIPASTEFLAG) / sizeof (cDebugEnumRecord));
#endif
#ifdef _DEBUG
//**************************************************************************
//
// IUnknownWatcher
//
//**************************************************************************
IUnknownWatcher::IUnknownWatcher( IUnknown *punk, char *name ) : pUnk( punk ){
strncpy( Name, name, sizeof( Name ) );
char tmp[80];
wsprintf( tmp, "%s %04x:%04x created, nRef=%d\n\r", Name, HIWORD((DWORD)pUnk),LOWORD((DWORD)pUnk), nRef() );
OutputDebugString( tmp );
}
HRESULT _IFUNC IUnknownWatcher::QueryInterface(REFIID iid, void FAR* FAR* pif){
HRESULT hr;
if( iid == IID_IUnknown ){
*pif = this;
pUnk->AddRef();
hr = ResultFromScode(S_OK);
} else
hr = pUnk->QueryInterface( iid, pif );
if( hr == ResultFromScode(S_OK) ){
char tmp[80];
wsprintf( tmp, "%s %04x:%04x QI OK, nRef=%d\n\r", Name, HIWORD((DWORD)pUnk),LOWORD((DWORD)pUnk), nRef() );
OutputDebugString( tmp );
}
return hr;
}
ULONG _IFUNC IUnknownWatcher::AddRef(){
int i = pUnk->AddRef();
char tmp[80];
wsprintf( tmp, "%s %04x:%04x AddRef to %d\n\r", Name, HIWORD((DWORD)pUnk),LOWORD((DWORD)pUnk), i );
OutputDebugString( tmp );
return i;
}
ULONG _IFUNC IUnknownWatcher::Release(){
int i = pUnk->Release();
char tmp[80];
wsprintf( tmp, "%s %04x:%04x Released to %d\n\r", Name, HIWORD((DWORD)pUnk),LOWORD((DWORD)pUnk), i );
OutputDebugString( tmp );
if( i-1 == 0 ){
wsprintf( tmp, "%s %04x:%04x DELETED\n\r", Name, HIWORD((DWORD)pUnk),LOWORD((DWORD)pUnk) );
OutputDebugString( tmp );
delete this;
return 0;
}
return i;
}
int IUnknownWatcher::nRef(){
int i = pUnk->AddRef();
pUnk->Release();
return i;
}
#endif
#ifdef _DEBUG
//**************************************************************************
//
// IMonikerWatcher
//
//**************************************************************************
IMonikerWatcher::IMonikerWatcher( IMoniker *pmoniker, char *name ) : pMoniker( pmoniker ){
strncpy( Name, name, sizeof( Name ) );
char tmp[80];
int i = pMoniker->AddRef();
pMoniker->Release();
wsprintf( tmp, "%s %04x:%04x created, nRef=%d\n\r",
Name, HIWORD((DWORD)pMoniker),LOWORD((DWORD)pMoniker), i-1 );
OutputDebugString( tmp );
}
// *** IUnknown methods ***
HRESULT _IFUNC
IMonikerWatcher::QueryInterface(REFIID riid, LPVOID FAR* ppvObj) {
HRESULT hr = ResultFromScode(S_OK);
int i;
if( riid == IID_IUnknown ){
*ppvObj = (IUnknown * )this;
i = pMoniker->AddRef();
} else
if( riid == IID_IMoniker ){
*ppvObj = (IMoniker * )this;
i = pMoniker->AddRef();
} else
hr = pMoniker->QueryInterface( riid, ppvObj );
if( hr == ResultFromScode(S_OK) ){
char tmp[80];
i = pMoniker->AddRef();
pMoniker->Release();
i--;
wsprintf( tmp, "%s %04x:%04x QI-OK, nRef=%d\n\r",
Name, HIWORD((DWORD)pMoniker),LOWORD((DWORD)pMoniker), i );
OutputDebugString( tmp );
}
return hr;
}
ULONG _IFUNC
IMonikerWatcher::AddRef(){
int i = pMoniker->AddRef();
char tmp[80];
wsprintf( tmp, "%s %04x:%04x AddRef, nRef=%d\n\r",
Name, HIWORD((DWORD)pMoniker),LOWORD((DWORD)pMoniker), i );
OutputDebugString( tmp );
return i;
}
ULONG _IFUNC
IMonikerWatcher::Release() {
int i = pMoniker->Release();
char tmp[80];
wsprintf( tmp, "%s %04x:%04x Release, nRef=%d\n\r",
Name, HIWORD((DWORD)pMoniker),LOWORD((DWORD)pMoniker), i );
OutputDebugString( tmp );
if( i == 0 ){
wsprintf( tmp, "%s %04x:%04x DELETED\n\r",
Name, HIWORD((DWORD)pMoniker),LOWORD((DWORD)pMoniker) );
OutputDebugString( tmp );
delete this;
return 0;
}
return i;
}
// *** IPersist methods ***
HRESULT _IFUNC
IMonikerWatcher::GetClassID(LPCLSID lpClassID) {
HRESULT hr;
hr = pMoniker->GetClassID(lpClassID) ;
return hr;
}
// *** IPersistStream methods ***
HRESULT _IFUNC
IMonikerWatcher::IsDirty() {
HRESULT hr;
hr = pMoniker->IsDirty() ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::Load(LPSTREAM pStm) {
HRESULT hr;
hr = pMoniker->Load(pStm) ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::Save(LPSTREAM pStm, BOOL fClearDirty) {
HRESULT hr;
hr = pMoniker->Save(pStm, fClearDirty) ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::GetSizeMax(ULARGE_INTEGER FAR * pcbSize) {
HRESULT hr;
hr = pMoniker->GetSizeMax(pcbSize) ;
return hr;
}
// *** IMoniker methods ***
HRESULT _IFUNC
IMonikerWatcher::BindToObject(LPBC pbc, LPMONIKER pmkToLeft, REFIID riidResult, LPVOID FAR* ppvResult) {
HRESULT hr;
hr = pMoniker->BindToObject(pbc, pmkToLeft, riidResult, ppvResult) ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::BindToStorage(LPBC pbc, LPMONIKER pmkToLeft, REFIID riid, LPVOID FAR* ppvObj) {
HRESULT hr;
hr = pMoniker->BindToStorage(pbc, pmkToLeft, riid, ppvObj) ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::Reduce(LPBC pbc, DWORD dwReduceHowFar, LPMONIKER FAR*ppmkToLeft, LPMONIKER FAR * ppmkReduced) {
HRESULT hr;
hr = pMoniker->Reduce(pbc, dwReduceHowFar, ppmkToLeft, ppmkReduced) ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::ComposeWith(LPMONIKER pmkRight, BOOL fOnlyIfNotGeneric, LPMONIKER FAR* ppmkComposite) {
HRESULT hr;
hr = pMoniker->ComposeWith(pmkRight, fOnlyIfNotGeneric, ppmkComposite) ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::Enum(BOOL fForward, LPENUMMONIKER FAR* ppenumMoniker){
HRESULT hr;
hr = pMoniker->Enum(fForward, ppenumMoniker);
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::IsEqual(LPMONIKER pmkOtherMoniker) {
HRESULT hr;
hr = pMoniker->IsEqual(pmkOtherMoniker) ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::Hash(LPDWORD pdwHash) {
HRESULT hr;
hr = pMoniker->Hash(pdwHash) ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::IsRunning(LPBC pbc, LPMONIKER pmkToLeft, LPMONIKER pmkNewlyRunning) {
HRESULT hr;
hr = pMoniker->IsRunning(pbc, pmkToLeft, pmkNewlyRunning) ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::GetTimeOfLastChange(LPBC pbc, LPMONIKER pmkToLeft, FILETIME FAR* pfiletime) {
HRESULT hr;
hr = pMoniker->GetTimeOfLastChange(pbc, pmkToLeft, pfiletime) ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::Inverse(LPMONIKER FAR* ppmk) {
HRESULT hr;
hr = pMoniker->Inverse(ppmk) ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::CommonPrefixWith(LPMONIKER pmkOther, LPMONIKER FAR*ppmkPrefix) {
HRESULT hr;
hr = pMoniker->CommonPrefixWith(pmkOther, ppmkPrefix) ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::RelativePathTo(LPMONIKER pmkOther, LPMONIKER FAR*ppmkRelPath) {
HRESULT hr;
hr = pMoniker->RelativePathTo(pmkOther, ppmkRelPath) ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::GetDisplayName(LPBC pbc, LPMONIKER pmkToLeft, LPSTR FAR* lplpszDisplayName) {
HRESULT hr;
hr = pMoniker->GetDisplayName(pbc, pmkToLeft, lplpszDisplayName) ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::ParseDisplayName(LPBC pbc, LPMONIKER pmkToLeft, LPSTR lpszDisplayName, ULONG FAR* pchEaten, LPMONIKER FAR* ppmkOut) {
HRESULT hr;
hr = pMoniker->ParseDisplayName(pbc, pmkToLeft, lpszDisplayName, pchEaten, ppmkOut) ;
return hr;
}
HRESULT _IFUNC
IMonikerWatcher::IsSystemMoniker(LPDWORD pdwMksys) {
HRESULT hr;
hr = pMoniker->IsSystemMoniker(pdwMksys) ;
return hr;
}
#endif
#ifdef _DEBUG
//**************************************************************************
//
// ReleaseWatcher
//
//**************************************************************************
HRESULT _IFUNC
ReleaseWatcher::QueryInterface( REFIID, LPVOID FAR *ppid ){
*ppid = NULL;
return ResultFromScode( E_NOINTERFACE );
}
ULONG _IFUNC
ReleaseWatcher::AddRef(){
return ++nRef;
}
ULONG _IFUNC
ReleaseWatcher::Release(){
return --nRef;
}
#endif
Reference in New Issue View Git Blame Copy Permalink