Initial

hookproc/APIENTRY.CPP

@@ -0,0 +1,55 @@
+#include <hookproc/apientry.hpp>
+
+#if defined(_MSC_VER)
+void APIEntry::createThunk(DWORD stackLength)
+{
+  pushEBP();
+	movEBPESP();
+  jmp(0x0008);
+	encodeDD();
+	encodeDD();
+	movEAX(FirstArgument);
+	addEAX(stackLength);
+	subEAX(0x0004);
+	cmpEAX(0x0004);
+	je(0x0013);
+	pushEBPEAXPLUS(0);
+	subEAX(4);
+	cmpEAX(FirstArgument);
+	jnl(-19);
+	push(base()+tell()+0x0014);
+	movECXOFFSETCS(base()+IATInstance);
+	movEAXOFFSETCS(base()+IATOffset);
+	pushEAX();
+	retn();
+	popEBP();
+  retn();
+}
+#else
+void APIEntry::createThunk(DWORD stackLength)
+{
+	pushEBP();
+	movEBPESP();
+	jmp(0x0008);
+	encodeDD();
+	encodeDD();
+	movEAX(FirstArgument);
+	addEAX(stackLength);
+	subEAX(0x0004);
+	cmpEAX(0x0004);
+	je(0x0013);
+	pushEBPEAXPLUS(0);
+	subEAX(4);
+	cmpEAX(FirstArgument);
+	jnl(-19);
+	movECXOFFSETCS(base()+IATInstance);
+	pushECX();
+	push(base()+tell()+0x000D);
+	movEAXOFFSETCS(base()+IATOffset);
+	pushEAX();
+	retn();                             
+	addESP(stackLength+sizeof(void*));
+	popEBP();
+	retn(stackLength);
+}
+#endif

hookproc/APIENTRY.HPP

@@ -0,0 +1,76 @@
+#ifndef _HOOKPROC_APIENTRY_HPP_
+#define _HOOKPROC_APIENTRY_HPP_
+#ifndef _COMMON_CODEGEN_HPP_
+#include <common/codegen.hpp>
+#endif
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class APIEntry : private CodeGen
+{
+public:
+  APIEntry(DWORD stackLength,DWORD instanceAddress,DWORD hookAddress);
+	virtual ~APIEntry();
+	DWORD codeBase(void)const;
+protected:
+	void entryPoint(DWORD entryPoint);
+private:
+  enum {CodeLength=1024,FirstArgument=8,IATOffset=5,IATInstance=9};
+	APIEntry(const APIEntry &someAPIEntry);
+	APIEntry &operator=(const APIEntry &someAPIEntry);
+	void createThunk(DWORD stackLength);
+  void saveIATAddress(DWORD hookAddress);
+	void saveIATInstance(DWORD instanceAddress);
+};
+
+inline
+APIEntry::APIEntry(DWORD stackLength,DWORD instanceAddress,DWORD hookAddress)
+: CodeGen(CodeLength)
+{
+  createThunk(stackLength);
+  saveIATAddress(hookAddress);
+	saveIATInstance(instanceAddress);
+}
+
+inline
+APIEntry::APIEntry(const APIEntry &/*someAPIEntry*/)
+{ // no implementation
+}
+
+inline
+APIEntry::~APIEntry()
+{
+}
+
+inline
+APIEntry &APIEntry::operator=(const APIEntry &/*someAPIEntry*/)
+{ // no implementation
+  return *this;
+}
+
+inline
+DWORD APIEntry::codeBase(void)const
+{
+  return base();
+}
+
+
+inline
+void APIEntry::saveIATAddress(DWORD hookAddress)
+{
+  ((PureViewOfFile&)((CodeGen&)*this)).push();
+	((PureViewOfFile&)((CodeGen&)*this)).seek(IATOffset,PureViewOfFile::SeekSet);
+	((PureViewOfFile&)((CodeGen&)*this)).write((int)hookAddress);
+	((PureViewOfFile&)((CodeGen&)*this)).pop();
+}
+
+inline
+void APIEntry::saveIATInstance(DWORD instanceAddress)
+{
+  ((PureViewOfFile&)((CodeGen&)*this)).push();
+	((PureViewOfFile&)((CodeGen&)*this)).seek(IATInstance,PureViewOfFile::SeekSet);
+	((PureViewOfFile&)((CodeGen&)*this)).write((int)instanceAddress);
+	((PureViewOfFile&)((CodeGen&)*this)).pop();
+}
+#endif

hookproc/DesktopEnumerator.hpp

@@ -0,0 +1,59 @@
+#ifndef _HOOKPROC_DESKTOPENUMERATOR_HPP_
+#define _HOOKPROC_DESKTOPENUMERATOR_HPP_
+#ifndef _HOOKPROC_ENUMDESKTOPHOOK_HPP_
+#include <hookproc/enumdesk.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _COMMON_WINDOWSTATION_HPP_
+#include <common/wstation.hpp>
+#endif
+
+class DesktopEnumerator : public EnumDesktopHook, public Block<String>
+{
+public:
+  DesktopEnumerator(void);
+	virtual ~DesktopEnumerator();
+	bool enumerateDesktops(WindowStation &windowStation);
+	DWORD size(void)const;
+protected:
+  virtual bool enumDesktopProc(const String &strDesktop);
+private:
+};
+
+inline
+DesktopEnumerator::DesktopEnumerator(void)
+{
+}
+
+inline
+DesktopEnumerator::~DesktopEnumerator()
+{
+}
+
+inline
+bool DesktopEnumerator::enumerateDesktops(WindowStation &windowStation)
+{
+  Block<String>::remove();
+  if(!windowStation.isOkay())return false;
+  ::EnumDesktops(windowStation.getHandle(),(LPFNENUMDESKTOPPROC)getHookAddress(),0);
+	return Block<String>::size()?true:false;
+}
+
+inline
+bool DesktopEnumerator::enumDesktopProc(const String &strDesktop)
+{
+  Block<String>::insert(&strDesktop);
+	return true;
+}
+
+inline
+DWORD DesktopEnumerator::size(void)const
+{
+  return Block<String>::size();
+}
+#endif

hookproc/DesktopWindowEnumerator.hpp

@@ -0,0 +1,59 @@
+#ifndef _HOOKPROC_DESKTOPWINDOWENUMERATOR_HPP_
+#define _HOOKPROC_DESKTOPWINDOWENUMERATOR_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _COMMON_DESKTOP_HPP_
+#include <common/desktop.hpp>
+#endif
+#ifndef _HOOKPROC_ENUMWINDOWSHOOK_HPP_
+#include <hookproc/enumwin.hpp>
+#endif
+
+class DesktopWindowEnumerator : public EnumWindowsHook, public Block<HWND>
+{
+public:
+  DesktopWindowEnumerator();
+	virtual ~DesktopWindowEnumerator();
+	bool enumerateDesktopWindows(Desktop &desktop);
+	DWORD size(void)const;
+protected:
+  virtual bool enumWindowsProc(HWND hWnd,LPARAM lParam);
+private:
+};
+
+inline
+DesktopWindowEnumerator::DesktopWindowEnumerator()
+{
+}
+
+inline
+DesktopWindowEnumerator::~DesktopWindowEnumerator()
+{
+}
+
+inline
+bool DesktopWindowEnumerator::enumerateDesktopWindows(Desktop &desktop)
+{
+  Block<HWND>::remove();
+	if(!desktop.isOkay())return false;
+	::EnumDesktopWindows(desktop.getHandle(),(LPFNENUMWINDOWPROC)getHookAddress(),0L);
+	return size()?true:false;
+}
+
+inline
+bool DesktopWindowEnumerator::enumWindowsProc(HWND hWnd,LPARAM lParam)
+{
+  Block<HWND>::insert(&hWnd); 
+	return true;
+}
+
+inline
+DWORD DesktopWindowEnumerator::size(void)const
+{
+  return Block<HWND>::size();
+}
+#endif

hookproc/ENUMWIN.CPP

@@ -0,0 +1,18 @@
+#include <hookproc/enumwin.hpp>
+#include <common/string.hpp>
+
+EnumWindowsHook::~EnumWindowsHook()
+{
+}
+
+bool EnumWindowsHook::entryProc(HWND hWnd,LPARAM lParam)
+{
+  return enumWindowsProc(hWnd,lParam);
+}
+
+// *** virtuals
+
+bool EnumWindowsHook::enumWindowsProc(HWND hWnd,LPARAM lParam)
+{
+  return true;
+}

hookproc/ENUMWIN.HPP

@@ -0,0 +1,45 @@
+#ifndef _HOOKPROC_ENUMWINDOWSHOOK_HPP_
+#define _HOOKPROC_ENUMWINDOWSHOOK_HPP_
+#ifndef _HOOKPROC_APIENTRY_HPP_
+#include <hookproc/apientry.hpp>
+#endif
+#ifndef _HOOKPROC_PROCADDRESS_HPP_
+#include <hookproc/procaddr.hpp>
+#endif
+
+class EnumWindowsHook;
+typedef ProcAddress<EnumWindowsHook> EnumWindowsHookProc;
+
+class EnumWindowsHook : protected APIEntry, private EnumWindowsHookProc
+{
+public:
+  typedef int (__stdcall *LPFNENUMWINDOWPROC)(HWND hWnd,LPARAM lParam);
+  EnumWindowsHook(void);
+	virtual ~EnumWindowsHook();
+	DWORD getHookAddress(void);
+protected:
+  virtual bool enumWindowsProc(HWND hWnd,LPARAM lParam);
+private:
+  enum {ParamLength=8};
+	EnumWindowsHook &operator=(const EnumWindowsHook &someEnumWindowsHook);
+	bool entryProc(HWND hWnd,LPARAM lParam);
+};
+
+inline
+EnumWindowsHook::EnumWindowsHook(void)
+: APIEntry(ParamLength,(DWORD)this,getProcAddress((ProcAddress<EnumWindowsHook>::LPFNMETHODVOID)&EnumWindowsHook::entryProc))
+{
+}
+
+inline
+EnumWindowsHook &EnumWindowsHook::operator=(const EnumWindowsHook &someEnumWindowsHook)
+{	// no implementation
+  return *this;
+}
+
+inline
+DWORD EnumWindowsHook::getHookAddress(void)
+{
+  return codeBase();
+}
+#endif

hookproc/EXCPTDLG.CPP

@@ -0,0 +1,897 @@
+#include <hookproc/excptdlg.hpp>
+#include <hookproc/excpthk.hpp>
+#include <common/font.hpp>
+
+WORD ExceptDlg::performDialog(const ExceptionRecord &exceptionRecord,const Context &exceptionContext)
+{
+  String staticControl("STATIC");
+	String editControl("EDIT");
+	DialogTemplate dlgTemplate;
+	DialogItemTemplate argEdit;
+	DialogItemTemplate argStatic;
+	DialogItemTemplate argButton;
+	DialogItemTemplate staticEAX;
+	DialogItemTemplate staticEBX;
+	DialogItemTemplate staticECX;
+	DialogItemTemplate staticEDX;
+	DialogItemTemplate staticESI;
+	DialogItemTemplate staticEDI;
+	DialogItemTemplate staticESP;
+	DialogItemTemplate staticEBP;
+	DialogItemTemplate staticDS;
+	DialogItemTemplate staticES;
+	DialogItemTemplate staticFS;
+	DialogItemTemplate staticGS;
+	DialogItemTemplate staticCS;
+	DialogItemTemplate staticSS;
+	DialogItemTemplate staticEIP;
+	DialogItemTemplate staticFlagsCarry;
+	DialogItemTemplate staticFlagsZero;
+	DialogItemTemplate staticFlagsOverflow;
+	DialogItemTemplate staticFlagsSign;
+	DialogItemTemplate staticFlagsAuxiliary;
+	DialogItemTemplate staticFlagsParity;
+	DialogItemTemplate staticFlagsDirection;
+	DialogItemTemplate staticFlagsInterrupt;
+	DialogItemTemplate registerEAX;
+	DialogItemTemplate registerEBX;
+	DialogItemTemplate registerECX;
+	DialogItemTemplate registerEDX;
+	DialogItemTemplate registerESI;
+	DialogItemTemplate registerEDI;
+	DialogItemTemplate registerESP;
+	DialogItemTemplate registerEBP;
+	DialogItemTemplate registerDS;
+	DialogItemTemplate registerES;
+	DialogItemTemplate registerFS;
+	DialogItemTemplate registerGS;
+	DialogItemTemplate registerCS;
+	DialogItemTemplate registerSS;
+	DialogItemTemplate registerEIP;
+	DialogItemTemplate registerFlagsSign;
+	DialogItemTemplate registerFlagsCarry;
+	DialogItemTemplate registerFlagsOverflow;
+	DialogItemTemplate registerFlagsZero;
+	DialogItemTemplate registerFlagsParity;
+	DialogItemTemplate registerFlagsAuxiliary;
+	DialogItemTemplate registerFlagsDirection;
+	DialogItemTemplate registerFlagsInterrupt;
+	DialogItemTemplate staticFlagsLabel;
+
+  mExceptionRecord=exceptionRecord;
+	mExceptionContext=exceptionContext;
+	dlgTemplate.titleText(exceptionRecord.exceptionCodeString().isNull()?"Exception Handler":(LPSTR)(String&)exceptionRecord.exceptionCodeString());
+	dlgTemplate.posRect(Rect(8,19,345,225)); 
+	dlgTemplate.pointSize(6);
+  dlgTemplate.typeFace("Helv");
+	dlgTemplate.style(DS_MODALFRAME|WS_TABSTOP|WS_VISIBLE|WS_CAPTION|DS_3DLOOK|DS_SETFONT|WS_POPUP|WS_SYSMENU);
+
+	argEdit.className(editControl);
+  argEdit.titleText("");
+	argEdit.style(WS_BORDER|WS_TABSTOP|WS_VISIBLE|WS_CHILD|ES_AUTOHSCROLL|ES_AUTOVSCROLL|ES_MULTILINE|ES_WANTRETURN|ES_READONLY);
+	argEdit.posRect(Rect(2,60,340,140));  
+	argEdit.itemID(EditControlID);
+
+	argButton.className("BUTTON");
+	argButton.titleText("Ok");
+	argButton.style(WS_CHILD|WS_VISIBLE|BS_DEFPUSHBUTTON);
+	argButton.posRect(Rect(145,205,50,14));
+	argButton.itemID(IDOK);
+
+	staticEAX.className(staticControl);
+	staticEAX.titleText("eax:");
+	staticEAX.style(WS_CHILD|WS_VISIBLE);
+	staticEAX.posRect(Rect(2,9,19,8));
+	staticEAX.itemID(-1);
+
+	staticEBX.className(staticControl);
+	staticEBX.titleText("ebx:");
+	staticEBX.style(WS_CHILD|WS_VISIBLE);
+	staticEBX.posRect(Rect(72,9,17,8));
+	staticEBX.itemID(-1);
+
+	staticECX.className(staticControl);
+	staticECX.titleText("ecx:");
+	staticECX.style(WS_CHILD|WS_VISIBLE);
+	staticECX.posRect(Rect(143,9,16,8));
+	staticECX.itemID(-1);
+
+	staticEDX.className(staticControl);
+	staticEDX.titleText("edx:");
+	staticEDX.style(WS_CHILD|WS_VISIBLE);
+	staticEDX.posRect(Rect(213,9,16,8));
+	staticEDX.itemID(-1);
+
+	staticESI.className(staticControl);
+	staticESI.titleText("esi:");
+	staticESI.style(WS_CHILD|WS_VISIBLE);
+	staticESI.posRect(Rect(2,23,19,8));
+	staticESI.itemID(-1);
+
+	staticEDI.className(staticControl);
+	staticEDI.titleText("edi:");
+	staticEDI.style(WS_CHILD|WS_VISIBLE);
+	staticEDI.posRect(Rect(72,23,14,8));
+	staticEDI.itemID(-1);
+
+	staticESP.className(staticControl);
+	staticESP.titleText("esp:");
+	staticESP.style(WS_CHILD|WS_VISIBLE);
+	staticESP.posRect(Rect(143,23,16,8));
+	staticESP.itemID(-1);
+
+	staticEBP.className(staticControl);
+	staticEBP.titleText("ebp:");
+	staticEBP.style(WS_CHILD|WS_VISIBLE);
+	staticEBP.posRect(Rect(213,23,17,8));
+	staticEBP.itemID(-1);
+
+	staticDS.className(staticControl);
+	staticDS.titleText("ds:");
+	staticDS.style(WS_CHILD|WS_VISIBLE);
+	staticDS.posRect(Rect(2,37,13,8));
+	staticDS.itemID(-1);
+
+	registerDS.className(editControl);
+	registerDS.titleText("");
+	registerDS.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerDS.posRect(Rect(17,36,26,12));
+	registerDS.itemID(DebugDS);
+
+	staticES.className(staticControl);
+	staticES.titleText("es:");
+	staticES.style(WS_CHILD|WS_VISIBLE);
+	staticES.posRect(Rect(45,37,13,8));
+	staticES.itemID(-1);
+
+	registerES.className(editControl);
+	registerES.titleText("");
+	registerES.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerES.posRect(Rect(59,36,26,12));
+	registerES.itemID(DebugES);
+
+	staticFS.className(staticControl);
+	staticFS.titleText("fs:");
+	staticFS.style(WS_CHILD|WS_VISIBLE);
+	staticFS.posRect(Rect(87,37,13,8));
+	staticFS.itemID(-1);
+
+	registerFS.className(editControl);
+	registerFS.titleText("");
+	registerFS.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerFS.posRect(Rect(101,36,26,12));
+	registerFS.itemID(DebugFS);
+
+	staticGS.className(staticControl);
+	staticGS.titleText("gs:");
+	staticGS.style(WS_CHILD|WS_VISIBLE);
+	staticGS.posRect(Rect(128,37,13,8));
+	staticGS.itemID(-1);
+
+	registerGS.className(editControl);
+	registerGS.titleText("");
+	registerGS.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerGS.posRect(Rect(142,36,26,12));
+	registerGS.itemID(DebugGS);
+
+	staticCS.className(staticControl);
+	staticCS.titleText("cs:");
+	staticCS.style(WS_CHILD|WS_VISIBLE);
+	staticCS.posRect(Rect(169,37,13,8));
+	staticCS.itemID(-1);
+
+	registerCS.className(editControl);
+	registerCS.titleText("");
+	registerCS.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerCS.posRect(Rect(183,36,26,12));
+	registerCS.itemID(DebugCS);
+
+	staticSS.className(staticControl);
+	staticSS.titleText("ss:");
+	staticSS.style(WS_CHILD|WS_VISIBLE);
+	staticSS.posRect(Rect(210,37,13,8));
+	staticSS.itemID(-1);
+
+	registerSS.className(editControl);
+	registerSS.titleText("");
+	registerSS.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerSS.posRect(Rect(224,36,26,12));
+	registerSS.itemID(DebugSS);
+
+	staticEIP.className(staticControl);
+	staticEIP.titleText("eip:");
+	staticEIP.style(WS_CHILD|WS_VISIBLE);
+	staticEIP.posRect(Rect(281,9,13,8));
+	staticEIP.itemID(-1);
+
+	registerEAX.className(editControl);
+	registerEAX.titleText("");
+	registerEAX.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerEAX.posRect(Rect(22,7,48,12));
+	registerEAX.itemID(DebugEAX);
+
+	registerEBX.className(editControl);
+	registerEBX.titleText("");
+	registerEBX.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerEBX.posRect(Rect(92,7,48,12));
+	registerEBX.itemID(DebugEBX);
+
+	registerECX.className(editControl);
+	registerECX.titleText("");
+	registerECX.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerECX.posRect(Rect(162,7,48,12));
+	registerECX.itemID(DebugECX);
+
+	registerEDX.className(editControl);
+	registerEDX.titleText("");
+	registerEDX.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerEDX.posRect(Rect(231,7,48,12));
+	registerEDX.itemID(DebugEDX);
+
+	registerESI.className(editControl);
+	registerESI.titleText("");
+	registerESI.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerESI.posRect(Rect(22,21,48,12));
+	registerESI.itemID(DebugESI);
+
+	registerEDI.className(editControl);
+	registerEDI.titleText("");
+	registerEDI.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerEDI.posRect(Rect(92,21,48,12));
+	registerEDI.itemID(DebugEDI);
+
+	registerESP.className(editControl);
+	registerESP.titleText("");
+	registerESP.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerESP.posRect(Rect(162,21,48,12));
+	registerESP.itemID(DebugESP);
+
+	registerEBP.className(editControl);
+	registerEBP.titleText("");
+	registerEBP.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerEBP.posRect(Rect(231,21,48,12));
+	registerEBP.itemID(DebugEBP);
+
+	registerEIP.className(editControl);
+	registerEIP.titleText("");
+	registerEIP.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerEIP.posRect(Rect(295,7,48,12));
+	registerEIP.itemID(DebugEIP);
+
+	registerFlagsCarry.className(editControl);
+	registerFlagsCarry.titleText("");
+	registerFlagsCarry.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerFlagsCarry.posRect(Rect(257,36,10,12));
+	registerFlagsCarry.itemID(DebugFlagsCarry);
+
+	registerFlagsZero.className(editControl);
+	registerFlagsZero.titleText("");
+	registerFlagsZero.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerFlagsZero.posRect(Rect(268,36,10,12));
+	registerFlagsZero.itemID(DebugFlagsZero);
+
+	registerFlagsSign.className(editControl);
+	registerFlagsSign.titleText("");
+	registerFlagsSign.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerFlagsSign.posRect(Rect(279,36,10,12));
+	registerFlagsSign.itemID(DebugFlagsSign);
+
+	registerFlagsOverflow.className(editControl);
+	registerFlagsOverflow.titleText("");
+	registerFlagsOverflow.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerFlagsOverflow.posRect(Rect(290,36,10,12));
+	registerFlagsOverflow.itemID(DebugFlagsOverflow);
+
+	registerFlagsParity.className(editControl);
+	registerFlagsParity.titleText("");
+	registerFlagsParity.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerFlagsParity.posRect(Rect(301,36,10,12));
+	registerFlagsParity.itemID(DebugFlagsParity);
+
+	registerFlagsAuxiliary.className(editControl);
+	registerFlagsAuxiliary.titleText("");
+	registerFlagsAuxiliary.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerFlagsAuxiliary.posRect(Rect(312,36,10,12));
+	registerFlagsAuxiliary.itemID(DebugFlagsAuxiliary);
+
+	registerFlagsDirection.className(editControl);
+	registerFlagsDirection.titleText("");
+	registerFlagsDirection.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerFlagsDirection.posRect(Rect(323,36,10,12));
+	registerFlagsDirection.itemID(DebugFlagsDirection);
+
+	registerFlagsInterrupt.className(editControl);
+	registerFlagsInterrupt.titleText("");
+	registerFlagsInterrupt.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
+	registerFlagsInterrupt.posRect(Rect(334,36,10,12));
+	registerFlagsInterrupt.itemID(DebugFlagsInterrupt);
+
+	staticFlagsLabel.className(staticControl);
+	staticFlagsLabel.titleText("Flags");
+	staticFlagsLabel.style(WS_CHILD|WS_VISIBLE);
+	staticFlagsLabel.posRect(Rect(293,25,24,8));
+	staticFlagsLabel.itemID(-1);
+
+	staticFlagsCarry.className(staticControl);
+	staticFlagsCarry.titleText("cf:");
+	staticFlagsCarry.style(WS_CHILD|WS_VISIBLE);
+	staticFlagsCarry.posRect(Rect(259,50,8,8));
+	staticFlagsCarry.itemID(-1);
+
+	staticFlagsZero.className(staticControl);
+	staticFlagsZero.titleText("zf:");
+	staticFlagsZero.style(WS_CHILD|WS_VISIBLE);
+	staticFlagsZero.posRect(Rect(270,50,8,8));
+	staticFlagsZero.itemID(-1);
+
+	staticFlagsSign.className(staticControl);
+	staticFlagsSign.titleText("sf:");
+	staticFlagsSign.style(WS_CHILD|WS_VISIBLE);
+	staticFlagsSign.posRect(Rect(281,50,8,8));
+	staticFlagsSign.itemID(-1);
+
+	staticFlagsOverflow.className(staticControl);
+	staticFlagsOverflow.titleText("ov:");
+	staticFlagsOverflow.style(WS_CHILD|WS_VISIBLE);
+	staticFlagsOverflow.posRect(Rect(292,50,8,8));
+	staticFlagsOverflow.itemID(-1);
+
+	staticFlagsParity.className(staticControl);
+	staticFlagsParity.titleText("pf:");
+	staticFlagsParity.style(WS_CHILD|WS_VISIBLE);
+	staticFlagsParity.posRect(Rect(303,50,8,8));
+	staticFlagsParity.itemID(-1);
+
+	staticFlagsAuxiliary.className(staticControl);
+	staticFlagsAuxiliary.titleText("af:");
+	staticFlagsAuxiliary.style(WS_CHILD|WS_VISIBLE);
+	staticFlagsAuxiliary.posRect(Rect(314,50,8,8));
+	staticFlagsAuxiliary.itemID(-1);
+
+	staticFlagsInterrupt.className(staticControl);
+	staticFlagsInterrupt.titleText("if:");
+	staticFlagsInterrupt.style(WS_CHILD|WS_VISIBLE);
+	staticFlagsInterrupt.posRect(Rect(336,50,8,8));
+	staticFlagsInterrupt.itemID(-1);
+
+	staticFlagsDirection.className(staticControl);
+	staticFlagsDirection.titleText("df:");
+	staticFlagsDirection.style(WS_CHILD|WS_VISIBLE);
+	staticFlagsDirection.posRect(Rect(325,50,8,8));
+	staticFlagsDirection.itemID(-1);
+
+	dlgTemplate+=argEdit;
+	dlgTemplate+=argButton;
+	dlgTemplate+=staticEAX;
+	dlgTemplate+=staticEBX;
+	dlgTemplate+=staticECX;
+	dlgTemplate+=staticEDX;
+	dlgTemplate+=staticESI;
+	dlgTemplate+=staticEDI;
+	dlgTemplate+=staticESP;
+	dlgTemplate+=staticEBP;
+	dlgTemplate+=staticDS;
+	dlgTemplate+=staticES;
+	dlgTemplate+=staticFS;
+	dlgTemplate+=staticGS;
+	dlgTemplate+=staticCS;
+	dlgTemplate+=staticSS;
+	dlgTemplate+=staticEIP;
+	dlgTemplate+=staticFlagsCarry;
+	dlgTemplate+=staticFlagsZero;
+	dlgTemplate+=staticFlagsOverflow;
+	dlgTemplate+=staticFlagsSign;
+	dlgTemplate+=staticFlagsAuxiliary;
+	dlgTemplate+=staticFlagsParity;
+	dlgTemplate+=staticFlagsDirection;
+	dlgTemplate+=staticFlagsInterrupt;
+	dlgTemplate+=registerEAX;
+	dlgTemplate+=registerEBX;
+	dlgTemplate+=registerECX;
+	dlgTemplate+=registerEDX;
+	dlgTemplate+=registerESI;
+	dlgTemplate+=registerEDI;
+	dlgTemplate+=registerESP;
+	dlgTemplate+=registerEBP;
+	dlgTemplate+=registerDS;
+	dlgTemplate+=registerES;
+	dlgTemplate+=registerFS;
+	dlgTemplate+=registerGS;
+	dlgTemplate+=registerCS;
+	dlgTemplate+=registerSS;
+	dlgTemplate+=registerEIP;
+	dlgTemplate+=registerFlagsSign;
+	dlgTemplate+=registerFlagsCarry;
+	dlgTemplate+=registerFlagsOverflow;
+	dlgTemplate+=registerFlagsZero;
+	dlgTemplate+=registerFlagsParity;
+	dlgTemplate+=registerFlagsAuxiliary;
+	dlgTemplate+=registerFlagsDirection;
+	dlgTemplate+=registerFlagsInterrupt;
+	dlgTemplate+=staticFlagsLabel;
+
+	createDialog(dlgTemplate);
+	clear();
+  return TRUE;
+}
+
+DWORD ExceptDlg::eax(void)const
+{
+  String strString;
+
+  sendMessage(DebugEAX,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::eax(DWORD eax)
+{
+  String strString;
+
+	::sprintf(strString,"%08lx",eax);
+	strString.upper();
+	sendMessage(DebugEAX,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+DWORD ExceptDlg::ebx(void)const
+{
+  String strString;
+
+	sendMessage(DebugEBX,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::ebx(DWORD ebx)
+{
+  String strString;
+
+	::sprintf(strString,"%08lx",ebx);
+	strString.upper();
+	sendMessage(DebugEBX,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+DWORD ExceptDlg::ecx(void)const
+{
+  String strString;
+
+	sendMessage(DebugECX,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::ecx(DWORD ecx)
+{
+  String strString;
+
+	::sprintf(strString,"%08lx",ecx);
+	strString.upper();
+	sendMessage(DebugECX,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+DWORD ExceptDlg::edx(void)const
+{
+  String strString;
+
+	sendMessage(DebugEDX,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::edx(DWORD edx)
+{
+  String strString;
+
+	::sprintf(strString,"%08lx",edx);
+	strString.upper();
+	sendMessage(DebugEDX,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+DWORD ExceptDlg::esi(void)const
+{
+  String strString;
+
+	sendMessage(DebugESI,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::esi(DWORD esi)
+{
+  String strString;
+
+	::sprintf(strString,"%08lx",esi);
+	strString.upper();
+	sendMessage(DebugESI,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+DWORD ExceptDlg::edi(void)const
+{
+  String strString;
+
+	sendMessage(DebugEDI,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::edi(DWORD edi)
+{
+  String strString;
+
+	::sprintf(strString,"%08lx",edi);
+	strString.upper();
+	sendMessage(DebugEDI,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+DWORD ExceptDlg::esp(void)const
+{
+  String strString;
+
+	sendMessage(DebugESP,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::esp(DWORD esp)
+{
+  String strString;
+
+	::sprintf(strString,"%08lx",esp);
+	strString.upper();
+	sendMessage(DebugESP,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+DWORD ExceptDlg::ebp(void)const
+{
+  String strString;
+
+	sendMessage(DebugEBP,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::ebp(DWORD ebp)
+{
+  String strString;
+
+	::sprintf(strString,"%08lx",ebp);
+	strString.upper();
+	sendMessage(DebugEBP,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+DWORD ExceptDlg::eip(void)const
+{
+  String strString;
+
+	sendMessage(DebugEIP,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::eip(DWORD eip)
+{
+  String strString;
+
+	::sprintf(strString,"%08lx",eip);
+	strString.upper();
+	sendMessage(DebugEIP,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+WORD ExceptDlg::ds(void)const
+{
+  String strString;
+
+	sendMessage(DebugDS,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::ds(WORD ds)
+{
+  String strString;
+
+	::sprintf(strString,"%04lx",ds);
+	strString.upper();
+	sendMessage(DebugDS,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+WORD ExceptDlg::es(void)const
+{
+  String strString;
+
+	sendMessage(DebugES,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::es(WORD es)
+{
+  String strString;
+
+	::sprintf(strString,"%04lx",es);
+	strString.upper();
+	sendMessage(DebugES,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+WORD ExceptDlg::fs(void)const
+{
+  String strString;
+
+	sendMessage(DebugFS,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::fs(WORD fs)
+{
+  String strString;
+
+	::sprintf(strString,"%04lx",fs);
+	strString.upper();
+	sendMessage(DebugFS,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+WORD ExceptDlg::gs(void)const
+{
+  String strString;
+
+	sendMessage(DebugGS,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::gs(WORD gs)
+{
+  String strString;
+
+  ::sprintf(strString,"%04lx",gs);
+	strString.upper();
+	sendMessage(DebugGS,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+WORD ExceptDlg::cs(void)const
+{
+  String strString;
+
+  sendMessage(DebugCS,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::cs(WORD cs)
+{
+  String strString;
+  
+	::sprintf(strString,"%04lx",cs);
+	strString.upper();
+	sendMessage(DebugCS,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+WORD ExceptDlg::ss(void)const
+{
+  String strString;
+
+	sendMessage(DebugSS,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::ss(WORD ss)
+{
+  String strString;
+
+	::sprintf(strString,"%04lx",ss);
+	strString.upper();
+	sendMessage(DebugSS,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+BOOL ExceptDlg::signFlag(void)const
+{
+  String strString;
+
+	sendMessage(DebugFlagsSign,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::signFlag(BOOL signFlag)
+{
+  String strString;
+
+	::sprintf(strString,"%01lx",signFlag);
+	strString.upper();
+	sendMessage(DebugFlagsSign,WM_SETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+}
+
+BOOL ExceptDlg::carryFlag(void)const
+{
+  String strString;
+
+  sendMessage(DebugFlagsCarry,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::carryFlag(BOOL carryFlag)
+{
+  String strString;
+
+	::sprintf(strString,"%01lx",carryFlag);
+	strString.upper();
+	sendMessage(DebugFlagsCarry,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+BOOL ExceptDlg::overflowFlag(void)const
+{
+  String strString;
+
+  sendMessage(DebugFlagsOverflow,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::overflowFlag(BOOL overflowFlag)
+{
+  String strString;
+
+  ::sprintf(strString,"%01lx",overflowFlag);
+	strString.upper();
+	sendMessage(DebugFlagsOverflow,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+BOOL ExceptDlg::zeroFlag(void)const
+{
+  String strString;
+
+	sendMessage(DebugFlagsZero,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::zeroFlag(BOOL zeroFlag)
+{
+  String strString;
+
+	::sprintf(strString,"%01lx",zeroFlag);
+	strString.upper();
+	sendMessage(DebugFlagsZero,WM_SETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+}
+
+BOOL ExceptDlg::parityFlag(void)const
+{
+  String strString;
+
+	sendMessage(DebugFlagsParity,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::parityFlag(BOOL parityFlag)
+{
+  String strString;
+
+  ::sprintf(strString,"%01lx",parityFlag);
+	strString.upper();
+	sendMessage(DebugFlagsParity,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+BOOL ExceptDlg::auxiliaryFlag(void)const
+{
+  String strString;
+
+	sendMessage(DebugFlagsAuxiliary,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::auxiliaryFlag(BOOL auxiliaryFlag)
+{
+  String strString;
+
+  ::sprintf(strString,"%01lx",auxiliaryFlag);
+	strString.upper();
+	sendMessage(DebugFlagsAuxiliary,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+BOOL ExceptDlg::directionFlag(void)const
+{
+  String strString;
+
+	sendMessage(DebugFlagsDirection,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::directionFlag(BOOL directionFlag)
+{
+  String strString;
+
+	::sprintf(strString,"%01lx",directionFlag);
+	strString.upper();
+	sendMessage(DebugFlagsDirection,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+BOOL ExceptDlg::interruptFlag(void)const
+{
+  String strString;
+
+	sendMessage(DebugFlagsInterrupt,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
+	return strString.hex();
+}
+
+void ExceptDlg::interruptFlag(BOOL interruptFlag)
+{
+  String strString;
+
+	::sprintf(strString,"%01lx",interruptFlag);
+	strString.upper();
+	sendMessage(DebugFlagsInterrupt,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
+}
+
+void ExceptDlg::clear(void)
+{
+  eax(0);ebx(0);ecx(0);edx(0);esi(0);edi(0);esp(0);ebp(0);eip(0);ds(0);es(0);fs(0);gs(0);cs(0);ss(0);
+	signFlag(FALSE);
+	carryFlag(FALSE);
+	overflowFlag(FALSE);
+	zeroFlag(FALSE);
+	parityFlag(FALSE);
+	auxiliaryFlag(FALSE);
+	directionFlag(FALSE);
+	interruptFlag(FALSE);
+}
+
+void ExceptDlg::showException(DWORD exceptionAddress)
+{
+  Block<String> codeLines;
+	PureViewOfFile codeView;
+	String codeLine;
+
+	codeView.createView(MaxDecodeBytes,exceptionAddress);
+	mDisAssembler.setBaseAddress(exceptionAddress);
+	mDisAssembler.displayLines(FALSE);
+	mDisAssembler.disassemble(codeLines,codeView);
+	for(int lineIndex=0;lineIndex<codeLines.size();lineIndex++)
+	{
+	  codeLine+=codeLines[lineIndex];
+		codeLine+="\r\n";
+	}
+  sendMessage(EditControlID,WM_SETTEXT,0,(LONG)(LPSTR)codeLine);
+}
+
+void ExceptDlg::showContext(void)
+{
+  eax(mExceptionContext.eax());
+	ebx(mExceptionContext.ebx());
+	ecx(mExceptionContext.ecx());
+	edx(mExceptionContext.edx());
+	esi(mExceptionContext.esi());
+	edi(mExceptionContext.edi());
+	esp(mExceptionContext.esp());
+	ebp(mExceptionContext.ebp());
+	eip(mExceptionContext.eip());
+	ds(mExceptionContext.segDS());
+	es(mExceptionContext.segES());
+	fs(mExceptionContext.segFS());
+	gs(mExceptionContext.segGS());
+	cs(mExceptionContext.segCS());
+	ss(mExceptionContext.segSS());
+	signFlag((mExceptionContext.eFlags()&0x00000080?TRUE:FALSE));
+	carryFlag((mExceptionContext.eFlags()&0x00000001?TRUE:FALSE));
+	overflowFlag((mExceptionContext.eFlags()&0xFFFFF800?TRUE:FALSE));
+	zeroFlag((mExceptionContext.eFlags()&0x00000040?TRUE:FALSE));
+	parityFlag((mExceptionContext.eFlags()&0x00000004?TRUE:FALSE));
+	auxiliaryFlag((mExceptionContext.eFlags()&0x00000010?TRUE:FALSE));
+	directionFlag((mExceptionContext.eFlags()&0x00000400?TRUE:FALSE));
+	interruptFlag((mExceptionContext.eFlags()&0x00000200?TRUE:FALSE));
+}
+
+// virtuals
+
+WORD ExceptDlg::dlgCommand(DWORD commandID,CallbackData &/*someCallbackData*/)
+{
+	switch(commandID)
+	{
+		case IDOK :
+			break;
+		case IDCANCEL :
+      break;
+	}
+  return FALSE;
+}
+
+WORD ExceptDlg::dlgCode(CallbackData &/*someCallbackData*/)
+{
+  return DLGC_WANTALLKEYS;
+}
+
+BOOL ExceptDlg::dlgInitDialog(CallbackData &/*someCallbackData*/)
+{
+	sendMessage(EditControlID,WM_SETFONT,(WPARAM)(HFONT)mEditFont,MAKELPARAM(TRUE,0));
+  showException((DWORD)mExceptionRecord.exceptionAddress());
+	showContext();
+	::SetFocus(getItem(IDOK));
+	return FALSE;
+}
+
+void ExceptDlg::dlgDestroyDialog(CallbackData &/*someCallbackData*/)
+{
+}

hookproc/EXCPTDLG.HPP

@@ -0,0 +1,112 @@
+#ifndef _HOOKPROC_EXCEPTDIALOG_HPP_
+#define _HOOKPROC_EXCEPTDIALOG_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_FONT_HPP_
+#include <common/font.hpp>
+#endif
+#ifndef _DIALOG_DYNAMICDIALOG_HPP_
+#include <dialog/dyndlg.hpp>
+#endif
+#ifndef _DECODE_DISASSEMBLER_HPP_
+#include <decode/disasm.hpp>
+#endif
+#ifndef _DEBUG_EXCEPTIONRECORD_HPP_
+#include <debug/except.hpp>
+#endif
+#ifndef _DEBUG_CONTEXT_HPP_
+#include <debug/context.hpp>
+#endif
+
+class ExceptDlg : public DynamicDialog
+{
+public:
+	ExceptDlg(void);
+	virtual ~ExceptDlg();
+	WORD performDialog(const ExceptionRecord &exceptionRecord,const Context &exceptionContext);
+	DWORD eax(void)const;
+	void eax(DWORD eax);
+	DWORD ebx(void)const;
+	void ebx(DWORD ebx);
+	DWORD ecx(void)const;
+	void ecx(DWORD ecx);
+	DWORD edx(void)const;
+	void edx(DWORD edx);
+	DWORD esi(void)const;
+	void esi(DWORD esi);
+	DWORD edi(void)const;
+	void edi(DWORD edi);
+	DWORD esp(void)const;
+	void esp(DWORD esp);
+	DWORD ebp(void)const;
+	void ebp(DWORD ebp);
+	DWORD eip(void)const;
+	void eip(DWORD eip);
+	WORD ds(void)const;
+	void ds(WORD ds);
+	WORD es(void)const;
+	void es(WORD es);
+	WORD fs(void)const;
+	void fs(WORD fs);
+	WORD gs(void)const;
+	void gs(WORD gs);
+	WORD cs(void)const;
+	void cs(WORD cs);
+	WORD ss(void)const;
+	void ss(WORD ss);
+	BOOL signFlag(void)const;
+	void signFlag(BOOL signFlag);
+	BOOL carryFlag(void)const;
+	void carryFlag(BOOL carryFlag);
+	BOOL overflowFlag(void)const;
+	void overflowFlag(BOOL overflowFlag);
+	BOOL zeroFlag(void)const;
+	void zeroFlag(BOOL zeroFlag);
+	BOOL parityFlag(void)const;
+	void parityFlag(BOOL parityFlag);
+	BOOL auxiliaryFlag(void)const;
+	void auxiliaryFlag(BOOL auxiliaryFlag);
+	BOOL directionFlag(void)const;
+	void directionFlag(BOOL directionFlag);
+	BOOL interruptFlag(void)const;
+	void interruptFlag(BOOL interruptFlag);
+	void clear(void);
+protected:
+  virtual WORD dlgCode(CallbackData &someCallbackData);
+	virtual WORD dlgCommand(DWORD commandID,CallbackData &someCallbackData);
+	virtual BOOL dlgInitDialog(CallbackData &someCallbackData);
+	virtual void dlgDestroyDialog(CallbackData &someCallbackData);
+private:
+	enum {EditControlID=200,MaxDecodeBytes=96};
+	enum {DebugEAX=500,DebugEBX=501,DebugECX=502,DebugEDX=503,DebugESI=504,DebugEDI=505,DebugESP=506,
+	      DebugEBP=507,DebugDS=508,DebugES=509,DebugFS=510,DebugGS=511,DebugCS=512,DebugSS=513,
+				DebugEIP=514,DebugFlagsSign=515,DebugFlagsCarry=516,DebugFlagsOverflow=517,DebugFlagsZero=518,
+				DebugFlagsParity=519,DebugFlagsAuxiliary=520,DebugFlagsDirection=521,DebugFlagsInterrupt=522};
+	ExceptDlg(const ExceptDlg &loginDialog);
+  void showException(DWORD exceptionAddress);
+  void showContext(void);
+
+  DisAssembler mDisAssembler;
+	ExceptionRecord mExceptionRecord;
+	Context mExceptionContext;
+	Font mEditFont;
+};
+
+inline
+ExceptDlg::ExceptDlg(void)
+: mEditFont("MS LineDraw",-8,Font::PitchFixed|Font::WeightBold)
+{
+}
+
+inline
+ExceptDlg::ExceptDlg(const ExceptDlg &/*argDialog*/)
+{
+}
+
+inline
+ExceptDlg::~ExceptDlg()
+{
+}
+#endif
+

hookproc/FRAME.ASM

@@ -0,0 +1,34 @@
+.386P
+.MODEL FLAT 
+.DATA
+.CODE
+_getFS proc near            ; PureExceptionRegistration *getFS(void)
+  push ebp                  ; save prior stack frame
+	mov ebp,esp               ; create new frame  
+	push esi                  ; save source index register
+  push es                   ; save extra segment register
+  push fs                   ; save fs register
+	pop es                    ; restor fs into es (Microsoft assembler quirk)
+	mov eax,es:[0]            ; move value of fs:[0] into eax
+	pop es                    ; restore extra segment register
+	pop esi                   ; restore source index register
+	pop ebp                   ; restore stack frame
+	retn                      ; return near to caller
+_getFS endp
+_setFS proc near            ; void setFS(PureExceptionRegistration *pPureExceptionRegistration)
+  push ebp                  ; save prior stack frame
+	mov ebp,esp               ; create new frame  
+	push esi                  ; save source index register
+  push es                   ; save extra segment register
+  push fs                   ; save fs register
+	pop es                    ; restor fs into es (Microsoft assembler quirk)
+	mov esi,[ebp+08h]         ; get pointer to PureExceptionRegistration
+	mov es:[0],esi            ; move it into FS register
+	pop es                    ; restore extra segment register
+	pop esi                   ; restore source index register
+	pop ebp                   ; restore stack frame
+	retn                      ; return near to caller
+_setFS endp
+public _getFS
+public _setFS
+END

hookproc/HOOKEXE.001

@@ -0,0 +1,131 @@
+# Microsoft Developer Studio Project File - Name="hookproc" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 5.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=hookproc - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "hookexe.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "hookexe.mak" CFG="hookproc - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "hookproc - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "hookproc - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\Release"
+# PROP BASE Intermediate_Dir ".\Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ".\Release"
+# PROP Intermediate_Dir ".\Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /W1 /GX /Od /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\Debug"
+# PROP BASE Intermediate_Dir ".\Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ".\msvcobj"
+# PROP Intermediate_Dir ".\msvcobj"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /YX /FD /I /work" /I /parts" " " /c
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib uuid.lib /nologo /subsystem:windows /debug /machine:I386
+# SUBTRACT LINK32 /pdb:none
+
+!ENDIF 
+
+# Begin Target
+
+# Name "hookproc - Win32 Release"
+# Name "hookproc - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\Main.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Exe\mscommon.lib
+# End Source File
+# Begin Source File
+
+SOURCE=..\Exe\mshook.lib
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\Apientry.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\excptdlg.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Excpthk.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Procaddr.hpp
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

hookproc/HOOKEXE.DSW

@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "hookproc"=.\hookexe.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+

hookproc/HOOKEXE.PLG

@@ -0,0 +1,35 @@
+<html>
+<body>
+<pre>
+<h1>Build Log</h1>
+<h3>
+--------------------Configuration: hookproc - Win32 Debug--------------------
+</h3>
+<h3>Command Lines</h3>
+Creating temporary file "C:\TEMP\RSP6BB3.tmp" with contents
+[
+/nologo /Zp1 /MTd /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /Fp".\msvcobj/hookexe.pch" /YX /Fo".\msvcobj/" /Fd".\msvcobj/" /FD /I /work" /I /parts" " " /c 
+"C:\Cortex\hookproc\Main.cpp"
+]
+Creating command line "cl.exe @C:\TEMP\RSP6BB3.tmp" 
+Creating temporary file "C:\TEMP\RSP6BB4.tmp" with contents
+[
+kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib uuid.lib /nologo /subsystem:windows /incremental:yes /pdb:".\msvcobj/hookexe.pdb" /debug /machine:I386 /out:".\msvcobj/hookexe.exe" 
+.\msvcobj\Main.obj
+..\Exe\mscommon.lib
+..\Exe\mshook.lib
+.\msvcobj\enumstation.obj
+]
+Creating command line "link.exe @C:\TEMP\RSP6BB4.tmp"
+<h3>Output Window</h3>
+Compiling...
+Main.cpp
+Linking...
+
+
+
+<h3>Results</h3>
+hookexe.exe - 0 error(s), 0 warning(s)
+</pre>
+</body>
+</html>

hookproc/HOOKPROC.001

@@ -0,0 +1,94 @@
+# Microsoft Developer Studio Project File - Name="hookproc" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 5.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=hookproc - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "hookproc.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "hookproc.mak" CFG="hookproc - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "hookproc - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "hookproc - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "msvcobj"
+# PROP Intermediate_Dir "msvcobj"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD CPP /nologo /Zp1 /MTd /Gm /GX /Zi /Od /I "\work" /I "\parts" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /YX /FD /c
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\mshook.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "hookproc - Win32 Release"
+# Name "hookproc - Win32 Debug"
+# Begin Source File
+
+SOURCE=.\Apientry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Enumdesk.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Msghook.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ofnhook.cpp
+# End Source File
+# End Target
+# End Project

hookproc/HOOKPROC.BAK

@@ -0,0 +1,581 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+!IF "$(CFG)" == ""
+CFG=hookproc - Win32 Debug
+!MESSAGE No configuration specified.  Defaulting to hookproc - Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "hookproc - Win32 Release" && "$(CFG)" !=\
+ "hookproc - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line.  For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "hookproc.mak" CFG="hookproc - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "hookproc - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "hookproc - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "hookproc - Win32 Debug"
+MTL=mktyplib.exe
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+OUTDIR=.\Release
+INTDIR=.\Release
+
+ALL : "$(OUTDIR)\hookproc.exe"
+
+CLEAN : 
+	-@erase "$(INTDIR)\Apientry.obj"
+	-@erase "$(INTDIR)\excptdlg.obj"
+	-@erase "$(INTDIR)\Excpthk.obj"
+	-@erase "$(INTDIR)\Main.obj"
+	-@erase "$(OUTDIR)\hookproc.exe"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS"\
+ /Fp"$(INTDIR)/hookproc.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\Release/
+CPP_SBRS=.\.
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /win32
+MTL_PROJ=/nologo /D "NDEBUG" /win32 
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/hookproc.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:windows /incremental:no\
+ /pdb:"$(OUTDIR)/hookproc.pdb" /machine:I386 /out:"$(OUTDIR)/hookproc.exe" 
+LINK32_OBJS= \
+	"$(INTDIR)\Apientry.obj" \
+	"$(INTDIR)\excptdlg.obj" \
+	"$(INTDIR)\Excpthk.obj" \
+	"$(INTDIR)\Main.obj" \
+	"..\Exe\mscommon.lib" \
+	"..\Exe\msdebug.lib" \
+	"..\Exe\msdecode.lib" \
+	"..\Exe\msdialog.lib"
+
+"$(OUTDIR)\hookproc.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "msvcobj"
+# PROP Intermediate_Dir "msvcobj"
+# PROP Target_Dir ""
+OUTDIR=.\msvcobj
+INTDIR=.\msvcobj
+
+ALL : "$(OUTDIR)\hookproc.exe"
+
+CLEAN : 
+	-@erase "$(INTDIR)\Apientry.obj"
+	-@erase "$(INTDIR)\excptdlg.obj"
+	-@erase "$(INTDIR)\Excpthk.obj"
+	-@erase "$(INTDIR)\Main.obj"
+	-@erase "$(INTDIR)\vc40.idb"
+	-@erase "$(INTDIR)\vc40.pdb"
+	-@erase "$(OUTDIR)\hookproc.exe"
+	-@erase "$(OUTDIR)\hookproc.ilk"
+	-@erase "$(OUTDIR)\hookproc.pdb"
+	-@erase ".\frame.obj"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /YX /c
+CPP_PROJ=/nologo /Zp1 /MTd /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS"\
+ /D "STRICT" /D "__FLAT__" /Fp"$(INTDIR)/hookproc.pch" /YX /Fo"$(INTDIR)/"\
+ /Fd"$(INTDIR)/" /c 
+CPP_OBJS=.\msvcobj/
+CPP_SBRS=.\.
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /win32
+MTL_PROJ=/nologo /D "_DEBUG" /win32 
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/hookproc.bsc" 
+BSC32_SBRS= \
+	
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib uuid.lib /nologo /subsystem:windows /debug /machine:I386
+# SUBTRACT LINK32 /pdb:none
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib uuid.lib /nologo /subsystem:windows /incremental:yes\
+ /pdb:"$(OUTDIR)/hookproc.pdb" /debug /machine:I386\
+ /out:"$(OUTDIR)/hookproc.exe" 
+LINK32_OBJS= \
+	"$(INTDIR)\Apientry.obj" \
+	"$(INTDIR)\excptdlg.obj" \
+	"$(INTDIR)\Excpthk.obj" \
+	"$(INTDIR)\Main.obj" \
+	"..\Exe\mscommon.lib" \
+	"..\Exe\msdebug.lib" \
+	"..\Exe\msdecode.lib" \
+	"..\Exe\msdialog.lib" \
+	".\frame.obj"
+
+"$(OUTDIR)\hookproc.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_OBJS)}.obj:
+   $(CPP) $(CPP_PROJ) $<  
+
+.c{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cpp{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+.cxx{$(CPP_SBRS)}.sbr:
+   $(CPP) $(CPP_PROJ) $<  
+
+################################################################################
+# Begin Target
+
+# Name "hookproc - Win32 Release"
+# Name "hookproc - Win32 Debug"
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\Main.cpp
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+DEP_CPP_MAIN_=\
+	{$(INCLUDE)}"\.\Apientry.hpp"\
+	{$(INCLUDE)}"\.\excptdlg.hpp"\
+	{$(INCLUDE)}"\.\Excpthk.hpp"\
+	{$(INCLUDE)}"\.\Procaddr.hpp"\
+	{$(INCLUDE)}"\.\Procaddr.tpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Codegen.hpp"\
+	{$(INCLUDE)}"\Common\Dwindow.hpp"\
+	{$(INCLUDE)}"\Common\Excpt.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Font.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\common\point.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdio.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\Common\Winnt.hpp"\
+	{$(INCLUDE)}"\Debug\Context.hpp"\
+	{$(INCLUDE)}"\Debug\Except.hpp"\
+	{$(INCLUDE)}"\Debug\Excptreg.hpp"\
+	{$(INCLUDE)}"\Debug\Savearea.hpp"\
+	{$(INCLUDE)}"\Decode\Base.hpp"\
+	{$(INCLUDE)}"\Decode\Disasm.hpp"\
+	{$(INCLUDE)}"\Decode\Extrinfo.hpp"\
+	{$(INCLUDE)}"\Decode\Isize.hpp"\
+	{$(INCLUDE)}"\Decode\Lines.hpp"\
+	{$(INCLUDE)}"\Decode\Mathcode.hpp"\
+	{$(INCLUDE)}"\Decode\Mathcode.tpp"\
+	{$(INCLUDE)}"\Decode\Mathinfo.hpp"\
+	{$(INCLUDE)}"\Decode\Opcode.hpp"\
+	{$(INCLUDE)}"\Decode\Opcode.tpp"\
+	{$(INCLUDE)}"\Decode\Opcodes.hpp"\
+	{$(INCLUDE)}"\Decode\Popcode.hpp"\
+	{$(INCLUDE)}"\Decode\Popcode.tpp"\
+	{$(INCLUDE)}"\Decode\Prefix.hpp"\
+	{$(INCLUDE)}"\Decode\Purepfx.hpp"\
+	{$(INCLUDE)}"\Decode\Value.hpp"\
+	{$(INCLUDE)}"\Dialog\Dlgitem.hpp"\
+	{$(INCLUDE)}"\Dialog\Dlgtmpl.hpp"\
+	{$(INCLUDE)}"\Dialog\Dyndlg.hpp"\
+	
+
+"$(INTDIR)\Main.obj" : $(SOURCE) $(DEP_CPP_MAIN_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+DEP_CPP_MAIN_=\
+	{$(INCLUDE)}"\.\excptdlg.hpp"\
+	{$(INCLUDE)}"\.\Excpthk.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dwindow.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Font.hpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdio.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\Decode\Base.hpp"\
+	{$(INCLUDE)}"\Decode\Disasm.hpp"\
+	{$(INCLUDE)}"\Decode\Extrinfo.hpp"\
+	{$(INCLUDE)}"\Decode\Isize.hpp"\
+	{$(INCLUDE)}"\Decode\Lines.hpp"\
+	{$(INCLUDE)}"\Decode\Mathcode.hpp"\
+	{$(INCLUDE)}"\Decode\Mathcode.tpp"\
+	{$(INCLUDE)}"\Decode\Mathinfo.hpp"\
+	{$(INCLUDE)}"\Decode\Opcode.hpp"\
+	{$(INCLUDE)}"\Decode\Opcode.tpp"\
+	{$(INCLUDE)}"\Decode\Opcodes.hpp"\
+	{$(INCLUDE)}"\Decode\Popcode.hpp"\
+	{$(INCLUDE)}"\Decode\Popcode.tpp"\
+	{$(INCLUDE)}"\Decode\Prefix.hpp"\
+	{$(INCLUDE)}"\Decode\Purepfx.hpp"\
+	{$(INCLUDE)}"\Decode\Value.hpp"\
+	{$(INCLUDE)}"\Dialog\Dlgitem.hpp"\
+	{$(INCLUDE)}"\Dialog\Dyndlg.hpp"\
+	
+
+"$(INTDIR)\Main.obj" : $(SOURCE) $(DEP_CPP_MAIN_) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=\Work\Exe\mscommon.lib
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Excpthk.cpp
+DEP_CPP_EXCPT=\
+	{$(INCLUDE)}"\.\Apientry.hpp"\
+	{$(INCLUDE)}"\.\Excpthk.hpp"\
+	{$(INCLUDE)}"\.\Procaddr.hpp"\
+	{$(INCLUDE)}"\.\Procaddr.tpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Codegen.hpp"\
+	{$(INCLUDE)}"\Common\Excpt.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdio.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Winnt.hpp"\
+	{$(INCLUDE)}"\Debug\Context.hpp"\
+	{$(INCLUDE)}"\Debug\Except.hpp"\
+	{$(INCLUDE)}"\Debug\Excptreg.hpp"\
+	{$(INCLUDE)}"\Debug\Savearea.hpp"\
+	
+
+"$(INTDIR)\Excpthk.obj" : $(SOURCE) $(DEP_CPP_EXCPT) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Apientry.cpp
+DEP_CPP_APIEN=\
+	{$(INCLUDE)}"\.\Apientry.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Codegen.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdio.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Apientry.obj" : $(SOURCE) $(DEP_CPP_APIEN) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=\Work\Exe\msdebug.lib
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=\Work\Exe\msdecode.lib
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\excptdlg.cpp
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+DEP_CPP_EXCPTD=\
+	{$(INCLUDE)}"\.\Apientry.hpp"\
+	{$(INCLUDE)}"\.\excptdlg.hpp"\
+	{$(INCLUDE)}"\.\Excpthk.hpp"\
+	{$(INCLUDE)}"\.\Procaddr.hpp"\
+	{$(INCLUDE)}"\.\Procaddr.tpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Codegen.hpp"\
+	{$(INCLUDE)}"\Common\Dwindow.hpp"\
+	{$(INCLUDE)}"\Common\Excpt.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Font.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.hpp"\
+	{$(INCLUDE)}"\Common\Gdata.tpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\common\point.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdio.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\Common\Winnt.hpp"\
+	{$(INCLUDE)}"\Debug\Context.hpp"\
+	{$(INCLUDE)}"\Debug\Except.hpp"\
+	{$(INCLUDE)}"\Debug\Excptreg.hpp"\
+	{$(INCLUDE)}"\Debug\Savearea.hpp"\
+	{$(INCLUDE)}"\Decode\Base.hpp"\
+	{$(INCLUDE)}"\Decode\Disasm.hpp"\
+	{$(INCLUDE)}"\Decode\Extrinfo.hpp"\
+	{$(INCLUDE)}"\Decode\Isize.hpp"\
+	{$(INCLUDE)}"\Decode\Lines.hpp"\
+	{$(INCLUDE)}"\Decode\Mathcode.hpp"\
+	{$(INCLUDE)}"\Decode\Mathcode.tpp"\
+	{$(INCLUDE)}"\Decode\Mathinfo.hpp"\
+	{$(INCLUDE)}"\Decode\Opcode.hpp"\
+	{$(INCLUDE)}"\Decode\Opcode.tpp"\
+	{$(INCLUDE)}"\Decode\Opcodes.hpp"\
+	{$(INCLUDE)}"\Decode\Popcode.hpp"\
+	{$(INCLUDE)}"\Decode\Popcode.tpp"\
+	{$(INCLUDE)}"\Decode\Prefix.hpp"\
+	{$(INCLUDE)}"\Decode\Purepfx.hpp"\
+	{$(INCLUDE)}"\Decode\Value.hpp"\
+	{$(INCLUDE)}"\Dialog\Dlgitem.hpp"\
+	{$(INCLUDE)}"\Dialog\Dlgtmpl.hpp"\
+	{$(INCLUDE)}"\Dialog\Dyndlg.hpp"\
+	
+
+"$(INTDIR)\excptdlg.obj" : $(SOURCE) $(DEP_CPP_EXCPTD) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+DEP_CPP_EXCPTD=\
+	{$(INCLUDE)}"\.\excptdlg.hpp"\
+	{$(INCLUDE)}"\.\Excpthk.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Callback.hpp"\
+	{$(INCLUDE)}"\Common\Callback.tpp"\
+	{$(INCLUDE)}"\Common\Cbdata.hpp"\
+	{$(INCLUDE)}"\Common\Cbptr.hpp"\
+	{$(INCLUDE)}"\Common\Dwindow.hpp"\
+	{$(INCLUDE)}"\Common\Font.hpp"\
+	{$(INCLUDE)}"\Common\Gdiobj.hpp"\
+	{$(INCLUDE)}"\Common\Guiwnd.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Rect.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Vhandler.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	{$(INCLUDE)}"\Dialog\Dlgitem.hpp"\
+	{$(INCLUDE)}"\Dialog\Dyndlg.hpp"\
+	
+
+"$(INTDIR)\excptdlg.obj" : $(SOURCE) $(DEP_CPP_EXCPTD) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=\Work\Exe\msdialog.lib
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\frame.asm
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+# Begin Custom Build
+InputPath=.\frame.asm
+InputName=frame
+
+"$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+   ml /c /Zi  /coff $(InputName).asm
+
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# End Target
+# End Project
+################################################################################

hookproc/HOOKPROC.PLG

@@ -0,0 +1,27 @@
+<html>
+<body>
+<pre>
+<h1>Build Log</h1>
+<h3>
+--------------------Configuration: hookproc - Win32 Debug--------------------
+</h3>
+<h3>Command Lines</h3>
+Creating temporary file "C:\TEMP\RSP45.tmp" with contents
+[
+/nologo /Gz /MTd /GX /ZI /Od /I "\cortex" /I "\parts" /D "_DEBUG" /D "STRICT" /D "__FLAT__" /D "WIN32" /D "_WINDOWS" /Fp"msvcobj/hookproc.pch" /YX /Fo"msvcobj/" /Fd"msvcobj/" /FD /c 
+"D:\work\HOOKPROC\EXCPTHK.CPP"
+]
+Creating command line "cl.exe @C:\TEMP\RSP45.tmp" 
+Creating command line "link.exe -lib /nologo /out:"..\exe\mshook.lib"  .\msvcobj\Apientry.obj .\msvcobj\enumdesk.obj .\msvcobj\enumstation.obj .\msvcobj\enumwin.obj .\msvcobj\Msghook.obj .\msvcobj\ofnhook.obj .\msvcobj\EXCPTHK.OBJ "
+<h3>Output Window</h3>
+Compiling...
+EXCPTHK.CPP
+Creating library...
+
+
+
+<h3>Results</h3>
+mshook.lib - 0 error(s), 0 warning(s)
+</pre>
+</body>
+</html>

hookproc/MAIN.CPP

@@ -0,0 +1,37 @@
+#include <common/wstation.hpp>
+#include <common/desktop.hpp>
+#include <hookproc/WindowStationEnumerator.hpp>
+#include <hookproc/DesktopEnumerator.hpp>
+#include <hookproc/DesktopWindowEnumerator.hpp>
+
+int PASCAL WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR /*lpszCmdLine*/,int nCmdShow)
+{
+  Desktop mainDesktop("Default");
+	if(!mainDesktop.isOkay())return false;
+
+  WindowStationEnumerator windowStationEnumerator;
+	windowStationEnumerator.enumerateWindowStations();
+	for(int index=0;index<windowStationEnumerator.size();index++)
+	{
+    DesktopEnumerator desktopEnumerator;
+	  WindowStation windowStation;
+	  ::OutputDebugString(String("WindowStationName: '")+windowStationEnumerator[index]+String("'\n"));
+		if(!windowStation.open(windowStationEnumerator[index]))::OutputDebugString("could not open window station\n");
+		desktopEnumerator.enumerateDesktops(windowStation);
+		for(int dindex=0;dindex<desktopEnumerator.size();dindex++)
+		{
+		  Desktop desktop;
+			::OutputDebugString(String("Desktop Name:")+desktopEnumerator[dindex]+String("\n"));
+			if(!desktop.open(desktopEnumerator[dindex]))continue;
+			DesktopWindowEnumerator desktopWindowEnumerator;
+			desktopWindowEnumerator.enumerateDesktopWindows(desktop);
+			for(int dwindex=0;dwindex<desktopWindowEnumerator.size();dwindex++)
+			{
+			  String strClassName;
+				::GetClassName(desktopWindowEnumerator[dwindex],(LPSTR)strClassName,String::MaxString);
+				::OutputDebugString(String("Windows Class Name:")+strClassName+String("\n"));
+			}
+		}
+	}
+  return 0;
+}

hookproc/MAIN.HPP

@@ -0,0 +1,67 @@
+#ifndef _HOOKPROC_MAIN_HPP_
+#define _HOOKPROC_MAIN_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class Main
+{
+public:
+  static HINSTANCE processInstance(HWND hWnd);
+  static HINSTANCE processInstance(void);
+	static HINSTANCE previousProcessInstance(void);
+	static void processInstance(HINSTANCE processInstance);
+  static void previousProcessInstance(HINSTANCE previousProcessInstance);
+  static void cmdShow(int nCmdShow);
+private:
+  static HINSTANCE smhInstance;
+  static HINSTANCE smhPrevInstance;
+  static int smnCmdShow;
+};
+
+inline
+void Main::processInstance(HINSTANCE hProcessInstance)
+{
+  smhInstance=hProcessInstance;
+}
+
+inline
+void Main::previousProcessInstance(HINSTANCE previousProcessInstance)
+{
+  smhPrevInstance=previousProcessInstance;
+}
+
+inline
+void Main::cmdShow(int nCmdShow)
+{
+}
+
+inline
+HINSTANCE Main::processInstance(void)
+{
+  return smhInstance;
+}
+
+inline
+HINSTANCE Main::previousProcessInstance(void)
+{
+  return smhPrevInstance;
+}
+
+#if defined(__FLAT__)
+inline
+HINSTANCE Main::processInstance(HWND hWnd)
+{
+  return (HINSTANCE)::GetWindowLong(hWnd,GWL_HINSTANCE);
+}
+#else
+inline
+HINSTANCE Main::processInstance(HWND hWnd)
+{
+  return (HINSTANCE)::GetWindowWord(hWnd,GWW_HINSTANCE);
+}
+#endif
+#define WM_REACTIVATE WM_USER+1
+#endif
+
+

hookproc/MAINWND.CPP

@@ -0,0 +1,117 @@
+#include <common/stdio.hpp>
+#include <common/rect.hpp>
+#include <common/purehdc.hpp>
+#include <hookproc/mainwnd.hpp>
+
+char MainWindow::szClassName[]="PROTO";
+char MainWindow::szMenuName[]="";
+
+MainWindow::MainWindow(void)
+: mPaintHandler(this,&MainWindow::paintHandler),
+	mDestroyHandler(this,&MainWindow::destroyHandler),
+	mCommandHandler(this,&MainWindow::commandHandler),
+	mKeyDownHandler(this,&MainWindow::keyDownHandler),
+	mSizeHandler(this,&MainWindow::sizeHandler),
+	mCreateHandler(this,&MainWindow::createHandler)
+{
+	insertHandlers();
+	registerClass();
+	::CreateWindow(szClassName,szClassName,
+		WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_SIZEBOX|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_DLGFRAME|WS_CLIPCHILDREN,
+		CW_USEDEFAULT,CW_USEDEFAULT,
+		CW_USEDEFAULT,CW_USEDEFAULT,
+		NULL,NULL,processInstance(),(LPSTR)this);
+	show(SW_SHOW);
+  update();
+}
+
+MainWindow::~MainWindow()
+{
+	destroy();
+}
+
+void MainWindow::insertHandlers(void)
+{
+	Window::insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	Window::insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	Window::insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	Window::insertHandler(VectorHandler::SizeHandler,&mSizeHandler);
+	Window::insertHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
+	Window::insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
+}
+
+void MainWindow::removeHandlers(void)
+{
+	Window::removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	Window::removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	Window::removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	Window::removeHandler(VectorHandler::SizeHandler,&mSizeHandler);
+	Window::removeHandler(VectorHandler::KeyDownHandler,&mKeyDownHandler);
+	Window::removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
+}
+
+void MainWindow::registerClass(void)const
+{
+	HINSTANCE hInstance(processInstance());
+	WNDCLASS wndClass;
+
+	if(::GetClassInfo(hInstance,className(),(WNDCLASS FAR*)&wndClass))return;
+	wndClass.style         =CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS;
+	wndClass.lpfnWndProc   =(WNDPROC)Window::WndProc;
+	wndClass.cbClsExtra    =0;
+	wndClass.cbWndExtra    =sizeof(MainWindow*);
+	wndClass.hInstance     =hInstance;
+	wndClass.hIcon         =::LoadIcon(NULL,IDI_APPLICATION);
+	wndClass.hCursor       =::LoadCursor(NULL,IDC_ARROW);
+	wndClass.hbrBackground =(HBRUSH)::GetStockObject(LTGRAY_BRUSH);
+	wndClass.lpszMenuName  =szMenuName;
+	wndClass.lpszClassName =szClassName;
+	::RegisterClass(&wndClass);
+	assert(0!=::GetClassInfo(hInstance,className(),(WNDCLASS FAR*)&wndClass));
+}
+
+CallbackData::ReturnType MainWindow::createHandler(CallbackData &/*someCallbackData*/)
+{
+  createControls();
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::destroyHandler(CallbackData &/*someCallbackData*/)
+{
+  removeHandlers();
+  ::PostQuitMessage(0);
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::sizeHandler(CallbackData &/*someCallbackData*/)
+{
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::commandHandler(CallbackData &someCallbackData)
+{
+	switch(someCallbackData.wParam())
+	{
+		default :
+      break;
+	}
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::keyDownHandler(CallbackData &/*someCallbackData*/)
+{
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainWindow::paintHandler(CallbackData &someCallbackData)
+{
+  PaintInformation &paintInfo=*((PaintInformation*)someCallbackData.lParam());
+	Rect frameRect(30,30,100,100);
+	::DrawFocusRect((PureDevice&)paintInfo,&((RECT&)frameRect));
+	return (CallbackData::ReturnType)FALSE;
+}
+
+void MainWindow::createControls(void)
+{
+}
+

hookproc/MAINWND.HPP

@@ -0,0 +1,57 @@
+#ifndef _HOOKPROC_MAINWINDOW_HPP_
+#define _HOOKPROC_MAINWINDOW_HPP_
+#ifndef _COMMON_WINDOW_HPP_
+#include <common/window.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _HOOKPROC_MESSAGEHOOK_HPP_
+#include <hookproc/msghook.hpp>
+#endif
+
+class MainWindow : public Window
+{
+public:
+	MainWindow(void);
+	virtual ~MainWindow();
+	int messageLoop(void)const;
+	static String className(void);
+private:
+	enum{TimerID=0};
+	void createControls(void);
+	void registerClass(void)const;
+	void insertHandlers(void);
+	void removeHandlers(void);
+
+	CallbackData::ReturnType paintHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType commandHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType keyDownHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType sizeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType createHandler(CallbackData &someCallbackData);
+	
+	Callback<MainWindow> mPaintHandler;
+	Callback<MainWindow> mDestroyHandler;
+	Callback<MainWindow> mCommandHandler;
+	Callback<MainWindow> mKeyDownHandler;
+	Callback<MainWindow> mSizeHandler;
+	Callback<MainWindow> mCreateHandler;
+
+	static char szClassName[];
+	static char szMenuName[];
+  MsgHook mMsgHook; 
+};
+
+inline
+String MainWindow::className(void)
+{
+	return String(szClassName);
+}
+
+inline
+int MainWindow::messageLoop(void)const
+{
+  return Window::messageLoop();
+}
+#endif

hookproc/MSGHOOK.CPP

@@ -0,0 +1,22 @@
+#include <hookproc/msghook.hpp>
+
+MsgHook::~MsgHook()
+{
+  if(!mhPrevHook)return;
+	::UnhookWindowsHookEx(mhPrevHook);
+	mhPrevHook=0;
+}
+
+int MsgHook::entryProc(int code,WPARAM wParam,LPARAM lParam)
+{
+  if(code<0)return ::CallNextHookEx(mhPrevHook,code,wParam,lParam);
+	if(!hookProc(code,wParam,lParam))::CallNextHookEx(mhPrevHook,code,wParam,lParam);
+	return FALSE;
+}
+
+// *** virtuals
+
+int MsgHook::hookProc(int /*code*/,WPARAM /*wParam*/,LPARAM /*lParam*/)
+{
+  return FALSE;
+}

hookproc/MSGHOOK.HPP

@@ -0,0 +1,41 @@
+#ifndef _HOOKPROC_MESSAGEHOOK_HPP_
+#define _HOOKPROC_MESSAGEHOOK_HPP_
+#ifndef _HOOKPROC_APIENTRY_HPP_
+#include <hookproc/apientry.hpp>
+#endif
+#ifndef _HOOKPROC_PROCADDRESS_HPP_
+#include <hookproc/procaddr.hpp>
+#endif
+
+class MsgHook;
+typedef ProcAddress<MsgHook> MessageHook;
+
+class MsgHook : protected APIEntry, private MessageHook
+{
+public:
+  MsgHook(void);
+	virtual ~MsgHook();
+protected:
+  virtual int hookProc(int code,WPARAM wParam,LPARAM lParam);
+private:
+  enum {ParamLength=12};
+	MsgHook &operator=(const MsgHook &someMsgHook);
+  int entryProc(int code,WPARAM wParam,LPARAM lParam);
+
+	HHOOK mhPrevHook;
+};
+
+inline
+MsgHook::MsgHook(void)
+: APIEntry(ParamLength,(DWORD)this,getProcAddress((ProcAddress<MsgHook>::LPFNMETHODVOID)&MsgHook::entryProc)),
+  mhPrevHook(0)
+{
+  mhPrevHook=::SetWindowsHookEx(WH_GETMESSAGE,(HOOKPROC)codeBase(),(HINSTANCE)::GetModuleHandle(0),::GetCurrentThreadId());
+}
+
+inline
+MsgHook &MsgHook::operator=(const MsgHook &someMsgHook)
+{	// no implementation
+  return *this;
+}
+#endif

hookproc/OFNHOOK.CPP

@@ -0,0 +1,22 @@
+#include <hookproc/ofnhook.hpp>
+
+OFNHook::~OFNHook()
+{
+}
+
+UINT OFNHook::entryProc(HWND hDlg,UINT uiMsg,WPARAM wParam,LPARAM lParam)
+{
+  if(!mhDlg)
+	{
+	  mhDlg=hDlg;
+		mhParent=::GetParent(mhDlg);
+	}
+  return hookProc(hDlg,uiMsg,wParam,lParam);
+}
+
+// *** virtuals
+
+UINT OFNHook::hookProc(HWND /*hDlg*/,UINT /*uiMsg*/,WPARAM /*wParam*/,LPARAM /*lParam*/)
+{
+  return FALSE;
+}

hookproc/OFNHOOK.HPP

@@ -0,0 +1,61 @@
+#ifndef _HOOKPROC_OFNHOOK_HPP_
+#define _HOOKPROC_OFNHOOK_HPP_
+#ifndef _HOOKPROC_APIENTRY_HPP_
+#include <hookproc/apientry.hpp>
+#endif
+#ifndef _HOOKPROC_PROCADDRESS_HPP_
+#include <hookproc/procaddr.hpp>
+#endif
+
+class OFNHook;
+typedef ProcAddress<OFNHook> OpenFileHook;
+
+class OFNHook : protected APIEntry, private OpenFileHook
+{
+public:
+  OFNHook(void);
+	virtual ~OFNHook();
+	DWORD getHookAddress(void);
+	HWND getHandle(void)const;
+	HWND getParent(void)const;
+protected:
+	virtual UINT hookProc(HWND hDlg,UINT uiMsg,WPARAM wParam,LPARAM lParam);
+private:
+  enum {ParamLength=16};
+	OFNHook &operator=(const OFNHook &someOFNHook);
+	UINT entryProc(HWND hDlg,UINT uiMsg,WPARAM wParam,LPARAM lParam);
+	HWND mhDlg;
+	HWND mhParent;
+};
+
+inline
+OFNHook::OFNHook(void)
+: APIEntry(ParamLength,(DWORD)this,getProcAddress((ProcAddress<OFNHook>::LPFNMETHODVOID)&OFNHook::entryProc)),
+  mhDlg(0), mhParent(0)
+{
+}
+
+inline
+OFNHook &OFNHook::operator=(const OFNHook &someOFNHook)
+{	// no implementation
+  return *this;
+}
+
+inline
+DWORD OFNHook::getHookAddress(void)
+{
+  return codeBase();
+}
+
+inline
+HWND OFNHook::getHandle(void)const
+{
+  return mhDlg;
+}
+
+inline
+HWND OFNHook::getParent(void)const
+{
+  return mhParent;
+}
+#endif

hookproc/PROCADDR.HPP

@@ -0,0 +1,20 @@
+#ifndef _HOOKPROC_PROCADDRESS_HPP_
+#define _HOOKPROC_PROCADDRESS_HPP_
+#if defined(_MSC_VER)
+#pragma warning(disable:4700)
+#endif
+
+template <class T>
+class ProcAddress
+{
+public:
+	typedef void (T::*LPFNMETHODVOID)(void);
+	ProcAddress(void);
+	virtual ~ProcAddress();
+  int getProcAddress(LPFNMETHODVOID lpfnMethod);
+private:
+};
+#if defined(_MSC_VER)
+#include <hookproc/procaddr.tpp>
+#endif
+#endif

hookproc/PROCADDR.TPP

@@ -0,0 +1,34 @@
+
+template <class T>
+ProcAddress<T>::ProcAddress(void)
+{
+}
+
+template <class T>
+ProcAddress<T>::~ProcAddress()
+{
+}
+
+#if defined(_MSC_VER)
+template <class T>
+int ProcAddress<T>::getProcAddress(LPFNMETHODVOID lpfnMethod)
+{
+	typedef void (*LPFNPROCVOID)(void);
+	int methodAddress=*((int*)&lpfnMethod);
+	return methodAddress;
+}
+#else
+template <class T>
+int ProcAddress<T>::getProcAddress(void (T::* /*lpfnMethod*/ )(void))
+{
+	typedef void (*LPFNPROCVOID)(void);
+  int methodAddress;
+	char assign[]={0x8B,0x5D,0x0C,0xC3};
+	char address[]={0x00,0x00,0x00,0x00};
+	*((DWORD*)address)=(DWORD)((DWORD*)assign);
+	((LPFNPROCVOID)address)();
+	return methodAddress;
+}
+#endif
+
+

hookproc/SCRAPS.TXT

@@ -0,0 +1,177 @@
+#include <common/string.hpp>
+#include <hookproc/main.hpp>
+#include <hookproc/mainwnd.hpp>
+
+HINSTANCE Main::smhInstance=0;
+HINSTANCE Main::smhPrevInstance=0;
+int Main::smnCmdShow=0;
+
+int PASCAL WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR /*lpszCmdLine*/,int nCmdShow)
+{
+	Main::processInstance(hInstance);
+	Main::previousProcessInstance(hPrevInstance);
+	Main::cmdShow(nCmdShow);
+	if(Main::previousProcessInstance())
+	{
+		HWND hWnd=::FindWindow(MainWindow::className(),MainWindow::className());
+		if(!hWnd)
+		{
+			::MessageBox(::GetFocus(),(LPSTR)"Failed to maximize previous instance",(LPSTR)"Error",MB_ICONSTOP|MB_SYSTEMMODAL);
+			return FALSE;
+		}
+		::PostMessage(hWnd,WM_REACTIVATE,0,0L);
+		return FALSE;
+	}
+	MainWindow applicationWindow;
+	return applicationWindow.messageLoop();
+}
+
+
+
+
+#include <common/windows.hpp>
+#include <hookproc/excptdlg.hpp>
+
+int PASCAL WinMain(HINSTANCE /*hInstance*/,HINSTANCE /*hPrevInstance*/,LPSTR /*lpszCmdLine*/,int /*nCmdShow*/)
+{
+  ExceptDlg exceptDlg;
+	exceptDlg.performDialog(0L);
+  return FALSE;
+}
+
+#if 0
+
+
+
+
+	staticDS.className(staticControl);
+	staticDS.titleText("ds:");
+	staticDS.style(WS_CHILD|WS_VISIBLE);
+	staticDS.posRect(Rect(282,10,13,8));
+	staticDS.itemID(-1);
+
+	staticES.className(staticControl);
+	staticES.titleText("es:");
+	staticES.style(WS_CHILD|WS_VISIBLE);
+	staticES.posRect(Rect(282,22,12,8));
+	staticES.itemID(-1);
+
+	staticFS.className(staticControl);
+	staticFS.titleText("fs:");
+	staticFS.style(WS_CHILD|WS_VISIBLE);
+	staticFS.posRect(Rect(282,35,13,8));
+	staticFS.itemID(-1);
+
+	staticGS.className(staticControl);
+	staticGS.titleText("gs:");
+	staticGS.style(WS_CHILD|WS_VISIBLE);
+	staticGS.posRect(Rect(282,48,13,8));
+	staticGS.itemID(-1);
+
+
+class ExceptionHandler
+{
+public:
+  ExceptionHandler(void);
+	virtual ~ExceptionHandler();
+private:
+  static PureExceptionRegistration::ExceptionDisposition _cdecl exceptionHandler(EXCEPTION_RECORD *pExceptionRecord,void *pEstablisherFrame,CONTEXT *pContext,void *pDispatcherContext);
+
+  PureExceptionRegistration *mpCurrentExceptionFrame;
+	ExceptionRegistration mExceptionFrame;
+};
+
+ExceptionHandler::ExceptionHandler(void)
+: mpCurrentExceptionFrame(0)
+{
+  installFrame(&mpCurrentExceptionFrame);
+	mExceptionFrame.prevRegistration(mpCurrentExceptionFrame);
+	mExceptionFrame.currHandler(ExceptionHandler::exceptionHandler);
+	mpCurrentExceptionFrame=&((PureExceptionRegistration&)mExceptionFrame);
+  PureExceptionRegistration *pCurrentExceptionFrame;
+	pCurrentExceptionFrame=mpCurrentExceptionFrame;
+	_asm mov eax,pCurrentExceptionFrame;
+	_asm mov fs:[0],eax
+}
+
+ExceptionHandler::~ExceptionHandler()
+{
+//  PureExceptionRegistration *pCurrentExceptionFrame;
+//	pCurrentExceptionFrame=mpCurrentExceptionFrame;
+//	_asm mov eax,pCurrentExceptionFrame;
+//	_asm mov fs:[0],eax
+}
+
+PureExceptionRegistration::ExceptionDisposition ExceptionHandler::exceptionHandler(EXCEPTION_RECORD *pExceptionRecord,void *pEstablisherFrame,CONTEXT *pContext,void *pDispatcherContext)
+{
+  ExceptionRecord exceptionRecord(*pExceptionRecord);
+
+  ExceptDlg exceptDlg;
+	exceptDlg.performDialog(exceptionRecord,*pContext);
+  return PureExceptionRegistration::ExceptionContinueSearch;
+}
+
+// ****************************************************************************************************
+
+
+
+  PureExceptionRegistration *pCurrentExceptionFrame;
+	ExceptionRegistration exceptionFrame;
+//	_asm mov eax,fs:[0];
+//	_asm mov pCurrentExceptionFrame,eax
+
+	pCurrentExceptionFrame=getFS();
+
+	exceptionFrame.prevRegistration(pCurrentExceptionFrame);
+	exceptionFrame.currHandler(exceptionHandler);
+	pCurrentExceptionFrame=&((PureExceptionRegistration&)exceptionFrame);
+	setFS(pCurrentExceptionFrame);
+//	_asm mov eax,pCurrentExceptionFrame;
+//	_asm mov fs:[0],eax
+//#endif
+
+	char *ptrData=0;
+	*ptrData=0;
+  return FALSE;
+
+
+
+
+
+
+
+#include <hookproc/excpthk.hpp>
+#include <hookproc/excptdlg.hpp>
+#include <decode/disasm.hpp>
+
+extern "C"
+{
+PureExceptionRegistration *getFS(void);
+void setFS(PureExceptionRegistration *pPureExceptionRegistration);
+}
+
+PureExceptionRegistration::ExceptionDisposition _cdecl exceptionHandler(EXCEPTION_RECORD *pExceptionRecord,void *pEstablisherFrame,CONTEXT *pContext,void *pDispatcherContext);
+
+int PASCAL WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR /*lpszCmdLine*/,int nCmdShow)
+{
+  PureExceptionRegistration *pCurrentExceptionFrame;
+	ExceptionRegistration exceptionFrame;
+	pCurrentExceptionFrame=getFS();
+	exceptionFrame.prevRegistration(pCurrentExceptionFrame);
+	exceptionFrame.currHandler(exceptionHandler);
+	pCurrentExceptionFrame=&((PureExceptionRegistration&)exceptionFrame);
+	setFS(pCurrentExceptionFrame);
+
+	char *ptrData=0;
+	*ptrData=0;
+  return FALSE;
+}
+
+PureExceptionRegistration::ExceptionDisposition _cdecl exceptionHandler(EXCEPTION_RECORD *pExceptionRecord,void *pEstablisherFrame,CONTEXT *pContext,void *pDispatcherContext)
+{
+  ExceptionRecord exceptionRecord(*pExceptionRecord);
+
+  ExceptDlg exceptDlg;
+	exceptDlg.performDialog(exceptionRecord,*pContext);
+  return PureExceptionRegistration::ExceptionContinueSearch;
+}

hookproc/STDTMPL.CPP

@@ -0,0 +1,21 @@
+#ifndef _MSC_VER
+#define _EXPAND_VECTOR_TEMPLATES_
+#define _EXPAND_BLOCK_TEMPLATES_
+#include <common/callback.hpp>
+#include <common/callback.tpp>
+#include <common/pvector.hpp>
+#include <common/pvector.tpp>
+#include <common/pointer.hpp>
+#include <common/pointer.tpp>
+#include <common/block.hpp>
+#include <common/block.tpp>
+#include <common/purebmp.hpp>
+#include <hookproc/procaddr.hpp>
+#include <hookproc/procaddr.tpp>
+#include <hookproc/msghook.hpp>
+
+class MainWindow;
+
+typedef Callback<MainWindow> a;
+typedef ProcAddress<MsgHook> b;
+#endif

hookproc/TEST.RC

@@ -0,0 +1,47 @@
+/****************************************************************************
+
+
+test.rc
+
+produced by Borland Resource Workshop
+
+
+*****************************************************************************/
+
+#define DIALOG_1	1
+#define IDC_EDIT1	101
+#define IDC_EDIT8	108
+#define IDC_EDIT7	107
+#define IDC_EDIT6	106
+#define IDC_EDIT5	105
+#define IDC_EDIT4	104
+#define IDC_EDIT3	103
+#define IDC_EDIT2	102
+
+DIALOG_1 DIALOG 6, 15, 207, 111
+STYLE DS_MODALFRAME | 0x4L | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
+CAPTION "DIALOG_1"
+FONT 8, "MS Sans Serif"
+{
+ DEFPUSHBUTTON "OK", IDOK, 148, 6, 50, 14
+ PUSHBUTTON "Cancel", IDCANCEL, 148, 24, 50, 14
+ PUSHBUTTON "Help", IDHELP, 148, 42, 50, 14
+ EDITTEXT IDC_EDIT1, 36, 31, 10, 12
+ EDITTEXT IDC_EDIT2, 46, 31, 10, 12
+ EDITTEXT IDC_EDIT3, 56, 31, 10, 12
+ EDITTEXT IDC_EDIT4, 66, 31, 10, 12
+ EDITTEXT IDC_EDIT5, 76, 31, 10, 12
+ EDITTEXT IDC_EDIT6, 86, 31, 10, 12
+ EDITTEXT IDC_EDIT7, 96, 31, 10, 12
+ EDITTEXT IDC_EDIT8, 106, 31, 10, 12
+ LTEXT "cf", -1, 38, 45, 6, 8
+ CTEXT "Flags", -1, 47, 20, 60, 8
+ LTEXT "zf", -1, 48, 45, 6, 8
+ LTEXT "sf", -1, 57, 45, 6, 8
+ LTEXT "ov", -1, 66, 45, 8, 8
+ LTEXT "pf", -1, 77, 45, 6, 8
+ LTEXT "af", -1, 87, 45, 6, 8
+ LTEXT "df", -1, 97, 45, 6, 8
+ LTEXT "if", -1, 109, 45, 6, 8
+}
+

hookproc/WindowStationEnumerator.hpp

@@ -0,0 +1,55 @@
+#ifndef _HOOKPROC_WINDOWSTATIONENUMERATOR_HPP_
+#define _HOOKPROC_WINDOWSTATIONENUMERATOR_HPP_
+#ifndef _HOOKPROC_ENUMWINDOWSTATIONHOOK_HPP_
+#include <hookproc/enumstation.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+
+class WindowStationEnumerator : public EnumWindowStationHook, public Block<String>
+{
+public:
+  WindowStationEnumerator();
+	virtual ~WindowStationEnumerator();
+	bool enumerateWindowStations(void);
+	DWORD size(void)const;
+protected:
+  virtual bool enumWindowStationProc(const String &strWindowStation);
+private:
+};
+
+inline
+WindowStationEnumerator::WindowStationEnumerator()
+{
+}
+
+inline
+WindowStationEnumerator::~WindowStationEnumerator()
+{
+}
+
+inline
+bool WindowStationEnumerator::enumerateWindowStations(void)
+{
+  remove();
+	::EnumWindowStations((LPFNENUMWINDOWSTATIONPROC)getHookAddress(),0L);
+	return Block<String>::size()?true:false;
+}
+
+inline
+bool WindowStationEnumerator::enumWindowStationProc(const String &strWindowStation)
+{
+  insert(&strWindowStation);
+  return true;
+}
+
+inline
+DWORD WindowStationEnumerator::size(void)const
+{
+  return Block<String>::size();
+}
+#endif

hookproc/enumdesk.cpp

@@ -0,0 +1,19 @@
+#include <hookproc/enumdesk.hpp>
+#include <common/string.hpp>
+
+EnumDesktopHook::~EnumDesktopHook()
+{
+}
+
+bool EnumDesktopHook::entryProc(LPSTR lpszDesktop,LPARAM lParam)
+{
+  return enumDesktopProc(String(lpszDesktop));
+}
+
+// *** virtuals
+
+bool EnumDesktopHook::enumDesktopProc(const String &strDesktop)
+{
+  ::OutputDebugString(strDesktop+String("\n"));
+  return true;
+}

hookproc/enumdesk.hpp

@@ -0,0 +1,45 @@
+#ifndef _HOOKPROC_ENUMDESKTOPHOOK_HPP_
+#define _HOOKPROC_ENUMDESKTOPHOOK_HPP_
+#ifndef _HOOKPROC_APIENTRY_HPP_
+#include <hookproc/apientry.hpp>
+#endif
+#ifndef _HOOKPROC_PROCADDRESS_HPP_
+#include <hookproc/procaddr.hpp>
+#endif
+
+class EnumDesktopHook;
+typedef ProcAddress<EnumDesktopHook> EnumDesktopHookProc;
+
+class EnumDesktopHook : protected APIEntry, private EnumDesktopHookProc
+{
+public:
+  typedef int (__stdcall *LPFNENUMDESKTOPPROC)(LPTSTR lpszDesktop,LPARAM lParam);
+  EnumDesktopHook(void);
+	virtual ~EnumDesktopHook();
+	DWORD getHookAddress(void);
+protected:
+  virtual bool enumDesktopProc(const String &strDesktop);
+private:
+  enum {ParamLength=8};
+	EnumDesktopHook &operator=(const EnumDesktopHook &someEnumDesktopHook);
+	bool entryProc(LPTSTR lpszDesktop,LPARAM lParam);
+};
+
+inline
+EnumDesktopHook::EnumDesktopHook(void)
+: APIEntry(ParamLength,(DWORD)this,getProcAddress((ProcAddress<EnumDesktopHook>::LPFNMETHODVOID)&EnumDesktopHook::entryProc))
+{
+}
+
+inline
+EnumDesktopHook &EnumDesktopHook::operator=(const EnumDesktopHook &someEnumDesktopHook)
+{	// no implementation
+  return *this;
+}
+
+inline
+DWORD EnumDesktopHook::getHookAddress(void)
+{
+  return codeBase();
+}
+#endif

hookproc/enumstation.cpp

@@ -0,0 +1,19 @@
+#include <hookproc/enumstation.hpp>
+#include <common/string.hpp>
+
+EnumWindowStationHook::~EnumWindowStationHook()
+{
+}
+
+bool EnumWindowStationHook::entryProc(LPSTR lpszWindowStation,LPARAM lParam)
+{
+  return enumWindowStationProc(String(lpszWindowStation));
+}
+
+// *** virtuals
+
+bool EnumWindowStationHook::enumWindowStationProc(const String &strWindowStation)
+{
+  ::OutputDebugString(String("'")+strWindowStation+String("'\n"));
+  return true;
+}

hookproc/enumstation.hpp

@@ -0,0 +1,45 @@
+#ifndef _HOOKPROC_ENUMWINDOWSTATIONHOOK_HPP_
+#define _HOOKPROC_ENUMWINDOWSTATIONHOOK_HPP_
+#ifndef _HOOKPROC_APIENTRY_HPP_
+#include <hookproc/apientry.hpp>
+#endif
+#ifndef _HOOKPROC_PROCADDRESS_HPP_
+#include <hookproc/procaddr.hpp>
+#endif
+
+class EnumWindowStationHook;
+typedef ProcAddress<EnumWindowStationHook> EnumWindowStationHookProc;
+
+class EnumWindowStationHook : protected APIEntry, private EnumWindowStationHookProc
+{
+public:
+  typedef int (__stdcall *LPFNENUMWINDOWSTATIONPROC)(LPTSTR lpszWindowStation,LPARAM lParam);
+  EnumWindowStationHook(void);
+	virtual ~EnumWindowStationHook();
+	DWORD getHookAddress(void);
+protected:
+  virtual bool enumWindowStationProc(const String &strWindowStation);
+private:
+  enum {ParamLength=8};
+	EnumWindowStationHook &operator=(const EnumWindowStationHook &someEnumWindowStationHook);
+	bool entryProc(LPTSTR lpszWIndowStation,LPARAM lParam);
+};
+
+inline
+EnumWindowStationHook::EnumWindowStationHook(void)
+: APIEntry(ParamLength,(DWORD)this,getProcAddress((ProcAddress<EnumWindowStationHook>::LPFNMETHODVOID)&EnumWindowStationHook::entryProc))
+{
+}
+
+inline
+EnumWindowStationHook &EnumWindowStationHook::operator=(const EnumWindowStationHook &someEnumWindowStationHook)
+{	// no implementation
+  return *this;
+}
+
+inline
+DWORD EnumWindowStationHook::getHookAddress(void)
+{
+  return codeBase();
+}
+#endif

hookproc/excpthk.cpp

@@ -0,0 +1,11 @@
+#include <hookproc/excpthk.hpp>
+
+PureExceptionRegistration::ExceptionDisposition ExcptHook::entryProc(EXCEPTION_RECORD *pExceptionRecord,void *pEstablisherFrame,CONTEXT *pContext,void *pDispatcherContext)
+{
+  return exceptionHandler(pExceptionRecord,pEstablisherFrame,pContext,pDispatcherContext);
+}
+
+PureExceptionRegistration::ExceptionDisposition ExcptHook::exceptionHandler(EXCEPTION_RECORD *pExceptionRecord,void *pEstablisherFrame,CONTEXT *pContext,void *pDispatcherContext)
+{
+  return PureExceptionRegistration::ExceptionContinueSearch;
+}

hookproc/excpthk.hpp

@@ -0,0 +1,80 @@
+#ifndef _HOOKPROC_EXCEPTIONHOOK_HPP_
+#define _HOOKPROC_EXCEPTIONHOOK_HPP_
+#ifndef _HOOKPROC_APIENTRY_HPP_
+#include <hookproc/apientry.hpp>
+#endif
+#ifndef _HOOKPROC_PROCADDRESS_HPP_
+#include <hookproc/procaddr.hpp>
+#endif
+#ifndef _DEBUG_EXCEPTIONREGISTRATION_HPP_
+#include <debug/excptreg.hpp>
+#endif
+
+class ExcptHook;
+typedef ProcAddress<ExcptHook> ExceptionHook;
+
+extern "C"
+{
+void registerHandler(PureExceptionRegistration::ExceptionHandler pExceptionHandler);
+void unregisterHandler(void);
+}
+
+class ExcptHook : protected APIEntry, private ExceptionHook
+{
+public:
+  ExcptHook(void);
+	virtual ~ExcptHook();
+	void registerHandler(void);
+protected:
+  virtual PureExceptionRegistration::ExceptionDisposition exceptionHandler(EXCEPTION_RECORD *pExceptionRecord,void *pEstablisherFrame,CONTEXT *pContext,void *pDispatcherContext);
+private:
+  enum {ParamLength=16};
+	ExcptHook &operator=(const ExcptHook &someExcptHook);
+  PureExceptionRegistration::ExceptionDisposition entryProc(EXCEPTION_RECORD *pExceptionRecord,void *pEstablisherFrame,CONTEXT *pContext,void *pDispatcherContext);
+	WORD isRegistered(void)const;
+	void isRegistered(WORD isRegistered);
+
+	WORD mIsRegistered;
+};
+
+inline
+ExcptHook::ExcptHook(void)
+: APIEntry(ParamLength,(DWORD)this,getProcAddress((ProcAddress<ExcptHook>::LPFNMETHODVOID)&ExcptHook::entryProc)),
+  mIsRegistered(FALSE)
+{
+}
+
+inline
+ExcptHook::~ExcptHook()
+{
+  if(!isRegistered())return;
+  ::unregisterHandler();
+}
+
+inline
+ExcptHook &ExcptHook::operator=(const ExcptHook &someExcptHook)
+{ // no implementation
+  return *this;
+}
+
+inline
+void ExcptHook::registerHandler(void)
+{
+  if(isRegistered())return;
+  ::registerHandler((PureExceptionRegistration::ExceptionHandler)codeBase());
+	isRegistered(TRUE);
+}
+
+inline
+WORD ExcptHook::isRegistered(void)const
+{
+  return mIsRegistered;
+}
+
+inline
+void ExcptHook::isRegistered(WORD isRegistered)
+{
+  mIsRegistered=isRegistered;
+}
+#endif
+

hookproc/hookexe.dsp

@@ -0,0 +1,135 @@
+# Microsoft Developer Studio Project File - Name="hookproc" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 5.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=hookproc - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "hookexe.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "hookexe.mak" CFG="hookproc - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "hookproc - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "hookproc - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE 
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\Release"
+# PROP BASE Intermediate_Dir ".\Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ".\Release"
+# PROP Intermediate_Dir ".\Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /GX /Zi /Od /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\Debug"
+# PROP BASE Intermediate_Dir ".\Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ".\msvcobj"
+# PROP Intermediate_Dir ".\msvcobj"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /Zp1 /MTd /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /YX /FD /I /work" /I /parts" " " /c
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib uuid.lib /nologo /subsystem:windows /debug /machine:I386
+# SUBTRACT LINK32 /pdb:none
+
+!ENDIF 
+
+# Begin Target
+
+# Name "hookproc - Win32 Release"
+# Name "hookproc - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\enumstation.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Main.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Exe\mscommon.lib
+# End Source File
+# Begin Source File
+
+SOURCE=..\Exe\mshook.lib
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\Apientry.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\excptdlg.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Excpthk.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Procaddr.hpp
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

hookproc/hookproc.002

@@ -0,0 +1,108 @@
+# Microsoft Developer Studio Project File - Name="hookproc" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 5.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=hookproc - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "hookproc.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "hookproc.mak" CFG="hookproc - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "hookproc - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "hookproc - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+RSC=rc.exe
+# ADD BASE RSC /l 0x409
+# ADD RSC /l 0x409
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "msvcobj"
+# PROP Intermediate_Dir "msvcobj"
+# PROP Target_Dir ""
+RSC=rc.exe
+# ADD BASE RSC /l 0x409
+# ADD RSC /l 0x409
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD CPP /nologo /Zp1 /MTd /GX /Zi /Od /I "\cortex" /I "\parts" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /YX /FD /c
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\mshook.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "hookproc - Win32 Release"
+# Name "hookproc - Win32 Debug"
+# Begin Source File
+
+SOURCE=.\Apientry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\enumdesk.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\enumstation.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\enumwin.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Msghook.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ofnhook.cpp
+# End Source File
+# End Target
+# End Project

hookproc/hookproc.dsp

@@ -0,0 +1,108 @@
+# Microsoft Developer Studio Project File - Name="hookproc" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=hookproc - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "hookproc.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "hookproc.mak" CFG="hookproc - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "hookproc - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "hookproc - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD CPP /nologo /MT /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /YX /FD /c
+# ADD BASE RSC /l 0x409
+# ADD RSC /l 0x409
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "msvcobj"
+# PROP Intermediate_Dir "msvcobj"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD CPP /nologo /Gz /MTd /GX /ZI /Od /I "\cortex" /I "\parts" /D "_DEBUG" /D "STRICT" /D "__FLAT__" /D "WIN32" /D "_WINDOWS" /YX /FD /c
+# ADD BASE RSC /l 0x409
+# ADD RSC /l 0x409
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\mshook.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "hookproc - Win32 Release"
+# Name "hookproc - Win32 Debug"
+# Begin Source File
+
+SOURCE=.\Apientry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\enumdesk.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\enumstation.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\enumwin.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Msghook.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ofnhook.cpp
+# End Source File
+# End Target
+# End Project

hookproc/hookproc.dsw

@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "hookproc"=.\hookproc.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+

hookproc/hookproc.mak

@@ -0,0 +1,507 @@
+# Microsoft Developer Studio Generated NMAKE File, Based on hookproc.dsp
+!IF "$(CFG)" == ""
+CFG=hookproc - Win32 Debug
+!MESSAGE No configuration specified. Defaulting to hookproc - Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "hookproc - Win32 Release" && "$(CFG)" !=\
+ "hookproc - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "hookproc.mak" CFG="hookproc - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "hookproc - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "hookproc - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+!ERROR An invalid configuration is specified.
+!ENDIF 
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE 
+NULL=nul
+!ENDIF 
+
+CPP=cl.exe
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+OUTDIR=.\Release
+INTDIR=.\Release
+# Begin Custom Macros
+OutDir=.\Release
+# End Custom Macros
+
+!IF "$(RECURSE)" == "0" 
+
+ALL : "$(OUTDIR)\hookproc.lib"
+
+!ELSE 
+
+ALL : "$(OUTDIR)\hookproc.lib"
+
+!ENDIF 
+
+CLEAN :
+	-@erase "$(INTDIR)\Apientry.obj"
+	-@erase "$(INTDIR)\enumdesk.obj"
+	-@erase "$(INTDIR)\enumstation.obj"
+	-@erase "$(INTDIR)\enumwin.obj"
+	-@erase "$(INTDIR)\Msghook.obj"
+	-@erase "$(INTDIR)\ofnhook.obj"
+	-@erase "$(INTDIR)\vc50.idb"
+	-@erase "$(OUTDIR)\hookproc.lib"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+RSC=rc.exe
+CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS"\
+ /Fp"$(INTDIR)\hookproc.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /c 
+CPP_OBJS=.\Release/
+CPP_SBRS=.
+BSC32=bscmake.exe
+BSC32_FLAGS=/nologo /o"$(OUTDIR)\hookproc.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)\hookproc.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\Apientry.obj" \
+	"$(INTDIR)\enumdesk.obj" \
+	"$(INTDIR)\enumstation.obj" \
+	"$(INTDIR)\enumwin.obj" \
+	"$(INTDIR)\Msghook.obj" \
+	"$(INTDIR)\ofnhook.obj"
+
+"$(OUTDIR)\hookproc.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+OUTDIR=.\msvcobj
+INTDIR=.\msvcobj
+
+!IF "$(RECURSE)" == "0" 
+
+ALL : "..\exe\mshook.lib"
+
+!ELSE 
+
+ALL : "..\exe\mshook.lib"
+
+!ENDIF 
+
+CLEAN :
+	-@erase "$(INTDIR)\Apientry.obj"
+	-@erase "$(INTDIR)\enumdesk.obj"
+	-@erase "$(INTDIR)\enumstation.obj"
+	-@erase "$(INTDIR)\enumwin.obj"
+	-@erase "$(INTDIR)\Msghook.obj"
+	-@erase "$(INTDIR)\ofnhook.obj"
+	-@erase "$(INTDIR)\vc50.idb"
+	-@erase "$(INTDIR)\vc50.pdb"
+	-@erase "..\exe\mshook.lib"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+RSC=rc.exe
+CPP_PROJ=/nologo /Zp1 /MTd /GX /Zi /Od /I "\cortex" /I "\parts" /D "WIN32" /D\
+ "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /Fp"$(INTDIR)\hookproc.pch"\
+ /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /c 
+CPP_OBJS=.\msvcobj/
+CPP_SBRS=.
+BSC32=bscmake.exe
+BSC32_FLAGS=/nologo /o"$(OUTDIR)\hookproc.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+LIB32_FLAGS=/nologo /out:"..\exe\mshook.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\Apientry.obj" \
+	"$(INTDIR)\enumdesk.obj" \
+	"$(INTDIR)\enumstation.obj" \
+	"$(INTDIR)\enumwin.obj" \
+	"$(INTDIR)\Msghook.obj" \
+	"$(INTDIR)\ofnhook.obj"
+
+"..\exe\mshook.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ENDIF 
+
+.c{$(CPP_OBJS)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cpp{$(CPP_OBJS)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cxx{$(CPP_OBJS)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.c{$(CPP_SBRS)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cpp{$(CPP_SBRS)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+.cxx{$(CPP_SBRS)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $< 
+<<
+
+
+!IF "$(CFG)" == "hookproc - Win32 Release" || "$(CFG)" ==\
+ "hookproc - Win32 Debug"
+SOURCE=.\Apientry.cpp
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+DEP_CPP_APIEN=\
+	".\apientry.hpp"\
+	{$(INCLUDE)}"common\block.hpp"\
+	{$(INCLUDE)}"common\block.tpp"\
+	{$(INCLUDE)}"common\codegen.hpp"\
+	{$(INCLUDE)}"common\except.hpp"\
+	{$(INCLUDE)}"common\filemap.hpp"\
+	{$(INCLUDE)}"common\gdata.hpp"\
+	{$(INCLUDE)}"common\gdata.tpp"\
+	{$(INCLUDE)}"common\puredwrd.hpp"\
+	{$(INCLUDE)}"common\pview.hpp"\
+	{$(INCLUDE)}"common\stdio.hpp"\
+	{$(INCLUDE)}"common\stdlib.hpp"\
+	{$(INCLUDE)}"common\string.hpp"\
+	{$(INCLUDE)}"common\types.hpp"\
+	{$(INCLUDE)}"common\windows.hpp"\
+	
+
+"$(INTDIR)\Apientry.obj" : $(SOURCE) $(DEP_CPP_APIEN) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+DEP_CPP_APIEN=\
+	".\apientry.hpp"\
+	{$(INCLUDE)}"common\block.hpp"\
+	{$(INCLUDE)}"common\block.tpp"\
+	{$(INCLUDE)}"common\codegen.hpp"\
+	{$(INCLUDE)}"common\except.hpp"\
+	{$(INCLUDE)}"common\filemap.hpp"\
+	{$(INCLUDE)}"common\gdata.hpp"\
+	{$(INCLUDE)}"common\gdata.tpp"\
+	{$(INCLUDE)}"common\puredwrd.hpp"\
+	{$(INCLUDE)}"common\pview.hpp"\
+	{$(INCLUDE)}"common\stdio.hpp"\
+	{$(INCLUDE)}"common\stdlib.hpp"\
+	{$(INCLUDE)}"common\string.hpp"\
+	{$(INCLUDE)}"common\types.hpp"\
+	{$(INCLUDE)}"common\windows.hpp"\
+	
+
+"$(INTDIR)\Apientry.obj" : $(SOURCE) $(DEP_CPP_APIEN) "$(INTDIR)"
+
+
+!ENDIF 
+
+SOURCE=.\enumdesk.cpp
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+DEP_CPP_ENUMD=\
+	".\apientry.hpp"\
+	".\enumdesk.hpp"\
+	".\procaddr.hpp"\
+	".\procaddr.tpp"\
+	{$(INCLUDE)}"common\block.hpp"\
+	{$(INCLUDE)}"common\block.tpp"\
+	{$(INCLUDE)}"common\codegen.hpp"\
+	{$(INCLUDE)}"common\except.hpp"\
+	{$(INCLUDE)}"common\filemap.hpp"\
+	{$(INCLUDE)}"common\gdata.hpp"\
+	{$(INCLUDE)}"common\gdata.tpp"\
+	{$(INCLUDE)}"common\puredwrd.hpp"\
+	{$(INCLUDE)}"common\pview.hpp"\
+	{$(INCLUDE)}"common\stdio.hpp"\
+	{$(INCLUDE)}"common\stdlib.hpp"\
+	{$(INCLUDE)}"common\string.hpp"\
+	{$(INCLUDE)}"common\types.hpp"\
+	{$(INCLUDE)}"common\windows.hpp"\
+	
+
+"$(INTDIR)\enumdesk.obj" : $(SOURCE) $(DEP_CPP_ENUMD) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+DEP_CPP_ENUMD=\
+	".\apientry.hpp"\
+	".\enumdesk.hpp"\
+	".\procaddr.hpp"\
+	".\procaddr.tpp"\
+	{$(INCLUDE)}"common\block.hpp"\
+	{$(INCLUDE)}"common\block.tpp"\
+	{$(INCLUDE)}"common\codegen.hpp"\
+	{$(INCLUDE)}"common\except.hpp"\
+	{$(INCLUDE)}"common\filemap.hpp"\
+	{$(INCLUDE)}"common\gdata.hpp"\
+	{$(INCLUDE)}"common\gdata.tpp"\
+	{$(INCLUDE)}"common\puredwrd.hpp"\
+	{$(INCLUDE)}"common\pview.hpp"\
+	{$(INCLUDE)}"common\stdio.hpp"\
+	{$(INCLUDE)}"common\stdlib.hpp"\
+	{$(INCLUDE)}"common\string.hpp"\
+	{$(INCLUDE)}"common\types.hpp"\
+	{$(INCLUDE)}"common\windows.hpp"\
+	
+
+"$(INTDIR)\enumdesk.obj" : $(SOURCE) $(DEP_CPP_ENUMD) "$(INTDIR)"
+
+
+!ENDIF 
+
+SOURCE=.\enumstation.cpp
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+DEP_CPP_ENUMS=\
+	".\apientry.hpp"\
+	".\enumstation.hpp"\
+	".\procaddr.hpp"\
+	".\procaddr.tpp"\
+	{$(INCLUDE)}"common\block.hpp"\
+	{$(INCLUDE)}"common\block.tpp"\
+	{$(INCLUDE)}"common\codegen.hpp"\
+	{$(INCLUDE)}"common\except.hpp"\
+	{$(INCLUDE)}"common\filemap.hpp"\
+	{$(INCLUDE)}"common\gdata.hpp"\
+	{$(INCLUDE)}"common\gdata.tpp"\
+	{$(INCLUDE)}"common\puredwrd.hpp"\
+	{$(INCLUDE)}"common\pview.hpp"\
+	{$(INCLUDE)}"common\stdio.hpp"\
+	{$(INCLUDE)}"common\stdlib.hpp"\
+	{$(INCLUDE)}"common\string.hpp"\
+	{$(INCLUDE)}"common\types.hpp"\
+	{$(INCLUDE)}"common\windows.hpp"\
+	
+
+"$(INTDIR)\enumstation.obj" : $(SOURCE) $(DEP_CPP_ENUMS) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+DEP_CPP_ENUMS=\
+	".\apientry.hpp"\
+	".\enumstation.hpp"\
+	".\procaddr.hpp"\
+	".\procaddr.tpp"\
+	{$(INCLUDE)}"common\block.hpp"\
+	{$(INCLUDE)}"common\block.tpp"\
+	{$(INCLUDE)}"common\codegen.hpp"\
+	{$(INCLUDE)}"common\except.hpp"\
+	{$(INCLUDE)}"common\filemap.hpp"\
+	{$(INCLUDE)}"common\gdata.hpp"\
+	{$(INCLUDE)}"common\gdata.tpp"\
+	{$(INCLUDE)}"common\puredwrd.hpp"\
+	{$(INCLUDE)}"common\pview.hpp"\
+	{$(INCLUDE)}"common\stdio.hpp"\
+	{$(INCLUDE)}"common\stdlib.hpp"\
+	{$(INCLUDE)}"common\string.hpp"\
+	{$(INCLUDE)}"common\types.hpp"\
+	{$(INCLUDE)}"common\windows.hpp"\
+	
+
+"$(INTDIR)\enumstation.obj" : $(SOURCE) $(DEP_CPP_ENUMS) "$(INTDIR)"
+
+
+!ENDIF 
+
+SOURCE=.\enumwin.cpp
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+DEP_CPP_ENUMW=\
+	".\apientry.hpp"\
+	".\enumwin.hpp"\
+	".\procaddr.hpp"\
+	".\procaddr.tpp"\
+	{$(INCLUDE)}"common\block.hpp"\
+	{$(INCLUDE)}"common\block.tpp"\
+	{$(INCLUDE)}"common\codegen.hpp"\
+	{$(INCLUDE)}"common\except.hpp"\
+	{$(INCLUDE)}"common\filemap.hpp"\
+	{$(INCLUDE)}"common\gdata.hpp"\
+	{$(INCLUDE)}"common\gdata.tpp"\
+	{$(INCLUDE)}"common\puredwrd.hpp"\
+	{$(INCLUDE)}"common\pview.hpp"\
+	{$(INCLUDE)}"common\stdio.hpp"\
+	{$(INCLUDE)}"common\stdlib.hpp"\
+	{$(INCLUDE)}"common\string.hpp"\
+	{$(INCLUDE)}"common\types.hpp"\
+	{$(INCLUDE)}"common\windows.hpp"\
+	
+
+"$(INTDIR)\enumwin.obj" : $(SOURCE) $(DEP_CPP_ENUMW) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+DEP_CPP_ENUMW=\
+	".\apientry.hpp"\
+	".\enumwin.hpp"\
+	".\procaddr.hpp"\
+	".\procaddr.tpp"\
+	{$(INCLUDE)}"common\block.hpp"\
+	{$(INCLUDE)}"common\block.tpp"\
+	{$(INCLUDE)}"common\codegen.hpp"\
+	{$(INCLUDE)}"common\except.hpp"\
+	{$(INCLUDE)}"common\filemap.hpp"\
+	{$(INCLUDE)}"common\gdata.hpp"\
+	{$(INCLUDE)}"common\gdata.tpp"\
+	{$(INCLUDE)}"common\puredwrd.hpp"\
+	{$(INCLUDE)}"common\pview.hpp"\
+	{$(INCLUDE)}"common\stdio.hpp"\
+	{$(INCLUDE)}"common\stdlib.hpp"\
+	{$(INCLUDE)}"common\string.hpp"\
+	{$(INCLUDE)}"common\types.hpp"\
+	{$(INCLUDE)}"common\windows.hpp"\
+	
+
+"$(INTDIR)\enumwin.obj" : $(SOURCE) $(DEP_CPP_ENUMW) "$(INTDIR)"
+
+
+!ENDIF 
+
+SOURCE=.\Msghook.cpp
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+DEP_CPP_MSGHO=\
+	".\apientry.hpp"\
+	".\msghook.hpp"\
+	".\procaddr.hpp"\
+	".\procaddr.tpp"\
+	{$(INCLUDE)}"common\block.hpp"\
+	{$(INCLUDE)}"common\block.tpp"\
+	{$(INCLUDE)}"common\codegen.hpp"\
+	{$(INCLUDE)}"common\except.hpp"\
+	{$(INCLUDE)}"common\filemap.hpp"\
+	{$(INCLUDE)}"common\gdata.hpp"\
+	{$(INCLUDE)}"common\gdata.tpp"\
+	{$(INCLUDE)}"common\puredwrd.hpp"\
+	{$(INCLUDE)}"common\pview.hpp"\
+	{$(INCLUDE)}"common\stdio.hpp"\
+	{$(INCLUDE)}"common\stdlib.hpp"\
+	{$(INCLUDE)}"common\string.hpp"\
+	{$(INCLUDE)}"common\types.hpp"\
+	{$(INCLUDE)}"common\windows.hpp"\
+	
+
+"$(INTDIR)\Msghook.obj" : $(SOURCE) $(DEP_CPP_MSGHO) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+DEP_CPP_MSGHO=\
+	".\apientry.hpp"\
+	".\msghook.hpp"\
+	".\procaddr.hpp"\
+	".\procaddr.tpp"\
+	{$(INCLUDE)}"common\block.hpp"\
+	{$(INCLUDE)}"common\block.tpp"\
+	{$(INCLUDE)}"common\codegen.hpp"\
+	{$(INCLUDE)}"common\except.hpp"\
+	{$(INCLUDE)}"common\filemap.hpp"\
+	{$(INCLUDE)}"common\gdata.hpp"\
+	{$(INCLUDE)}"common\gdata.tpp"\
+	{$(INCLUDE)}"common\puredwrd.hpp"\
+	{$(INCLUDE)}"common\pview.hpp"\
+	{$(INCLUDE)}"common\stdio.hpp"\
+	{$(INCLUDE)}"common\stdlib.hpp"\
+	{$(INCLUDE)}"common\string.hpp"\
+	{$(INCLUDE)}"common\types.hpp"\
+	{$(INCLUDE)}"common\windows.hpp"\
+	
+
+"$(INTDIR)\Msghook.obj" : $(SOURCE) $(DEP_CPP_MSGHO) "$(INTDIR)"
+
+
+!ENDIF 
+
+SOURCE=.\ofnhook.cpp
+
+!IF  "$(CFG)" == "hookproc - Win32 Release"
+
+DEP_CPP_OFNHO=\
+	".\apientry.hpp"\
+	".\ofnhook.hpp"\
+	".\procaddr.hpp"\
+	".\procaddr.tpp"\
+	{$(INCLUDE)}"common\block.hpp"\
+	{$(INCLUDE)}"common\block.tpp"\
+	{$(INCLUDE)}"common\codegen.hpp"\
+	{$(INCLUDE)}"common\except.hpp"\
+	{$(INCLUDE)}"common\filemap.hpp"\
+	{$(INCLUDE)}"common\gdata.hpp"\
+	{$(INCLUDE)}"common\gdata.tpp"\
+	{$(INCLUDE)}"common\puredwrd.hpp"\
+	{$(INCLUDE)}"common\pview.hpp"\
+	{$(INCLUDE)}"common\stdio.hpp"\
+	{$(INCLUDE)}"common\stdlib.hpp"\
+	{$(INCLUDE)}"common\string.hpp"\
+	{$(INCLUDE)}"common\types.hpp"\
+	{$(INCLUDE)}"common\windows.hpp"\
+	
+
+"$(INTDIR)\ofnhook.obj" : $(SOURCE) $(DEP_CPP_OFNHO) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "hookproc - Win32 Debug"
+
+DEP_CPP_OFNHO=\
+	".\apientry.hpp"\
+	".\ofnhook.hpp"\
+	".\procaddr.hpp"\
+	".\procaddr.tpp"\
+	{$(INCLUDE)}"common\block.hpp"\
+	{$(INCLUDE)}"common\block.tpp"\
+	{$(INCLUDE)}"common\codegen.hpp"\
+	{$(INCLUDE)}"common\except.hpp"\
+	{$(INCLUDE)}"common\filemap.hpp"\
+	{$(INCLUDE)}"common\gdata.hpp"\
+	{$(INCLUDE)}"common\gdata.tpp"\
+	{$(INCLUDE)}"common\puredwrd.hpp"\
+	{$(INCLUDE)}"common\pview.hpp"\
+	{$(INCLUDE)}"common\stdio.hpp"\
+	{$(INCLUDE)}"common\stdlib.hpp"\
+	{$(INCLUDE)}"common\string.hpp"\
+	{$(INCLUDE)}"common\types.hpp"\
+	{$(INCLUDE)}"common\windows.hpp"\
+	
+
+"$(INTDIR)\ofnhook.obj" : $(SOURCE) $(DEP_CPP_OFNHO) "$(INTDIR)"
+
+
+!ENDIF 
+
+
+!ENDIF 
+