Initial

image/COMP.RSP

@@ -0,0 +1,7 @@
+/D__FLAT__
+/DSTRICT
+/IC:\PARTS\MSVC\INCLUDE
+/I..
+/c
+/FoMSVCOBJ\EXPORT.OBJ
+EXPORT.CPP

image/DBGDIR.HPP

@@ -0,0 +1,191 @@
+#ifndef _IMAGE_IMAGEDEBUGDIRECTORY_HPP_
+#define _IMAGE_IMAGEDEBUGDIRECTORY_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+#include <common/pview.hpp>
+#endif
+
+class ImageDebugDirectory : private IMAGE_DEBUG_DIRECTORY
+{
+public:
+  ImageDebugDirectory(void);
+	ImageDebugDirectory(const ImageDebugDirectory &someImageDebugDirectory);
+	virtual ~ImageDebugDirectory();
+  PureViewOfFile &operator<<(PureViewOfFile &pureViewOfFile);
+	ImageDebugDirectory &operator=(const ImageDebugDirectory &someImageDebugDirectory);
+	WORD operator==(const ImageDebugDirectory &someImageDebugDirectory)const;
+	DWORD characteristics(void)const;
+	void characteristics(DWORD characteristics);
+	DWORD timeDate(void)const;
+	void timeDate(DWORD timeDate);
+	WORD majorVersion(void)const;
+	void majorVersion(WORD majorVersion);
+	WORD minorVersion(void)const;
+	void minorVersion(WORD minorVersion);
+	DWORD type(void)const;
+	void type(DWORD type);
+	DWORD sizeofData(void)const;
+	void sizeofData(DWORD sizeofData);
+	DWORD addressOfRawData(void)const;
+	void addressOfRawData(DWORD addressOfRawData);
+	DWORD pointerToRawData(void)const;
+  void pointerToRawData(DWORD pointerToRawData);
+private:
+};
+
+inline
+ImageDebugDirectory::ImageDebugDirectory(void)
+{
+	characteristics(0);
+	timeDate(0);
+	majorVersion(0);
+	minorVersion(0);
+	type(0);
+	sizeofData(0);
+	addressOfRawData(0);
+  pointerToRawData(0);
+}
+
+inline
+ImageDebugDirectory::ImageDebugDirectory(const ImageDebugDirectory &someImageDebugDirectory)
+{
+  *this=someImageDebugDirectory;
+}
+
+inline
+ImageDebugDirectory::~ImageDebugDirectory()
+{
+}
+
+inline
+ImageDebugDirectory &ImageDebugDirectory::operator=(const ImageDebugDirectory &someImageDebugDirectory)
+{
+	characteristics(someImageDebugDirectory.characteristics());
+	timeDate(someImageDebugDirectory.timeDate());
+	majorVersion(someImageDebugDirectory.majorVersion());
+	minorVersion(someImageDebugDirectory.minorVersion());
+	type(someImageDebugDirectory.type());
+	sizeofData(someImageDebugDirectory.sizeofData());
+	addressOfRawData(someImageDebugDirectory.addressOfRawData());
+	pointerToRawData(someImageDebugDirectory.pointerToRawData());
+  return *this;
+}
+
+inline
+WORD ImageDebugDirectory::operator==(const ImageDebugDirectory &someImageDebugDirectory)const
+{
+	return (characteristics()==someImageDebugDirectory.characteristics()&&
+	        timeDate()==someImageDebugDirectory.timeDate()&&
+	        majorVersion()==someImageDebugDirectory.majorVersion()&&
+	        minorVersion()==someImageDebugDirectory.minorVersion()&&
+	        type()==someImageDebugDirectory.type()&&
+	        sizeofData()==someImageDebugDirectory.sizeofData()&&
+	        addressOfRawData()==someImageDebugDirectory.addressOfRawData()&&
+	        pointerToRawData()==someImageDebugDirectory.pointerToRawData());
+}
+
+inline
+PureViewOfFile &ImageDebugDirectory::operator<<(PureViewOfFile &pureViewOfFile)
+{
+	pureViewOfFile.read((char*)&((IMAGE_DEBUG_DIRECTORY&)*this),sizeof(IMAGE_DEBUG_DIRECTORY));
+  return pureViewOfFile;
+}
+
+inline
+DWORD ImageDebugDirectory::characteristics(void)const
+{
+  return IMAGE_DEBUG_DIRECTORY::Characteristics;
+}
+
+inline
+void ImageDebugDirectory::characteristics(DWORD characteristics)
+{
+  IMAGE_DEBUG_DIRECTORY::Characteristics=characteristics;
+}
+
+inline
+DWORD ImageDebugDirectory::timeDate(void)const
+{
+  return IMAGE_DEBUG_DIRECTORY::TimeDateStamp;
+}
+
+inline
+void ImageDebugDirectory::timeDate(DWORD timeDate)
+{
+  IMAGE_DEBUG_DIRECTORY::TimeDateStamp=timeDate;
+}
+
+inline
+WORD ImageDebugDirectory::majorVersion(void)const
+{
+  return IMAGE_DEBUG_DIRECTORY::MajorVersion;
+}
+
+inline
+void ImageDebugDirectory::majorVersion(WORD majorVersion)
+{
+  IMAGE_DEBUG_DIRECTORY::MajorVersion=majorVersion;
+}
+
+inline
+WORD ImageDebugDirectory::minorVersion(void)const
+{
+  return IMAGE_DEBUG_DIRECTORY::MinorVersion;
+}
+
+inline
+void ImageDebugDirectory::minorVersion(WORD minorVersion)
+{
+  IMAGE_DEBUG_DIRECTORY::MinorVersion=minorVersion;
+}
+
+inline
+DWORD ImageDebugDirectory::type(void)const
+{
+  return IMAGE_DEBUG_DIRECTORY::Type;
+}
+
+inline
+void ImageDebugDirectory::type(DWORD type)
+{
+  IMAGE_DEBUG_DIRECTORY::Type=type;
+}
+
+inline
+DWORD ImageDebugDirectory::sizeofData(void)const
+{
+  return IMAGE_DEBUG_DIRECTORY::SizeOfData;
+}
+
+inline
+void ImageDebugDirectory::sizeofData(DWORD sizeofData)
+{
+  IMAGE_DEBUG_DIRECTORY::SizeOfData=sizeofData;
+}
+
+inline
+DWORD ImageDebugDirectory::addressOfRawData(void)const
+{
+  return IMAGE_DEBUG_DIRECTORY::AddressOfRawData;
+}
+
+inline
+void ImageDebugDirectory::addressOfRawData(DWORD addressOfRawData)
+{
+  IMAGE_DEBUG_DIRECTORY::AddressOfRawData=addressOfRawData;
+}
+
+inline
+DWORD ImageDebugDirectory::pointerToRawData(void)const
+{
+  return IMAGE_DEBUG_DIRECTORY::PointerToRawData;
+}
+
+inline
+void ImageDebugDirectory::pointerToRawData(DWORD pointerToRawData)
+{
+  IMAGE_DEBUG_DIRECTORY::PointerToRawData;
+}
+#endif

image/DIRENTRY.BAK

@@ -0,0 +1,68 @@
+#include <image/direntry.hpp>
+#include <image/resdrstr.hpp>
+#include <common/stdio.hpp>
+
+ImageResourceDirectoryEntry::operator String(void)
+{
+  String resDirString;
+
+  resDirString.reserve(256);
+	::sprintf(resDirString,"offName:%ld nameIsString:%ld name:%ld resID:%ld offData:%ld offDir:%ld dataIsDir:%ld",
+	  offsetName(),nameIsString(),name(),resID(),offsetData(),offsetDirectory(),dataIsDirectory());
+	return resDirString;
+}
+
+void ImageResourceDirectoryEntry::read(DWORD resBase,DWORD deltaOffset,PureViewOfFile &pureView)
+{
+  pureView.read((char*)&((IMAGE_RESOURCE_DIRECTORY_ENTRY&)*this),sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
+	pureView.push();
+	if(nameIsString())
+	{
+	  ImageResourceDirString resDirString;
+	  pureView.push();
+		pureView.seek(resBase+offsetName(),PureViewOfFile::SeekSet);
+		resDirString.read(pureView);
+		mResourceName=resDirString.name();
+		pureView.pop();
+	}
+	if(dataIsDirectory())
+	{
+		if(mResourceName.isNull())mResourceName=getResource(name());
+//		if(!mResourceName.isNull())::OutputDebugString(mResourceName+String("\n"));
+		pureView.seek(resBase+offsetDirectory(),PureViewOfFile::SeekSet);
+		mImageResourceDirectory.read(resBase,deltaOffset,pureView);
+	}
+	else
+	{
+	  pureView.seek(resBase+offsetDirectory(),PureViewOfFile::SeekSet);
+		mImageResourceDataEntry.read(deltaOffset,pureView);
+	}
+	pureView.pop();
+}
+
+const String &ImageResourceDirectoryEntry::getResource(DWORD resIndex)
+{
+	if(resIndex>=mResStrings.size())return mResStrings[0];
+	return mResStrings[resIndex];
+}
+
+void ImageResourceDirectoryEntry::createResStrings(void)
+{
+	mResStrings.insert(&String("???_0"));
+	mResStrings.insert(&String("CURSOR"));
+	mResStrings.insert(&String("BITMAP"));
+	mResStrings.insert(&String("ICON"));
+	mResStrings.insert(&String("MENU"));
+	mResStrings.insert(&String("DIALOG"));
+	mResStrings.insert(&String("STRING"));
+	mResStrings.insert(&String("FONTDIR"));
+	mResStrings.insert(&String("FONT"));
+	mResStrings.insert(&String("ACCELERATORS"));
+	mResStrings.insert(&String("RCDATA"));
+	mResStrings.insert(&String("MESSAGETABLE"));
+	mResStrings.insert(&String("GROUP_CURSOR"));
+	mResStrings.insert(&String("???_13"));
+	mResStrings.insert(&String("GROUP_ICON"));
+	mResStrings.insert(&String("???_15"));
+	mResStrings.insert(&String("VERSION"));
+}

image/DIRENTRY.CPP

@@ -0,0 +1,68 @@
+#include <image/direntry.hpp>
+#include <image/resdrstr.hpp>
+#include <common/stdio.hpp>
+
+ImageResourceDirectoryEntry::operator String(void)
+{
+  String resDirString;
+
+  resDirString.reserve(256);
+	::sprintf(resDirString,"offName:%ld nameIsString:%ld name:%ld resID:%ld offData:%ld offDir:%ld dataIsDir:%ld",
+	  offsetName(),nameIsString(),name(),resID(),offsetData(),offsetDirectory(),dataIsDirectory());
+	return resDirString;
+}
+
+void ImageResourceDirectoryEntry::read(DWORD resBase,DWORD deltaOffset,PureViewOfFile &pureView)
+{
+  pureView.read((char*)&((IMAGE_RESOURCE_DIRECTORY_ENTRY&)*this),sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
+	pureView.push();
+	if(nameIsString())
+	{
+	  ImageResourceDirString resDirString;
+	  pureView.push();
+		pureView.seek(resBase+offsetName(),PureViewOfFile::SeekSet);
+		resDirString.read(pureView);
+		mResourceName=resDirString.name();
+		pureView.pop();
+	}
+	if(dataIsDirectory())
+	{
+		if(mResourceName.isNull())mResourceName=getResource(name());
+//		if(!mResourceName.isNull())::OutputDebugString(mResourceName+String("\n"));
+		pureView.seek(resBase+offsetDirectory(),PureViewOfFile::SeekSet);
+		mImageResourceDirectory.read(resBase,deltaOffset,pureView);
+	}
+	else
+	{
+	  pureView.seek(resBase+offsetDirectory(),PureViewOfFile::SeekSet);
+		mImageResourceDataEntry.read(deltaOffset,pureView);
+	}
+	pureView.pop();
+}
+
+String ImageResourceDirectoryEntry::getResource(DWORD resIndex)
+{
+	if(resIndex>=mResStrings.size())return mResStrings[0];
+	return mResStrings[resIndex];
+}
+
+void ImageResourceDirectoryEntry::createResStrings(void)
+{
+	mResStrings.insert(&StrPointer("???_0"));
+	mResStrings.insert(&StrPointer("CURSOR"));
+	mResStrings.insert(&StrPointer("BITMAP"));
+	mResStrings.insert(&StrPointer("ICON"));
+	mResStrings.insert(&StrPointer("MENU"));
+	mResStrings.insert(&StrPointer("DIALOG"));
+	mResStrings.insert(&StrPointer("STRING"));
+	mResStrings.insert(&StrPointer("FONTDIR"));
+	mResStrings.insert(&StrPointer("FONT"));
+	mResStrings.insert(&StrPointer("ACCELERATORS"));
+	mResStrings.insert(&StrPointer("RCDATA"));
+	mResStrings.insert(&StrPointer("MESSAGETABLE"));
+	mResStrings.insert(&StrPointer("GROUP_CURSOR"));
+	mResStrings.insert(&StrPointer("???_13"));
+	mResStrings.insert(&StrPointer("GROUP_ICON"));
+	mResStrings.insert(&StrPointer("???_15"));
+	mResStrings.insert(&StrPointer("VERSION"));
+}

image/DIRENTRY.HPP

@@ -0,0 +1,286 @@
+#ifndef _IMAGE_IMAGERESOURCEDIRECTORYENTRY_HPP_
+#define _IMAGE_IMAGERESOURCEDIRECTORYENTRY_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _IMAGE_IMAGERESOURCEDATAENTRY_HPP_
+#include <image/dtaentry.hpp>
+#endif
+#ifndef _IMAGE_IMAGERESOURCEDIRECTORY_HPP_
+#include <image/imresdir.hpp>
+#endif
+#ifndef _IMAGE_STRPOINTER_HPP_
+#include <image/strptr.hpp>
+#endif
+
+template <class T>
+class SmartPointer;
+template <class T>
+class Block;
+class PureViewOfFile;
+
+class ImageResourceDirectoryEntry : public IMAGE_RESOURCE_DIRECTORY_ENTRY
+{
+public:
+  ImageResourceDirectoryEntry(void);
+	ImageResourceDirectoryEntry(const ImageResourceDirectoryEntry &someImageResourceDirectoryEntry);
+	virtual ~ImageResourceDirectoryEntry();
+	ImageResourceDirectoryEntry &operator=(const ImageResourceDirectoryEntry &someImageResourceDirectoryEntry);
+	WORD operator==(const ImageResourceDirectoryEntry &someImageResourceDirectoryEntry)const;
+	operator IMAGE_RESOURCE_DIRECTORY_ENTRY &(void);
+	operator String(void);
+	const String &resName(void)const;
+	DWORD offsetName(void)const;
+	void offsetName(DWORD offsetName);
+	DWORD nameIsString(void)const;
+	void nameIsString(DWORD nameIsString);
+	DWORD name(void)const;
+	void name(DWORD name);
+	DWORD resID(void)const;
+	void resID(DWORD resID);
+	DWORD offsetData(void)const;
+	void offsetData(DWORD offsetData);
+	DWORD offsetDirectory(void)const;
+	void offsetDirectory(DWORD offsetDirectory);
+	DWORD dataIsDirectory(void)const;
+	void dataIsDirectory(DWORD dataIsDirectory);
+	void read(DWORD resBase,DWORD deltaOffset,PureViewOfFile &pureView);
+	ImageResourceDirectory &imageResourceDirectory(void);
+	ImageResourceDataEntry &imageResourceDataEntry(void);
+private:
+  void createResStrings(void);
+  String getResource(DWORD resIndex);
+  void setZero(void);
+
+	String mResourceName;
+	Block<StrPointer> mResStrings;
+	ImageResourceDirectory mImageResourceDirectory;
+	ImageResourceDataEntry mImageResourceDataEntry;
+};
+
+inline
+ImageResourceDirectoryEntry::ImageResourceDirectoryEntry(void)
+{
+  setZero();
+	createResStrings();
+}
+
+inline
+ImageResourceDirectoryEntry::ImageResourceDirectoryEntry(const ImageResourceDirectoryEntry &someImageResourceDirectoryEntry)
+{
+  createResStrings();
+  *this=someImageResourceDirectoryEntry;
+}
+
+inline
+ImageResourceDirectoryEntry::~ImageResourceDirectoryEntry()
+{
+}
+
+inline
+ImageResourceDirectoryEntry &ImageResourceDirectoryEntry::operator=(const ImageResourceDirectoryEntry &someImageResourceDirectoryEntry)
+{
+  mResourceName=someImageResourceDirectoryEntry.mResourceName;
+  offsetName(someImageResourceDirectoryEntry.offsetName());
+	nameIsString(someImageResourceDirectoryEntry.nameIsString());
+	name(someImageResourceDirectoryEntry.name());
+	resID(someImageResourceDirectoryEntry.resID());
+	offsetData(someImageResourceDirectoryEntry.offsetData());
+	offsetDirectory(someImageResourceDirectoryEntry.offsetDirectory());
+	dataIsDirectory(someImageResourceDirectoryEntry.dataIsDirectory());
+	mImageResourceDirectory=someImageResourceDirectoryEntry.mImageResourceDirectory;
+	mImageResourceDataEntry=someImageResourceDirectoryEntry.mImageResourceDataEntry;
+	return *this;
+}
+
+inline
+WORD ImageResourceDirectoryEntry::operator==(const ImageResourceDirectoryEntry &someImageResourceDirectoryEntry)const
+{
+  return (offsetName()==someImageResourceDirectoryEntry.offsetName()&&
+	        nameIsString()==someImageResourceDirectoryEntry.nameIsString()&&
+	        name()==someImageResourceDirectoryEntry.name()&&
+					resID()==someImageResourceDirectoryEntry.resID()&&
+	        offsetData()==someImageResourceDirectoryEntry.offsetData()&&
+	        offsetDirectory()==someImageResourceDirectoryEntry.offsetDirectory()&&
+	        dataIsDirectory()==someImageResourceDirectoryEntry.dataIsDirectory());
+}
+
+inline
+ImageResourceDirectoryEntry::operator IMAGE_RESOURCE_DIRECTORY_ENTRY &(void)
+{
+  return *this;
+}
+
+inline
+DWORD ImageResourceDirectoryEntry::offsetName(void)const
+{
+#ifndef _MSC_VER
+	return IMAGE_RESOURCE_DIRECTORY_ENTRY::u.s.NameOffset;
+#else
+	return IMAGE_RESOURCE_DIRECTORY_ENTRY::NameOffset;
+#endif
+}
+
+inline
+void ImageResourceDirectoryEntry::offsetName(DWORD offsetName)
+{
+#ifndef _MSC_VER
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::u.s.NameOffset=offsetName;
+#else
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::NameOffset=offsetName;
+#endif
+}
+
+inline
+DWORD ImageResourceDirectoryEntry::nameIsString(void)const
+{
+#ifndef _MSC_VER
+	return IMAGE_RESOURCE_DIRECTORY_ENTRY::u.s.NameIsString;
+#else
+	return IMAGE_RESOURCE_DIRECTORY_ENTRY::NameIsString;
+#endif
+}
+
+inline
+void ImageResourceDirectoryEntry::nameIsString(DWORD nameIsString)
+{
+#ifndef _MSC_VER
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::u.s.NameIsString=nameIsString;
+#else
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::NameIsString=nameIsString;
+#endif
+}
+
+inline
+DWORD ImageResourceDirectoryEntry::name(void)const
+{
+#ifndef _MSC_VER
+	return IMAGE_RESOURCE_DIRECTORY_ENTRY::u.Name;
+#else
+	return IMAGE_RESOURCE_DIRECTORY_ENTRY::Name;
+#endif
+}
+
+inline
+void ImageResourceDirectoryEntry::name(DWORD name)
+{
+#ifndef _MSC_VER
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::u.Name=name;
+#else
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::Name=name;
+#endif
+}
+
+inline
+DWORD ImageResourceDirectoryEntry::resID(void)const
+{
+#ifndef _MSC_VER
+	return IMAGE_RESOURCE_DIRECTORY_ENTRY::u.Id;
+#else
+	return IMAGE_RESOURCE_DIRECTORY_ENTRY::Id;
+#endif
+}
+
+inline
+void ImageResourceDirectoryEntry::resID(DWORD resID)
+{
+#ifndef _MSC_VER
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::u.Id=resID;
+#else
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::Id=resID;
+#endif
+}
+
+inline
+DWORD ImageResourceDirectoryEntry::offsetData(void)const
+{
+#ifndef _MSC_VER
+	return IMAGE_RESOURCE_DIRECTORY_ENTRY::u2.OffsetToData;
+#else
+	return IMAGE_RESOURCE_DIRECTORY_ENTRY::OffsetToData;
+#endif
+}
+
+inline
+void ImageResourceDirectoryEntry::offsetData(DWORD offsetData)
+{
+#ifndef _MSC_VER
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::u2.OffsetToData=offsetData;
+#else
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::OffsetToData=offsetData;
+#endif
+}
+
+inline
+DWORD ImageResourceDirectoryEntry::offsetDirectory(void)const
+{
+#ifndef _MSC_VER
+	return IMAGE_RESOURCE_DIRECTORY_ENTRY::u2.s.OffsetToDirectory;
+#else
+	return IMAGE_RESOURCE_DIRECTORY_ENTRY::OffsetToDirectory;
+#endif
+}
+
+inline
+void ImageResourceDirectoryEntry::offsetDirectory(DWORD offsetDirectory)
+{
+#ifndef _MSC_VER
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::u2.s.OffsetToDirectory=offsetDirectory;
+#else
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::OffsetToDirectory=offsetDirectory;
+#endif
+}
+
+inline
+DWORD ImageResourceDirectoryEntry::dataIsDirectory(void)const
+{
+#ifndef _MSC_VER
+	return IMAGE_RESOURCE_DIRECTORY_ENTRY::u2.s.DataIsDirectory;
+#else
+	return IMAGE_RESOURCE_DIRECTORY_ENTRY::DataIsDirectory;
+#endif
+}
+
+inline
+void ImageResourceDirectoryEntry::dataIsDirectory(DWORD dataIsDirectory)
+{
+#ifndef _MSC_VER
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::u2.s.DataIsDirectory=dataIsDirectory;
+#else
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::DataIsDirectory=dataIsDirectory;
+#endif
+}
+
+inline
+const String &ImageResourceDirectoryEntry::resName(void)const
+{
+  return mResourceName;
+}
+
+inline
+ImageResourceDirectory &ImageResourceDirectoryEntry::imageResourceDirectory(void)
+{
+  return mImageResourceDirectory;
+}
+
+inline
+ImageResourceDataEntry &ImageResourceDirectoryEntry::imageResourceDataEntry(void)
+{
+  return mImageResourceDataEntry;
+}
+
+inline
+void ImageResourceDirectoryEntry::setZero(void)
+{
+#ifndef _MSC_VER
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::u.Name=0;
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::u2.OffsetToData=0;
+#else
+  IMAGE_RESOURCE_DIRECTORY_ENTRY::Name=0;
+	IMAGE_RESOURCE_DIRECTORY_ENTRY::OffsetToData=0;
+#endif
+}
+#endif

image/DLLFLAGS.HPP

@@ -0,0 +1,88 @@
+#ifndef _IMAGE_DLLFLAGS_HPP_
+#define _IMAGE_DLLFLAGS_HPP_
+#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+#include <common/pview.hpp>
+#endif
+
+class DLLFlags
+{
+public:
+	enum DLLType{PerProcessLibInit=0x0001,PerProcessLibTerm=0x0002,
+			 PerThreadLibInit=0x0004,PerThreadLibTerm=0x0008};
+	DLLFlags(DLLType dllType=PerProcessLibInit);
+	DLLFlags(const DLLFlags &someDLLFlags);
+	~DLLFlags();
+	DLLFlags &operator=(const DLLFlags &someDLLFlags);
+	WORD operator==(const DLLFlags &someDLLFlags)const;
+	WORD operator<<(PureViewOfFile &pureView);
+	DLLType dllType(void)const;
+	void dllType(DLLType dllType);
+	WORD isValid(void)const;
+private:
+	DLLType mDLLType;
+};
+
+inline
+DLLFlags::DLLFlags(DLLType dllType)
+: mDLLType(dllType)
+{
+}
+
+inline
+DLLFlags::DLLFlags(const DLLFlags &someDLLFlags)
+{
+  *this=someDLLFlags;
+}
+
+inline
+DLLFlags::~DLLFlags()
+{
+}
+
+inline
+DLLFlags &DLLFlags::operator=(const DLLFlags &someDLLFlags)
+{
+	dllType(someDLLFlags.dllType());
+  return *this;
+}
+
+inline
+WORD DLLFlags::operator==(const DLLFlags &someDLLFlags)const
+{
+  return dllType()==someDLLFlags.dllType();
+}
+
+inline
+WORD DLLFlags::operator<<(PureViewOfFile &pureView)
+{
+	WORD dllType;
+
+	pureView.read(dllType);
+	mDLLType=(DLLType)dllType;
+	if(!isValid())return FALSE;
+	return TRUE;
+}
+
+inline
+DLLFlags::DLLType DLLFlags::dllType(void)const
+{
+	return mDLLType;
+}
+
+inline
+void DLLFlags::dllType(DLLType dllType)
+{
+  mDLLType=dllType;
+}
+
+inline
+WORD DLLFlags::isValid(void)const
+{
+	if(PerProcessLibInit==dllType())return TRUE;
+	if(PerProcessLibTerm==dllType())return TRUE;
+	if(PerThreadLibInit==dllType())return TRUE;
+	if(PerThreadLibTerm==dllType())return TRUE;
+	return FALSE;
+}
+#endif
+

image/DOSHDR.HPP

@@ -0,0 +1,185 @@
+#ifndef _IMAGE_DOSHEADER_HPP_
+#define _IMAGE_DOSHEADER_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+#include <common/pview.hpp>
+#endif
+
+class DOSHeader : private _IMAGE_DOS_HEADER
+{
+public:
+	enum{MZSignature=IMAGE_DOS_SIGNATURE};
+	DOSHeader(void);
+  DOSHeader(const DOSHeader &someDOSHeader);
+	~DOSHeader();
+	DOSHeader &operator=(const DOSHeader &someDOSHeader);
+  WORD operator==(const DOSHeader &someDOSHeader);
+	WORD operator<<(PureViewOfFile &pureView);
+	WORD magic(void)const;
+	WORD bytesLastPage(void)const;
+	WORD pages(void)const;
+	WORD relocations(void)const;
+	WORD headerParagraphs(void)const;
+	WORD minExtraParagraphs(void)const;
+	WORD maxExtraParagraphs(void)const;
+	WORD initialStackSegment(void)const;
+	WORD initialStackPointer(void)const;
+	WORD checksum(void)const;
+	WORD relocationTableAddress(void)const;
+	WORD overlayNumber(void)const;
+	WORD oemID(void)const;
+	WORD oemInfo(void)const;
+	LONG neHeaderAddress(void)const;
+	WORD isOkay(void)const;
+private:
+};
+
+inline
+DOSHeader::DOSHeader(void)
+{
+  ::memset((char*)&((_IMAGE_DOS_HEADER&)*this),0,sizeof(_IMAGE_DOS_HEADER));
+}
+
+inline
+DOSHeader::DOSHeader(const DOSHeader &someDOSHeader)
+{
+	*this=someDOSHeader;
+}
+
+inline
+DOSHeader::~DOSHeader()
+{
+}
+
+inline
+WORD DOSHeader::operator<<(PureViewOfFile &pureView)
+{
+	if(sizeof(_IMAGE_DOS_HEADER)!=pureView.read((char*)&((_IMAGE_DOS_HEADER&)*this),sizeof(_IMAGE_DOS_HEADER)))return FALSE;
+  return isOkay();
+}
+
+inline
+DOSHeader &DOSHeader::operator=(const DOSHeader &someDOSHeader)
+{
+	::memcpy((char*)&((_IMAGE_DOS_HEADER&)*this),(char*)&((_IMAGE_DOS_HEADER&)someDOSHeader),sizeof(_IMAGE_DOS_HEADER));
+	return *this;
+}
+
+inline
+WORD DOSHeader::operator==(const DOSHeader &someDOSHeader)
+{
+	return (magic()==someDOSHeader.magic()&&
+					bytesLastPage()==someDOSHeader.bytesLastPage()&&
+					pages()==someDOSHeader.pages()&&
+					relocations()==someDOSHeader.relocations()&&
+					headerParagraphs()==someDOSHeader.headerParagraphs()&&
+					minExtraParagraphs()==someDOSHeader.minExtraParagraphs()&&
+					maxExtraParagraphs()==someDOSHeader.maxExtraParagraphs()&&
+					initialStackSegment()==someDOSHeader.initialStackSegment()&&
+					initialStackPointer()==someDOSHeader.initialStackPointer()&&
+					checksum()==someDOSHeader.checksum()&&
+					relocationTableAddress()==someDOSHeader.relocationTableAddress()&&
+					overlayNumber()==someDOSHeader.overlayNumber()&&
+					oemID()==someDOSHeader.oemID()&&
+					oemInfo()==someDOSHeader.oemInfo()&&
+					neHeaderAddress()==someDOSHeader.neHeaderAddress());
+}
+
+inline
+WORD DOSHeader::magic(void)const
+{
+  return _IMAGE_DOS_HEADER::e_magic;
+}
+
+inline
+WORD DOSHeader::bytesLastPage(void)const
+{
+	return _IMAGE_DOS_HEADER::e_cblp;
+}
+
+inline
+WORD DOSHeader::pages(void)const
+{
+	return _IMAGE_DOS_HEADER::e_cp;
+}
+
+inline
+WORD DOSHeader::relocations(void)const
+{
+	return _IMAGE_DOS_HEADER::e_crlc;
+}
+
+inline
+WORD DOSHeader::headerParagraphs(void)const
+{
+	return _IMAGE_DOS_HEADER::e_cparhdr;
+}
+
+inline
+WORD DOSHeader::minExtraParagraphs(void)const
+{
+	return _IMAGE_DOS_HEADER::e_minalloc;
+}
+
+inline
+WORD DOSHeader::maxExtraParagraphs(void)const
+{
+	return _IMAGE_DOS_HEADER::e_maxalloc;
+}
+
+inline
+WORD DOSHeader::initialStackSegment(void)const
+{
+	return _IMAGE_DOS_HEADER::e_ss;
+}
+
+inline
+WORD DOSHeader::initialStackPointer(void)const
+{
+	return _IMAGE_DOS_HEADER::e_sp;
+}
+
+inline
+WORD DOSHeader::checksum(void)const
+{
+	return _IMAGE_DOS_HEADER::e_csum;
+}
+
+inline
+WORD DOSHeader::relocationTableAddress(void)const
+{
+	return _IMAGE_DOS_HEADER::e_lfarlc;
+}
+
+inline
+WORD DOSHeader::overlayNumber(void)const
+{
+	return _IMAGE_DOS_HEADER::e_ovno;
+}
+
+inline
+WORD DOSHeader::oemID(void)const
+{
+	return _IMAGE_DOS_HEADER::e_oemid;
+}
+
+inline
+WORD DOSHeader::oemInfo(void)const
+{
+	return _IMAGE_DOS_HEADER::e_oeminfo;
+}
+
+inline
+LONG DOSHeader::neHeaderAddress(void)const
+{
+	return _IMAGE_DOS_HEADER::e_lfanew;
+}
+
+inline
+WORD DOSHeader::isOkay(void)const
+{
+	return MZSignature==magic();
+}
+#endif

image/DTAENTRY.BAK

@@ -0,0 +1,135 @@
+#ifndef _IMAGE_IMAGERESOURCEDATAENTRY_HPP_
+#define _IMAGE_IMAGERESOURCEDATAENTRY_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_GLOBALDATA_HPP_
+#include <common/gdata.hpp>
+#endif
+
+class PureViewOfFile;
+
+class ImageResourceDataEntry : private IMAGE_RESOURCE_DATA_ENTRY
+{
+public:
+  ImageResourceDataEntry(void);
+	ImageResourceDataEntry(const ImageResourceDataEntry &someImageResourceDataEntry);
+	virtual ~ImageResourceDataEntry();
+	ImageResourceDataEntry &operator=(const ImageResourceDataEntry &someImageResourceDataEntry);
+	WORD operator==(const ImageResourceDataEntry &someImageResourceDataEntry)const;
+	operator IMAGE_RESOURCE_DATA_ENTRY &(void);
+	DWORD offsetData(void)const;
+	void offsetData(DWORD offsetData);
+	DWORD size(void)const;
+	void size(DWORD size);
+	DWORD codePage(void)const;
+	void codePage(DWORD codePage);
+	DWORD reserved(void)const;
+	void reserved(DWORD reserved);
+	void read(DWORD deltaOffset,PureViewOfFile &pureView);
+private:
+  void setZero(void);
+	GlobalData<BYTE> mRawData;
+};
+
+inline
+ImageResourceDataEntry::ImageResourceDataEntry(void)
+{
+  setZero();
+}
+
+inline
+ImageResourceDataEntry::ImageResourceDataEntry(const ImageResourceDataEntry &someImageResourceDataEntry)
+{
+  *this=someImageResourceDataEntry;
+}
+
+inline
+ImageResourceDataEntry::~ImageResourceDataEntry()
+{
+}
+
+inline
+ImageResourceDataEntry &ImageResourceDataEntry::operator=(const ImageResourceDataEntry &someImageResourceDataEntry)
+{
+  offsetData(someImageResourceDataEntry.offsetData());
+	size(someImageResourceDataEntry.size());
+	codePage(someImageResourceDataEntry.codePage());
+	reserved(someImageResourceDataEntry.reserved());
+	mRawData=someImageResourceDataEntry.mRawData;
+	return *this;
+}
+
+inline
+WORD ImageResourceDataEntry::operator==(const ImageResourceDataEntry &someImageResourceDataEntry)const
+{
+  return (offsetData()==someImageResourceDataEntry.offsetData()&&
+	        size()==someImageResourceDataEntry.size()&&
+					codePage()==someImageResourceDataEntry.codePage()&&
+					reserved()==someImageResourceDataEntry.reserved()&&
+					mRawData==someImageResourceDataEntry.mRawData);
+}
+
+inline
+ImageResourceDataEntry::operator IMAGE_RESOURCE_DATA_ENTRY &(void)
+{
+  return *this;
+}
+
+inline
+DWORD ImageResourceDataEntry::offsetData(void)const
+{
+  return IMAGE_RESOURCE_DATA_ENTRY::OffsetToData;
+}
+
+inline
+void ImageResourceDataEntry::offsetData(DWORD offsetData)
+{
+  IMAGE_RESOURCE_DATA_ENTRY::OffsetToData=offsetData;
+}
+
+inline
+DWORD ImageResourceDataEntry::size(void)const
+{
+  return IMAGE_RESOURCE_DATA_ENTRY::Size;
+}
+
+inline
+void ImageResourceDataEntry::size(DWORD size)
+{
+  IMAGE_RESOURCE_DATA_ENTRY::Size=size;
+}
+
+inline
+DWORD ImageResourceDataEntry::codePage(void)const
+{
+  return IMAGE_RESOURCE_DATA_ENTRY::CodePage;
+}
+
+inline
+void ImageResourceDataEntry::codePage(DWORD codePage)
+{
+  IMAGE_RESOURCE_DATA_ENTRY::CodePage=codePage;
+}
+
+inline
+DWORD ImageResourceDataEntry::reserved(void)const
+{
+  return IMAGE_RESOURCE_DATA_ENTRY::Reserved;
+}
+
+inline
+void ImageResourceDataEntry::reserved(DWORD reserved)
+{
+  IMAGE_RESOURCE_DATA_ENTRY::Reserved=reserved;
+}
+
+inline
+void ImageResourceDataEntry::setZero(void)
+{
+  IMAGE_RESOURCE_DATA_ENTRY::OffsetToData=0;
+  IMAGE_RESOURCE_DATA_ENTRY::Size=0;
+  IMAGE_RESOURCE_DATA_ENTRY::CodePage=0;
+  IMAGE_RESOURCE_DATA_ENTRY::Reserved=0;
+}
+#endif

image/DTAENTRY.CPP

@@ -0,0 +1,13 @@
+#include <image/dtaentry.hpp>
+#include <common/pview.hpp>
+
+void ImageResourceDataEntry::read(DWORD deltaOffset,PureViewOfFile &pureView)
+{
+  pureView.push();
+	pureView.read((char*)&((IMAGE_RESOURCE_DATA_ENTRY&)*this),sizeof(IMAGE_RESOURCE_DATA_ENTRY));
+	mRawData.size(size());
+  pureView.seek(offsetData()-deltaOffset,PureViewOfFile::SeekSet);
+	pureView.read((char*)((BYTE*)&mRawData[0]),mRawData.size());
+	pureView.pop();
+}
+

image/DTAENTRY.HPP

@@ -0,0 +1,142 @@
+#ifndef _IMAGE_IMAGERESOURCEDATAENTRY_HPP_
+#define _IMAGE_IMAGERESOURCEDATAENTRY_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_GLOBALDATA_HPP_
+#include <common/gdata.hpp>
+#endif
+
+class PureViewOfFile;
+
+class ImageResourceDataEntry : private IMAGE_RESOURCE_DATA_ENTRY
+{
+public:
+  ImageResourceDataEntry(void);
+	ImageResourceDataEntry(const ImageResourceDataEntry &someImageResourceDataEntry);
+	virtual ~ImageResourceDataEntry();
+	ImageResourceDataEntry &operator=(const ImageResourceDataEntry &someImageResourceDataEntry);
+	WORD operator==(const ImageResourceDataEntry &someImageResourceDataEntry)const;
+	operator IMAGE_RESOURCE_DATA_ENTRY &(void);
+	DWORD offsetData(void)const;
+	void offsetData(DWORD offsetData);
+	DWORD size(void)const;
+	void size(DWORD size);
+	DWORD codePage(void)const;
+	void codePage(DWORD codePage);
+	DWORD reserved(void)const;
+	void reserved(DWORD reserved);
+	GlobalData<BYTE> &rawData(void);
+	void read(DWORD deltaOffset,PureViewOfFile &pureView);
+private:
+  void setZero(void);
+	GlobalData<BYTE> mRawData;
+};
+
+inline
+ImageResourceDataEntry::ImageResourceDataEntry(void)
+{
+  setZero();
+}
+
+inline
+ImageResourceDataEntry::ImageResourceDataEntry(const ImageResourceDataEntry &someImageResourceDataEntry)
+{
+  *this=someImageResourceDataEntry;
+}
+
+inline
+ImageResourceDataEntry::~ImageResourceDataEntry()
+{
+}
+
+inline
+ImageResourceDataEntry &ImageResourceDataEntry::operator=(const ImageResourceDataEntry &someImageResourceDataEntry)
+{
+  offsetData(someImageResourceDataEntry.offsetData());
+	size(someImageResourceDataEntry.size());
+	codePage(someImageResourceDataEntry.codePage());
+	reserved(someImageResourceDataEntry.reserved());
+	mRawData=someImageResourceDataEntry.mRawData;
+	return *this;
+}
+
+inline
+WORD ImageResourceDataEntry::operator==(const ImageResourceDataEntry &someImageResourceDataEntry)const
+{
+  return (offsetData()==someImageResourceDataEntry.offsetData()&&
+	        size()==someImageResourceDataEntry.size()&&
+					codePage()==someImageResourceDataEntry.codePage()&&
+					reserved()==someImageResourceDataEntry.reserved()&&
+					mRawData==someImageResourceDataEntry.mRawData);
+}
+
+inline
+ImageResourceDataEntry::operator IMAGE_RESOURCE_DATA_ENTRY &(void)
+{
+  return *this;
+}
+
+inline
+DWORD ImageResourceDataEntry::offsetData(void)const
+{
+  return IMAGE_RESOURCE_DATA_ENTRY::OffsetToData;
+}
+
+inline
+void ImageResourceDataEntry::offsetData(DWORD offsetData)
+{
+  IMAGE_RESOURCE_DATA_ENTRY::OffsetToData=offsetData;
+}
+
+inline
+DWORD ImageResourceDataEntry::size(void)const
+{
+  return IMAGE_RESOURCE_DATA_ENTRY::Size;
+}
+
+inline
+void ImageResourceDataEntry::size(DWORD size)
+{
+  IMAGE_RESOURCE_DATA_ENTRY::Size=size;
+}
+
+inline
+DWORD ImageResourceDataEntry::codePage(void)const
+{
+  return IMAGE_RESOURCE_DATA_ENTRY::CodePage;
+}
+
+inline
+void ImageResourceDataEntry::codePage(DWORD codePage)
+{
+  IMAGE_RESOURCE_DATA_ENTRY::CodePage=codePage;
+}
+
+inline
+DWORD ImageResourceDataEntry::reserved(void)const
+{
+  return IMAGE_RESOURCE_DATA_ENTRY::Reserved;
+}
+
+inline
+void ImageResourceDataEntry::reserved(DWORD reserved)
+{
+  IMAGE_RESOURCE_DATA_ENTRY::Reserved=reserved;
+}
+
+inline
+GlobalData<BYTE> &ImageResourceDataEntry::rawData(void)
+{
+  return mRawData;
+}
+
+inline
+void ImageResourceDataEntry::setZero(void)
+{
+  IMAGE_RESOURCE_DATA_ENTRY::OffsetToData=0;
+  IMAGE_RESOURCE_DATA_ENTRY::Size=0;
+  IMAGE_RESOURCE_DATA_ENTRY::CodePage=0;
+  IMAGE_RESOURCE_DATA_ENTRY::Reserved=0;
+}
+#endif

image/EXPDIR.HPP

@@ -0,0 +1,250 @@
+#ifndef _IMAGE_IMAGEEXPORTDIRECTORY_HPP_
+#define _IMAGE_IMAGEEXPORTDIRECTORY_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+#include <common/pview.hpp>
+#endif
+
+class ImageExportDirectory : private IMAGE_EXPORT_DIRECTORY
+{
+public:
+	ImageExportDirectory(void);
+	ImageExportDirectory(const ImageExportDirectory &someImageExportDirectory);
+	virtual ~ImageExportDirectory();
+	ImageExportDirectory &operator=(const ImageExportDirectory &someImageExportDirectory);
+  ImageExportDirectory &operator<<(PureViewOfFile &pureView);
+	WORD operator==(const ImageExportDirectory &someImageExportDirectory);
+	DWORD characteristics(void)const;
+	void characteristics(DWORD characteristics);
+	DWORD timeDate(void)const;
+	void timeDate(DWORD timeDate);
+	WORD majorVersion(void)const;
+	void majorVersion(WORD majorVersion);
+	WORD minorVersion(void)const;
+	void minorVersion(WORD minorVersion);
+	DWORD name(void)const;
+	void name(DWORD name);
+	DWORD base(void)const;
+	void base(DWORD base);
+	DWORD numberOfFunctions(void)const;
+	void numberOfFunctions(DWORD numberOfunctions);
+	DWORD numberOfNames(void)const;
+	void numberOfNames(DWORD numberOfNames);
+	DWORD addressOfFunctions(void)const;
+	void addressOfFunctions(DWORD addressOfFunctions);
+	DWORD addressOfNames(void)const;
+	void addressOfNames(DWORD addressOfNames);
+	DWORD addressOfNameOrdinals(void)const;
+	void addressOfNameOrdinals(DWORD addressOfNameOrdinals);
+private:
+	void zeroInit(void);
+};
+
+inline
+ImageExportDirectory::ImageExportDirectory(void)
+{
+	zeroInit();
+}
+
+inline
+ImageExportDirectory::ImageExportDirectory(const ImageExportDirectory &someImageExportDirectory)
+{
+	*this=someImageExportDirectory;
+}
+
+inline
+ImageExportDirectory::~ImageExportDirectory()
+{
+}
+
+inline
+ImageExportDirectory &ImageExportDirectory::operator=(const ImageExportDirectory &someImageExportDirectory)
+{
+	characteristics(someImageExportDirectory.characteristics());
+	timeDate(someImageExportDirectory.timeDate());
+	majorVersion(someImageExportDirectory.majorVersion());
+	minorVersion(someImageExportDirectory.minorVersion());
+	name(someImageExportDirectory.name());
+	base(someImageExportDirectory.base());
+	numberOfFunctions(someImageExportDirectory.numberOfFunctions());
+	numberOfNames(someImageExportDirectory.numberOfNames());
+	addressOfFunctions(someImageExportDirectory.addressOfFunctions());
+	addressOfNames(someImageExportDirectory.addressOfNames());
+	addressOfNameOrdinals(someImageExportDirectory.addressOfNameOrdinals());
+	return *this;
+}
+
+inline
+WORD ImageExportDirectory::operator==(const ImageExportDirectory &someImageExportDirectory)
+{
+	return (characteristics()==someImageExportDirectory.characteristics()&&
+					timeDate()==someImageExportDirectory.timeDate()&&
+					majorVersion()==someImageExportDirectory.majorVersion()&&
+					minorVersion()==someImageExportDirectory.minorVersion()&&
+					name()==someImageExportDirectory.name()&&
+					base()==someImageExportDirectory.base()&&
+					numberOfFunctions()==someImageExportDirectory.numberOfFunctions()&&
+					numberOfNames()==someImageExportDirectory.numberOfNames()&&
+					addressOfFunctions()==someImageExportDirectory.addressOfFunctions()&&
+					addressOfNames()==someImageExportDirectory.addressOfNames()&&
+					addressOfNameOrdinals()==someImageExportDirectory.addressOfNameOrdinals());
+}
+
+inline
+ImageExportDirectory &ImageExportDirectory::operator<<(PureViewOfFile &pureView)
+{
+	pureView.read((char*)&((IMAGE_EXPORT_DIRECTORY&)*this),sizeof(IMAGE_EXPORT_DIRECTORY));
+  return *this;
+}
+
+inline
+DWORD ImageExportDirectory::characteristics(void)const
+{
+	return IMAGE_EXPORT_DIRECTORY::Characteristics;
+}
+
+inline
+void ImageExportDirectory::characteristics(DWORD characteristics)
+{
+	IMAGE_EXPORT_DIRECTORY::Characteristics=characteristics;
+}
+
+inline
+DWORD ImageExportDirectory::timeDate(void)const
+{
+	return IMAGE_EXPORT_DIRECTORY::TimeDateStamp;
+}
+
+inline
+void ImageExportDirectory::timeDate(DWORD timeDate)
+{
+	IMAGE_EXPORT_DIRECTORY::TimeDateStamp=timeDate;
+}
+
+inline
+WORD ImageExportDirectory::majorVersion(void)const
+{
+	return IMAGE_EXPORT_DIRECTORY::MajorVersion;
+}
+
+inline
+void ImageExportDirectory::majorVersion(WORD majorVersion)
+{
+	IMAGE_EXPORT_DIRECTORY::MajorVersion=majorVersion;
+}
+
+inline
+WORD ImageExportDirectory::minorVersion(void)const
+{
+	return IMAGE_EXPORT_DIRECTORY::MinorVersion;
+}
+
+inline
+void ImageExportDirectory::minorVersion(WORD minorVersion)
+{
+	IMAGE_EXPORT_DIRECTORY::MinorVersion=minorVersion;
+}
+
+inline
+DWORD ImageExportDirectory::name(void)const
+{
+	return IMAGE_EXPORT_DIRECTORY::Name;
+}
+
+inline
+void ImageExportDirectory::name(DWORD name)
+{
+	IMAGE_EXPORT_DIRECTORY::Name=name;
+}
+
+inline
+DWORD ImageExportDirectory::base(void)const
+{
+	return IMAGE_EXPORT_DIRECTORY::Base;
+}
+
+inline
+void ImageExportDirectory::base(DWORD base)
+{
+	IMAGE_EXPORT_DIRECTORY::Base=base;
+}
+
+inline
+DWORD ImageExportDirectory::numberOfFunctions(void)const
+{
+	return IMAGE_EXPORT_DIRECTORY::NumberOfFunctions;
+}
+
+inline
+void ImageExportDirectory::numberOfFunctions(DWORD numberOfFunctions)
+{
+	IMAGE_EXPORT_DIRECTORY::NumberOfFunctions=numberOfFunctions;
+}
+
+inline
+DWORD ImageExportDirectory::numberOfNames(void)const
+{
+	return IMAGE_EXPORT_DIRECTORY::NumberOfNames;
+}
+
+inline
+void ImageExportDirectory::numberOfNames(DWORD numberOfNames)
+{
+	IMAGE_EXPORT_DIRECTORY::NumberOfNames=numberOfNames;
+}
+
+inline
+DWORD ImageExportDirectory::addressOfFunctions(void)const
+{
+	return (DWORD)IMAGE_EXPORT_DIRECTORY::AddressOfFunctions;
+}
+
+inline
+void ImageExportDirectory::addressOfFunctions(DWORD addressOfFunctions)
+{
+	IMAGE_EXPORT_DIRECTORY::AddressOfFunctions=(DWORD)(PDWORD*)addressOfFunctions;
+}
+
+inline
+DWORD ImageExportDirectory::addressOfNames(void)const
+{
+	return (DWORD)IMAGE_EXPORT_DIRECTORY::AddressOfNames;
+}
+
+inline
+void ImageExportDirectory::addressOfNames(DWORD addressOfNames)
+{
+	IMAGE_EXPORT_DIRECTORY::AddressOfNames=(DWORD)(PDWORD*)addressOfNames;
+}
+
+inline
+DWORD ImageExportDirectory::addressOfNameOrdinals(void)const
+{
+	return (DWORD)IMAGE_EXPORT_DIRECTORY::AddressOfNameOrdinals;
+}
+
+inline
+void ImageExportDirectory::addressOfNameOrdinals(DWORD addressOfNameOrdinals)
+{
+	IMAGE_EXPORT_DIRECTORY::AddressOfNameOrdinals=(DWORD)(PWORD*)addressOfNameOrdinals;
+}
+
+inline
+void ImageExportDirectory::zeroInit(void)
+{
+	IMAGE_EXPORT_DIRECTORY::Characteristics=0;
+	IMAGE_EXPORT_DIRECTORY::TimeDateStamp=0;
+	IMAGE_EXPORT_DIRECTORY::MajorVersion=0;
+	IMAGE_EXPORT_DIRECTORY::MinorVersion=0;
+	IMAGE_EXPORT_DIRECTORY::Name=0;
+	IMAGE_EXPORT_DIRECTORY::Base=0;
+	IMAGE_EXPORT_DIRECTORY::NumberOfFunctions=0;
+	IMAGE_EXPORT_DIRECTORY::NumberOfNames=0;
+	IMAGE_EXPORT_DIRECTORY::AddressOfFunctions=0;
+	IMAGE_EXPORT_DIRECTORY::AddressOfNames=0;
+	IMAGE_EXPORT_DIRECTORY::AddressOfNameOrdinals=0;
+}
+#endif
+

image/EXPDSC.HPP

@@ -0,0 +1,130 @@
+#ifndef _IMAGE_IMAGEEXPORTDESCRIPTOR_HPP_
+#define _IMAGE_IMAGEEXPORTDESCRIPTOR_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_PUREDWORD_HPP_
+#include <common/puredwrd.hpp>
+#endif
+#ifndef _COMMON_PUREWORD_HPP_
+#include <common/purewrd.hpp>
+#endif
+#ifndef _COMMON_STDIO_HPP_
+#include <common/stdio.hpp>
+#endif
+
+class ImageExportDescriptor
+{
+public:
+	ImageExportDescriptor(void);
+	ImageExportDescriptor(const ImageExportDescriptor &someImageExportDescriptor);
+	virtual ~ImageExportDescriptor();
+	ImageExportDescriptor &operator=(const ImageExportDescriptor &someImageExportDescriptor);
+	WORD operator==(const ImageExportDescriptor &someImageExportDescriptor)const;
+	WORD operator<(const ImageExportDescriptor &someImageExportDescriptor)const;
+	WORD operator>(const ImageExportDescriptor &someImageExportDescriptor)const;
+  operator String(void)const;
+	String imageExportName(void)const;
+	void imageExportName(const String &imageExportName);
+	PureWORD imageExportOrdinal(void)const;
+	void imageExportOrdinal(PureWORD imageExportOrdinal);
+	PureDWORD imageExportEntryPoint(void)const;
+	void imageExportEntryPoint(PureDWORD imageExportEntryPoint);
+private:
+	String mImageExportName;
+	PureWORD mImageExportOrdinal;
+	PureDWORD mImageExportEntryPoint;
+};
+
+inline
+ImageExportDescriptor::ImageExportDescriptor(void)
+{
+}
+
+inline
+ImageExportDescriptor::ImageExportDescriptor(const ImageExportDescriptor &someImageExportDescriptor)
+{
+	*this=someImageExportDescriptor;
+}
+
+inline
+ImageExportDescriptor::~ImageExportDescriptor()
+{
+}
+
+inline
+ImageExportDescriptor &ImageExportDescriptor::operator=(const ImageExportDescriptor &someImageExportDescriptor)
+{
+	imageExportName(someImageExportDescriptor.imageExportName());
+	imageExportOrdinal(someImageExportDescriptor.imageExportOrdinal());
+	imageExportEntryPoint(someImageExportDescriptor.imageExportEntryPoint());
+	return *this;
+}
+
+inline
+WORD ImageExportDescriptor::operator==(const ImageExportDescriptor &someImageExportDescriptor)const
+{
+	return (imageExportName()==someImageExportDescriptor.imageExportName()&&
+					imageExportOrdinal()==someImageExportDescriptor.imageExportOrdinal()&&
+					imageExportEntryPoint()==someImageExportDescriptor.imageExportEntryPoint());
+}
+
+inline
+WORD ImageExportDescriptor::operator<(const ImageExportDescriptor &someImageExportDescriptor)const
+{
+	return imageExportEntryPoint()<someImageExportDescriptor.imageExportEntryPoint();
+}
+
+inline
+WORD ImageExportDescriptor::operator>(const ImageExportDescriptor &someImageExportDescriptor)const
+{
+	return imageExportEntryPoint()>someImageExportDescriptor.imageExportEntryPoint();
+}
+
+inline
+ImageExportDescriptor::operator String(void)const
+{
+	String descriptorString;
+	::sprintf((LPSTR)descriptorString,"%s @%ld 0x%08lx",
+		imageExportName().str(),
+		imageExportOrdinal().getValue(),
+		imageExportEntryPoint().getValue());
+	return descriptorString;
+}
+
+inline
+String ImageExportDescriptor::imageExportName(void)const
+{
+	return mImageExportName;
+}
+
+inline
+void ImageExportDescriptor::imageExportName(const String &imageExportName)
+{
+	mImageExportName=imageExportName;
+}
+
+inline
+PureWORD ImageExportDescriptor::imageExportOrdinal(void)const
+{
+	return mImageExportOrdinal;
+}
+
+inline
+void ImageExportDescriptor::imageExportOrdinal(PureWORD imageExportOrdinal)
+{
+	mImageExportOrdinal=imageExportOrdinal;
+}
+
+inline
+PureDWORD ImageExportDescriptor::imageExportEntryPoint(void)const
+{
+	return mImageExportEntryPoint;
+}
+
+inline
+void ImageExportDescriptor::imageExportEntryPoint(PureDWORD imageExportEntryPoint)
+{
+	mImageExportEntryPoint=imageExportEntryPoint;
+}
+#endif

image/EXPORT.CPP

@@ -0,0 +1,148 @@
+#include <image/export.hpp>
+#include <common/qsort.hpp>
+#include <common/qsort.tpp>
+#include <common/stdio.hpp>
+
+WORD ImageExportDescriptors::loadImageExports(PureViewOfFile &pureView,ImageSectionHeaders &imageSectionHeaders,WORD sortFlag)
+{
+	ImageSectionHeader exportFunctionsSectionHeader;
+	QuickSort<ImageExportDescriptor> quickSort;
+	Array<PureDWORD> exportFunctions;
+	Array<PureWORD> exportOrdinals;
+	PureDWORD exportFunctionEntryPoint;
+	Array<String> exportNames;
+	DWORD deltaFunctions;
+
+	size(0);
+	(ImageExportDirectory&)*this<<pureView;
+	loadExportNames(exportNames,imageSectionHeaders,pureView);
+	loadExportOrdinals(exportOrdinals,imageSectionHeaders,pureView);
+	loadExportFunctions(exportFunctions,imageSectionHeaders,pureView);
+	combineExportDescriptors(exportNames,exportOrdinals,exportFunctions);
+  if(sortFlag)quickSort.sortItems((Array<ImageExportDescriptor>&)*this);
+	return TRUE;
+}
+
+WORD ImageExportDescriptors::loadExportNames(Array<String> &exportNames,ImageSectionHeaders &imageSectionHeaders,PureViewOfFile &pureView)
+{
+	ImageSectionHeader exportNamesSectionHeader;
+	String exportName;
+	DWORD deltaNames;
+	DWORD nameRVA;
+
+	if(!numberOfNames())return false;
+  exportNames.size(numberOfNames());
+	imageSectionHeaders.enclosingSectionHeader(addressOfNames(),exportNamesSectionHeader,deltaNames);
+	pureView.seek(addressOfNames()-deltaNames,PureViewOfFile::SeekSet);
+	for(DWORD nameIndex=0;nameIndex<numberOfNames();nameIndex++)
+	{
+		pureView.read(nameRVA);
+		pureView.push();
+		pureView.seek(nameRVA-deltaNames,PureViewOfFile::SeekSet);
+		pureView.getLine(exportName);
+		exportNames[nameIndex]=exportName;
+		pureView.pop();
+	}
+  return TRUE;
+}
+
+WORD ImageExportDescriptors::loadExportOrdinals(Array<PureWORD> &exportOrdinals,ImageSectionHeaders &imageSectionHeaders,PureViewOfFile &pureView)
+{
+	ImageSectionHeader exportOrdinalsSectionHeader;
+	WORD exportOrdinal;
+	DWORD deltaOrdinals;
+
+  if(!numberOfNames())return false;
+	exportOrdinals.size(numberOfNames());
+	imageSectionHeaders.enclosingSectionHeader(addressOfNameOrdinals(),exportOrdinalsSectionHeader,deltaOrdinals);
+	pureView.seek(addressOfNameOrdinals()-deltaOrdinals,PureViewOfFile::SeekSet);
+	for(DWORD ordinalIndex=0;ordinalIndex<numberOfNames();ordinalIndex++)
+	{
+		pureView.read(exportOrdinal);
+		exportOrdinals[ordinalIndex]=exportOrdinal;
+	}
+	return TRUE;
+}
+
+WORD ImageExportDescriptors::loadExportFunctions(Array<PureDWORD> &exportFunctions,ImageSectionHeaders &imageSectionHeaders,PureViewOfFile &pureView)
+{
+	ImageSectionHeader exportFunctionsSectionHeader;
+  DWORD exportFunction;
+	DWORD deltaFunctions;
+
+  if(!numberOfFunctions())return false;
+	exportFunctions.size(numberOfFunctions());
+	imageSectionHeaders.enclosingSectionHeader(addressOfFunctions(),exportFunctionsSectionHeader,deltaFunctions);
+	pureView.seek(addressOfFunctions()-deltaFunctions,PureViewOfFile::SeekSet);
+	for(DWORD functionIndex=0;functionIndex<numberOfFunctions();functionIndex++)
+	{
+		pureView.read(exportFunction);
+		exportFunctions[functionIndex]=exportFunction;
+	}
+	return TRUE;
+}
+
+WORD ImageExportDescriptors::combineExportDescriptors(Array<String> &exportNames,Array<PureWORD> &exportOrdinals,Array<PureDWORD> &exportFunctions)
+{
+	DWORD sizeExportNames(exportNames.size());
+	DWORD sizeExportFunctions(exportFunctions.size());
+	String entryPointString;
+
+	size(sizeExportFunctions);
+	for(DWORD functionIndex=0;functionIndex<sizeExportFunctions;functionIndex++)
+	{
+		((Array<ImageExportDescriptor>&)*this)[functionIndex].imageExportEntryPoint(exportFunctions[functionIndex]);
+    ((Array<ImageExportDescriptor>&)*this)[functionIndex].imageExportOrdinal(functionIndex+base());
+	}
+	for(LONG nameIndex=0;nameIndex<sizeExportNames;nameIndex++)
+	{
+		((Array<ImageExportDescriptor>&)*this)[exportOrdinals[nameIndex].getValue()].imageExportName(exportNames[nameIndex]);
+		((Array<ImageExportDescriptor>&)*this)[exportOrdinals[nameIndex].getValue()].imageExportOrdinal(exportOrdinals[nameIndex].getValue()+(WORD)base());
+	}
+	for(functionIndex=0;functionIndex<sizeExportFunctions;functionIndex++)
+	{
+		if(((Array<ImageExportDescriptor>&)*this)[functionIndex].imageExportName().isNull())
+		{
+			::sprintf(entryPointString,"@%d",((Array<ImageExportDescriptor>&)*this)[functionIndex].imageExportOrdinal().getValue());
+			((Array<ImageExportDescriptor>&)*this)[functionIndex].imageExportName(entryPointString);
+		}
+	}
+	return TRUE;
+}
+
+WORD ImageExportDescriptors::locateImageExportName(String imageExportName,ImageExportDescriptor &imageExportDescriptor,DWORD &exportIndex)
+{
+	DWORD sizeExportFunctions(size());
+	WORD exportOrdinal;
+
+	if(imageExportName.isNull())return FALSE;
+	for(DWORD itemIndex=0;itemIndex<sizeExportFunctions;itemIndex++)
+	{
+		if(imageExportName==operator[](itemIndex).imageExportName())
+		{
+			imageExportDescriptor=operator[](itemIndex);
+			exportIndex=itemIndex;
+			return TRUE;
+		}
+	}
+	if(makeOrdinalValue(imageExportName,exportOrdinal))
+		return locateImageExportOrdinal(exportOrdinal,imageExportDescriptor,exportIndex);
+	return FALSE;
+}
+
+WORD ImageExportDescriptors::locateImageExportOrdinal(DWORD exportOrdinal,ImageExportDescriptor &imageExportDescriptor,DWORD &exportIndex)
+{
+	DWORD sizeExportFunctions(size());
+
+	for(DWORD itemIndex=0;itemIndex<sizeExportFunctions;itemIndex++)
+	{
+		if(exportOrdinal==operator[](itemIndex).imageExportOrdinal().getValue())
+		{
+			imageExportDescriptor=operator[](itemIndex);
+			exportIndex=itemIndex;
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+

image/EXPORT.HPP

@@ -0,0 +1,82 @@
+#ifndef _IMAGE_EXPORTDESCRIPTOR_HPP_
+#define _IMAGE_EXPORTDESCRIPTOR_HPP_
+#ifndef _COMMON_PUREDWORD_HPP_
+#include <common/puredwrd.hpp>
+#endif
+#ifndef _COMMON_PUREWORD_HPP_
+#include <common/purewrd.hpp>
+#endif
+#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+#include <common/pview.hpp>
+#endif
+#ifndef _COMMON_ARRAY_HPP_
+#include <common/array.hpp>
+#endif
+#ifndef _IMAGE_IMAGESECTIONHEADERS_HPP_
+#include <image/sctnhdrs.hpp>
+#endif
+#ifndef _IMAGE_IMAGEEXPORTDIRECTORY_HPP_
+#include <image/expdir.hpp>
+#endif
+#ifndef _IMAGE_IMAGEEXPORTDESCRIPTOR_HPP_
+#include <image/expdsc.hpp>
+#endif
+
+class ImageExportDescriptors : public ImageExportDirectory, public Array<ImageExportDescriptor>
+{
+public:
+	ImageExportDescriptors(void);
+	ImageExportDescriptors(const ImageExportDescriptors &someImageExportDescriptors);
+	virtual ~ImageExportDescriptors();
+	ImageExportDescriptors &operator=(const ImageExportDescriptors &someImageExportDecsriptors);
+	WORD operator==(const ImageExportDescriptors &someImageExportDescriptors)const;
+	WORD loadImageExports(PureViewOfFile &pureView,ImageSectionHeaders &imageSectionHeaders,WORD sortFlag);
+	WORD locateImageExportName(String imageExportName,ImageExportDescriptor &imageExportDescriptor,DWORD &exportIndex);
+	WORD locateImageExportOrdinal(DWORD exportOrdinal,ImageExportDescriptor &imageExportDescriptor,DWORD &exportIndex);
+private:
+  enum {OrdinalPrefix='@'};
+	WORD loadExportNames(Array<String> &exportNames,ImageSectionHeaders &imageSectionHeaders,PureViewOfFile &pureView);
+	WORD loadExportOrdinals(Array<PureWORD> &exportOrdinals,ImageSectionHeaders &imageSectionHeaders,PureViewOfFile &pureView);
+	WORD loadExportFunctions(Array<PureDWORD> &exportFunctions,ImageSectionHeaders &imageSectionHeaders,PureViewOfFile &pureView);
+	WORD combineExportDescriptors(Array<String> &exportNames,Array<PureWORD> &exportOrdinals,Array<PureDWORD> &exportFunctions);
+  WORD makeOrdinalValue(String imageExportName,WORD &exportOrdinal)const;
+};
+
+inline
+ImageExportDescriptors::ImageExportDescriptors(void)
+{
+}
+
+inline
+ImageExportDescriptors::ImageExportDescriptors(const ImageExportDescriptors &someImageExportDescriptors)
+{
+	*this=someImageExportDescriptors;
+}
+
+inline
+ImageExportDescriptors::~ImageExportDescriptors()
+{
+}
+
+inline
+ImageExportDescriptors &ImageExportDescriptors::operator=(const ImageExportDescriptors &someImageExportDescriptors)
+{
+	(Array<ImageExportDescriptor>&)*this=(Array<ImageExportDescriptor>&)someImageExportDescriptors;
+	return *this;
+}
+
+inline
+WORD ImageExportDescriptors::operator==(const ImageExportDescriptors &someImageExportDescriptors)const
+{
+	return (Array<ImageExportDescriptor>&)*this==(Array<ImageExportDescriptor>&)someImageExportDescriptors;
+}
+
+inline
+WORD ImageExportDescriptors::makeOrdinalValue(String imageExportName,WORD &exportOrdinal)const
+{
+  if(imageExportName.isNull())return FALSE;
+	if(OrdinalPrefix!=imageExportName[(DWORD)0])return FALSE;
+	exportOrdinal=(int)imageExportName.betweenString(OrdinalPrefix,0).toInt();
+  return TRUE;
+} 
+#endif

image/HARDWARE.CPP

@@ -0,0 +1,19 @@
+#include <image/hardware.hpp>
+
+Hardware::operator String(void)const
+{
+	if(CPUUnknown==cpuType())return "CPU_UNKNOWN";
+	else if(CPU80386==cpuType())return "CPU_80386";
+	else if(CPU80486==cpuType())return "CPU_80486";
+	else if(CPU80586==cpuType())return "CPU_80586";
+	else if(CPUMIPSR3000==cpuType())return "CPU_MIPS_R3000";
+	else if(CPUMIPSMARKII==cpuType())return "CPU_MIPS_MARKII";
+	else if(CPUMIPSMARKIII==cpuType())return "CPU_MIPS_MARKIII";
+	else if(CPUMIPSR4000==cpuType())return "CPU_MIPS_R4000";
+	else if(CPUDECALPHAAXP==cpuType())return "CPU_DEC_ALPHA_AXP";
+	else if(CPUPOWERPC==cpuType())return "CPU_POWERPC";
+	else if(CPUMOTOROLA68000==cpuType())return "CPU_MOTOROLA_68000";
+	else if(CPUPARISC==cpuType())return "CPU_PA_RISC";
+	else if(CPUMIPS10000==cpuType())return "CPU_MIPS-10000";
+  else return "*********";
+}

image/HARDWARE.HPP

@@ -0,0 +1,109 @@
+#ifndef _IMAGE_HARDWARE_HPP_
+#define _IMAGE_HARDWARE_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+#include <common/pview.hpp>
+#endif
+
+class Hardware
+{
+public:
+	enum CPUType{CPUUnknown=0x0000,CPU80386=0x014C,CPU80486=0x14D,CPU80586,
+			 CPUMIPSR3000=0x0162,CPUMIPSMARKII=0x0163,CPUMIPSMARKIII=0x164,
+			 CPUMIPSR4000=0x0166,CPUMIPS10000=0x0168,CPUDECALPHAAXP=0x0184,
+			 CPUPOWERPC=0x01F0,CPUMOTOROLA68000=0x0268,CPUPARISC=0x0290};
+	Hardware(CPUType cpuType=CPUUnknown);
+	Hardware(const Hardware &someHardware);
+  Hardware(WORD machine);
+	~Hardware();
+	Hardware &operator=(const Hardware &someHardware);
+	WORD operator==(const Hardware &someHardware)const;
+	WORD operator<<(PureViewOfFile &pureView);
+  WORD isValid(void)const;
+	CPUType cpuType(void)const;
+	void cpuType(CPUType cpuType);
+  operator String(void)const;
+private:
+	CPUType mCPUType;
+};
+
+inline
+Hardware::Hardware(CPUType cpuType)
+: mCPUType(cpuType)
+{
+}
+
+inline
+Hardware::Hardware(WORD machine)
+{
+  mCPUType=(CPUType)machine;
+}
+
+inline
+Hardware::Hardware(const Hardware &someHardware)
+{
+	*this=someHardware;
+}
+
+inline
+Hardware::~Hardware()
+{
+}
+
+inline
+Hardware &Hardware::operator=(const Hardware &someHardware)
+{
+	cpuType(someHardware.cpuType());
+	return *this;
+}
+
+inline
+WORD Hardware::operator==(const Hardware &someHardware)const
+{
+	return cpuType()==someHardware.cpuType();
+}
+
+inline
+Hardware::CPUType Hardware::cpuType(void)const
+{
+	return mCPUType;
+}
+
+inline
+void Hardware::cpuType(CPUType cpuType)
+{
+	mCPUType=cpuType;
+}
+
+inline
+WORD Hardware::operator<<(PureViewOfFile &pureView)
+{
+	WORD cpuType;
+
+	pureView.read(cpuType);
+	mCPUType=(CPUType)cpuType;
+	if(!isValid())return FALSE;
+	return TRUE;
+}
+
+inline
+WORD Hardware::isValid(void)const
+{
+	if(CPUUnknown==cpuType())return TRUE;
+	if(CPU80386==cpuType())return TRUE;
+	if(CPU80486==cpuType())return TRUE;
+	if(CPU80586==cpuType())return TRUE;
+	if(CPUMIPSR3000==cpuType())return TRUE;
+	if(CPUMIPSMARKII==cpuType())return TRUE;
+	if(CPUMIPSMARKIII==cpuType())return TRUE;
+	if(CPUMIPSR4000==cpuType())return TRUE;
+	if(CPUDECALPHAAXP==cpuType())return TRUE;
+	if(CPUPOWERPC==cpuType())return TRUE;
+	if(CPUMOTOROLA68000==cpuType())return TRUE;
+	if(CPUPARISC==cpuType())return TRUE;
+	if(CPUMIPS10000==cpuType())return TRUE;
+	return FALSE;
+}
+#endif

image/HOLD/RELOC.HPP

@@ -0,0 +1,122 @@
+#ifndef _IMAGE_IMAGERELOCATION_HPP_
+#define _IMAGE_IMAGERELOCATION_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+
+class ImageRelocation : private IMAGE_RELOCATION
+{
+public:
+  ImageRelocation(void);
+	ImageRelocation(const ImageRelocation &someImageRelocation);
+	virtual ~ImageRelocation();
+	ImageRelocation &operator=(const ImageRelocation &someImageRelocation);
+	bool operator==(const ImageRelocation &someImageRelocation)const;
+	DWORD virtualAddress(void)const;
+	void virtualAddress(DWORD virtualAddress);
+	DWORD relocationCount(void)const;
+	void relocationCount(DWORD relocationCount);
+	DWORD symbolTableIndex(void)const;
+	void symbolTableIndex(DWORD symbolTableIndex);
+	WORD relocationType(void)const;
+	void relocationType(WORD relocationType);
+private:
+  void setZero(void);
+};
+
+inline
+ImageRelocation::ImageRelocation(void)
+{
+  setZero();
+}
+
+inline
+ImageRelocation::ImageRelocation(const ImageRelocation &someImageRelocation)
+{
+  *this=someImageRelocation;
+}
+
+inline
+ImageRelocation::~ImageRelocation()
+{
+}
+
+inline
+ImageRelocation &ImageRelocation::operator=(const ImageRelocation &someImageRelocation)
+{
+  virtualAddress(someImageRelocation.virtualAddress());
+	symbolTableIndex(someImageRelocation.symbolTableIndex());
+	relocationType(someImageRelocation.relocationType());
+  return *this;
+}
+
+inline
+bool ImageRelocation::operator==(const ImageRelocation &someImageRelocation)const
+{
+  return (virtualAddress()==someImageRelocation.virtualAddress()&&
+	       symbolTableIndex()==someImageRelocation.symbolTableIndex()&&
+				 relocationType()==someImageRelocation.relocationType());
+}
+
+inline
+DWORD ImageRelocation::virtualAddress(void)const
+{
+  return IMAGE_RELOCATION::VirtualAddress;
+}
+
+inline
+void ImageRelocation::virtualAddress(DWORD virtualAddress)
+{
+  IMAGE_RELOCATION::VirtualAddress=virtualAddress;
+}
+
+inline
+DWORD ImageRelocation::relocationCount(void)const
+{
+  return IMAGE_RELOCATION::RelocCount;
+}
+
+inline
+void ImageRelocation::relocationCount(DWORD relocationCount)
+{
+  IMAGE_RELOCATION::RelocCount=relocationCount;
+}
+
+inline
+DWORD ImageRelocation::symbolTableIndex(void)const
+{
+  return IMAGE_RELOCATION::SymbolTableIndex;
+}
+
+inline
+void ImageRelocation::symbolTableIndex(DWORD symbolTableIndex)
+{
+  IMAGE_RELOCATION::SymbolTableIndex=symbolTableIndex;
+}
+
+inline
+WORD ImageRelocation::relocationType(void)const
+{
+  return IMAGE_RELOCATION::Type;
+}
+
+inline
+void ImageRelocation::relocationType(WORD relocationType)
+{
+  IMAGE_RELOCATION::Type=relocationType;
+}
+
+inline
+void ImageRelocation::setZero(void)
+{
+  IMAGE_RELOCATION::VirtualAddress=0;  
+	IMAGE_RELOCATION::SymbolTableIndex=0;
+	IMAGE_RELOCATION::Type=0;
+}
+
+typedef Block<ImageRelocation> ImageRelocations;
+
+#endif

image/IFLAGS.HPP

@@ -0,0 +1,118 @@
+#ifndef _IMAGE_IMAGEFLAGS_HPP_
+#define _IMAGE_IMAGEFLAGS_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class ImageFlags
+{
+public:
+  ImageFlags(const ImageFlags &someImageFlags);
+	ImageFlags(WORD imageFlags=0);
+	~ImageFlags();
+	ImageFlags &operator=(const ImageFlags &someImageFlags);
+	WORD operator==(const ImageFlags &someImageFlags);
+	WORD hasRelocations(void)const;
+	WORD hasLineNumbers(void)const;
+	WORD hasLocalSymbols(void)const;
+	WORD hasBytesReversedLo(void)const;
+	WORD hasBytesReversedHi(void)const;
+	WORD hasDebugInfo(void)const;
+	WORD is32BitMachine(void)const;
+	WORD isExeFile(void)const;
+	WORD isDllFile(void)const;
+	WORD isSystemFile(void)const;
+private:
+	WORD mImageFlags;
+};
+
+inline
+ImageFlags::ImageFlags(WORD imageFlags)
+: mImageFlags(imageFlags)
+{
+}
+
+inline
+ImageFlags::ImageFlags(const ImageFlags &someImageFlags)
+{
+	*this=someImageFlags;
+}
+
+inline
+ImageFlags::~ImageFlags()
+{
+}
+
+inline
+ImageFlags &ImageFlags::operator=(const ImageFlags &someImageFlags)
+{
+	mImageFlags=someImageFlags.mImageFlags;
+	return *this;
+}
+
+inline
+WORD ImageFlags::operator==(const ImageFlags &someImageFlags)
+{
+	return mImageFlags==someImageFlags.mImageFlags;
+}
+
+inline
+WORD ImageFlags::hasRelocations(void)const
+{
+	return (!(IMAGE_FILE_RELOCS_STRIPPED==(mImageFlags&IMAGE_FILE_RELOCS_STRIPPED)));
+}
+
+inline
+WORD ImageFlags::hasLineNumbers(void)const
+{
+	return (!(IMAGE_FILE_LINE_NUMS_STRIPPED==(mImageFlags&IMAGE_FILE_LINE_NUMS_STRIPPED)));
+}
+
+inline
+WORD ImageFlags::hasLocalSymbols(void)const
+{
+	return (!(IMAGE_FILE_LOCAL_SYMS_STRIPPED==(mImageFlags&IMAGE_FILE_LOCAL_SYMS_STRIPPED)));
+}
+
+inline
+WORD ImageFlags::hasBytesReversedLo(void)const
+{
+	return (IMAGE_FILE_BYTES_REVERSED_LO==(mImageFlags&IMAGE_FILE_BYTES_REVERSED_LO));
+}
+
+inline
+WORD ImageFlags::hasBytesReversedHi(void)const
+{
+	return (IMAGE_FILE_BYTES_REVERSED_HI==(mImageFlags&IMAGE_FILE_BYTES_REVERSED_HI));
+}
+
+inline
+WORD ImageFlags::hasDebugInfo(void)const
+{
+	return (!(IMAGE_FILE_DEBUG_STRIPPED==(mImageFlags&IMAGE_FILE_DEBUG_STRIPPED)));
+}
+
+inline
+WORD ImageFlags::is32BitMachine(void)const
+{
+	return (IMAGE_FILE_32BIT_MACHINE==(mImageFlags&IMAGE_FILE_32BIT_MACHINE));
+}
+
+inline
+WORD ImageFlags::isExeFile(void)const
+{
+	return (IMAGE_FILE_EXECUTABLE_IMAGE==(mImageFlags&IMAGE_FILE_EXECUTABLE_IMAGE));
+}
+
+inline
+WORD ImageFlags::isDllFile(void)const
+{
+	return (IMAGE_FILE_DLL==(mImageFlags&IMAGE_FILE_DLL));
+}
+
+inline
+WORD ImageFlags::isSystemFile(void)const
+{
+	return (IMAGE_FILE_SYSTEM==(mImageFlags&IMAGE_FILE_SYSTEM));
+}
+#endif

image/IMAGE.BAK

@@ -0,0 +1,779 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+!IF "$(CFG)" == ""
+CFG=image - Win32 Debug
+!MESSAGE No configuration specified.  Defaulting to image - Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "image - Win32 Release" && "$(CFG)" != "image - 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 "Image.mak" CFG="image - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "image - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "image - 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 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "image - Win32 Debug"
+CPP=cl.exe
+
+!IF  "$(CFG)" == "image - 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)\Image.lib"
+
+CLEAN : 
+	-@erase "$(INTDIR)\Direntry.obj"
+	-@erase "$(INTDIR)\Dtaentry.obj"
+	-@erase "$(INTDIR)\Export.obj"
+	-@erase "$(INTDIR)\Hardware.obj"
+	-@erase "$(INTDIR)\Import.obj"
+	-@erase "$(INTDIR)\Imresdir.obj"
+	-@erase "$(INTDIR)\Pehdr.obj"
+	-@erase "$(INTDIR)\Sctnhdrs.obj"
+	-@erase "$(INTDIR)\Stdtmpl.obj"
+	-@erase "$(INTDIR)\Vxdhdr.obj"
+	-@erase "$(INTDIR)\vxdname.obj"
+	-@erase "$(INTDIR)\vxdobj.obj"
+	-@erase "$(OUTDIR)\Image.lib"
+
+"$(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)/Image.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\Release/
+CPP_SBRS=.\.
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/Image.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/Image.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\Direntry.obj" \
+	"$(INTDIR)\Dtaentry.obj" \
+	"$(INTDIR)\Export.obj" \
+	"$(INTDIR)\Hardware.obj" \
+	"$(INTDIR)\Import.obj" \
+	"$(INTDIR)\Imresdir.obj" \
+	"$(INTDIR)\Pehdr.obj" \
+	"$(INTDIR)\Sctnhdrs.obj" \
+	"$(INTDIR)\Stdtmpl.obj" \
+	"$(INTDIR)\Vxdhdr.obj" \
+	"$(INTDIR)\vxdname.obj" \
+	"$(INTDIR)\vxdobj.obj"
+
+"$(OUTDIR)\Image.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "image - 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 : "..\exe\msimage.lib"
+
+CLEAN : 
+	-@erase "$(INTDIR)\Direntry.obj"
+	-@erase "$(INTDIR)\Dtaentry.obj"
+	-@erase "$(INTDIR)\Export.obj"
+	-@erase "$(INTDIR)\Hardware.obj"
+	-@erase "$(INTDIR)\Import.obj"
+	-@erase "$(INTDIR)\Imresdir.obj"
+	-@erase "$(INTDIR)\Pehdr.obj"
+	-@erase "$(INTDIR)\Sctnhdrs.obj"
+	-@erase "$(INTDIR)\Stdtmpl.obj"
+	-@erase "$(INTDIR)\Vxdhdr.obj"
+	-@erase "$(INTDIR)\vxdname.obj"
+	-@erase "$(INTDIR)\vxdobj.obj"
+	-@erase "..\exe\msimage.lib"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /G4 /Zp1 /MTd /GX /Z7 /O2 /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /Fp"..\exe\msvc42.pch" /YX"windows.h" /c
+CPP_PROJ=/nologo /G4 /Zp1 /MTd /GX /Z7 /O2 /D "WIN32" /D "_DEBUG" /D "_WINDOWS"\
+ /D "__FLAT__" /D "STRICT" /Fp"..\exe\msvc42.pch" /YX"windows.h" /Fo"$(INTDIR)/"\
+ /c 
+CPP_OBJS=.\msvcobj/
+CPP_SBRS=.\.
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/Image.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\msimage.lib"
+LIB32_FLAGS=/nologo /out:"..\exe\msimage.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\Direntry.obj" \
+	"$(INTDIR)\Dtaentry.obj" \
+	"$(INTDIR)\Export.obj" \
+	"$(INTDIR)\Hardware.obj" \
+	"$(INTDIR)\Import.obj" \
+	"$(INTDIR)\Imresdir.obj" \
+	"$(INTDIR)\Pehdr.obj" \
+	"$(INTDIR)\Sctnhdrs.obj" \
+	"$(INTDIR)\Stdtmpl.obj" \
+	"$(INTDIR)\Vxdhdr.obj" \
+	"$(INTDIR)\vxdname.obj" \
+	"$(INTDIR)\vxdobj.obj"
+
+"..\exe\msimage.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) $<  
+
+################################################################################
+# Begin Target
+
+# Name "image - Win32 Release"
+# Name "image - Win32 Debug"
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\Vxdhdr.cpp
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+DEP_CPP_VXDHD=\
+	{$(INCLUDE)}"\.\Doshdr.hpp"\
+	{$(INCLUDE)}"\.\Vxdhdr.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Vxdhdr.obj" : $(SOURCE) $(DEP_CPP_VXDHD) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+DEP_CPP_VXDHD=\
+	{$(INCLUDE)}"\.\Doshdr.hpp"\
+	{$(INCLUDE)}"\.\Vxdhdr.hpp"\
+	{$(INCLUDE)}"\.\vxdname.hpp"\
+	{$(INCLUDE)}"\.\vxdnames.hpp"\
+	{$(INCLUDE)}"\.\vxdobj.hpp"\
+	{$(INCLUDE)}"\.\vxdobjs.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Vxdhdr.obj" : $(SOURCE) $(DEP_CPP_VXDHD) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Hardware.cpp
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+DEP_CPP_HARDW=\
+	{$(INCLUDE)}"\.\Hardware.hpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Hardware.obj" : $(SOURCE) $(DEP_CPP_HARDW) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+DEP_CPP_HARDW=\
+	{$(INCLUDE)}"\.\Hardware.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Hardware.obj" : $(SOURCE) $(DEP_CPP_HARDW) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Import.cpp
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+DEP_CPP_IMPOR=\
+	{$(INCLUDE)}"\.\Impexp.hpp"\
+	{$(INCLUDE)}"\.\Import.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\.\Thnkdata.hpp"\
+	{$(INCLUDE)}"\.\Thnkname.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Import.obj" : $(SOURCE) $(DEP_CPP_IMPOR) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+DEP_CPP_IMPOR=\
+	{$(INCLUDE)}"\.\Impexp.hpp"\
+	{$(INCLUDE)}"\.\Import.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\.\Thnkdata.hpp"\
+	{$(INCLUDE)}"\.\Thnkname.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Import.obj" : $(SOURCE) $(DEP_CPP_IMPOR) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Pehdr.cpp
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+DEP_CPP_PEHDR=\
+	{$(INCLUDE)}"\.\Dbgdir.hpp"\
+	{$(INCLUDE)}"\.\Dllflags.hpp"\
+	{$(INCLUDE)}"\.\Doshdr.hpp"\
+	{$(INCLUDE)}"\.\Hardware.hpp"\
+	{$(INCLUDE)}"\.\Iflags.hpp"\
+	{$(INCLUDE)}"\.\Imagedir.hpp"\
+	{$(INCLUDE)}"\.\Imagehdr.hpp"\
+	{$(INCLUDE)}"\.\Ntsubsys.hpp"\
+	{$(INCLUDE)}"\.\Optlhdr.hpp"\
+	{$(INCLUDE)}"\.\Pehdr.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Filetime.hpp"\
+	{$(INCLUDE)}"\Common\Openfile.hpp"\
+	{$(INCLUDE)}"\Common\overlap.hpp"\
+	{$(INCLUDE)}"\Common\Pathfnd.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Systime.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Pehdr.obj" : $(SOURCE) $(DEP_CPP_PEHDR) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+DEP_CPP_PEHDR=\
+	{$(INCLUDE)}"\.\Dbgdir.hpp"\
+	{$(INCLUDE)}"\.\Dllflags.hpp"\
+	{$(INCLUDE)}"\.\Doshdr.hpp"\
+	{$(INCLUDE)}"\.\Expdir.hpp"\
+	{$(INCLUDE)}"\.\Expdsc.hpp"\
+	{$(INCLUDE)}"\.\Export.hpp"\
+	{$(INCLUDE)}"\.\Hardware.hpp"\
+	{$(INCLUDE)}"\.\Iflags.hpp"\
+	{$(INCLUDE)}"\.\Imagedir.hpp"\
+	{$(INCLUDE)}"\.\Imagehdr.hpp"\
+	{$(INCLUDE)}"\.\Impexp.hpp"\
+	{$(INCLUDE)}"\.\Import.hpp"\
+	{$(INCLUDE)}"\.\Keydir.hpp"\
+	{$(INCLUDE)}"\.\Ntsubsys.hpp"\
+	{$(INCLUDE)}"\.\Optlhdr.hpp"\
+	{$(INCLUDE)}"\.\Pehdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\.\Thnkdata.hpp"\
+	{$(INCLUDE)}"\.\Thnkname.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Filetime.hpp"\
+	{$(INCLUDE)}"\Common\Finddata.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Openfile.hpp"\
+	{$(INCLUDE)}"\Common\overlap.hpp"\
+	{$(INCLUDE)}"\Common\Pathfnd.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purewrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdio.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Systime.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Pehdr.obj" : $(SOURCE) $(DEP_CPP_PEHDR) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Sctnhdrs.cpp
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+DEP_CPP_SCTNH=\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Sctnhdrs.obj" : $(SOURCE) $(DEP_CPP_SCTNH) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+DEP_CPP_SCTNH=\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Sctnhdrs.obj" : $(SOURCE) $(DEP_CPP_SCTNH) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Stdtmpl.cpp
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+DEP_CPP_STDTM=\
+	{$(INCLUDE)}"\.\Dbgdir.hpp"\
+	{$(INCLUDE)}"\.\Expdir.hpp"\
+	{$(INCLUDE)}"\.\Expdsc.hpp"\
+	{$(INCLUDE)}"\.\Export.hpp"\
+	{$(INCLUDE)}"\.\Import.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\.\Thnkdata.hpp"\
+	{$(INCLUDE)}"\.\Thnkname.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\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purewrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.tpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Sortopt.hpp"\
+	{$(INCLUDE)}"\Common\Stdio.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Stdtmpl.obj" : $(SOURCE) $(DEP_CPP_STDTM) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+DEP_CPP_STDTM=\
+	{$(INCLUDE)}"\.\Dbgdir.hpp"\
+	{$(INCLUDE)}"\.\Expdir.hpp"\
+	{$(INCLUDE)}"\.\Expdsc.hpp"\
+	{$(INCLUDE)}"\.\Export.hpp"\
+	{$(INCLUDE)}"\.\Impexp.hpp"\
+	{$(INCLUDE)}"\.\Import.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\.\Thnkdata.hpp"\
+	{$(INCLUDE)}"\.\Thnkname.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\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purewrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.tpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Sortopt.hpp"\
+	{$(INCLUDE)}"\Common\Stdio.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Stdtmpl.obj" : $(SOURCE) $(DEP_CPP_STDTM) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Export.cpp
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+DEP_CPP_EXPOR=\
+	{$(INCLUDE)}"\.\Expdir.hpp"\
+	{$(INCLUDE)}"\.\Expdsc.hpp"\
+	{$(INCLUDE)}"\.\Export.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purewrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.tpp"\
+	{$(INCLUDE)}"\Common\Sortopt.hpp"\
+	{$(INCLUDE)}"\Common\Stdio.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Export.obj" : $(SOURCE) $(DEP_CPP_EXPOR) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+DEP_CPP_EXPOR=\
+	{$(INCLUDE)}"\.\Expdir.hpp"\
+	{$(INCLUDE)}"\.\Expdsc.hpp"\
+	{$(INCLUDE)}"\.\Export.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purewrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.tpp"\
+	{$(INCLUDE)}"\Common\Sortopt.hpp"\
+	{$(INCLUDE)}"\Common\Stdio.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Export.obj" : $(SOURCE) $(DEP_CPP_EXPOR) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Imresdir.cpp
+DEP_CPP_IMRES=\
+	{$(INCLUDE)}"\.\Direntry.hpp"\
+	{$(INCLUDE)}"\.\Dtaentry.hpp"\
+	{$(INCLUDE)}"\.\Imresdir.hpp"\
+	{$(INCLUDE)}"\.\Strptr.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(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\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Imresdir.obj" : $(SOURCE) $(DEP_CPP_IMRES) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Direntry.cpp
+DEP_CPP_DIREN=\
+	{$(INCLUDE)}"\.\Direntry.hpp"\
+	{$(INCLUDE)}"\.\Dtaentry.hpp"\
+	{$(INCLUDE)}"\.\Imresdir.hpp"\
+	{$(INCLUDE)}"\.\Resdrstr.hpp"\
+	{$(INCLUDE)}"\.\Strptr.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(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"\
+	{$(INCLUDE)}"\Common\Winnls.hpp"\
+	
+
+"$(INTDIR)\Direntry.obj" : $(SOURCE) $(DEP_CPP_DIREN) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Dtaentry.cpp
+DEP_CPP_DTAEN=\
+	{$(INCLUDE)}"\.\Dtaentry.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(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\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Dtaentry.obj" : $(SOURCE) $(DEP_CPP_DTAEN) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\vxdobj.cpp
+DEP_CPP_VXDOB=\
+	{$(INCLUDE)}"\.\vxdobj.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\vxdobj.obj" : $(SOURCE) $(DEP_CPP_VXDOB) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\vxdname.cpp
+DEP_CPP_VXDNA=\
+	{$(INCLUDE)}"\.\vxdname.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\vxdname.obj" : $(SOURCE) $(DEP_CPP_VXDNA) "$(INTDIR)"
+
+
+# End Source File
+# End Target
+# End Project
+################################################################################

image/IMAGE.PLG

@@ -0,0 +1,65 @@
+<html>
+<body>
+<pre>
+<h1>Build Log</h1>
+<h3>
+--------------------Configuration: image - Win32 Debug--------------------
+</h3>
+<h3>Command Lines</h3>
+Creating temporary file "C:\DOCUME~1\TERNET~1\LOCALS~1\Temp\RSP281.tmp" with contents
+[
+/nologo /Gz /MTd /GX /Z7 /Od /I "\work" /I "\parts" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /Fp"..\exe\msvc42.pch" /YX"windows.h" /Fo".\msvcobj/" /Fd".\msvcobj/" /FD /c 
+"F:\work\image\Direntry.cpp"
+"F:\work\image\Dtaentry.cpp"
+"F:\work\image\Export.cpp"
+"F:\work\image\Hardware.cpp"
+"F:\work\image\Import.cpp"
+"F:\work\image\Imresdir.cpp"
+"F:\work\image\Pehdr.cpp"
+"F:\work\image\Sctnhdrs.cpp"
+"F:\work\image\Stdtmpl.cpp"
+"F:\work\image\Vxdhdr.cpp"
+"F:\work\image\vxdname.cpp"
+"F:\work\image\vxdobj.cpp"
+]
+Creating command line "cl.exe @C:\DOCUME~1\TERNET~1\LOCALS~1\Temp\RSP281.tmp" 
+Creating temporary file "C:\DOCUME~1\TERNET~1\LOCALS~1\Temp\RSP282.tmp" with contents
+[
+/nologo /out:"..\exe\msimage.lib" 
+.\msvcobj\Direntry.obj
+.\msvcobj\Dtaentry.obj
+.\msvcobj\Export.obj
+.\msvcobj\Hardware.obj
+.\msvcobj\Import.obj
+.\msvcobj\Imresdir.obj
+.\msvcobj\Pehdr.obj
+.\msvcobj\Sctnhdrs.obj
+.\msvcobj\Stdtmpl.obj
+.\msvcobj\Vxdhdr.obj
+.\msvcobj\vxdname.obj
+.\msvcobj\vxdobj.obj
+]
+Creating command line "link.exe -lib @C:\DOCUME~1\TERNET~1\LOCALS~1\Temp\RSP282.tmp"
+<h3>Output Window</h3>
+Compiling...
+Direntry.cpp
+Dtaentry.cpp
+Export.cpp
+Hardware.cpp
+Import.cpp
+Imresdir.cpp
+Pehdr.cpp
+Sctnhdrs.cpp
+Stdtmpl.cpp
+Vxdhdr.cpp
+vxdname.cpp
+vxdobj.cpp
+Creating library...
+
+
+
+<h3>Results</h3>
+msimage.lib - 0 error(s), 0 warning(s)
+</pre>
+</body>
+</html>

image/IMAGE32.MAK

@@ -0,0 +1,106 @@
+#
+# Borland C++ IDE generated makefile
+#
+.AUTODEPEND
+
+
+#
+# Borland C++ tools
+#
+IMPLIB  = Implib
+BCC32   = Bcc32 -v -vi -4 -Jgx -Os -Z- -O- -O-l -O-m -O-i -w-sig -O-c -d -WM -W
+TLINK32 = TLink32
+TLIB    = TLib
+BRC32   = Brc32
+TASM32  = Tasm32
+#
+# IDE macros
+#
+
+
+#
+# Options
+#
+IDE_LFLAGS32 =  -L\bc45\lib
+IDE_RFLAGS32 = 
+LLATW32_ddbEXEbimage32dlib =  -LC:\BC45\LIB;..\EXE -Tpe -aa -c
+RLATW32_ddbEXEbimage32dlib =  -w32
+BLATW32_ddbEXEbimage32dlib =  /P128
+CNIEAT_ddbEXEbimage32dlib = -IC:\BC45\INCLUDE;.. -D
+LNIEAT_ddbEXEbimage32dlib = -x
+LEAT_ddbEXEbimage32dlib = $(LLATW32_ddbEXEbimage32dlib)
+REAT_ddbEXEbimage32dlib = $(RLATW32_ddbEXEbimage32dlib)
+BEAT_ddbEXEbimage32dlib = $(BLATW32_ddbEXEbimage32dlib)
+CLATW16_ddbexebcommon32dlib = 
+LLATW16_ddbexebcommon32dlib = 
+RLATW16_ddbexebcommon32dlib = 
+BLATW16_ddbexebcommon32dlib = 
+CEAT_ddbexebcommon32dlib = $(CEAT_ddbEXEbimage32dlib) $(CLATW16_ddbexebcommon32dlib)
+CNIEAT_ddbexebcommon32dlib = -IC:\BC45\INCLUDE;.. -D
+LNIEAT_ddbexebcommon32dlib = -x
+LEAT_ddbexebcommon32dlib = $(LEAT_ddbEXEbimage32dlib) $(LLATW16_ddbexebcommon32dlib)
+REAT_ddbexebcommon32dlib = $(REAT_ddbEXEbimage32dlib) $(RLATW16_ddbexebcommon32dlib)
+BEAT_ddbexebcommon32dlib = $(BEAT_ddbEXEbimage32dlib) $(BLATW16_ddbexebcommon32dlib)
+
+#
+# Dependency List
+#
+Dep_image32 = \
+   ..\EXE\image32.lib
+
+Dep_ddbEXEbimage32dlib = \
+   ..\exe\common32.lib\
+   EXEOBJ32\export.obj\
+   EXEOBJ32\sctnhdrs.obj\
+   EXEOBJ32\import.obj\
+   EXEOBJ32\hardware.obj\
+   EXEOBJ32\vxdhdr.obj\
+   EXEOBJ32\pehdr.obj\
+   EXEOBJ32\stdtmpl.obj
+
+..\EXE\image32.lib : $(Dep_ddbEXEbimage32dlib)
+  $(TLIB) $< $(IDE_BFLAGS) $(BEAT_ddbEXEbimage32dlib) @&&|
+ -+EXEOBJ32\export.obj &
+-+EXEOBJ32\sctnhdrs.obj &
+-+EXEOBJ32\import.obj &
+-+EXEOBJ32\hardware.obj &
+-+EXEOBJ32\vxdhdr.obj &
+-+EXEOBJ32\pehdr.obj &
+-+EXEOBJ32\stdtmpl.obj &
+-+..\exe\common32.lib
+|
+
+EXEOBJ32\export.obj :  export.cpp
+  $(BCC32) -c @&&|
+ $(CEAT_ddbEXEbimage32dlib) $(CNIEAT_ddbEXEbimage32dlib) -o$@ export.cpp
+|
+
+EXEOBJ32\sctnhdrs.obj :  sctnhdrs.cpp
+  $(BCC32) -c @&&|
+ $(CEAT_ddbEXEbimage32dlib) $(CNIEAT_ddbEXEbimage32dlib) -o$@ sctnhdrs.cpp
+|
+
+EXEOBJ32\import.obj :  import.cpp
+  $(BCC32) -c @&&|
+ $(CEAT_ddbEXEbimage32dlib) $(CNIEAT_ddbEXEbimage32dlib) -o$@ import.cpp
+|
+
+EXEOBJ32\hardware.obj :  hardware.cpp
+  $(BCC32) -c @&&|
+ $(CEAT_ddbEXEbimage32dlib) $(CNIEAT_ddbEXEbimage32dlib) -o$@ hardware.cpp
+|
+
+EXEOBJ32\vxdhdr.obj :  vxdhdr.cpp
+  $(BCC32) -c @&&|
+ $(CEAT_ddbEXEbimage32dlib) $(CNIEAT_ddbEXEbimage32dlib) -o$@ vxdhdr.cpp
+|
+
+EXEOBJ32\pehdr.obj :  pehdr.cpp
+  $(BCC32) -c @&&|
+ $(CEAT_ddbEXEbimage32dlib) $(CNIEAT_ddbEXEbimage32dlib) -o$@ pehdr.cpp
+|
+
+EXEOBJ32\stdtmpl.obj :  stdtmpl.cpp
+  $(BCC32) -c @&&|
+ $(CEAT_ddbEXEbimage32dlib) $(CNIEAT_ddbEXEbimage32dlib) -o$@ stdtmpl.cpp
+|

image/IMAGEDIR.BAK

@@ -0,0 +1,69 @@
+#ifndef _IMAGE_IMAGEDATADIRECTORY_HPP_
+#define _IMAGE_IMAGEDATADIRECTORY_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class ImageDataDirectory : private _IMAGE_DATA_DIRECTORY
+{
+public:
+	ImageDataDirectory(void);
+	ImageDataDirectory(const ImageDataDirectory &someImageDataDirectory);
+	ImageDataDirectory(const _IMAGE_DATA_DIRECTORY &someImageDataDirectory);
+	~ImageDataDirectory();
+	ImageDataDirectory &operator=(const ImageDataDirectory &someImageDataDirectory);
+	WORD operator==(const ImageDataDirectory &someImageDataDirectory)const;
+	DWORD virtualAddress(void)const;
+	DWORD size(void)const;
+private:
+};
+
+inline
+ImageDataDirectory::ImageDataDirectory(void)
+{
+  ::memset((char*)&((_IMAGE_DATA_DIRECTORY&)*this),0,sizeof(_IMAGE_DATA_DIRECTORY));
+}
+
+inline
+ImageDataDirectory::ImageDataDirectory(const ImageDataDirectory &someImageDataDirectory)
+{
+  *this=someImageDataDirectory;
+}
+
+inline
+ImageDataDirectory::ImageDataDirectory(const _IMAGE_DATA_DIRECTORY &someImageDataDirectory)
+{
+	::memcpy((char*)&((_IMAGE_DATA_DIRECTORY&)*this),(char*)&someImageDataDirectory,sizeof(_IMAGE_DATA_DIRECTORY));
+}
+
+inline
+ImageDataDirectory::~ImageDataDirectory()
+{
+}
+
+inline
+ImageDataDirectory &ImageDataDirectory::operator=(const ImageDataDirectory &someImageDataDirectory)
+{
+	::memcpy((char*)&((_IMAGE_DATA_DIRECTORY&)*this),(char*)&((_IMAGE_DATA_DIRECTORY&)someImageDataDirectory),sizeof(_IMAGE_DATA_DIRECTORY));
+  return *this;
+}
+
+inline
+WORD ImageDataDirectory::operator==(const ImageDataDirectory &someImageDataDirectory)const
+{
+	return (virtualAddress()==someImageDataDirectory.virtualAddress()&&
+          size()==someImageDataDirectory.size());
+}
+
+inline
+DWORD ImageDataDirectory::virtualAddress(void)const
+{
+  return _IMAGE_DATA_DIRECTORY::VirtualAddress;
+}
+
+inline
+DWORD ImageDataDirectory::size(void)const
+{
+  return _IMAGE_DATA_DIRECTORY::Size;
+}
+#endif

image/IMAGEDIR.HPP

@@ -0,0 +1,69 @@
+#ifndef _IMAGE_IMAGEDATADIRECTORY_HPP_
+#define _IMAGE_IMAGEDATADIRECTORY_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class ImageDataDirectory : private _IMAGE_DATA_DIRECTORY
+{
+public:
+	ImageDataDirectory(void);
+	ImageDataDirectory(const ImageDataDirectory &someImageDataDirectory);
+	ImageDataDirectory(const _IMAGE_DATA_DIRECTORY &someImageDataDirectory);
+	~ImageDataDirectory();
+	ImageDataDirectory &operator=(const ImageDataDirectory &someImageDataDirectory);
+	WORD operator==(const ImageDataDirectory &someImageDataDirectory)const;
+	DWORD virtualAddress(void)const;
+	DWORD size(void)const;
+private:
+};
+
+inline
+ImageDataDirectory::ImageDataDirectory(void)
+{
+  ::memset((char*)&((_IMAGE_DATA_DIRECTORY&)*this),0,sizeof(_IMAGE_DATA_DIRECTORY));
+}
+
+inline
+ImageDataDirectory::ImageDataDirectory(const ImageDataDirectory &someImageDataDirectory)
+{
+  *this=someImageDataDirectory;
+}
+
+inline
+ImageDataDirectory::ImageDataDirectory(const _IMAGE_DATA_DIRECTORY &someImageDataDirectory)
+{
+	::memcpy((char*)&((_IMAGE_DATA_DIRECTORY&)*this),(char*)&someImageDataDirectory,sizeof(_IMAGE_DATA_DIRECTORY));
+}
+
+inline
+ImageDataDirectory::~ImageDataDirectory()
+{
+}
+
+inline
+ImageDataDirectory &ImageDataDirectory::operator=(const ImageDataDirectory &someImageDataDirectory)
+{
+	::memcpy((char*)&((_IMAGE_DATA_DIRECTORY&)*this),(char*)&((_IMAGE_DATA_DIRECTORY&)someImageDataDirectory),sizeof(_IMAGE_DATA_DIRECTORY));
+  return *this;
+}
+
+inline
+WORD ImageDataDirectory::operator==(const ImageDataDirectory &someImageDataDirectory)const
+{
+	return (virtualAddress()==someImageDataDirectory.virtualAddress()&&
+          size()==someImageDataDirectory.size());
+}
+
+inline
+DWORD ImageDataDirectory::virtualAddress(void)const
+{
+  return _IMAGE_DATA_DIRECTORY::VirtualAddress;
+}
+
+inline
+DWORD ImageDataDirectory::size(void)const
+{
+  return _IMAGE_DATA_DIRECTORY::Size;
+}
+#endif

image/IMAGEHDR.BAK

@@ -0,0 +1,118 @@
+#ifndef _IMAGE_IMAGEHEADER_HPP_
+#define _IMAGE_IMAGEHEADER_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+#include <common/pview.hpp>
+#endif
+#ifndef _IMAGE_HARDWARE_HPP_
+#include <image/hardware.hpp>
+#endif
+#ifndef _IMAGE_IMAGEFLAGS_HPP_
+#include <image/iflags.hpp>
+#endif
+
+class ImageHeader : private _IMAGE_FILE_HEADER
+{
+public:
+	ImageHeader(void);
+	ImageHeader(const ImageHeader &someImageHeader);
+	~ImageHeader();
+	ImageHeader &operator=(const ImageHeader &someImageHeader);
+	WORD operator==(const ImageHeader &someImageHeader);
+	WORD operator<<(PureViewOfFile &pureView);
+	Hardware hardware(void)const;
+	WORD sectionCount(void)const;
+	DWORD timeDateStamp(void)const;
+	DWORD pointerSymbolTable(void)const;
+	DWORD symbolCount(void)const;
+	WORD sizeOptionalHeader(void)const;
+  ImageFlags imageFlags(void)const;
+private:
+};
+
+inline
+ImageHeader::ImageHeader(void)
+{
+	::memset((char*)&((_IMAGE_FILE_HEADER&)*this),0,sizeof(_IMAGE_FILE_HEADER));
+}
+
+inline
+ImageHeader::ImageHeader(const ImageHeader &someImageHeader)
+{
+	*this=someImageHeader;
+}
+
+inline
+ImageHeader::~ImageHeader()
+{
+}
+
+inline
+ImageHeader &ImageHeader::operator=(const ImageHeader &someImageHeader)
+{
+	::memcpy((char*)&((_IMAGE_FILE_HEADER&)*this),(char*)&((_IMAGE_FILE_HEADER&)someImageHeader),sizeof(_IMAGE_FILE_HEADER));
+  return *this;
+}
+
+inline
+WORD ImageHeader::operator==(const ImageHeader &someImageHeader)
+{
+	return (hardware()==someImageHeader.hardware()&&
+					sectionCount()==someImageHeader.sectionCount()&&
+					timeDateStamp()==someImageHeader.timeDateStamp()&&
+					pointerSymbolTable()==someImageHeader.pointerSymbolTable()&&
+					symbolCount()==someImageHeader.symbolCount()&&
+					sizeOptionalHeader()==someImageHeader.sizeOptionalHeader()&&
+					imageFlags()==someImageHeader.imageFlags());
+}
+
+inline
+WORD ImageHeader::operator<<(PureViewOfFile &pureView)
+{
+  return sizeof(_IMAGE_FILE_HEADER)==pureView.read((char*)&((_IMAGE_FILE_HEADER&)*this),sizeof(_IMAGE_FILE_HEADER));
+}
+
+inline
+Hardware ImageHeader::hardware(void)const
+{
+  return Hardware(_IMAGE_FILE_HEADER::Machine);
+}
+
+inline
+WORD ImageHeader::sectionCount(void)const
+{
+	return _IMAGE_FILE_HEADER::NumberOfSections;
+}
+
+inline
+DWORD ImageHeader::timeDateStamp(void)const
+{
+	return _IMAGE_FILE_HEADER::TimeDateStamp;
+}
+
+inline
+DWORD ImageHeader::pointerSymbolTable(void)const
+{
+	return _IMAGE_FILE_HEADER::PointerToSymbolTable;
+}
+
+inline
+DWORD ImageHeader::symbolCount(void)const
+{
+	return _IMAGE_FILE_HEADER::NumberOfSymbols;
+}
+
+inline
+WORD ImageHeader::sizeOptionalHeader(void)const
+{
+	return _IMAGE_FILE_HEADER::SizeOfOptionalHeader;
+}
+
+inline
+ImageFlags ImageHeader::imageFlags(void)const
+{
+  return ImageFlags(_IMAGE_FILE_HEADER::Characteristics);
+}
+#endif

image/IMAGEHDR.HPP

@@ -0,0 +1,118 @@
+#ifndef _IMAGE_IMAGEHEADER_HPP_
+#define _IMAGE_IMAGEHEADER_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+#include <common/pview.hpp>
+#endif
+#ifndef _IMAGE_HARDWARE_HPP_
+#include <image/hardware.hpp>
+#endif
+#ifndef _IMAGE_IMAGEFLAGS_HPP_
+#include <image/iflags.hpp>
+#endif
+
+class ImageHeader : private _IMAGE_FILE_HEADER
+{
+public:
+	ImageHeader(void);
+	ImageHeader(const ImageHeader &someImageHeader);
+	~ImageHeader();
+	ImageHeader &operator=(const ImageHeader &someImageHeader);
+	WORD operator==(const ImageHeader &someImageHeader);
+	WORD operator<<(PureViewOfFile &pureView);
+	Hardware hardware(void)const;
+	WORD sectionCount(void)const;
+	DWORD timeDateStamp(void)const;
+	DWORD pointerSymbolTable(void)const;
+	DWORD symbolCount(void)const;
+	WORD sizeOptionalHeader(void)const;
+  ImageFlags imageFlags(void)const;
+private:
+};
+
+inline
+ImageHeader::ImageHeader(void)
+{
+	::memset((char*)&((_IMAGE_FILE_HEADER&)*this),0,sizeof(_IMAGE_FILE_HEADER));
+}
+
+inline
+ImageHeader::ImageHeader(const ImageHeader &someImageHeader)
+{
+	*this=someImageHeader;
+}
+
+inline
+ImageHeader::~ImageHeader()
+{
+}
+
+inline
+ImageHeader &ImageHeader::operator=(const ImageHeader &someImageHeader)
+{
+	::memcpy((char*)&((_IMAGE_FILE_HEADER&)*this),(char*)&((_IMAGE_FILE_HEADER&)someImageHeader),sizeof(_IMAGE_FILE_HEADER));
+  return *this;
+}
+
+inline
+WORD ImageHeader::operator==(const ImageHeader &someImageHeader)
+{
+	return (hardware()==someImageHeader.hardware()&&
+					sectionCount()==someImageHeader.sectionCount()&&
+					timeDateStamp()==someImageHeader.timeDateStamp()&&
+					pointerSymbolTable()==someImageHeader.pointerSymbolTable()&&
+					symbolCount()==someImageHeader.symbolCount()&&
+					sizeOptionalHeader()==someImageHeader.sizeOptionalHeader()&&
+					imageFlags()==someImageHeader.imageFlags());
+}
+
+inline
+WORD ImageHeader::operator<<(PureViewOfFile &pureView)
+{
+  return sizeof(_IMAGE_FILE_HEADER)==pureView.read((char*)&((_IMAGE_FILE_HEADER&)*this),sizeof(_IMAGE_FILE_HEADER));
+}
+
+inline
+Hardware ImageHeader::hardware(void)const
+{
+  return Hardware(_IMAGE_FILE_HEADER::Machine);
+}
+
+inline
+WORD ImageHeader::sectionCount(void)const
+{
+	return _IMAGE_FILE_HEADER::NumberOfSections;
+}
+
+inline
+DWORD ImageHeader::timeDateStamp(void)const
+{
+	return _IMAGE_FILE_HEADER::TimeDateStamp;
+}
+
+inline
+DWORD ImageHeader::pointerSymbolTable(void)const
+{
+	return _IMAGE_FILE_HEADER::PointerToSymbolTable;
+}
+
+inline
+DWORD ImageHeader::symbolCount(void)const
+{
+	return _IMAGE_FILE_HEADER::NumberOfSymbols;
+}
+
+inline
+WORD ImageHeader::sizeOptionalHeader(void)const
+{
+	return _IMAGE_FILE_HEADER::SizeOfOptionalHeader;
+}
+
+inline
+ImageFlags ImageHeader::imageFlags(void)const
+{
+  return ImageFlags(_IMAGE_FILE_HEADER::Characteristics);
+}
+#endif

image/IMPEXP.HPP

@@ -0,0 +1,140 @@
+#ifndef _IMAGE_IMAGEIMPORTDESCRIPTOREXPAND_HPP_
+#define _IMAGE_IMAGEIMPORTDESCRIPTOREXPAND_HPP_
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _ENGINEER_IMAGETHUNKDATA_HPP_
+#include <image/thnkdata.hpp>
+#endif
+#ifndef _IMAGE_IMAGETHUNKNAME_HPP_
+#include <image/thnkname.hpp>
+#endif
+
+class ImageImportDescriptorExpand
+{
+public:
+	typedef Block<ImageThunkData> ImageThunkDataBlock;
+	typedef Block<ImageThunkName> ImageThunkNameBlock;
+	ImageImportDescriptorExpand(void);
+	ImageImportDescriptorExpand(const ImageImportDescriptorExpand &someImageImportDescriptorExpand);
+	virtual ~ImageImportDescriptorExpand();
+	ImageImportDescriptorExpand &operator=(const ImageImportDescriptorExpand &someImageImportDescriptor);
+	WORD operator==(const ImageImportDescriptorExpand &someImageImportDescriptorExpand)const;
+	ImageThunkDataBlock &imageOriginalThunkImportOrdinals(void);
+	void imageOriginalThunkImportOrdinals(const ImageThunkDataBlock &someImageOriginalThunkImportOrdinals);
+	ImageThunkNameBlock &imageOriginalThunkImportNames(void);
+	void imageOriginalThunkImportNames(const ImageThunkNameBlock &someImageOriginalThunkImportNames);
+	ImageThunkDataBlock &imageThunkImportOrdinals(void);
+	void imageThunkImportOrdinals(const ImageThunkDataBlock &someImageThunkImportOrdinals);
+	ImageThunkNameBlock &imageThunkImportNames(void);
+	void imageThunkImportNames(const ImageThunkNameBlock &someImageThunkImportNames);
+	String moduleName(void)const;
+	void moduleName(const String &moduleName);
+private:
+	ImageThunkDataBlock mImageOriginalThunkImportOrdinals;
+	ImageThunkNameBlock mImageOriginalThunkImportNames;
+	ImageThunkDataBlock mImageThunkImportOrdinals;
+	ImageThunkNameBlock mImageThunkImportNames;
+	String mModuleName;
+};
+
+inline
+ImageImportDescriptorExpand::ImageImportDescriptorExpand(void)
+{
+}
+
+inline
+ImageImportDescriptorExpand::ImageImportDescriptorExpand(const ImageImportDescriptorExpand &someImageImportDescriptorExpand)
+{
+	*this=someImageImportDescriptorExpand;
+}
+
+inline
+ImageImportDescriptorExpand::~ImageImportDescriptorExpand()
+{
+}
+
+inline
+ImageImportDescriptorExpand &ImageImportDescriptorExpand::operator=(const ImageImportDescriptorExpand &someImageImportDescriptorExpand)
+{
+	moduleName(someImageImportDescriptorExpand.moduleName());
+	imageOriginalThunkImportOrdinals(((ImageImportDescriptorExpand&)someImageImportDescriptorExpand).imageOriginalThunkImportOrdinals());
+	imageOriginalThunkImportNames(((ImageImportDescriptorExpand&)someImageImportDescriptorExpand).imageOriginalThunkImportNames());
+	imageThunkImportOrdinals(((ImageImportDescriptorExpand&)someImageImportDescriptorExpand).imageThunkImportOrdinals());
+	imageThunkImportNames(((ImageImportDescriptorExpand&)someImageImportDescriptorExpand).imageThunkImportNames());
+	return *this;
+}
+
+inline
+WORD ImageImportDescriptorExpand::operator==(const ImageImportDescriptorExpand &someImageImportDescriptorExpand)const
+{
+	return (moduleName()==someImageImportDescriptorExpand.moduleName()&&
+		mImageOriginalThunkImportOrdinals==someImageImportDescriptorExpand.mImageOriginalThunkImportOrdinals&&
+		mImageOriginalThunkImportNames==someImageImportDescriptorExpand.mImageOriginalThunkImportNames&&
+		mImageThunkImportOrdinals==someImageImportDescriptorExpand.mImageThunkImportOrdinals&&
+		mImageThunkImportNames==someImageImportDescriptorExpand.mImageThunkImportNames);
+}
+
+inline
+String ImageImportDescriptorExpand::moduleName(void)const
+{
+	return mModuleName;
+}
+
+inline
+void ImageImportDescriptorExpand::moduleName(const String &moduleName)
+{
+	mModuleName=moduleName;
+}
+
+inline
+ImageImportDescriptorExpand::ImageThunkDataBlock &ImageImportDescriptorExpand::imageOriginalThunkImportOrdinals(void)
+{
+	return mImageOriginalThunkImportOrdinals;
+}
+
+inline
+void ImageImportDescriptorExpand::imageOriginalThunkImportOrdinals(const ImageThunkDataBlock &someImageOriginalThunkImportOrdinals)
+{
+	mImageOriginalThunkImportOrdinals=someImageOriginalThunkImportOrdinals;
+}
+
+inline
+ImageImportDescriptorExpand::ImageThunkNameBlock &ImageImportDescriptorExpand::imageOriginalThunkImportNames(void)
+{
+	return mImageOriginalThunkImportNames;
+}
+
+inline
+void ImageImportDescriptorExpand::imageOriginalThunkImportNames(const ImageThunkNameBlock &someImageOriginalThunkImportNames)
+{
+	mImageOriginalThunkImportNames=someImageOriginalThunkImportNames;
+}
+
+inline
+ImageImportDescriptorExpand::ImageThunkDataBlock &ImageImportDescriptorExpand::imageThunkImportOrdinals(void)
+{
+	return mImageThunkImportOrdinals;
+}
+
+inline
+void ImageImportDescriptorExpand::imageThunkImportOrdinals(const ImageThunkDataBlock &someImageThunkImportOrdinals)
+{
+	mImageThunkImportOrdinals=someImageThunkImportOrdinals;
+}
+
+inline
+ImageImportDescriptorExpand::ImageThunkNameBlock &ImageImportDescriptorExpand::imageThunkImportNames(void)
+{
+	return mImageThunkImportNames;
+}
+
+inline
+void ImageImportDescriptorExpand::imageThunkImportNames(const ImageThunkNameBlock &someImageThunkImportNames)
+{
+	mImageThunkImportNames=someImageThunkImportNames;
+}
+#endif

image/IMPNAME.HPP

@@ -0,0 +1,85 @@
+#ifndef _ENGINEER_IMAGEIMPORTBYNAME_HPP_
+#define _ENGINEER_IMAGEIMPORTBYNAME_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class ImageImportByName : private IMAGE_IMPORT_BY_NAME
+{
+public:
+	ImageImportByName(void);
+	ImageImportByName(const ImageImportByName &someImageImportByName);
+	~ImageImportByName();
+	ImageImportByName &operator=(const ImageImportByName &someImageImportByName);
+	WORD operator==(const ImageImportByName &someImageImportByName)const;
+	WORD hint(void)const;
+	void hint(WORD hint);
+	BYTE name(void)const;
+	void name(BYTE name);
+private:
+	void setZero(void);
+};
+
+inline
+ImageImportByName::ImageImportByName(void)
+{
+  setZero();
+}
+
+inline
+ImageImportByName::ImageImportByName(const ImageImportByName &someImageImportByName)
+{
+	*this=someImageImportByName;
+}
+
+inline
+ImageImportByName::~ImageImportByName()
+{
+}
+
+inline
+ImageImportByName &ImageImportByName::operator=(const ImageImportByName &someImageImportByName)
+{
+	name(someImageImportByName.name());
+	hint(someImageImportByName.hint());
+	return *this;
+}
+
+inline
+WORD ImageImportByName::operator==(const ImageImportByName &someImageImportByName)const
+{
+	return (name()==someImageImportByName.name()&&
+          hint()==someImageImportByName.hint());
+}
+
+inline
+WORD ImageImportByName::hint(void)const
+{
+	return IMAGE_IMPORT_BY_NAME::Hint;
+}
+
+inline
+void ImageImportByName::hint(WORD hint)
+{
+	IMAGE_IMPORT_BY_NAME::Hint=hint;
+}
+
+inline
+BYTE ImageImportByName::name(void)const
+{
+	return IMAGE_IMPORT_BY_NAME::Name[0];
+}
+
+inline
+void ImageImportByName::name(BYTE name)
+{
+	IMAGE_IMPORT_BY_NAME::Name[0]=name;
+}
+
+inline
+void ImageImportByName::setZero(void)
+{
+	IMAGE_IMPORT_BY_NAME::Hint=0;
+	IMAGE_IMPORT_BY_NAME::Name[0]=0;
+}
+#endif

image/IMPORT.CPP

@@ -0,0 +1,48 @@
+#include <image/import.hpp>
+
+void ImageImportDescriptor::loadImageImportThunks(DWORD deltaOffset,PureViewOfFile &pureView,ImageSectionHeaders &imageSectionHeaders)
+{
+	if(!isOkay())return;
+	if(!firstThunkRVA()&&!originalFirstThunkRVA())return;
+	if(originalFirstThunkRVA())loadImageImportThunk(originalFirstThunkRVA(),deltaOffset,
+		imageOriginalThunkImportOrdinals(),imageOriginalThunkImportNames(),pureView,imageSectionHeaders);
+	else if(firstThunkRVA())loadImageImportThunk(firstThunkRVA(),deltaOffset,
+		imageThunkImportOrdinals(),imageThunkImportNames(),pureView,imageSectionHeaders);
+}
+
+void ImageImportDescriptor::loadImageFirstThunk(DWORD deltaOffset,PureViewOfFile &pureView,ImageSectionHeaders &imageSectionHeaders)
+{
+	if(!isOkay()||!firstThunkRVA())return;
+	loadImageImportThunk(firstThunkRVA(),deltaOffset,
+    imageThunkImportOrdinals(),imageThunkImportNames(),pureView,imageSectionHeaders);
+}
+
+void ImageImportDescriptor::loadImageImportThunk(DWORD virtualAddress,DWORD deltaOffset,Block<ImageThunkData> &imageThunkImportOrdinals,Block<ImageThunkName> &imageThunkImportNames,PureViewOfFile &pureView,ImageSectionHeaders &imageSectionHeaders)
+{
+	ImageSectionHeader imageSectionHeader;
+
+	imageThunkImportOrdinals.remove();
+	imageThunkImportNames.remove();
+	pureView.push();
+	pureView.seek(virtualAddress-deltaOffset,PureViewOfFile::SeekSet);
+	while(TRUE)
+	{
+		ImageThunkData imageThunkData;
+		imageThunkData<<pureView;
+		if(!imageThunkData.isOkay())break;
+		if(imageThunkData.isOrdinalImport())imageThunkImportOrdinals.insert(&imageThunkData);
+		else
+		{
+			ImageThunkName imageThunkName;
+			pureView.push();
+			imageSectionHeaders.enclosingSectionHeader(imageThunkData.addressOfDataRVA(),imageSectionHeader,deltaOffset);
+			pureView.seek(imageThunkData.addressOfDataRVA()-deltaOffset,PureViewOfFile::SeekSet);
+			imageThunkName<<pureView;
+			imageThunkImportNames.insert(&imageThunkName);
+			pureView.pop();
+		}
+	}
+	pureView.pop();
+}
+
+

image/IMPORT.HPP

@@ -0,0 +1,187 @@
+#ifndef _IMAGE_IMAGEIMPORTDESCRIPTOR_HPP_
+#define _IMAGE_IMAGEIMPORTDESCRIPTOR_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+#include <common/pview.hpp>
+#endif
+#ifndef _IMAGE_IMAGESECTIONHEADERS_HPP_
+#include <image/sctnhdrs.hpp>
+#endif
+#ifndef _IMAGE_IMAGEIMPORTDESCRIPTOREXPAND_HPP_
+#include <image/impexp.hpp>
+#endif
+
+class ImageImportDescriptor : public ImageImportDescriptorExpand, private IMAGE_IMPORT_DESCRIPTOR
+{
+public:
+	ImageImportDescriptor(void);
+	ImageImportDescriptor(const ImageImportDescriptor &someImageImportDescriptor);
+	virtual ~ImageImportDescriptor();
+	ImageImportDescriptor &operator=(const ImageImportDescriptor &someImageImportDescriptor);
+	WORD operator==(const ImageImportDescriptor &someImageImportDescriptor)const;
+	operator IMAGE_IMPORT_DESCRIPTOR &(void);
+	ImageImportDescriptor &operator<<(PureViewOfFile &pureView);
+	DWORD characteristicsRVA(void)const;
+	void characteristicsRVA(DWORD characteristicsRVA);
+	DWORD originalFirstThunkRVA(void)const;
+	void originalFirstThunkRVA(DWORD originalFirstThunkRVA);
+	DWORD timeDateStamp(void)const;
+	void timeDateStamp(DWORD timeDateStamp);
+	DWORD forwarderChainIndex(void)const;
+	void forwarderChainIndex(DWORD forwarderChainIndex);
+	DWORD nameRVA(void)const;
+	void nameRVA(DWORD nameRVA);
+	DWORD firstThunkRVA(void)const;
+	void firstThunkRVA(DWORD firstThunkRVA);
+	WORD isOkay(void)const;
+	void loadImageImportThunks(DWORD deltaOffset,PureViewOfFile &pureView,ImageSectionHeaders &imageSectionHeaders);
+  void loadImageFirstThunk(DWORD deltaOffset,PureViewOfFile &pureView,ImageSectionHeaders &imageSectionHeaders);
+private:
+	void loadImageImportThunk(DWORD virtualAddress,DWORD deltaOffset,Block<ImageThunkData> &imageThunkImportOrdinals,Block<ImageThunkName> &imageThunkImportNames,PureViewOfFile &pureView,ImageSectionHeaders &imageSectionHeaders);
+	void setZero(void);
+};
+
+inline
+ImageImportDescriptor::ImageImportDescriptor(void)
+{
+	setZero();
+}
+
+inline
+ImageImportDescriptor::ImageImportDescriptor(const ImageImportDescriptor &someImageImportDescriptor)
+{
+	*this=someImageImportDescriptor;
+}
+
+inline
+ImageImportDescriptor::~ImageImportDescriptor()
+{
+}
+
+inline
+ImageImportDescriptor::operator IMAGE_IMPORT_DESCRIPTOR &(void)
+{
+	return *this;
+}
+
+inline
+ImageImportDescriptor &ImageImportDescriptor::operator=(const ImageImportDescriptor &someImageImportDescriptor)
+{
+	characteristicsRVA(someImageImportDescriptor.characteristicsRVA());
+	originalFirstThunkRVA(someImageImportDescriptor.originalFirstThunkRVA());
+	timeDateStamp(someImageImportDescriptor.timeDateStamp());
+	forwarderChainIndex(someImageImportDescriptor.forwarderChainIndex());
+	nameRVA(someImageImportDescriptor.nameRVA());
+	firstThunkRVA(someImageImportDescriptor.firstThunkRVA());
+  (ImageImportDescriptorExpand&)*this=(ImageImportDescriptorExpand&)someImageImportDescriptor;
+	return *this;
+}
+
+inline
+ImageImportDescriptor &ImageImportDescriptor::operator<<(PureViewOfFile &pureView)
+{
+	pureView.read((char*)&((IMAGE_IMPORT_DESCRIPTOR&)*this),sizeof(IMAGE_IMPORT_DESCRIPTOR));
+	return *this;
+}
+
+inline
+WORD ImageImportDescriptor::operator==(const ImageImportDescriptor &someImageImportDescriptor)const
+{
+	return (characteristicsRVA()==someImageImportDescriptor.characteristicsRVA()&&
+	        originalFirstThunkRVA()==someImageImportDescriptor.originalFirstThunkRVA()&&
+	        timeDateStamp()==someImageImportDescriptor.timeDateStamp()&&
+         	forwarderChainIndex()==someImageImportDescriptor.forwarderChainIndex()&&
+	        nameRVA()==someImageImportDescriptor.nameRVA()&&
+					firstThunkRVA()==someImageImportDescriptor.firstThunkRVA());
+}
+
+inline
+DWORD ImageImportDescriptor::characteristicsRVA(void)const
+{
+	return IMAGE_IMPORT_DESCRIPTOR::Characteristics;
+}
+
+inline
+DWORD ImageImportDescriptor::originalFirstThunkRVA(void)const
+{
+	return (DWORD)IMAGE_IMPORT_DESCRIPTOR::OriginalFirstThunk;
+}
+
+inline
+DWORD ImageImportDescriptor::timeDateStamp(void)const
+{
+	return IMAGE_IMPORT_DESCRIPTOR::TimeDateStamp;
+}
+
+inline
+DWORD ImageImportDescriptor::forwarderChainIndex(void)const
+{
+	return IMAGE_IMPORT_DESCRIPTOR::ForwarderChain;
+}
+
+inline
+DWORD ImageImportDescriptor::nameRVA(void)const
+{
+	return IMAGE_IMPORT_DESCRIPTOR::Name;
+}
+
+inline
+DWORD ImageImportDescriptor::firstThunkRVA(void)const
+{
+	return (DWORD)IMAGE_IMPORT_DESCRIPTOR::FirstThunk;
+}
+
+inline
+void ImageImportDescriptor::characteristicsRVA(DWORD characteristicsRVA)
+{
+	IMAGE_IMPORT_DESCRIPTOR::Characteristics=characteristicsRVA;
+}
+
+inline
+void ImageImportDescriptor::originalFirstThunkRVA(DWORD originalFirstThunkRVA)
+{
+	IMAGE_IMPORT_DESCRIPTOR::OriginalFirstThunk=(unsigned long)(PIMAGE_THUNK_DATA)originalFirstThunkRVA;
+}
+
+inline
+void ImageImportDescriptor::timeDateStamp(DWORD timeDateStamp)
+{
+	IMAGE_IMPORT_DESCRIPTOR::TimeDateStamp=timeDateStamp;
+}
+
+inline
+void ImageImportDescriptor::forwarderChainIndex(DWORD forwarderChainIndex)
+{
+	IMAGE_IMPORT_DESCRIPTOR::ForwarderChain=forwarderChainIndex;
+}
+
+inline
+void ImageImportDescriptor::nameRVA(DWORD nameRVA)
+{
+	IMAGE_IMPORT_DESCRIPTOR::Name=nameRVA;
+}
+
+inline
+void ImageImportDescriptor::firstThunkRVA(DWORD firstThunkRVA)
+{
+	IMAGE_IMPORT_DESCRIPTOR::FirstThunk=(unsigned long)(PIMAGE_THUNK_DATA)firstThunkRVA;
+}
+
+inline
+WORD ImageImportDescriptor::isOkay(void)const
+{
+	if(!characteristicsRVA()&&!originalFirstThunkRVA()&&
+		 !timeDateStamp()&&!forwarderChainIndex()&&
+		 !nameRVA()&&!firstThunkRVA())return FALSE;
+	return TRUE;
+}
+
+inline
+void ImageImportDescriptor::setZero(void)
+{
+	::memset(&((IMAGE_IMPORT_DESCRIPTOR&)*this),0,sizeof(IMAGE_IMPORT_DESCRIPTOR));
+}
+#endif
+

image/IMRESDIR.BAK

@@ -0,0 +1,188 @@
+#ifndef _IMAGE_IMAGERESOURCEDIRECTORY_HPP_
+#define _IMAGE_IMAGERESOURCEDIRECTORY_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+
+class ImageResourceDirectory;
+class ImageResourceDirectoryEntry;
+class PureViewOfFile;
+
+class ImageResourceDirectory : private IMAGE_RESOURCE_DIRECTORY
+{
+public:
+  typedef Block<ImageResourceDirectoryEntry> ImageResourceDirectoryEntries;
+  ImageResourceDirectory(void);
+	ImageResourceDirectory(const ImageResourceDirectory &someImageResourceDirectory);
+	virtual ~ImageResourceDirectory();
+	ImageResourceDirectory &operator=(const ImageResourceDirectory &someImageResourceDirectory);
+	ImageResourceDirectoryEntry &operator[](UINT itemIndex);
+	WORD operator==(const ImageResourceDirectory &someImageResourceDirectory)const;
+	operator IMAGE_RESOURCE_DIRECTORY &(void);
+  DWORD characteristics(void)const;
+	void characteristics(DWORD characteristics);
+	DWORD timeDate(void)const;
+	void timeDate(DWORD timeDate);
+	WORD majorVersion(void)const;
+	void majorVersion(WORD majorVersion);
+	WORD minorVersion(void)const;
+	void minorVersion(WORD minorVersion);
+	WORD entriesByName(void)const;
+	void entriesByName(WORD entriesByName);
+	WORD entriesByID(void)const;
+	void entriesByID(WORD entriesByID);
+	WORD entries(void)const;
+  void read(DWORD resBase,DWORD deltaOffset,PureViewOfFile &pureView);
+	void clear(void);
+private:
+  void zeroInit(void);
+	ImageResourceDirectoryEntries mImageResourceDirectoryEntries;
+};
+
+inline
+ImageResourceDirectory::ImageResourceDirectory(void)
+{
+  zeroInit();
+}
+
+inline
+ImageResourceDirectory::ImageResourceDirectory(const ImageResourceDirectory &someImageResourceDirectory)
+{
+  *this=someImageResourceDirectory;
+}
+
+inline
+ImageResourceDirectory::~ImageResourceDirectory()
+{
+}
+
+inline
+ImageResourceDirectory &ImageResourceDirectory::operator=(const ImageResourceDirectory &someImageResourceDirectory)
+{
+  characteristics(someImageResourceDirectory.characteristics());
+  timeDate(someImageResourceDirectory.timeDate());
+	majorVersion(someImageResourceDirectory.majorVersion());
+	minorVersion(someImageResourceDirectory.minorVersion());
+	entriesByName(someImageResourceDirectory.entriesByName());
+	entriesByID(someImageResourceDirectory.entriesByID());
+	mImageResourceDirectoryEntries=someImageResourceDirectory.mImageResourceDirectoryEntries;
+	return *this;
+}
+
+inline
+WORD ImageResourceDirectory::operator==(const ImageResourceDirectory &someImageResourceDirectory)const
+{
+  return (characteristics()==someImageResourceDirectory.characteristics()&&
+	       timeDate()==someImageResourceDirectory.timeDate()&&
+				 majorVersion()==someImageResourceDirectory.majorVersion()&&
+				 minorVersion()==someImageResourceDirectory.minorVersion()&&
+				 entriesByName()==someImageResourceDirectory.entriesByName()&&
+				 entriesByID()==someImageResourceDirectory.entriesByID()&&
+				 mImageResourceDirectoryEntries==someImageResourceDirectory.mImageResourceDirectoryEntries);
+}
+
+inline
+ImageResourceDirectory::operator IMAGE_RESOURCE_DIRECTORY &(void)
+{
+  return *this;
+}
+
+inline
+DWORD ImageResourceDirectory::characteristics(void)const
+{
+  return IMAGE_RESOURCE_DIRECTORY::Characteristics;
+}
+
+inline
+void ImageResourceDirectory::characteristics(DWORD characteristics)
+{
+  IMAGE_RESOURCE_DIRECTORY::Characteristics=characteristics;
+}
+
+inline
+DWORD ImageResourceDirectory::timeDate(void)const
+{
+  return IMAGE_RESOURCE_DIRECTORY::TimeDateStamp;
+}
+
+inline
+void ImageResourceDirectory::timeDate(DWORD timeDate)
+{
+  IMAGE_RESOURCE_DIRECTORY::TimeDateStamp=timeDate;
+}
+
+inline
+WORD ImageResourceDirectory::majorVersion(void)const
+{
+  return IMAGE_RESOURCE_DIRECTORY::MajorVersion;
+}
+
+inline
+void ImageResourceDirectory::majorVersion(WORD majorVersion)
+{
+  IMAGE_RESOURCE_DIRECTORY::MajorVersion=majorVersion;
+}
+
+inline
+WORD ImageResourceDirectory::minorVersion(void)const
+{
+  return IMAGE_RESOURCE_DIRECTORY::MinorVersion;
+}
+
+inline
+void ImageResourceDirectory::minorVersion(WORD minorVersion)
+{
+  IMAGE_RESOURCE_DIRECTORY::MinorVersion=minorVersion;
+}
+
+inline
+WORD ImageResourceDirectory::entries(void)const
+{
+  return entriesByName()+entriesByID();
+}
+
+inline
+WORD ImageResourceDirectory::entriesByName(void)const
+{
+  return IMAGE_RESOURCE_DIRECTORY::NumberOfNamedEntries;
+}
+
+inline
+void ImageResourceDirectory::entriesByName(WORD entriesByName)
+{
+  IMAGE_RESOURCE_DIRECTORY::NumberOfNamedEntries=entriesByName;
+}
+
+inline
+WORD ImageResourceDirectory::entriesByID(void)const
+{
+  return IMAGE_RESOURCE_DIRECTORY::NumberOfIdEntries;
+}
+
+inline
+void ImageResourceDirectory::entriesByID(WORD entriesByID)
+{
+  IMAGE_RESOURCE_DIRECTORY::NumberOfIdEntries=entriesByID;
+}
+
+inline
+void ImageResourceDirectory::zeroInit(void)
+{
+  IMAGE_RESOURCE_DIRECTORY::Characteristics=0;
+  IMAGE_RESOURCE_DIRECTORY::TimeDateStamp=0;
+  IMAGE_RESOURCE_DIRECTORY::MajorVersion=0;
+  IMAGE_RESOURCE_DIRECTORY::MinorVersion=0;
+  IMAGE_RESOURCE_DIRECTORY::NumberOfNamedEntries=0;
+  IMAGE_RESOURCE_DIRECTORY::NumberOfIdEntries=0;
+}
+
+inline
+void ImageResourceDirectory::clear(void)
+{
+  zeroInit();
+  mImageResourceDirectoryEntries.remove();
+}
+#endif

image/IMRESDIR.CPP

@@ -0,0 +1,24 @@
+#include <image/imresdir.hpp>
+#include <image/direntry.hpp>
+#include <common/pview.hpp>
+#include <common/assert.hpp>
+
+ImageResourceDirectoryEntry &ImageResourceDirectory::operator[](UINT itemIndex)
+{
+  assert(itemIndex<mImageResourceDirectoryEntries.size());
+	return mImageResourceDirectoryEntries[itemIndex];
+}
+
+void ImageResourceDirectory::read(DWORD resBase,DWORD deltaOffset,PureViewOfFile &pureView)
+{
+  DWORD entryCount;
+
+	clear();
+	pureView.read((char*)&((IMAGE_RESOURCE_DIRECTORY&)*this),sizeof(IMAGE_RESOURCE_DIRECTORY));
+	entryCount=entries();
+	for(int entryIndex=0;entryIndex<entryCount;entryIndex++)
+	{
+	  mImageResourceDirectoryEntries.insert(&ImageResourceDirectoryEntry());
+		mImageResourceDirectoryEntries[mImageResourceDirectoryEntries.size()-1].read(resBase,deltaOffset,pureView);
+	}
+}

image/IMRESDIR.HPP

@@ -0,0 +1,188 @@
+#ifndef _IMAGE_IMAGERESOURCEDIRECTORY_HPP_
+#define _IMAGE_IMAGERESOURCEDIRECTORY_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+
+class ImageResourceDirectory;
+class ImageResourceDirectoryEntry;
+class PureViewOfFile;
+
+class ImageResourceDirectory : private IMAGE_RESOURCE_DIRECTORY
+{
+public:
+  typedef Block<ImageResourceDirectoryEntry> ImageResourceDirectoryEntries;
+  ImageResourceDirectory(void);
+	ImageResourceDirectory(const ImageResourceDirectory &someImageResourceDirectory);
+	virtual ~ImageResourceDirectory();
+	ImageResourceDirectory &operator=(const ImageResourceDirectory &someImageResourceDirectory);
+	ImageResourceDirectoryEntry &operator[](UINT itemIndex);
+	WORD operator==(const ImageResourceDirectory &someImageResourceDirectory)const;
+	operator IMAGE_RESOURCE_DIRECTORY &(void);
+  DWORD characteristics(void)const;
+	void characteristics(DWORD characteristics);
+	DWORD timeDate(void)const;
+	void timeDate(DWORD timeDate);
+	WORD majorVersion(void)const;
+	void majorVersion(WORD majorVersion);
+	WORD minorVersion(void)const;
+	void minorVersion(WORD minorVersion);
+	WORD entriesByName(void)const;
+	void entriesByName(WORD entriesByName);
+	WORD entriesByID(void)const;
+	void entriesByID(WORD entriesByID);
+	WORD entries(void)const;
+  void read(DWORD resBase,DWORD deltaOffset,PureViewOfFile &pureView);
+	void clear(void);
+private:
+  void zeroInit(void);
+	ImageResourceDirectoryEntries mImageResourceDirectoryEntries;
+};
+
+inline
+ImageResourceDirectory::ImageResourceDirectory(void)
+{
+  zeroInit();
+}
+
+inline
+ImageResourceDirectory::ImageResourceDirectory(const ImageResourceDirectory &someImageResourceDirectory)
+{
+  *this=someImageResourceDirectory;
+}
+
+inline
+ImageResourceDirectory::~ImageResourceDirectory()
+{
+}
+
+inline
+ImageResourceDirectory &ImageResourceDirectory::operator=(const ImageResourceDirectory &someImageResourceDirectory)
+{
+  characteristics(someImageResourceDirectory.characteristics());
+  timeDate(someImageResourceDirectory.timeDate());
+	majorVersion(someImageResourceDirectory.majorVersion());
+	minorVersion(someImageResourceDirectory.minorVersion());
+	entriesByName(someImageResourceDirectory.entriesByName());
+	entriesByID(someImageResourceDirectory.entriesByID());
+	mImageResourceDirectoryEntries=someImageResourceDirectory.mImageResourceDirectoryEntries;
+	return *this;
+}
+
+inline
+WORD ImageResourceDirectory::operator==(const ImageResourceDirectory &someImageResourceDirectory)const
+{
+  return (characteristics()==someImageResourceDirectory.characteristics()&&
+	       timeDate()==someImageResourceDirectory.timeDate()&&
+				 majorVersion()==someImageResourceDirectory.majorVersion()&&
+				 minorVersion()==someImageResourceDirectory.minorVersion()&&
+				 entriesByName()==someImageResourceDirectory.entriesByName()&&
+				 entriesByID()==someImageResourceDirectory.entriesByID()&&
+				 mImageResourceDirectoryEntries==someImageResourceDirectory.mImageResourceDirectoryEntries);
+}
+
+inline
+ImageResourceDirectory::operator IMAGE_RESOURCE_DIRECTORY &(void)
+{
+  return *this;
+}
+
+inline
+DWORD ImageResourceDirectory::characteristics(void)const
+{
+  return IMAGE_RESOURCE_DIRECTORY::Characteristics;
+}
+
+inline
+void ImageResourceDirectory::characteristics(DWORD characteristics)
+{
+  IMAGE_RESOURCE_DIRECTORY::Characteristics=characteristics;
+}
+
+inline
+DWORD ImageResourceDirectory::timeDate(void)const
+{
+  return IMAGE_RESOURCE_DIRECTORY::TimeDateStamp;
+}
+
+inline
+void ImageResourceDirectory::timeDate(DWORD timeDate)
+{
+  IMAGE_RESOURCE_DIRECTORY::TimeDateStamp=timeDate;
+}
+
+inline
+WORD ImageResourceDirectory::majorVersion(void)const
+{
+  return IMAGE_RESOURCE_DIRECTORY::MajorVersion;
+}
+
+inline
+void ImageResourceDirectory::majorVersion(WORD majorVersion)
+{
+  IMAGE_RESOURCE_DIRECTORY::MajorVersion=majorVersion;
+}
+
+inline
+WORD ImageResourceDirectory::minorVersion(void)const
+{
+  return IMAGE_RESOURCE_DIRECTORY::MinorVersion;
+}
+
+inline
+void ImageResourceDirectory::minorVersion(WORD minorVersion)
+{
+  IMAGE_RESOURCE_DIRECTORY::MinorVersion=minorVersion;
+}
+
+inline
+WORD ImageResourceDirectory::entries(void)const
+{
+  return entriesByName()+entriesByID();
+}
+
+inline
+WORD ImageResourceDirectory::entriesByName(void)const
+{
+  return IMAGE_RESOURCE_DIRECTORY::NumberOfNamedEntries;
+}
+
+inline
+void ImageResourceDirectory::entriesByName(WORD entriesByName)
+{
+  IMAGE_RESOURCE_DIRECTORY::NumberOfNamedEntries=entriesByName;
+}
+
+inline
+WORD ImageResourceDirectory::entriesByID(void)const
+{
+  return IMAGE_RESOURCE_DIRECTORY::NumberOfIdEntries;
+}
+
+inline
+void ImageResourceDirectory::entriesByID(WORD entriesByID)
+{
+  IMAGE_RESOURCE_DIRECTORY::NumberOfIdEntries=entriesByID;
+}
+
+inline
+void ImageResourceDirectory::zeroInit(void)
+{
+  IMAGE_RESOURCE_DIRECTORY::Characteristics=0;
+  IMAGE_RESOURCE_DIRECTORY::TimeDateStamp=0;
+  IMAGE_RESOURCE_DIRECTORY::MajorVersion=0;
+  IMAGE_RESOURCE_DIRECTORY::MinorVersion=0;
+  IMAGE_RESOURCE_DIRECTORY::NumberOfNamedEntries=0;
+  IMAGE_RESOURCE_DIRECTORY::NumberOfIdEntries=0;
+}
+
+inline
+void ImageResourceDirectory::clear(void)
+{
+  zeroInit();
+  mImageResourceDirectoryEntries.remove();
+}
+#endif

image/Image.mak

@@ -0,0 +1,779 @@
+# Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+!IF "$(CFG)" == ""
+CFG=image - Win32 Debug
+!MESSAGE No configuration specified.  Defaulting to image - Win32 Debug.
+!ENDIF 
+
+!IF "$(CFG)" != "image - Win32 Release" && "$(CFG)" != "image - 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 "Image.mak" CFG="image - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "image - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "image - 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 
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "image - Win32 Debug"
+CPP=cl.exe
+
+!IF  "$(CFG)" == "image - 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)\Image.lib"
+
+CLEAN : 
+	-@erase "$(INTDIR)\Direntry.obj"
+	-@erase "$(INTDIR)\Dtaentry.obj"
+	-@erase "$(INTDIR)\Export.obj"
+	-@erase "$(INTDIR)\Hardware.obj"
+	-@erase "$(INTDIR)\Import.obj"
+	-@erase "$(INTDIR)\Imresdir.obj"
+	-@erase "$(INTDIR)\Pehdr.obj"
+	-@erase "$(INTDIR)\Sctnhdrs.obj"
+	-@erase "$(INTDIR)\Stdtmpl.obj"
+	-@erase "$(INTDIR)\Vxdhdr.obj"
+	-@erase "$(INTDIR)\vxdname.obj"
+	-@erase "$(INTDIR)\vxdobj.obj"
+	-@erase "$(OUTDIR)\Image.lib"
+
+"$(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)/Image.pch" /YX /Fo"$(INTDIR)/" /c 
+CPP_OBJS=.\Release/
+CPP_SBRS=.\.
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/Image.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+LIB32_FLAGS=/nologo /out:"$(OUTDIR)/Image.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\Direntry.obj" \
+	"$(INTDIR)\Dtaentry.obj" \
+	"$(INTDIR)\Export.obj" \
+	"$(INTDIR)\Hardware.obj" \
+	"$(INTDIR)\Import.obj" \
+	"$(INTDIR)\Imresdir.obj" \
+	"$(INTDIR)\Pehdr.obj" \
+	"$(INTDIR)\Sctnhdrs.obj" \
+	"$(INTDIR)\Stdtmpl.obj" \
+	"$(INTDIR)\Vxdhdr.obj" \
+	"$(INTDIR)\vxdname.obj" \
+	"$(INTDIR)\vxdobj.obj"
+
+"$(OUTDIR)\Image.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS)
+    $(LIB32) @<<
+  $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS)
+<<
+
+!ELSEIF  "$(CFG)" == "image - 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 : "..\exe\msimage.lib"
+
+CLEAN : 
+	-@erase "$(INTDIR)\Direntry.obj"
+	-@erase "$(INTDIR)\Dtaentry.obj"
+	-@erase "$(INTDIR)\Export.obj"
+	-@erase "$(INTDIR)\Hardware.obj"
+	-@erase "$(INTDIR)\Import.obj"
+	-@erase "$(INTDIR)\Imresdir.obj"
+	-@erase "$(INTDIR)\Pehdr.obj"
+	-@erase "$(INTDIR)\Sctnhdrs.obj"
+	-@erase "$(INTDIR)\Stdtmpl.obj"
+	-@erase "$(INTDIR)\Vxdhdr.obj"
+	-@erase "$(INTDIR)\vxdname.obj"
+	-@erase "$(INTDIR)\vxdobj.obj"
+	-@erase "..\exe\msimage.lib"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /G4 /Zp1 /MTd /GX /Z7 /O2 /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /Fp"..\exe\msvc42.pch" /YX"windows.h" /c
+CPP_PROJ=/nologo /G4 /Zp1 /MTd /GX /Z7 /O2 /D "WIN32" /D "_DEBUG" /D "_WINDOWS"\
+ /D "__FLAT__" /D "STRICT" /Fp"..\exe\msvc42.pch" /YX"windows.h" /Fo"$(INTDIR)/"\
+ /c 
+CPP_OBJS=.\msvcobj/
+CPP_SBRS=.\.
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/Image.bsc" 
+BSC32_SBRS= \
+	
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\exe\msimage.lib"
+LIB32_FLAGS=/nologo /out:"..\exe\msimage.lib" 
+LIB32_OBJS= \
+	"$(INTDIR)\Direntry.obj" \
+	"$(INTDIR)\Dtaentry.obj" \
+	"$(INTDIR)\Export.obj" \
+	"$(INTDIR)\Hardware.obj" \
+	"$(INTDIR)\Import.obj" \
+	"$(INTDIR)\Imresdir.obj" \
+	"$(INTDIR)\Pehdr.obj" \
+	"$(INTDIR)\Sctnhdrs.obj" \
+	"$(INTDIR)\Stdtmpl.obj" \
+	"$(INTDIR)\Vxdhdr.obj" \
+	"$(INTDIR)\vxdname.obj" \
+	"$(INTDIR)\vxdobj.obj"
+
+"..\exe\msimage.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) $<  
+
+################################################################################
+# Begin Target
+
+# Name "image - Win32 Release"
+# Name "image - Win32 Debug"
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+!ENDIF 
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\Vxdhdr.cpp
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+DEP_CPP_VXDHD=\
+	{$(INCLUDE)}"\.\Doshdr.hpp"\
+	{$(INCLUDE)}"\.\Vxdhdr.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Vxdhdr.obj" : $(SOURCE) $(DEP_CPP_VXDHD) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+DEP_CPP_VXDHD=\
+	{$(INCLUDE)}"\.\Doshdr.hpp"\
+	{$(INCLUDE)}"\.\Vxdhdr.hpp"\
+	{$(INCLUDE)}"\.\vxdname.hpp"\
+	{$(INCLUDE)}"\.\vxdnames.hpp"\
+	{$(INCLUDE)}"\.\vxdobj.hpp"\
+	{$(INCLUDE)}"\.\vxdobjs.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Vxdhdr.obj" : $(SOURCE) $(DEP_CPP_VXDHD) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Hardware.cpp
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+DEP_CPP_HARDW=\
+	{$(INCLUDE)}"\.\Hardware.hpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Hardware.obj" : $(SOURCE) $(DEP_CPP_HARDW) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+DEP_CPP_HARDW=\
+	{$(INCLUDE)}"\.\Hardware.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Hardware.obj" : $(SOURCE) $(DEP_CPP_HARDW) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Import.cpp
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+DEP_CPP_IMPOR=\
+	{$(INCLUDE)}"\.\Impexp.hpp"\
+	{$(INCLUDE)}"\.\Import.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\.\Thnkdata.hpp"\
+	{$(INCLUDE)}"\.\Thnkname.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Import.obj" : $(SOURCE) $(DEP_CPP_IMPOR) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+DEP_CPP_IMPOR=\
+	{$(INCLUDE)}"\.\Impexp.hpp"\
+	{$(INCLUDE)}"\.\Import.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\.\Thnkdata.hpp"\
+	{$(INCLUDE)}"\.\Thnkname.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Import.obj" : $(SOURCE) $(DEP_CPP_IMPOR) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Pehdr.cpp
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+DEP_CPP_PEHDR=\
+	{$(INCLUDE)}"\.\Dbgdir.hpp"\
+	{$(INCLUDE)}"\.\Dllflags.hpp"\
+	{$(INCLUDE)}"\.\Doshdr.hpp"\
+	{$(INCLUDE)}"\.\Hardware.hpp"\
+	{$(INCLUDE)}"\.\Iflags.hpp"\
+	{$(INCLUDE)}"\.\Imagedir.hpp"\
+	{$(INCLUDE)}"\.\Imagehdr.hpp"\
+	{$(INCLUDE)}"\.\Ntsubsys.hpp"\
+	{$(INCLUDE)}"\.\Optlhdr.hpp"\
+	{$(INCLUDE)}"\.\Pehdr.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Filetime.hpp"\
+	{$(INCLUDE)}"\Common\Openfile.hpp"\
+	{$(INCLUDE)}"\Common\overlap.hpp"\
+	{$(INCLUDE)}"\Common\Pathfnd.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Systime.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Pehdr.obj" : $(SOURCE) $(DEP_CPP_PEHDR) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+DEP_CPP_PEHDR=\
+	{$(INCLUDE)}"\.\Dbgdir.hpp"\
+	{$(INCLUDE)}"\.\Dllflags.hpp"\
+	{$(INCLUDE)}"\.\Doshdr.hpp"\
+	{$(INCLUDE)}"\.\Expdir.hpp"\
+	{$(INCLUDE)}"\.\Expdsc.hpp"\
+	{$(INCLUDE)}"\.\Export.hpp"\
+	{$(INCLUDE)}"\.\Hardware.hpp"\
+	{$(INCLUDE)}"\.\Iflags.hpp"\
+	{$(INCLUDE)}"\.\Imagedir.hpp"\
+	{$(INCLUDE)}"\.\Imagehdr.hpp"\
+	{$(INCLUDE)}"\.\Impexp.hpp"\
+	{$(INCLUDE)}"\.\Import.hpp"\
+	{$(INCLUDE)}"\.\Keydir.hpp"\
+	{$(INCLUDE)}"\.\Ntsubsys.hpp"\
+	{$(INCLUDE)}"\.\Optlhdr.hpp"\
+	{$(INCLUDE)}"\.\Pehdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\.\Thnkdata.hpp"\
+	{$(INCLUDE)}"\.\Thnkname.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Filetime.hpp"\
+	{$(INCLUDE)}"\Common\Finddata.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Openfile.hpp"\
+	{$(INCLUDE)}"\Common\overlap.hpp"\
+	{$(INCLUDE)}"\Common\Pathfnd.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purewrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdio.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Systime.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Pehdr.obj" : $(SOURCE) $(DEP_CPP_PEHDR) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Sctnhdrs.cpp
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+DEP_CPP_SCTNH=\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Sctnhdrs.obj" : $(SOURCE) $(DEP_CPP_SCTNH) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+DEP_CPP_SCTNH=\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Sctnhdrs.obj" : $(SOURCE) $(DEP_CPP_SCTNH) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Stdtmpl.cpp
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+DEP_CPP_STDTM=\
+	{$(INCLUDE)}"\.\Dbgdir.hpp"\
+	{$(INCLUDE)}"\.\Expdir.hpp"\
+	{$(INCLUDE)}"\.\Expdsc.hpp"\
+	{$(INCLUDE)}"\.\Export.hpp"\
+	{$(INCLUDE)}"\.\Import.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\.\Thnkdata.hpp"\
+	{$(INCLUDE)}"\.\Thnkname.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\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\common\gdipoint.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purewrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.tpp"\
+	{$(INCLUDE)}"\common\rect.hpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Sortopt.hpp"\
+	{$(INCLUDE)}"\Common\Stdio.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Stdtmpl.obj" : $(SOURCE) $(DEP_CPP_STDTM) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+DEP_CPP_STDTM=\
+	{$(INCLUDE)}"\.\Dbgdir.hpp"\
+	{$(INCLUDE)}"\.\Expdir.hpp"\
+	{$(INCLUDE)}"\.\Expdsc.hpp"\
+	{$(INCLUDE)}"\.\Export.hpp"\
+	{$(INCLUDE)}"\.\Impexp.hpp"\
+	{$(INCLUDE)}"\.\Import.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\.\Thnkdata.hpp"\
+	{$(INCLUDE)}"\.\Thnkname.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\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Pcallbck.hpp"\
+	{$(INCLUDE)}"\Common\Point.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purewrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.tpp"\
+	{$(INCLUDE)}"\Common\Rgbcolor.hpp"\
+	{$(INCLUDE)}"\Common\Sortopt.hpp"\
+	{$(INCLUDE)}"\Common\Stdio.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	{$(INCLUDE)}"\Common\Windowsx.hpp"\
+	
+
+"$(INTDIR)\Stdtmpl.obj" : $(SOURCE) $(DEP_CPP_STDTM) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Export.cpp
+
+!IF  "$(CFG)" == "image - Win32 Release"
+
+DEP_CPP_EXPOR=\
+	{$(INCLUDE)}"\.\Expdir.hpp"\
+	{$(INCLUDE)}"\.\Expdsc.hpp"\
+	{$(INCLUDE)}"\.\Export.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purewrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.tpp"\
+	{$(INCLUDE)}"\Common\Sortopt.hpp"\
+	{$(INCLUDE)}"\Common\Stdio.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Export.obj" : $(SOURCE) $(DEP_CPP_EXPOR) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "image - Win32 Debug"
+
+DEP_CPP_EXPOR=\
+	{$(INCLUDE)}"\.\Expdir.hpp"\
+	{$(INCLUDE)}"\.\Expdsc.hpp"\
+	{$(INCLUDE)}"\.\Export.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdr.hpp"\
+	{$(INCLUDE)}"\.\Sctnhdrs.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Fixup.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Purewrd.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.hpp"\
+	{$(INCLUDE)}"\Common\Pvector.tpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.hpp"\
+	{$(INCLUDE)}"\Common\Qsort.tpp"\
+	{$(INCLUDE)}"\Common\Sortopt.hpp"\
+	{$(INCLUDE)}"\Common\Stdio.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Export.obj" : $(SOURCE) $(DEP_CPP_EXPOR) "$(INTDIR)"
+
+
+!ENDIF 
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Imresdir.cpp
+DEP_CPP_IMRES=\
+	{$(INCLUDE)}"\.\Direntry.hpp"\
+	{$(INCLUDE)}"\.\Dtaentry.hpp"\
+	{$(INCLUDE)}"\.\Imresdir.hpp"\
+	{$(INCLUDE)}"\.\Strptr.hpp"\
+	{$(INCLUDE)}"\Common\Assert.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(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\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Imresdir.obj" : $(SOURCE) $(DEP_CPP_IMRES) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Direntry.cpp
+DEP_CPP_DIREN=\
+	{$(INCLUDE)}"\.\Direntry.hpp"\
+	{$(INCLUDE)}"\.\Dtaentry.hpp"\
+	{$(INCLUDE)}"\.\Imresdir.hpp"\
+	{$(INCLUDE)}"\.\Resdrstr.hpp"\
+	{$(INCLUDE)}"\.\Strptr.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(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"\
+	{$(INCLUDE)}"\Common\Winnls.hpp"\
+	
+
+"$(INTDIR)\Direntry.obj" : $(SOURCE) $(DEP_CPP_DIREN) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Dtaentry.cpp
+DEP_CPP_DTAEN=\
+	{$(INCLUDE)}"\.\Dtaentry.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(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\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Types.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\Dtaentry.obj" : $(SOURCE) $(DEP_CPP_DTAEN) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\vxdobj.cpp
+DEP_CPP_VXDOB=\
+	{$(INCLUDE)}"\.\vxdobj.hpp"\
+	{$(INCLUDE)}"\Common\Block.hpp"\
+	{$(INCLUDE)}"\Common\Block.tpp"\
+	{$(INCLUDE)}"\Common\except.hpp"\
+	{$(INCLUDE)}"\Common\Filemap.hpp"\
+	{$(INCLUDE)}"\Common\Puredwrd.hpp"\
+	{$(INCLUDE)}"\Common\Pview.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\vxdobj.obj" : $(SOURCE) $(DEP_CPP_VXDOB) "$(INTDIR)"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\vxdname.cpp
+DEP_CPP_VXDNA=\
+	{$(INCLUDE)}"\.\vxdname.hpp"\
+	{$(INCLUDE)}"\Common\Stdlib.hpp"\
+	{$(INCLUDE)}"\Common\String.hpp"\
+	{$(INCLUDE)}"\Common\Windows.hpp"\
+	
+
+"$(INTDIR)\vxdname.obj" : $(SOURCE) $(DEP_CPP_VXDNA) "$(INTDIR)"
+
+
+# End Source File
+# End Target
+# End Project
+################################################################################

image/KEYDIR.HPP

@@ -0,0 +1,77 @@
+#ifndef _IMAGE_DIRECTORYENTRYKEY_HPP_
+#define _IMAGE_DIRECTORYENTRYKEY_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class DirectoryEntryKey
+{
+public:
+	enum Key{ExportDirectory=IMAGE_DIRECTORY_ENTRY_EXPORT,
+			 ImportDirectory=IMAGE_DIRECTORY_ENTRY_IMPORT,
+			 ResourceDirectory=IMAGE_DIRECTORY_ENTRY_RESOURCE,
+			 ExceptionDirectory=IMAGE_DIRECTORY_ENTRY_EXCEPTION,
+			 SecurityDirectory=IMAGE_DIRECTORY_ENTRY_SECURITY,
+			 BaseRelocationTableDirectory=IMAGE_DIRECTORY_ENTRY_BASERELOC,
+			 DebugDirectory=IMAGE_DIRECTORY_ENTRY_DEBUG,
+			 DescriptionStringDirectory=IMAGE_DIRECTORY_ENTRY_COPYRIGHT,
+			 MachineValueDirectory=IMAGE_DIRECTORY_ENTRY_GLOBALPTR,
+			 ThreadLocalStorageDirectory=IMAGE_DIRECTORY_ENTRY_TLS,
+			 LoadConfigurationDirectory=IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG,
+			 BoundImportDirectory=IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT,
+			 ImportAddressTableDirectory=IMAGE_DIRECTORY_ENTRY_IAT,
+//			 DelayImportDirectory=IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT
+			 };
+	DirectoryEntryKey(Key entryEntry=ImportDirectory);
+	DirectoryEntryKey(const DirectoryEntryKey &someDirectoryEntryKey);
+	virtual ~DirectoryEntryKey();
+	DirectoryEntryKey &operator=(const DirectoryEntryKey &someDirectoryEntryKey);
+	WORD operator==(const DirectoryEntryKey &someDirectoryEntryKey);
+	Key entryKey(void)const;
+	void entryKey(Key entryKey);
+private:
+	Key mDirectoryKey;
+};
+
+inline
+DirectoryEntryKey::DirectoryEntryKey(Key entryKey)
+: mDirectoryKey(entryKey)
+{
+}
+
+inline
+DirectoryEntryKey::DirectoryEntryKey(const DirectoryEntryKey &someDirectoryEntryKey)
+{
+  *this=someDirectoryEntryKey;
+}
+
+inline
+DirectoryEntryKey::~DirectoryEntryKey()
+{
+}
+
+inline
+DirectoryEntryKey &DirectoryEntryKey::operator=(const DirectoryEntryKey &someDirectoryEntryKey)
+{
+	entryKey(someDirectoryEntryKey.entryKey());
+	return *this;
+}
+
+inline
+WORD DirectoryEntryKey::operator==(const DirectoryEntryKey &someDirectoryEntryKey)
+{
+  return entryKey()==someDirectoryEntryKey.entryKey();
+}
+
+inline
+DirectoryEntryKey::Key DirectoryEntryKey::entryKey(void)const
+{
+	return mDirectoryKey;
+}
+
+inline
+void DirectoryEntryKey::entryKey(Key entryKey)
+{
+  mDirectoryKey=entryKey;
+}
+#endif

image/LIB.RSP

@@ -0,0 +1,11 @@
+/OUT:C:\WORK\IMAGE\MSVCOBJ\MSIMAGE.LIB
+/MACHINE:IX86
+/SUBSYSTEM:WINDOWS
+/DEBUGTYPE:BOTH
+MSVCOBJ\EXPORT.OBJ
+MSVCOBJ\HARDWARE.OBJ
+MSVCOBJ\IMPORT.OBJ
+MSVCOBJ\PEHDR.OBJ
+MSVCOBJ\SCTNHDRS.OBJ
+MSVCOBJ\VXDHDR.OBJ
+MSVCOBJ\STDTMPL.OBJ

image/MAIN.CPP

@@ -0,0 +1,33 @@
+#include <stdarg.h>
+#include <common/block.hpp>
+#include <common/windows.hpp>
+#include <common/console.hpp>
+#include <common/string.hpp>
+#include <image/pehdr.hpp>
+#include <image/vxdhdr.hpp>
+#include <image/dbgdir.hpp>
+
+int PASCAL WinMain(HINSTANCE /*hInstance*/,HINSTANCE /*hPrevInstance*/,LPSTR /*lpszCmdLine*/,int /*nCmdShow*/)
+{
+//	FileHandle peFile("C:\\WORK\\EXE\\MIDISQ32.DLL");
+//	FileHandle peFile("C:\\WINDOWS\\SYSTEM\\DISKCOPY.DLL",FileHandle::Read,FileHandle::ShareReadWrite);
+//	FileHandle peFile("C:\\WINDOWS\\SYSTEM\\KERNEL32.DLL",FileHandle::Read,FileHandle::ShareReadWrite);
+//	FileHandle peFile("C:\\WINDOWS\\SYSTEM\\DISKCOPY.DLL",FileHandle::Read,FileHandle::ShareReadWrite);
+	FileHandle peFile("D:\\WORK\\EXE\\ENGINEER.EXE",FileHandle::Read,FileHandle::ShareReadWrite);
+	FileMap peMap(peFile);
+	PureViewOfFile peView(peMap);
+	PEHeader peHeader;
+	peHeader<<peView;
+	if(!peHeader.isOkay())return FALSE;
+
+	Block<ImageImportDescriptor> imageImportDescriptors;
+  Block<ImageDebugDirectory> imageDebugDirectory;
+	ImageExportDescriptors imageExportDescriptors;
+	ImageSectionHeader importSectionHeader;
+	ImageSectionHeader exportSectionHeader;
+//	peHeader.loadImageImportDescriptors(imageImportDescriptors,importSectionHeader,peView);
+//	peHeader.loadImageExportDescriptors(imageExportDescriptors,exportSectionHeader,peView);
+  peHeader.loadImageDebugDirectory(imageDebugDirectory,peView);
+	return FALSE;
+}
+

image/MAKE.RSP

@@ -0,0 +1,23 @@
+/D__FLAT__
+/DSTRICT
+/DWIN32
+/D_WINDOWS
+/IC:\PARTS\MSVC\INCLUDE
+/I..
+/Od
+/GD
+/G4
+/Zi
+/Yd
+/YX
+/c
+/nologo
+/FoMSVCOBJ\
+SCTNHDRS.CPP
+EXPORT.CPP
+HARDWARE.CPP
+IMPORT.CPP
+PEHDR.CPP
+VXDHDR.CPP
+STDTMPL.CPP
+

image/NTSUBSYS.HPP

@@ -0,0 +1,77 @@
+#ifndef _IMAGE_NTSUBSYS_HPP_
+#define _IMAGE_NTSUBSYS_HPP_
+#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+#include <common/pview.hpp>
+#endif
+
+class NTSubSystem
+{
+public:
+	enum SubSystem{Unknown=0x0000,Native=0x0001,WindowsGUI=0x0002,WindowsChar=0x0003,OS2Char=0x0005,PosixChar=0x0007};
+	NTSubSystem(WORD subSystem=0);
+	NTSubSystem(const NTSubSystem &someNTSubSystem);
+	~NTSubSystem();
+	NTSubSystem &operator=(const NTSubSystem &someNTSubSystem);
+	WORD operator==(const NTSubSystem &someNTSubSystem);
+	SubSystem subSystem(void)const;
+	void subSystem(SubSystem subSystem);
+	operator String(void)const;
+private:
+	SubSystem mSubSystem;
+};
+
+inline
+NTSubSystem::NTSubSystem(WORD subSystem)
+: mSubSystem((SubSystem)subSystem)
+{
+}
+
+inline
+NTSubSystem::NTSubSystem(const NTSubSystem &someNTSubSystem)
+{
+	*this=someNTSubSystem;
+}
+
+inline
+NTSubSystem::~NTSubSystem()
+{
+}
+
+inline
+NTSubSystem &NTSubSystem::operator=(const NTSubSystem &someNTSubSystem)
+{
+	subSystem(someNTSubSystem.subSystem());
+	return *this;
+}
+
+inline
+WORD NTSubSystem::operator==(const NTSubSystem &someNTSubSystem)
+{
+	return subSystem()==someNTSubSystem.subSystem();
+}
+
+inline
+NTSubSystem::SubSystem NTSubSystem::subSystem(void)const
+{
+	return mSubSystem;
+}
+
+inline
+void NTSubSystem::subSystem(SubSystem subSystem)
+{
+	mSubSystem=subSystem;
+}
+
+inline
+NTSubSystem::operator String(void)const
+{
+	if(Unknown==subSystem())return "Unknown";
+	else if(Native==subSystem())return "Native";
+	else if(WindowsGUI==subSystem())return "WindowsGUI";
+	else if(WindowsChar==subSystem())return "WindowsChar";
+	else if(OS2Char==subSystem())return "OS2Char";
+	else if(PosixChar==subSystem())return "PosixChar";
+  else return "********";
+}
+#endif
+

image/OPTLHDR.HPP

@@ -0,0 +1,284 @@
+#ifndef _IMAGE_IMAGEOPTIONALHEADER_HPP_
+#define _IMAGE_IMAGEOPTIONALHEADER_HPP_
+#ifndef _IMAGE_IMAGEDATADIRECTORY_HPP_
+#include <image/imagedir.hpp>
+#endif
+#ifndef _IMAGE_DIRECTORYENTRYKEY_HPP_
+#include <image/keydir.hpp>
+#endif
+#ifndef _IMAGE_NTSUBSYS_HPP_
+#include <image/ntsubsys.hpp>
+#endif
+#ifndef _COMMON_ASSERT_HPP_
+#include <common/assert.hpp>
+#endif
+
+class ImageOptionalHeader : private _IMAGE_OPTIONAL_HEADER
+{
+public:
+  enum{NTMagic=0x010B,ROMMagic=0x0107};
+	ImageOptionalHeader(void);
+	ImageOptionalHeader(const ImageOptionalHeader &someImageOptionalHeader);
+	~ImageOptionalHeader();
+	ImageOptionalHeader &operator=(const ImageOptionalHeader &someImageOptionalHeader);
+	WORD operator==(const ImageOptionalHeader &someImageOptionalHeader);
+  WORD operator<<(PureViewOfFile &pureView);
+	ImageDataDirectory operator[](DirectoryEntryKey entryKey);
+	WORD magic(void)const;
+	BYTE majorLinkerVersion(void)const;
+	BYTE minorLinkerVersion(void)const;
+	DWORD sizeofCode(void)const;
+	DWORD sizeofInitializedData(void)const;
+	DWORD sizeofUninitializedData(void)const;
+	DWORD entryPointAddress(void)const;
+	DWORD codeBase(void)const;
+	DWORD dataBase(void)const;
+	DWORD imageBase(void)const;
+	DWORD sectionAlignment(void)const;
+	DWORD fileAlignment(void)const;
+	WORD majorOSVersion(void)const;
+	WORD minorOSVersion(void)const;
+	WORD majorImageVersion(void)const;
+	WORD minorImageVersion(void)const;
+	WORD majorSubsystemVersion(void)const;
+	WORD minorSubsystemVersion(void)const;
+	DWORD sizeofImage(void)const;
+	DWORD sizeofHeaders(void)const;
+	DWORD checksum(void)const;
+	NTSubSystem subsystem(void)const;
+	WORD dllCharacteristics(void)const;
+	DWORD sizeofStackReserve(void)const;
+	DWORD sizeofStackCommit(void)const;
+	DWORD sizeofHeapReserve(void)const;
+	DWORD sizeofHeapCommit(void)const;
+	DWORD loaderFlags(void)const;
+	DWORD numberOfRvaAndSizes(void)const;
+  WORD isOkay(void)const;
+private:
+	enum{NumberOfDirectoryEntries=IMAGE_NUMBEROF_DIRECTORY_ENTRIES};
+};
+
+inline
+ImageOptionalHeader::ImageOptionalHeader(void)
+{
+  ::memset((char*)&((_IMAGE_OPTIONAL_HEADER&)*this),0,sizeof(_IMAGE_OPTIONAL_HEADER));
+}
+
+inline
+ImageOptionalHeader::ImageOptionalHeader(const ImageOptionalHeader &someImageOptionalHeader)
+{
+  *this=someImageOptionalHeader;
+}
+
+inline
+ImageOptionalHeader::~ImageOptionalHeader()
+{
+}
+
+inline
+ImageOptionalHeader &ImageOptionalHeader::operator=(const ImageOptionalHeader &someImageOptionalHeader)
+{
+	::memcpy((char*)&((_IMAGE_OPTIONAL_HEADER&)*this),(char*)&((_IMAGE_OPTIONAL_HEADER&)someImageOptionalHeader),sizeof(_IMAGE_OPTIONAL_HEADER));
+  return *this;
+}
+
+inline
+WORD ImageOptionalHeader::operator==(const ImageOptionalHeader &someImageOptionalHeader)
+{
+  return ::memcmp((char*)&((_IMAGE_OPTIONAL_HEADER&)*this),(char*)&((_IMAGE_OPTIONAL_HEADER&)someImageOptionalHeader),sizeof(_IMAGE_OPTIONAL_HEADER));
+}
+
+inline
+WORD ImageOptionalHeader::operator<<(PureViewOfFile &pureView)
+{
+	if(sizeof(_IMAGE_OPTIONAL_HEADER)!=pureView.read((char*)&((_IMAGE_OPTIONAL_HEADER&)*this),sizeof(_IMAGE_OPTIONAL_HEADER)))return FALSE;
+  return isOkay();
+}
+
+inline
+ImageDataDirectory ImageOptionalHeader::operator[](DirectoryEntryKey entryKey)
+{
+	assert(entryKey.entryKey()<numberOfRvaAndSizes());
+  return ImageDataDirectory(_IMAGE_OPTIONAL_HEADER::DataDirectory[entryKey.entryKey()]);
+}
+
+inline
+WORD ImageOptionalHeader::magic(void)const
+{
+  return _IMAGE_OPTIONAL_HEADER::Magic;
+}
+
+inline
+BYTE ImageOptionalHeader::majorLinkerVersion(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::MajorLinkerVersion;
+}
+
+inline
+BYTE ImageOptionalHeader::minorLinkerVersion(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::MinorLinkerVersion;
+}
+
+inline
+DWORD ImageOptionalHeader::sizeofCode(void)const
+{
+  return _IMAGE_OPTIONAL_HEADER::SizeOfCode;
+}
+
+inline
+DWORD ImageOptionalHeader::sizeofInitializedData(void)const
+{
+  return _IMAGE_OPTIONAL_HEADER::SizeOfInitializedData;
+}
+
+inline
+DWORD ImageOptionalHeader::sizeofUninitializedData(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::SizeOfUninitializedData;
+}
+
+inline
+DWORD ImageOptionalHeader::entryPointAddress(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::AddressOfEntryPoint;
+}
+
+inline
+DWORD ImageOptionalHeader::codeBase(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::BaseOfCode;
+}
+
+inline
+DWORD ImageOptionalHeader::dataBase(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::BaseOfData;
+}
+
+inline
+DWORD ImageOptionalHeader::imageBase(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::ImageBase;
+}
+
+inline
+DWORD ImageOptionalHeader::sectionAlignment(void)const
+{
+  return _IMAGE_OPTIONAL_HEADER::SectionAlignment;
+}
+
+inline
+DWORD ImageOptionalHeader::fileAlignment(void)const
+{
+  return _IMAGE_OPTIONAL_HEADER::FileAlignment;
+}
+
+inline
+WORD ImageOptionalHeader::majorOSVersion(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::MajorOperatingSystemVersion;
+}
+
+inline
+WORD ImageOptionalHeader::minorOSVersion(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::MinorOperatingSystemVersion;
+}
+
+inline
+WORD ImageOptionalHeader::majorImageVersion(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::MajorImageVersion;
+}
+
+inline
+WORD ImageOptionalHeader::minorImageVersion(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::MinorImageVersion;
+}
+
+inline
+WORD ImageOptionalHeader::majorSubsystemVersion(void)const
+{
+  return _IMAGE_OPTIONAL_HEADER::MajorSubsystemVersion;
+}
+
+inline
+WORD ImageOptionalHeader::minorSubsystemVersion(void)const
+{
+  return _IMAGE_OPTIONAL_HEADER::MinorSubsystemVersion;
+}
+
+inline
+DWORD ImageOptionalHeader::sizeofImage(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::SizeOfImage;
+}
+
+inline
+DWORD ImageOptionalHeader::sizeofHeaders(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::SizeOfHeaders;
+}
+
+inline
+DWORD ImageOptionalHeader::checksum(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::CheckSum;
+}
+
+inline
+NTSubSystem ImageOptionalHeader::subsystem(void)const
+{
+	return NTSubSystem(_IMAGE_OPTIONAL_HEADER::Subsystem);
+}
+
+inline
+WORD ImageOptionalHeader::dllCharacteristics(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::DllCharacteristics;
+}
+
+inline
+DWORD ImageOptionalHeader::sizeofStackReserve(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::SizeOfStackReserve;
+}
+
+inline
+DWORD ImageOptionalHeader::sizeofStackCommit(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::SizeOfStackCommit;
+}
+
+inline
+DWORD ImageOptionalHeader::sizeofHeapReserve(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::SizeOfHeapReserve;
+}
+
+inline
+DWORD ImageOptionalHeader::sizeofHeapCommit(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::SizeOfHeapCommit;
+}
+
+inline
+DWORD ImageOptionalHeader::loaderFlags(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::LoaderFlags;
+}
+
+inline
+DWORD ImageOptionalHeader::numberOfRvaAndSizes(void)const
+{
+	return _IMAGE_OPTIONAL_HEADER::NumberOfRvaAndSizes;
+}
+
+inline
+WORD ImageOptionalHeader::isOkay(void)const
+{
+	return (NTMagic==magic()||ROMMagic==magic());
+}
+#endif

image/PEHDR.BAK

@@ -0,0 +1,148 @@
+#include <common/pathfnd.hpp>
+#include <common/pvector.hpp>
+#include <common/pvector.tpp>
+#include <common/pview.hpp>
+#include <common/openfile.hpp>
+#include <image/pehdr.hpp>
+#include <image/dbgdir.hpp>
+
+WORD PEHeader::operator<<(PureViewOfFile &pureView)
+{
+	pureView.rewind();
+	if(!((DOSHeader&)*this<<pureView))return FALSE;
+	if(!pureView.seek(neHeaderAddress(),PureViewOfFile::SeekSet))return FALSE;
+	pureView.read(mPESignature);
+	if(!((ImageHeader&)*this<<pureView))return FALSE;
+	if(sizeof(ImageOptionalHeader)==sizeOptionalHeader())
+		if(!((ImageOptionalHeader&)*this<<pureView))return FALSE;
+	size(sectionCount());
+	for(short itemIndex=0;itemIndex<sectionCount();itemIndex++)
+		((PureVector<ImageSectionHeader>&)*this)[itemIndex]<<pureView;
+	return TRUE;
+}
+
+WORD PEHeader::loadImageImportDescriptors(Block<ImageImportDescriptor> &imageImportDescriptors,ImageSectionHeader &importSectionHeader,PureViewOfFile &pureView,WORD memImage)
+{
+	DirectoryEntryKey sectionKey(DirectoryEntryKey::ImportDirectory);
+	ImageDataDirectory imageSectionDirectory(((ImageOptionalHeader&)*this)[sectionKey]);
+	ImageImportDescriptor imageImportDescriptor;
+	ImageSectionHeader importNamesSectionHeader;
+	DWORD deltaOffset;
+	DWORD deltaNames;
+
+	imageImportDescriptors.remove();
+  isMemImage(memImage);
+	if(!enclosingSectionHeader(imageSectionDirectory.virtualAddress(),importSectionHeader,deltaOffset))return FALSE;
+	pureView.seek(imageSectionDirectory.virtualAddress()-deltaOffset,PureViewOfFile::SeekSet);
+	while(TRUE)
+	{
+		String moduleName;
+		imageImportDescriptor<<pureView;
+		if(!imageImportDescriptor.isOkay())break;
+		enclosingSectionHeader(imageImportDescriptor.nameRVA(),importNamesSectionHeader,deltaNames);
+		pureView.push();
+		pureView.seek(imageImportDescriptor.nameRVA()-deltaNames,PureViewOfFile::SeekSet);
+		pureView.getLine(moduleName);
+		imageImportDescriptor.moduleName(moduleName);
+		pureView.pop();
+		imageImportDescriptor.loadImageImportThunks(deltaOffset,pureView,(ImageSectionHeaders&)*this);
+		imageImportDescriptors.insert(&imageImportDescriptor);
+	}
+	return imageImportDescriptors.size();
+}
+
+WORD PEHeader::loadImageFirstThunk(Block<ImageImportDescriptor> &imageImportDescriptors,ImageSectionHeader &importSectionHeader,PureViewOfFile &pureView,WORD memImage)
+{
+	DirectoryEntryKey sectionKey(DirectoryEntryKey::ImportDirectory);
+	ImageDataDirectory imageSectionDirectory(((ImageOptionalHeader&)*this)[sectionKey]);
+	ImageImportDescriptor imageImportDescriptor;
+	ImageSectionHeader importNamesSectionHeader;
+	DWORD deltaOffset;
+	DWORD deltaNames;
+
+	imageImportDescriptors.remove();
+  isMemImage(memImage);
+	if(!enclosingSectionHeader(imageSectionDirectory.virtualAddress(),importSectionHeader,deltaOffset))return FALSE;
+	pureView.seek(imageSectionDirectory.virtualAddress()-deltaOffset,PureViewOfFile::SeekSet);
+	while(TRUE)
+	{
+		String moduleName;
+		imageImportDescriptor<<pureView;
+		if(!imageImportDescriptor.isOkay())break;
+		enclosingSectionHeader(imageImportDescriptor.nameRVA(),importNamesSectionHeader,deltaNames);
+		pureView.push();
+		pureView.seek(imageImportDescriptor.nameRVA()-deltaNames,PureViewOfFile::SeekSet);
+		pureView.getLine(moduleName);
+		imageImportDescriptor.moduleName(moduleName);
+		pureView.pop();
+		imageImportDescriptor.loadImageFirstThunk(deltaOffset,pureView,(ImageSectionHeaders&)*this);
+		imageImportDescriptors.insert(&imageImportDescriptor);
+	}
+	return imageImportDescriptors.size();
+}
+
+WORD PEHeader::loadImageExportDescriptors(ImageExportDescriptors &imageExportDescriptors,ImageSectionHeader &exportSectionHeader,PureViewOfFile &pureView,WORD sortFlag,WORD memImage)
+{
+	DirectoryEntryKey sectionKey(DirectoryEntryKey::ExportDirectory);
+	ImageDataDirectory imageSectionDirectory(((ImageOptionalHeader&)*this)[sectionKey]);
+	DWORD deltaOffset;
+
+	imageExportDescriptors.size(0);
+	if(!imageSectionDirectory.size())return FALSE;
+  isMemImage(memImage);
+	if(!enclosingSectionHeader(imageSectionDirectory.virtualAddress(),exportSectionHeader,deltaOffset))return FALSE;
+	if(mImageExportDescriptorsCache.size())
+	{
+		imageExportDescriptors=mImageExportDescriptorsCache;
+		return (imageExportDescriptors.size()?TRUE:FALSE);
+	}
+	pureView.push();
+	pureView.seek(imageSectionDirectory.virtualAddress()-deltaOffset,PureViewOfFile::SeekSet);
+	mImageExportDescriptorsCache.loadImageExports(pureView,(ImageSectionHeaders&)*this,sortFlag);
+	imageExportDescriptors=mImageExportDescriptorsCache;
+	pureView.pop();
+	return (imageExportDescriptors.size()?TRUE:FALSE);
+}
+
+WORD PEHeader::loadImageExportDescriptors(ImageExportDescriptors &imageExportDescriptors,ImageSectionHeader &exportSectionHeader,const String &moduleName)
+{
+	String pathFileName;
+	PathFind pathFind;
+	PEHeader peHeader;
+
+	if(moduleName.isNull())return FALSE;
+	if(!pathFind.findFile(moduleName,pathFileName))return FALSE;
+	FileHandle peFile(pathFileName,FileHandle::Read,FileHandle::ShareReadWrite);
+	if(!peFile.isOkay())return FALSE;
+	FileMap peMap(peFile);
+	PureViewOfFile peView(peMap);
+	peHeader<<peView;
+	peHeader.loadImageExportDescriptors(imageExportDescriptors,exportSectionHeader,peView);
+	return imageExportDescriptors.size();
+}
+
+WORD PEHeader::loadImageDebugDirectory(Block<ImageDebugDirectory> &imageDebugDirectories,PureViewOfFile &pureView,WORD memImage)
+{
+	DirectoryEntryKey sectionKey(DirectoryEntryKey::DebugDirectory);
+	ImageDataDirectory imageSectionDirectory(((ImageOptionalHeader&)*this)[sectionKey]);
+	ImageSectionHeader exportSectionHeader;
+	DWORD imageDirectoryEntries;
+	DWORD deltaOffset;
+	WORD msImage(FALSE);
+
+  imageDebugDirectories.remove();
+  isMemImage(memImage);
+	if(!enclosingSectionHeader(imageSectionDirectory.virtualAddress(),exportSectionHeader,deltaOffset))return FALSE;
+	for(short sectionIndex=0;sectionIndex<size();sectionIndex++)if(((PureVector<ImageSectionHeader>&)*this)[sectionIndex].name()==String(".text"))msImage=TRUE;
+	imageDirectoryEntries=imageSectionDirectory.size();
+  if(msImage)imageDirectoryEntries/=sizeof(IMAGE_DEBUG_DIRECTORY);
+	pureView.push();
+	pureView.seek(imageSectionDirectory.virtualAddress()-deltaOffset,PureViewOfFile::SeekSet);
+	for(long entryIndex=0;entryIndex<imageDirectoryEntries;entryIndex++)
+	{
+		imageDebugDirectories.insert(&ImageDebugDirectory());
+		imageDebugDirectories[entryIndex]<<pureView;
+	}
+	pureView.pop();
+	return FALSE;
+}

image/PEHDR.CPP

@@ -0,0 +1,148 @@
+#include <common/pathfnd.hpp>
+#include <common/pview.hpp>
+#include <common/array.hpp>
+#include <common/openfile.hpp>
+#include <image/pehdr.hpp>
+#include <image/dbgdir.hpp>
+
+WORD PEHeader::operator<<(PureViewOfFile &pureView)
+{
+	pureView.rewind();
+	if(!((DOSHeader&)*this<<pureView))return FALSE;
+	if(!pureView.seek(neHeaderAddress(),PureViewOfFile::SeekSet))return FALSE;
+	pureView.read(mPESignature);
+	if(!((ImageHeader&)*this<<pureView))return FALSE;
+	if(sizeof(ImageOptionalHeader)==sizeOptionalHeader())
+		if(!((ImageOptionalHeader&)*this<<pureView))return FALSE;
+	size(sectionCount());
+	for(short itemIndex=0;itemIndex<sectionCount();itemIndex++)
+		((Array<ImageSectionHeader>&)*this)[itemIndex]<<pureView;
+	return TRUE;
+}
+
+WORD PEHeader::loadImageImportDescriptors(Block<ImageImportDescriptor> &imageImportDescriptors,ImageSectionHeader &importSectionHeader,PureViewOfFile &pureView,WORD memImage)
+{
+	DirectoryEntryKey sectionKey(DirectoryEntryKey::ImportDirectory);
+	ImageDataDirectory imageSectionDirectory(((ImageOptionalHeader&)*this)[sectionKey]);
+	ImageImportDescriptor imageImportDescriptor;
+	ImageSectionHeader importNamesSectionHeader;
+	DWORD deltaOffset;
+	DWORD deltaNames;
+
+	imageImportDescriptors.remove();
+  isMemImage(memImage);
+	if(!enclosingSectionHeader(imageSectionDirectory.virtualAddress(),importSectionHeader,deltaOffset))return FALSE;
+	pureView.seek(imageSectionDirectory.virtualAddress()-deltaOffset,PureViewOfFile::SeekSet);
+	while(TRUE)
+	{
+		String moduleName;
+		imageImportDescriptor<<pureView;
+		if(!imageImportDescriptor.isOkay())break;
+		enclosingSectionHeader(imageImportDescriptor.nameRVA(),importNamesSectionHeader,deltaNames);
+		pureView.push();
+		pureView.seek(imageImportDescriptor.nameRVA()-deltaNames,PureViewOfFile::SeekSet);
+		pureView.getLine(moduleName);
+		imageImportDescriptor.moduleName(moduleName);
+		pureView.pop();
+		imageImportDescriptor.loadImageImportThunks(deltaOffset,pureView,(ImageSectionHeaders&)*this);
+		imageImportDescriptors.insert(&imageImportDescriptor);
+	}
+	return imageImportDescriptors.size();
+}
+
+WORD PEHeader::loadImageFirstThunk(Block<ImageImportDescriptor> &imageImportDescriptors,ImageSectionHeader &importSectionHeader,PureViewOfFile &pureView,WORD memImage)
+{
+	DirectoryEntryKey sectionKey(DirectoryEntryKey::ImportDirectory);
+	ImageDataDirectory imageSectionDirectory(((ImageOptionalHeader&)*this)[sectionKey]);
+	ImageImportDescriptor imageImportDescriptor;
+	ImageSectionHeader importNamesSectionHeader;
+	DWORD deltaOffset;
+	DWORD deltaNames;
+
+	imageImportDescriptors.remove();
+  isMemImage(memImage);
+	if(!enclosingSectionHeader(imageSectionDirectory.virtualAddress(),importSectionHeader,deltaOffset))return FALSE;
+	pureView.seek(imageSectionDirectory.virtualAddress()-deltaOffset,PureViewOfFile::SeekSet);
+	while(TRUE)
+	{
+		String moduleName;
+		imageImportDescriptor<<pureView;
+		if(!imageImportDescriptor.isOkay())break;
+		enclosingSectionHeader(imageImportDescriptor.nameRVA(),importNamesSectionHeader,deltaNames);
+		pureView.push();
+		pureView.seek(imageImportDescriptor.nameRVA()-deltaNames,PureViewOfFile::SeekSet);
+		pureView.getLine(moduleName);
+		imageImportDescriptor.moduleName(moduleName);
+		pureView.pop();
+		imageImportDescriptor.loadImageFirstThunk(deltaOffset,pureView,(ImageSectionHeaders&)*this);
+		imageImportDescriptors.insert(&imageImportDescriptor);
+	}
+	return imageImportDescriptors.size();
+}
+
+WORD PEHeader::loadImageExportDescriptors(ImageExportDescriptors &imageExportDescriptors,ImageSectionHeader &exportSectionHeader,PureViewOfFile &pureView,WORD sortFlag,WORD memImage)
+{
+	DirectoryEntryKey sectionKey(DirectoryEntryKey::ExportDirectory);
+	ImageDataDirectory imageSectionDirectory(((ImageOptionalHeader&)*this)[sectionKey]);
+	DWORD deltaOffset;
+
+	imageExportDescriptors.size(0);
+	if(!imageSectionDirectory.size())return FALSE;
+  isMemImage(memImage);
+	if(!enclosingSectionHeader(imageSectionDirectory.virtualAddress(),exportSectionHeader,deltaOffset))return FALSE;
+	if(mImageExportDescriptorsCache.size())
+	{
+		imageExportDescriptors=mImageExportDescriptorsCache;
+		return (imageExportDescriptors.size()?TRUE:FALSE);
+	}
+	pureView.push();
+	pureView.seek(imageSectionDirectory.virtualAddress()-deltaOffset,PureViewOfFile::SeekSet);
+	mImageExportDescriptorsCache.loadImageExports(pureView,(ImageSectionHeaders&)*this,sortFlag);
+	imageExportDescriptors=mImageExportDescriptorsCache;
+	pureView.pop();
+	return (imageExportDescriptors.size()?TRUE:FALSE);
+}
+
+WORD PEHeader::loadImageExportDescriptors(ImageExportDescriptors &imageExportDescriptors,ImageSectionHeader &exportSectionHeader,const String &moduleName)
+{
+	String pathFileName;
+	PathFind pathFind;
+	PEHeader peHeader;
+
+	if(moduleName.isNull())return FALSE;
+	if(!pathFind.findFile(moduleName,pathFileName))return FALSE;
+	FileHandle peFile(pathFileName,FileHandle::Read,FileHandle::ShareReadWrite);
+	if(!peFile.isOkay())return FALSE;
+	FileMap peMap(peFile);
+	PureViewOfFile peView(peMap);
+	peHeader<<peView;
+	peHeader.loadImageExportDescriptors(imageExportDescriptors,exportSectionHeader,peView);
+	return imageExportDescriptors.size();
+}
+
+WORD PEHeader::loadImageDebugDirectory(Block<ImageDebugDirectory> &imageDebugDirectories,PureViewOfFile &pureView,WORD memImage)
+{
+	DirectoryEntryKey sectionKey(DirectoryEntryKey::DebugDirectory);
+	ImageDataDirectory imageSectionDirectory(((ImageOptionalHeader&)*this)[sectionKey]);
+	ImageSectionHeader exportSectionHeader;
+	DWORD imageDirectoryEntries;
+	DWORD deltaOffset;
+	WORD msImage(FALSE);
+
+  imageDebugDirectories.remove();
+  isMemImage(memImage);
+	if(!enclosingSectionHeader(imageSectionDirectory.virtualAddress(),exportSectionHeader,deltaOffset))return FALSE;
+	for(short sectionIndex=0;sectionIndex<size();sectionIndex++)if(((Array<ImageSectionHeader>&)*this)[sectionIndex].name()==String(".text"))msImage=TRUE;
+	imageDirectoryEntries=imageSectionDirectory.size();
+  if(msImage)imageDirectoryEntries/=sizeof(IMAGE_DEBUG_DIRECTORY);
+	pureView.push();
+	pureView.seek(imageSectionDirectory.virtualAddress()-deltaOffset,PureViewOfFile::SeekSet);
+	for(long entryIndex=0;entryIndex<imageDirectoryEntries;entryIndex++)
+	{
+		imageDebugDirectories.insert(&ImageDebugDirectory());
+		imageDebugDirectories[entryIndex]<<pureView;
+	}
+	pureView.pop();
+	return FALSE;
+}
+

image/PEHDR.HPP

@@ -0,0 +1,108 @@
+#ifndef _IMAGE_PEHEADER_HPP_
+#define _IMAGE_PEHEADER_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _IMAGE_DOSHEADER_HPP_
+#include <image/doshdr.hpp>
+#endif
+#ifndef _IMAGE_HARDWARE_HPP_
+#include <image/hardware.hpp>
+#endif
+#ifndef _IMAGE_IMAGEFLAGS_HPP_
+#include <image/iflags.hpp>
+#endif
+#ifndef _IMAGE_NTSUBSYS_HPP_
+#include <image/ntsubsys.hpp>
+#endif
+#ifndef _IMAGE_DLLFLAGS_HPP_
+#include <image/dllflags.hpp>
+#endif
+#ifndef _IMAGE_IMAGEHEADER_HPP_
+#include <image/imagehdr.hpp>
+#endif
+#ifndef _IMAGE_IMAGEOPTIONALHEADER_HPP_
+#include <image/optlhdr.hpp>
+#endif
+#ifndef _IMAGE_IMAGESECTIONHEADERS_HPP_
+#include <image/sctnhdrs.hpp>
+#endif
+#ifndef _IMAGE_IMAGEIMPORTDESCRIPTOR_HPP_
+#include <image/import.hpp>
+#endif
+#ifndef _IMAGE_EXPORTDESCRIPTOR_HPP_
+#include <image/export.hpp>
+#endif
+#ifndef _ENGINEER_IMAGETHUNKDATA_HPP_
+#include <image/thnkdata.hpp>
+#endif
+#ifndef _IMAGE_IMAGETHUNKNAME_HPP_
+#include <image/thnkname.hpp>
+#endif
+
+class ImageDebugDirectory;
+class PureViewOfFile;
+
+class PEHeader : public DOSHeader, public ImageHeader, public ImageOptionalHeader, public ImageSectionHeaders
+{
+public:
+  enum {PESignature=0x4550};
+	PEHeader(void);
+	PEHeader(const PEHeader &somePEHeader);
+	~PEHeader();
+	PEHeader &operator=(const PEHeader &somePEHeader);
+	WORD operator==(const PEHeader &somePEHeader);
+	WORD operator<<(PureViewOfFile &pureView);
+	WORD loadImageImportDescriptors(Block<ImageImportDescriptor> &imageImportDescriptors,ImageSectionHeader &importSectionHeader,PureViewOfFile &pureView,WORD memImage=FALSE);
+  WORD loadImageFirstThunk(Block<ImageImportDescriptor> &imageImportDescriptors,ImageSectionHeader &importSectionHeader,PureViewOfFile &pureView,WORD memImage=FALSE);
+	WORD loadImageExportDescriptors(ImageExportDescriptors &imageExportDescriptors,ImageSectionHeader &importSectionHeader,PureViewOfFile &pureView,WORD sortFlag=TRUE,WORD memImage=FALSE);
+  WORD loadImageDebugDirectory(Block<ImageDebugDirectory> &imageDebugDirectories,PureViewOfFile &pureView,WORD memImage=FALSE);
+	WORD isOkay(void)const;
+private:
+  WORD loadImageExportDescriptors(ImageExportDescriptors &imageExportDescriptors,ImageSectionHeader &exportSectionHeader,const String &moduleName);
+	DWORD mPESignature;
+  ImageExportDescriptors mImageExportDescriptorsCache;
+};
+
+inline
+PEHeader::PEHeader(void)
+: mPESignature(0)
+{
+}
+
+inline
+PEHeader::PEHeader(const PEHeader &somePEHeader)
+{
+	*this=somePEHeader;
+}
+
+inline
+PEHeader::~PEHeader()
+{
+}
+
+inline
+PEHeader &PEHeader::operator=(const PEHeader &somePEHeader)
+{
+	(DOSHeader&)*this=(DOSHeader&)somePEHeader;
+	(ImageHeader&)*this=(ImageHeader&)somePEHeader;
+  mImageExportDescriptorsCache=somePEHeader.mImageExportDescriptorsCache;
+ return *this;
+}
+
+inline
+WORD PEHeader::operator==(const PEHeader &somePEHeader)
+{
+	return ((DOSHeader&)*this==(DOSHeader&)somePEHeader&&
+	        (ImageHeader&)*this==(ImageHeader&)somePEHeader);
+}
+
+inline
+WORD PEHeader::isOkay(void)const
+{
+	return PESignature==mPESignature;
+}
+#endif

image/PUREIMP.HPP

@@ -0,0 +1,168 @@
+#ifndef _IMAGE_PUREIMPORT_HPP_
+#define _IMAGE_PUREIMPORT_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#include <stdio.h>
+
+class PureImport
+{
+public:
+	enum ThunkType{StandardThunk,WIN95Thunk};
+	PureImport(void);
+	PureImport(const PureImport &somePureImport);
+	PureImport(const String &moduleName,const String &importName,DWORD importAddress=0L,DWORD rewriteAddress=0L,ThunkType thunkType=StandardThunk);
+  virtual ~PureImport();
+	PureImport &operator=(const PureImport &somePureImport);
+	WORD operator==(const PureImport &somePureImport)const;
+	WORD operator>(const PureImport &somePureImport)const;
+  WORD operator<(const PureImport &somePureImport)const;
+	operator String(void)const;
+	const String &moduleName(void)const;
+	void moduleName(const String &moduleName);
+	String importName(void)const;
+	void importName(const String &importName);
+	DWORD importAddress(void)const;
+	void importAddress(DWORD importAddress);
+	DWORD rewriteAddress(void)const;
+	void rewriteAddress(DWORD rewriteAddress);
+	ThunkType thunkType(void)const;
+  void thunkType(ThunkType thunkType);
+private:
+	String mModuleName;
+	String mImportName;
+	DWORD mImportAddress;
+	DWORD mRewriteAddress;
+	ThunkType mThunkType;
+};
+
+inline
+PureImport::PureImport(void)
+: mImportAddress(0), mRewriteAddress(0), mThunkType(StandardThunk)
+{
+}
+
+inline
+PureImport::PureImport(const PureImport &somePureImport)
+{
+  *this=somePureImport;
+}
+
+inline
+PureImport::PureImport(const String &moduleName,const String &importName,DWORD importAddress,DWORD rewriteAddress,ThunkType thunkType)
+: mModuleName(moduleName), mImportName(importName), mImportAddress(importAddress),
+	mRewriteAddress(rewriteAddress), mThunkType(thunkType)
+{
+}
+
+inline
+PureImport::~PureImport()
+{
+}
+
+inline
+PureImport &PureImport::operator=(const PureImport &somePureImport)
+{
+  moduleName(somePureImport.moduleName());
+	importName(somePureImport.importName());
+	importAddress(somePureImport.importAddress());
+	rewriteAddress(somePureImport.rewriteAddress());
+  thunkType(somePureImport.thunkType());
+  return *this;
+}
+
+inline
+WORD PureImport::operator==(const PureImport &somePureImport)const
+{
+  return importAddress()==somePureImport.importAddress();
+}
+
+inline
+WORD PureImport::operator>(const PureImport &somePureImport)const
+{
+	return (importAddress()>somePureImport.importAddress());
+}
+
+inline
+WORD PureImport::operator<(const PureImport &somePureImport)const
+{
+  return (importAddress()<somePureImport.importAddress());
+}
+
+inline
+PureImport::operator String(void)const
+{
+	String importString;
+	::sprintf((LPSTR)importString,"%s!%s @0x%08lx @0x%08lx(%08lx) %s",
+		(LPSTR)moduleName(),
+		(LPSTR)importName(),
+		importAddress(),
+		rewriteAddress(),
+		rewriteAddress()?*((DWORD*)rewriteAddress()):0x00000000,
+		(thunkType()==StandardThunk?"StandardThunk":"WIN95 Thunk"));
+  return importString;
+}
+
+inline
+const String &PureImport::moduleName(void)const
+{
+  return mModuleName;
+}
+
+inline
+void PureImport::moduleName(const String &moduleName)
+{
+  mModuleName=moduleName;
+}
+
+inline
+String PureImport::importName(void)const
+{
+	return mImportName;
+}
+
+inline
+void PureImport::importName(const String &importName)
+{
+  mImportName=importName;
+}
+
+inline
+DWORD PureImport::importAddress(void)const
+{
+	return mImportAddress;
+}
+
+inline
+void PureImport::importAddress(DWORD importAddress)
+{
+  mImportAddress=importAddress;
+}
+
+inline
+DWORD PureImport::rewriteAddress(void)const
+{
+  return mRewriteAddress;
+}
+
+inline
+void PureImport::rewriteAddress(DWORD rewriteAddress)
+{
+  mRewriteAddress=rewriteAddress;
+}
+
+inline
+PureImport::ThunkType PureImport::thunkType(void)const
+{
+	return mThunkType;
+}
+
+inline
+void PureImport::thunkType(ThunkType thunkType)
+{
+  mThunkType=thunkType;
+}
+#endif

image/RESDRSTR.BAK

@@ -0,0 +1,94 @@
+#ifndef _IMAGE_IMAGERESOURCEDIRSTRING_HPP_
+#define _IMAGE_IMAGERESOURCEDIRSTRING_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+#include <common/pview.hpp>
+#endif
+#ifndef _COMMON_WINNLS_HPP_
+#include <common/winnls.hpp>
+#endif
+
+class ImageResourceDirString : private IMAGE_RESOURCE_DIR_STRING_U
+{
+public:
+  ImageResourceDirString(void);
+	virtual ~ImageResourceDirString();
+	operator IMAGE_RESOURCE_DIR_STRING_U &(void);
+	String name(void)const;
+	void read(PureViewOfFile &pureView);
+private:
+	WORD length(void)const;
+	ImageResourceDirString(const ImageResourceDirString &someImageResourceDirString);
+	ImageResourceDirString &operator=(const ImageResourceDirString &imageResourceDirString);
+  void zeroInit(void);
+	String mResourceName;
+};
+
+inline
+ImageResourceDirString::ImageResourceDirString(void)
+{
+  zeroInit();
+}
+
+inline
+ImageResourceDirString::ImageResourceDirString(const ImageResourceDirString &someImageResourceDirString)
+{
+  *this=someImageResourceDirString;
+}
+
+inline
+ImageResourceDirString::~ImageResourceDirString()
+{
+}
+
+inline
+ImageResourceDirString &ImageResourceDirString::operator=(const ImageResourceDirString &/*imageResourceDirString*/)
+{
+  return *this;
+}
+
+inline
+ImageResourceDirString::operator IMAGE_RESOURCE_DIR_STRING_U &(void)
+{
+  return *this;
+}
+
+inline
+WORD ImageResourceDirString::length(void)const
+{
+  return IMAGE_RESOURCE_DIR_STRING_U::Length;
+}
+
+inline
+String ImageResourceDirString::name(void)const
+{
+  return mResourceName;
+}
+
+inline
+void ImageResourceDirString::read(PureViewOfFile &pureView)
+{
+  WCHAR wszBuffer[String::MaxString];
+
+  pureView.push();
+	::memset(wszBuffer,0,sizeof(wszBuffer));
+	mResourceName.reserve(String::MaxString);
+  pureView.read((char*)&((IMAGE_RESOURCE_DIR_STRING_U&)*this),sizeof(IMAGE_RESOURCE_DIR_STRING_U));
+	wszBuffer[0]=IMAGE_RESOURCE_DIR_STRING_U::NameString[0];
+	pureView.read((char*)(wszBuffer+1),length()*sizeof(WCHAR));
+  ::WideCharToMultiByte(CP_ACP,0,wszBuffer,IMAGE_RESOURCE_DIR_STRING_U::Length,(LPSTR)mResourceName,String::MaxString,0,0);
+	pureView.pop();
+}
+
+inline
+void ImageResourceDirString::zeroInit(void)
+{
+  IMAGE_RESOURCE_DIR_STRING_U::Length=0;
+	IMAGE_RESOURCE_DIR_STRING_U::NameString[0]=0;  
+}
+#endif

image/RESDRSTR.HPP

@@ -0,0 +1,94 @@
+#ifndef _IMAGE_IMAGERESOURCEDIRSTRING_HPP_
+#define _IMAGE_IMAGERESOURCEDIRSTRING_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+#include <common/pview.hpp>
+#endif
+#ifndef _COMMON_WINNLS_HPP_
+#include <common/winnls.hpp>
+#endif
+
+class ImageResourceDirString : private IMAGE_RESOURCE_DIR_STRING_U
+{
+public:
+  ImageResourceDirString(void);
+	virtual ~ImageResourceDirString();
+	operator IMAGE_RESOURCE_DIR_STRING_U &(void);
+	String name(void)const;
+	void read(PureViewOfFile &pureView);
+private:
+	WORD length(void)const;
+	ImageResourceDirString(const ImageResourceDirString &someImageResourceDirString);
+	ImageResourceDirString &operator=(const ImageResourceDirString &imageResourceDirString);
+  void zeroInit(void);
+	String mResourceName;
+};
+
+inline
+ImageResourceDirString::ImageResourceDirString(void)
+{
+  zeroInit();
+}
+
+inline
+ImageResourceDirString::ImageResourceDirString(const ImageResourceDirString &someImageResourceDirString)
+{
+  *this=someImageResourceDirString;
+}
+
+inline
+ImageResourceDirString::~ImageResourceDirString()
+{
+}
+
+inline
+ImageResourceDirString &ImageResourceDirString::operator=(const ImageResourceDirString &/*imageResourceDirString*/)
+{
+  return *this;
+}
+
+inline
+ImageResourceDirString::operator IMAGE_RESOURCE_DIR_STRING_U &(void)
+{
+  return *this;
+}
+
+inline
+WORD ImageResourceDirString::length(void)const
+{
+  return IMAGE_RESOURCE_DIR_STRING_U::Length;
+}
+
+inline
+String ImageResourceDirString::name(void)const
+{
+  return mResourceName;
+}
+
+inline
+void ImageResourceDirString::read(PureViewOfFile &pureView)
+{
+  WCHAR wszBuffer[String::MaxString];
+
+  pureView.push();
+	::memset(wszBuffer,0,sizeof(wszBuffer));
+	mResourceName.reserve(String::MaxString);
+  pureView.read((char*)&((IMAGE_RESOURCE_DIR_STRING_U&)*this),sizeof(IMAGE_RESOURCE_DIR_STRING_U));
+	wszBuffer[0]=IMAGE_RESOURCE_DIR_STRING_U::NameString[0];
+	pureView.read((char*)(wszBuffer+1),length()*sizeof(WCHAR));
+  ::WideCharToMultiByte(CP_ACP,0,wszBuffer,IMAGE_RESOURCE_DIR_STRING_U::Length,(LPSTR)mResourceName,String::MaxString,0,0);
+	pureView.pop();
+}
+
+inline
+void ImageResourceDirString::zeroInit(void)
+{
+  IMAGE_RESOURCE_DIR_STRING_U::Length=0;
+	IMAGE_RESOURCE_DIR_STRING_U::NameString[0]=0;  
+}
+#endif

image/SCRAPS.BAK

@@ -0,0 +1,365 @@
+  void loadImageImportThunks(DWORD deltaOffset,PureViewOfFile &pureView,ImageSectionHeaders &imageSectionHeaders,ImageExportDescriptors &imageExportDescriptors);
+
+
+void ImageImportDescriptor::loadImageImportThunk(DWORD virtualAddress,DWORD deltaOffset,Block<ImageThunkData> &imageThunkImportOrdinals,Block<ImageThunkName> &imageThunkImportNames,PureViewOfFile &pureView,ImageSectionHeaders &imageSectionHeaders,ImageExportDescriptors &imageExportDescriptors)
+{
+	ImageSectionHeader imageSectionHeader;
+
+	imageThunkImportOrdinals.remove();
+	imageThunkImportNames.remove();
+	pureView.push();
+	pureView.seek(virtualAddress-deltaOffset,PureViewOfFile::SeekSet);
+	while(TRUE)
+	{
+		ImageThunkData imageThunkData;
+		imageThunkData<<pureView;
+		if(!imageThunkData.isOkay())break;
+		if(imageThunkData.isOrdinalImport())
+		{
+			ImageExportDescriptor imageExportDescriptor;
+			ImageThunkName imageThunkName;
+			DWORD exportIndex;
+			if(imageExportDescriptors.locateImageExportOrdinal(imageThunkData.ordinal(),imageExportDescriptor,exportIndex))
+			{
+				imageThunkName.importName(imageExportDescriptor.imageExportName());
+				imageThunkImportNames.insert(&imageThunkName);
+			}
+			else imageThunkImportOrdinals.insert(&imageThunkData);
+		}
+		else
+		{
+			ImageThunkName imageThunkName;
+			pureView.push();
+			imageSectionHeaders.enclosingSectionHeader(imageThunkData.addressOfDataRVA(),imageSectionHeader,deltaOffset);
+			pureView.seek(imageThunkData.addressOfDataRVA()-deltaOffset,PureViewOfFile::SeekSet);
+			imageThunkName<<pureView;
+			imageThunkImportNames.insert(&imageThunkName);
+			pureView.pop();
+		}
+	}
+	pureView.pop();
+}
+
+
+
+void ImageImportDescriptor::loadImageImportThunks(DWORD deltaOffset,PureViewOfFile &pureView,ImageSectionHeaders &imageSectionHeaders,ImageExportDescriptors &imageExportDescriptors)
+{
+	if(!isOkay())return;
+	if(!firstThunkRVA()&&!originalFirstThunkRVA())return;
+	if(originalFirstThunkRVA())loadImageImportThunk(originalFirstThunkRVA(),deltaOffset,
+		imageOriginalThunkImportOrdinals(),imageOriginalThunkImportNames(),pureView,imageSectionHeaders,imageExportDescriptors);
+	else if(firstThunkRVA())loadImageImportThunk(firstThunkRVA(),deltaOffset,
+		imageThunkImportOrdinals(),imageThunkImportNames(),pureView,imageSectionHeaders,imageExportDescriptors);
+}
+
+
+WORD PEHeader::loadImageImportDescriptors(Block<ImageImportDescriptor> &imageImportDescriptors,ImageSectionHeader &importSectionHeader,ImageExportDescriptors &imageExportDescriptors,PureViewOfFile &pureView)
+{
+	DirectoryEntryKey sectionKey(DirectoryEntryKey::ImportDirectory);
+	ImageDataDirectory imageSectionDirectory(((ImageOptionalHeader&)*this)[sectionKey]);
+	ImageImportDescriptor imageImportDescriptor;
+	ImageSectionHeader importNamesSectionHeader;
+	ImageSectionHeader exportSectionHeader;
+	DWORD deltaOffset;
+	DWORD deltaNames;
+
+	imageImportDescriptors.remove();
+	imageExportDescriptors.size(0);
+	if(!enclosingSectionHeader(imageSectionDirectory.virtualAddress(),importSectionHeader,deltaOffset))return FALSE;
+	pureView.seek(imageSectionDirectory.virtualAddress()-deltaOffset,PureViewOfFile::SeekSet);
+	while(TRUE)
+	{
+		String moduleName;
+		imageImportDescriptor<<pureView;
+		if(!imageImportDescriptor.isOkay())break;
+		enclosingSectionHeader(imageImportDescriptor.nameRVA(),importNamesSectionHeader,deltaNames);
+		pureView.push();
+		pureView.seek(imageImportDescriptor.nameRVA()-deltaNames,PureViewOfFile::SeekSet);
+		pureView.getLine(moduleName);
+		loadImageExportDescriptors(imageExportDescriptors,exportSectionHeader,moduleName);
+		imageImportDescriptor.moduleName(moduleName);
+		pureView.pop();
+		imageImportDescriptor.loadImageImportThunks(deltaOffset,pureView,(ImageSectionHeaders&)*this,imageExportDescriptors);
+		imageImportDescriptors.insert(&imageImportDescriptor);
+	}
+	return imageImportDescriptors.size();
+}
+
+
+	WORD loadImageImportDescriptors(Block<ImageImportDescriptor> &imageImportDescriptors,ImageSectionHeader &importSectionHeader,ImageExportDescriptors &imageExportDescriptors,PureViewOfFile &pureView);
+
+//			::sprintf(entryPointString,"&0x%08lx",(DWORD)((PureVector<ImageExportDescriptor>&)*this)[functionIndex].imageExportEntryPoint());
+
+void replaceImageImportOrdinals(Block<ImageImportDescriptor> &imageImportDescriptors,PureViewOfFile &pureView);
+void PEHeader::replaceImageImportOrdinals(Block<ImageImportDescriptor> &imageImportDescriptors,PureViewOfFile &pureView)
+{
+	ImageExportDescriptors imageExportDescriptors;
+  ImageExportDescriptor imageExportDescriptor;
+	ImageSectionHeader exportSectionHeader;
+	DWORD itemCount;
+	DWORD importModuleCount;
+	DWORD exportIndex;
+
+	if(!(importModuleCount=imageImportDescriptors.size()))return;
+	loadImageExportDescriptors(imageExportDescriptors,exportSectionHeader,pureView);
+	for(short importModuleIndex=0;importModuleIndex<importModuleCount;importModuleIndex++)
+	{
+		ImageImportDescriptor &imageImportDescriptor(imageImportDescriptors[importModuleIndex]);
+		itemCount=imageImportDescriptor.imageOriginalThunkImportOrdinals().size();
+		for(DWORD itemIndex=0;itemIndex<itemCount;itemIndex++)
+		{
+			ImageImportDescriptorExpand::ImageThunkDataBlock &imageThunkDataBlock(imageImportDescriptor.imageOriginalThunkImportOrdinals());
+			if(imageExportDescriptors.locateImageExportOrdinal(imageThunkDataBlock[itemIndex].ordinal(),imageExportDescriptor,exportIndex))
+			{
+        imageImportDescriptor.imageOriginalThunkImportNames().insert
+			}
+		}
+		itemCount=imageImportDescriptor.imageThunkImportOrdinals().size();
+		for(itemIndex=0;itemIndex<itemCount;itemIndex++)
+		{
+			ImageImportDescriptorExpand::ImageThunkDataBlock &imageThunkDataBlock(imageImportDescriptor.imageThunkImportOrdinals());
+			if(imageExportDescriptors.locateImageExportOrdinal(imageThunkDataBlock[itemIndex].ordinal(),imageExportDescriptor,exportIndex))
+			{
+			}
+		}
+	}
+}
+
+
+
+
+
+//		((PureVector<ImageExportDescriptor>&)*this)[(WORD)exportOrdinals[nameIndex]-1].imageExportName(exportNames[nameIndex]);
+//		((PureVector<ImageExportDescriptor>&)*this)[(WORD)exportOrdinals[nameIndex]-1].imageExportOrdinal(exportOrdinals[nameIndex]);
+
+WORD PEHeader::enclosingSectionHeader(DWORD virtualAddress,ImageSectionHeader &someImageSectionHeader,DWORD &deltaOffset)
+{
+	DWORD sectionCount(((PureVector<ImageSectionHeader>&)*this).size());
+
+	for(short sectionIndex=0;sectionIndex<sectionCount;sectionIndex++)
+	{
+		ImageSectionHeader &imageSectionHeader(((PureVector<ImageSectionHeader>&)*this)[sectionIndex]);
+		if(virtualAddress>=imageSectionHeader.virtualAddress()&&
+			 virtualAddress<imageSectionHeader.virtualAddress()+imageSectionHeader.virtualSize())
+		{
+			someImageSectionHeader=imageSectionHeader;
+			deltaOffset=imageSectionHeader.virtualAddress()-imageSectionHeader.pointerRawData();
+			return TRUE;
+		}
+	}
+	return TRUE;
+}
+
+#if 0
+WORD PEHeader::loadImageImportDescriptors(Block<ImageImportDescriptor> &imageImportDescriptors,ImageSectionHeader &importSectionHeader,PureViewOfFile &pureView)
+{
+	DirectoryEntryKey sectionKey(DirectoryEntryKey::ImportDirectory);
+	ImageDataDirectory imageSectionDirectory(((ImageOptionalHeader&)*this)[sectionKey]);
+	ImageImportDescriptor imageImportDescriptor;
+	DWORD deltaOffset;
+  DWORD deltaNames;
+
+	imageImportDescriptors.remove();
+	if(!enclosingSectionHeader(imageSectionDirectory.virtualAddress(),importSectionHeader))return FALSE;
+	deltaOffset=importSectionHeader.virtualAddress()-importSectionHeader.pointerRawData();
+	pureView.seek(imageSectionDirectory.virtualAddress()-deltaOffset,PureViewOfFile::SeekSet);
+	while(TRUE)
+	{
+		String moduleName;
+		imageImportDescriptor<<pureView;
+		if(!imageImportDescriptor.isOkay())break;
+		deltaOffset=importNamesSectionHeader.virtualAddress()-importNamesSectionHeader.pointerRawData();
+		pureView.push();
+		pureView.seek(imageImportDescriptor.nameRVA()-deltaOffset,PureViewOfFile::SeekSet);
+		pureView.getLine(moduleName);
+		imageImportDescriptor.moduleName(moduleName);
+		pureView.pop();
+		imageImportDescriptor.loadImageImportThunks(deltaOffset,pureView);
+		imageImportDescriptors.insert(&imageImportDescriptor);
+	}
+	return imageImportDescriptors.size();
+}
+#endif
+
+
+
+
+
+
+	if(originalFirstThunkRVA())loadImageImportThunk(originalFirstThunkRVA(),deltaOffset,
+		imageOriginalThunkImportOrdinals(),imageOriginalThunkImportNames(),pureView);
+
+
+  void loadImageImportThunks(DWORD virtualAddress,DWORD deltaOffset,Block<ImageThunkData> &imageThunkImportOrdinals,Block<ImageThunkName> &imageThunkImportNames,PureViewOfFile &pureView);
+
+
+
+void PEHeader::loadImageImportThunks(DWORD virtualAddress,DWORD deltaOffset,Block<ImageThunkData> &imageThunkImportOrdinals,Block<ImageThunkName> &imageThunkImportNames,PureViewOfFile &pureView)
+{
+	imageThunkImportOrdinals.remove();
+	imageThunkImportNames.remove();
+	pureView.push();
+	pureView.seek(virtualAddress-deltaOffset,PureViewOfFile::SeekSet);
+	while(TRUE)
+	{
+		ImageThunkData imageThunkData;
+		imageThunkData<<pureView;
+		if(!imageThunkData.isOkay())break;
+		if(imageThunkData.isOrdinalImport())imageThunkImportOrdinals.insert(&imageThunkData);
+		else
+		{
+			ImageThunkName imageThunkName;
+			pureView.push();
+			pureView.seek(imageThunkData.addressOfDataRVA()-deltaOffset,PureViewOfFile::SeekSet);
+			imageThunkName<<pureView;
+			imageThunkImportNames.insert(&imageThunkName);
+			pureView.pop();
+		}
+	}
+	pureView.pop();
+}
+
+
+
+//		Block<ImageThunkData> imageOriginalThunkImportOrdinals;
+//		Block<ImageThunkName> imageOriginalThunkImportNames;
+//		if(imageImportDescriptor.originalFirstThunkRVA())
+//			loadImageImportThunks(imageImportDescriptor.originalFirstThunkRVA(),deltaOffset,
+//				imageOriginalThunkImportOrdinals,imageOriginalThunkImportNames,pureView);
+
+//		Block<ImageThunkData> imageThunkImportOrdinals;
+//		Block<ImageThunkName> imageThunkImportNames;
+//		if(imageImportDescriptor.firstThunkRVA())
+//			loadImageImportThunks(imageImportDescriptor.firstThunkRVA(),deltaOffset,
+//				imageThunkImportOrdinals,imageThunkImportNames,pureView);
+
+
+
+		pureView.push();
+		if(imageImportDescriptor.originalFirstThunkRVA())
+		{
+			pureView.seek(imageImportDescriptor.originalFirstThunkRVA()-deltaOffset,PureViewOfFile::SeekSet);
+			while(TRUE)
+			{
+				ImageThunkData imageThunkData;
+				imageThunkData<<pureView;
+				if(!imageThunkData.isOkay())break;
+			}
+		}
+		pureView.pop();
+
+#if 0
+		pureView.push();
+		if(imageImportDescriptor.firstThunkRVA())
+		{
+			pureView.seek(imageImportDescriptor.firstThunkRVA()-deltaOffset,PureViewOfFile::SeekSet);
+			while(TRUE)
+			{
+				ImageThunkData imageThunkData;
+				imageThunkData<<pureView;
+				if(!imageThunkData.isOkay())break;
+				if(imageThunkData.isOrdinalImport())
+				{
+				}
+				else
+				{
+					ImageThunkName imageThunkName;
+					pureView.push();
+					pureView.seek(imageThunkData.addressOfDataRVA()-deltaOffset,PureViewOfFile::SeekSet);
+					imageThunkName<<pureView;
+					pureView.pop();
+				}
+			}
+		}
+		pureView.pop();
+#endif
+
+
+//				ImageThunkName imageThunkName;
+//				imageThunkName<<pureView;
+//        break;
+//	pureView.seek(imageImportDescriptor.nameRVA()-deltaOffset,PureViewOfFile::SeekSet);
+//	char *lpString((char*)(imageImportDescriptor.nameRVA()-deltaOffset+pureView.base()));
+//	if(!lpString)return;
+
+
+//	pureView.seek(deltaOffset-imageImportDescriptor.nameRVA(),PureViewOfFile::SeekSet);
+//	char *lpString((char*)(imageImportDescriptor.nameRVA()-deltaOffset+pureView.base()));
+//	if(!lpString)return;
+//	lpString=0;
+
+
+
+	Bitmap kcBitmap("C:\\WORK\\SCENE\\MEDIA\\BMP\\KC.BMP");
+	HWND hDisplayWnd;
+
+	hDisplayWnd=::CreateWindow("BUTTON","",WS_VISIBLE,0,0,100,100,(HWND)0,(HMENU)0,hInstance,(LPVOID)0);
+	if(!hDisplayWnd)return FALSE;
+	::ShowWindow(hDisplayWnd,SW_SHOW);
+  ::UpdateWindow(hDisplayWnd);
+	kcBitmap.displayBitmap(hDisplayWnd);
+	::Sleep(10000);
+  ::DestroyWindow(hDisplayWnd);
+
+
+  
+
+//	DisAssembler disAssembler;
+//	disAssembler.pageBreak(FALSE);
+//	disAssembler.disassemble("C:\\COMMAND.COM");
+//	winConsole.writeLine("Finished, press any key.");
+//	winConsole.read();
+
+//#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+//#include <common/pview.hpp>
+//#endif
+//#ifndef _COMMON_BLOCK_TPP_
+//#include <common/block.tpp>
+//#endif
+
+
+
+#if 0
+//	Block<SmartPointer<char> > mResStrings;
+
+	mResStrings.insert(&SmartPointer<char>("???_0"));
+	mResStrings.insert(&SmartPointer<char>("CURSOR"));
+	mResStrings.insert(&SmartPointer<char>("BITMAP"));
+	mResStrings.insert(&SmartPointer<char>("ICON"));
+	mResStrings.insert(&SmartPointer<char>("MENU"));
+	mResStrings.insert(&SmartPointer<char>("DIALOG"));
+	mResStrings.insert(&SmartPointer<char>("STRING"));
+	mResStrings.insert(&SmartPointer<char>("FONTDIR"));
+	mResStrings.insert(&SmartPointer<char>("FONT"));
+	mResStrings.insert(&SmartPointer<char>("ACCELERATORS"));
+	mResStrings.insert(&SmartPointer<char>("RCDATA"));
+	mResStrings.insert(&SmartPointer<char>("MESSAGETABLE"));
+	mResStrings.insert(&SmartPointer<char>("GROUP_CURSOR"));
+	mResStrings.insert(&SmartPointer<char>("???_13"));
+	mResStrings.insert(&SmartPointer<char>("GROUP_ICON"));
+	mResStrings.insert(&SmartPointer<char>("???_15"));
+	mResStrings.insert(&SmartPointer<char>("VERSION"));
+	for(short itemIndex=0;itemIndex<mResStrings.size();itemIndex++)
+		mResStrings[itemIndex].disposition(PointerDisposition::Assume);
+#endif
+
+
+//	imgResDir.read(imageSectionHeader.pointerRawData(),pureView);
+//	pureView.seek(imageSectionHeader.pointerRawData(),PureViewOfFile::SeekSet);
+//	sectionData.size(imageSectionHeader.sizeofRawData());
+//	imgResDir.read(imageSectionHeader.pointerRawData(),pureView);
+//	descendResourceDirectory(imgResDir);
+
+
+void ImageResourceDataEntry::read(DWORD resBase,DWORD deltaOffset,PureViewOfFile &pureView)
+{
+  pureView.push();
+	pureView.read((char*)&((IMAGE_RESOURCE_DATA_ENTRY&)*this),sizeof(IMAGE_RESOURCE_DATA_ENTRY));
+	mRawData.size(size());
+  pureView.seek(offsetData()-deltaOffset,PureViewOfFile::SeekSet);
+	pureView.read((char*)((BYTE*)mRawData),mRawData.size());
+//  FileHandle resFile("RES.DAT",FileHandle::Write,FileHandle::ShareNone,FileHandle::Overwrite);
+//	resFile.write((BYTE*)mRawData,mRawData.size());
+	pureView.pop();
+}
+

image/SCRAPS.TXT

@@ -0,0 +1,495 @@
+  void loadImageImportThunks(DWORD deltaOffset,PureViewOfFile &pureView,ImageSectionHeaders &imageSectionHeaders,ImageExportDescriptors &imageExportDescriptors);
+
+
+void ImageImportDescriptor::loadImageImportThunk(DWORD virtualAddress,DWORD deltaOffset,Block<ImageThunkData> &imageThunkImportOrdinals,Block<ImageThunkName> &imageThunkImportNames,PureViewOfFile &pureView,ImageSectionHeaders &imageSectionHeaders,ImageExportDescriptors &imageExportDescriptors)
+{
+	ImageSectionHeader imageSectionHeader;
+
+	imageThunkImportOrdinals.remove();
+	imageThunkImportNames.remove();
+	pureView.push();
+	pureView.seek(virtualAddress-deltaOffset,PureViewOfFile::SeekSet);
+	while(TRUE)
+	{
+		ImageThunkData imageThunkData;
+		imageThunkData<<pureView;
+		if(!imageThunkData.isOkay())break;
+		if(imageThunkData.isOrdinalImport())
+		{
+			ImageExportDescriptor imageExportDescriptor;
+			ImageThunkName imageThunkName;
+			DWORD exportIndex;
+			if(imageExportDescriptors.locateImageExportOrdinal(imageThunkData.ordinal(),imageExportDescriptor,exportIndex))
+			{
+				imageThunkName.importName(imageExportDescriptor.imageExportName());
+				imageThunkImportNames.insert(&imageThunkName);
+			}
+			else imageThunkImportOrdinals.insert(&imageThunkData);
+		}
+		else
+		{
+			ImageThunkName imageThunkName;
+			pureView.push();
+			imageSectionHeaders.enclosingSectionHeader(imageThunkData.addressOfDataRVA(),imageSectionHeader,deltaOffset);
+			pureView.seek(imageThunkData.addressOfDataRVA()-deltaOffset,PureViewOfFile::SeekSet);
+			imageThunkName<<pureView;
+			imageThunkImportNames.insert(&imageThunkName);
+			pureView.pop();
+		}
+	}
+	pureView.pop();
+}
+
+
+
+void ImageImportDescriptor::loadImageImportThunks(DWORD deltaOffset,PureViewOfFile &pureView,ImageSectionHeaders &imageSectionHeaders,ImageExportDescriptors &imageExportDescriptors)
+{
+	if(!isOkay())return;
+	if(!firstThunkRVA()&&!originalFirstThunkRVA())return;
+	if(originalFirstThunkRVA())loadImageImportThunk(originalFirstThunkRVA(),deltaOffset,
+		imageOriginalThunkImportOrdinals(),imageOriginalThunkImportNames(),pureView,imageSectionHeaders,imageExportDescriptors);
+	else if(firstThunkRVA())loadImageImportThunk(firstThunkRVA(),deltaOffset,
+		imageThunkImportOrdinals(),imageThunkImportNames(),pureView,imageSectionHeaders,imageExportDescriptors);
+}
+
+
+WORD PEHeader::loadImageImportDescriptors(Block<ImageImportDescriptor> &imageImportDescriptors,ImageSectionHeader &importSectionHeader,ImageExportDescriptors &imageExportDescriptors,PureViewOfFile &pureView)
+{
+	DirectoryEntryKey sectionKey(DirectoryEntryKey::ImportDirectory);
+	ImageDataDirectory imageSectionDirectory(((ImageOptionalHeader&)*this)[sectionKey]);
+	ImageImportDescriptor imageImportDescriptor;
+	ImageSectionHeader importNamesSectionHeader;
+	ImageSectionHeader exportSectionHeader;
+	DWORD deltaOffset;
+	DWORD deltaNames;
+
+	imageImportDescriptors.remove();
+	imageExportDescriptors.size(0);
+	if(!enclosingSectionHeader(imageSectionDirectory.virtualAddress(),importSectionHeader,deltaOffset))return FALSE;
+	pureView.seek(imageSectionDirectory.virtualAddress()-deltaOffset,PureViewOfFile::SeekSet);
+	while(TRUE)
+	{
+		String moduleName;
+		imageImportDescriptor<<pureView;
+		if(!imageImportDescriptor.isOkay())break;
+		enclosingSectionHeader(imageImportDescriptor.nameRVA(),importNamesSectionHeader,deltaNames);
+		pureView.push();
+		pureView.seek(imageImportDescriptor.nameRVA()-deltaNames,PureViewOfFile::SeekSet);
+		pureView.getLine(moduleName);
+		loadImageExportDescriptors(imageExportDescriptors,exportSectionHeader,moduleName);
+		imageImportDescriptor.moduleName(moduleName);
+		pureView.pop();
+		imageImportDescriptor.loadImageImportThunks(deltaOffset,pureView,(ImageSectionHeaders&)*this,imageExportDescriptors);
+		imageImportDescriptors.insert(&imageImportDescriptor);
+	}
+	return imageImportDescriptors.size();
+}
+
+
+	WORD loadImageImportDescriptors(Block<ImageImportDescriptor> &imageImportDescriptors,ImageSectionHeader &importSectionHeader,ImageExportDescriptors &imageExportDescriptors,PureViewOfFile &pureView);
+
+//			::sprintf(entryPointString,"&0x%08lx",(DWORD)((PureVector<ImageExportDescriptor>&)*this)[functionIndex].imageExportEntryPoint());
+
+void replaceImageImportOrdinals(Block<ImageImportDescriptor> &imageImportDescriptors,PureViewOfFile &pureView);
+void PEHeader::replaceImageImportOrdinals(Block<ImageImportDescriptor> &imageImportDescriptors,PureViewOfFile &pureView)
+{
+	ImageExportDescriptors imageExportDescriptors;
+  ImageExportDescriptor imageExportDescriptor;
+	ImageSectionHeader exportSectionHeader;
+	DWORD itemCount;
+	DWORD importModuleCount;
+	DWORD exportIndex;
+
+	if(!(importModuleCount=imageImportDescriptors.size()))return;
+	loadImageExportDescriptors(imageExportDescriptors,exportSectionHeader,pureView);
+	for(short importModuleIndex=0;importModuleIndex<importModuleCount;importModuleIndex++)
+	{
+		ImageImportDescriptor &imageImportDescriptor(imageImportDescriptors[importModuleIndex]);
+		itemCount=imageImportDescriptor.imageOriginalThunkImportOrdinals().size();
+		for(DWORD itemIndex=0;itemIndex<itemCount;itemIndex++)
+		{
+			ImageImportDescriptorExpand::ImageThunkDataBlock &imageThunkDataBlock(imageImportDescriptor.imageOriginalThunkImportOrdinals());
+			if(imageExportDescriptors.locateImageExportOrdinal(imageThunkDataBlock[itemIndex].ordinal(),imageExportDescriptor,exportIndex))
+			{
+        imageImportDescriptor.imageOriginalThunkImportNames().insert
+			}
+		}
+		itemCount=imageImportDescriptor.imageThunkImportOrdinals().size();
+		for(itemIndex=0;itemIndex<itemCount;itemIndex++)
+		{
+			ImageImportDescriptorExpand::ImageThunkDataBlock &imageThunkDataBlock(imageImportDescriptor.imageThunkImportOrdinals());
+			if(imageExportDescriptors.locateImageExportOrdinal(imageThunkDataBlock[itemIndex].ordinal(),imageExportDescriptor,exportIndex))
+			{
+			}
+		}
+	}
+}
+
+
+
+
+
+//		((PureVector<ImageExportDescriptor>&)*this)[(WORD)exportOrdinals[nameIndex]-1].imageExportName(exportNames[nameIndex]);
+//		((PureVector<ImageExportDescriptor>&)*this)[(WORD)exportOrdinals[nameIndex]-1].imageExportOrdinal(exportOrdinals[nameIndex]);
+
+WORD PEHeader::enclosingSectionHeader(DWORD virtualAddress,ImageSectionHeader &someImageSectionHeader,DWORD &deltaOffset)
+{
+	DWORD sectionCount(((PureVector<ImageSectionHeader>&)*this).size());
+
+	for(short sectionIndex=0;sectionIndex<sectionCount;sectionIndex++)
+	{
+		ImageSectionHeader &imageSectionHeader(((PureVector<ImageSectionHeader>&)*this)[sectionIndex]);
+		if(virtualAddress>=imageSectionHeader.virtualAddress()&&
+			 virtualAddress<imageSectionHeader.virtualAddress()+imageSectionHeader.virtualSize())
+		{
+			someImageSectionHeader=imageSectionHeader;
+			deltaOffset=imageSectionHeader.virtualAddress()-imageSectionHeader.pointerRawData();
+			return TRUE;
+		}
+	}
+	return TRUE;
+}
+
+#if 0
+WORD PEHeader::loadImageImportDescriptors(Block<ImageImportDescriptor> &imageImportDescriptors,ImageSectionHeader &importSectionHeader,PureViewOfFile &pureView)
+{
+	DirectoryEntryKey sectionKey(DirectoryEntryKey::ImportDirectory);
+	ImageDataDirectory imageSectionDirectory(((ImageOptionalHeader&)*this)[sectionKey]);
+	ImageImportDescriptor imageImportDescriptor;
+	DWORD deltaOffset;
+  DWORD deltaNames;
+
+	imageImportDescriptors.remove();
+	if(!enclosingSectionHeader(imageSectionDirectory.virtualAddress(),importSectionHeader))return FALSE;
+	deltaOffset=importSectionHeader.virtualAddress()-importSectionHeader.pointerRawData();
+	pureView.seek(imageSectionDirectory.virtualAddress()-deltaOffset,PureViewOfFile::SeekSet);
+	while(TRUE)
+	{
+		String moduleName;
+		imageImportDescriptor<<pureView;
+		if(!imageImportDescriptor.isOkay())break;
+		deltaOffset=importNamesSectionHeader.virtualAddress()-importNamesSectionHeader.pointerRawData();
+		pureView.push();
+		pureView.seek(imageImportDescriptor.nameRVA()-deltaOffset,PureViewOfFile::SeekSet);
+		pureView.getLine(moduleName);
+		imageImportDescriptor.moduleName(moduleName);
+		pureView.pop();
+		imageImportDescriptor.loadImageImportThunks(deltaOffset,pureView);
+		imageImportDescriptors.insert(&imageImportDescriptor);
+	}
+	return imageImportDescriptors.size();
+}
+#endif
+
+
+
+
+
+
+	if(originalFirstThunkRVA())loadImageImportThunk(originalFirstThunkRVA(),deltaOffset,
+		imageOriginalThunkImportOrdinals(),imageOriginalThunkImportNames(),pureView);
+
+
+  void loadImageImportThunks(DWORD virtualAddress,DWORD deltaOffset,Block<ImageThunkData> &imageThunkImportOrdinals,Block<ImageThunkName> &imageThunkImportNames,PureViewOfFile &pureView);
+
+
+
+void PEHeader::loadImageImportThunks(DWORD virtualAddress,DWORD deltaOffset,Block<ImageThunkData> &imageThunkImportOrdinals,Block<ImageThunkName> &imageThunkImportNames,PureViewOfFile &pureView)
+{
+	imageThunkImportOrdinals.remove();
+	imageThunkImportNames.remove();
+	pureView.push();
+	pureView.seek(virtualAddress-deltaOffset,PureViewOfFile::SeekSet);
+	while(TRUE)
+	{
+		ImageThunkData imageThunkData;
+		imageThunkData<<pureView;
+		if(!imageThunkData.isOkay())break;
+		if(imageThunkData.isOrdinalImport())imageThunkImportOrdinals.insert(&imageThunkData);
+		else
+		{
+			ImageThunkName imageThunkName;
+			pureView.push();
+			pureView.seek(imageThunkData.addressOfDataRVA()-deltaOffset,PureViewOfFile::SeekSet);
+			imageThunkName<<pureView;
+			imageThunkImportNames.insert(&imageThunkName);
+			pureView.pop();
+		}
+	}
+	pureView.pop();
+}
+
+
+
+//		Block<ImageThunkData> imageOriginalThunkImportOrdinals;
+//		Block<ImageThunkName> imageOriginalThunkImportNames;
+//		if(imageImportDescriptor.originalFirstThunkRVA())
+//			loadImageImportThunks(imageImportDescriptor.originalFirstThunkRVA(),deltaOffset,
+//				imageOriginalThunkImportOrdinals,imageOriginalThunkImportNames,pureView);
+
+//		Block<ImageThunkData> imageThunkImportOrdinals;
+//		Block<ImageThunkName> imageThunkImportNames;
+//		if(imageImportDescriptor.firstThunkRVA())
+//			loadImageImportThunks(imageImportDescriptor.firstThunkRVA(),deltaOffset,
+//				imageThunkImportOrdinals,imageThunkImportNames,pureView);
+
+
+
+		pureView.push();
+		if(imageImportDescriptor.originalFirstThunkRVA())
+		{
+			pureView.seek(imageImportDescriptor.originalFirstThunkRVA()-deltaOffset,PureViewOfFile::SeekSet);
+			while(TRUE)
+			{
+				ImageThunkData imageThunkData;
+				imageThunkData<<pureView;
+				if(!imageThunkData.isOkay())break;
+			}
+		}
+		pureView.pop();
+
+#if 0
+		pureView.push();
+		if(imageImportDescriptor.firstThunkRVA())
+		{
+			pureView.seek(imageImportDescriptor.firstThunkRVA()-deltaOffset,PureViewOfFile::SeekSet);
+			while(TRUE)
+			{
+				ImageThunkData imageThunkData;
+				imageThunkData<<pureView;
+				if(!imageThunkData.isOkay())break;
+				if(imageThunkData.isOrdinalImport())
+				{
+				}
+				else
+				{
+					ImageThunkName imageThunkName;
+					pureView.push();
+					pureView.seek(imageThunkData.addressOfDataRVA()-deltaOffset,PureViewOfFile::SeekSet);
+					imageThunkName<<pureView;
+					pureView.pop();
+				}
+			}
+		}
+		pureView.pop();
+#endif
+
+
+//				ImageThunkName imageThunkName;
+//				imageThunkName<<pureView;
+//        break;
+//	pureView.seek(imageImportDescriptor.nameRVA()-deltaOffset,PureViewOfFile::SeekSet);
+//	char *lpString((char*)(imageImportDescriptor.nameRVA()-deltaOffset+pureView.base()));
+//	if(!lpString)return;
+
+
+//	pureView.seek(deltaOffset-imageImportDescriptor.nameRVA(),PureViewOfFile::SeekSet);
+//	char *lpString((char*)(imageImportDescriptor.nameRVA()-deltaOffset+pureView.base()));
+//	if(!lpString)return;
+//	lpString=0;
+
+
+
+	Bitmap kcBitmap("C:\\WORK\\SCENE\\MEDIA\\BMP\\KC.BMP");
+	HWND hDisplayWnd;
+
+	hDisplayWnd=::CreateWindow("BUTTON","",WS_VISIBLE,0,0,100,100,(HWND)0,(HMENU)0,hInstance,(LPVOID)0);
+	if(!hDisplayWnd)return FALSE;
+	::ShowWindow(hDisplayWnd,SW_SHOW);
+  ::UpdateWindow(hDisplayWnd);
+	kcBitmap.displayBitmap(hDisplayWnd);
+	::Sleep(10000);
+  ::DestroyWindow(hDisplayWnd);
+
+
+  
+
+//	DisAssembler disAssembler;
+//	disAssembler.pageBreak(FALSE);
+//	disAssembler.disassemble("C:\\COMMAND.COM");
+//	winConsole.writeLine("Finished, press any key.");
+//	winConsole.read();
+
+//#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+//#include <common/pview.hpp>
+//#endif
+//#ifndef _COMMON_BLOCK_TPP_
+//#include <common/block.tpp>
+//#endif
+
+
+
+#if 0
+//	Block<SmartPointer<char> > mResStrings;
+
+	mResStrings.insert(&SmartPointer<char>("???_0"));
+	mResStrings.insert(&SmartPointer<char>("CURSOR"));
+	mResStrings.insert(&SmartPointer<char>("BITMAP"));
+	mResStrings.insert(&SmartPointer<char>("ICON"));
+	mResStrings.insert(&SmartPointer<char>("MENU"));
+	mResStrings.insert(&SmartPointer<char>("DIALOG"));
+	mResStrings.insert(&SmartPointer<char>("STRING"));
+	mResStrings.insert(&SmartPointer<char>("FONTDIR"));
+	mResStrings.insert(&SmartPointer<char>("FONT"));
+	mResStrings.insert(&SmartPointer<char>("ACCELERATORS"));
+	mResStrings.insert(&SmartPointer<char>("RCDATA"));
+	mResStrings.insert(&SmartPointer<char>("MESSAGETABLE"));
+	mResStrings.insert(&SmartPointer<char>("GROUP_CURSOR"));
+	mResStrings.insert(&SmartPointer<char>("???_13"));
+	mResStrings.insert(&SmartPointer<char>("GROUP_ICON"));
+	mResStrings.insert(&SmartPointer<char>("???_15"));
+	mResStrings.insert(&SmartPointer<char>("VERSION"));
+	for(short itemIndex=0;itemIndex<mResStrings.size();itemIndex++)
+		mResStrings[itemIndex].disposition(PointerDisposition::Assume);
+#endif
+
+
+//	imgResDir.read(imageSectionHeader.pointerRawData(),pureView);
+//	pureView.seek(imageSectionHeader.pointerRawData(),PureViewOfFile::SeekSet);
+//	sectionData.size(imageSectionHeader.sizeofRawData());
+//	imgResDir.read(imageSectionHeader.pointerRawData(),pureView);
+//	descendResourceDirectory(imgResDir);
+
+
+void ImageResourceDataEntry::read(DWORD resBase,DWORD deltaOffset,PureViewOfFile &pureView)
+{
+  pureView.push();
+	pureView.read((char*)&((IMAGE_RESOURCE_DATA_ENTRY&)*this),sizeof(IMAGE_RESOURCE_DATA_ENTRY));
+	mRawData.size(size());
+  pureView.seek(offsetData()-deltaOffset,PureViewOfFile::SeekSet);
+	pureView.read((char*)((BYTE*)mRawData),mRawData.size());
+//  FileHandle resFile("RES.DAT",FileHandle::Write,FileHandle::ShareNone,FileHandle::Overwrite);
+//	resFile.write((BYTE*)mRawData,mRawData.size());
+	pureView.pop();
+}
+
+
+void ImageResourceDirectoryEntry::read(DWORD resBase,DWORD deltaOffset,PureViewOfFile &pureView)
+{
+  pureView.read((char*)&((IMAGE_RESOURCE_DIRECTORY_ENTRY&)*this),sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
+	pureView.push();
+	if(nameIsString())
+	{
+	  ImageResourceDirString resDirString;
+	  pureView.push();
+		pureView.seek(resBase+offsetName(),PureViewOfFile::SeekSet);
+		resDirString.read(pureView);
+		mResourceName=resDirString.name();
+		pureView.pop();
+	}
+	if(dataIsDirectory())
+	{
+//	  String resString=getResource(name());
+//		if(!resString.isNull())::OutputDebugString(resString+String("\n"));
+//	  mResourceType=getResource(name());
+		if(mResourceName.isNull())mResourceName=getResource(name());
+		if(!mResourceName.isNull())::OutputDebugString(mResourceName+String("\n"));
+		pureView.seek(resBase+offsetDirectory(),PureViewOfFile::SeekSet);
+		mImageResourceDirectory.read(resBase,deltaOffset,pureView);
+	}
+	else
+	{
+	  pureView.seek(resBase+offsetDirectory(),PureViewOfFile::SeekSet);
+		mImageResourceDataEntry.read(deltaOffset,pureView);
+	}
+	pureView.pop();
+}
+
+
+
+//	  ImageResourceDirectoryEntry imgResDirEntry;
+//		imgResDirEntry.read(resBase,deltaOffset,pureView);
+//		mImageResourceDirectoryEntries.insert(&imgResDirEntry);
+
+
+
+
+
+
+
+	mResStrings.insert(&String("???_0"));
+	mResStrings.insert(&String("CURSOR"));
+	mResStrings.insert(&String("BITMAP"));
+	mResStrings.insert(&String("ICON"));
+	mResStrings.insert(&String("MENU"));
+	mResStrings.insert(&String("DIALOG"));
+	mResStrings.insert(&String("STRING"));
+	mResStrings.insert(&String("FONTDIR"));
+	mResStrings.insert(&String("FONT"));
+	mResStrings.insert(&String("ACCELERATORS"));
+	mResStrings.insert(&String("RCDATA"));
+	mResStrings.insert(&String("MESSAGETABLE"));
+	mResStrings.insert(&String("GROUP_CURSOR"));
+	mResStrings.insert(&String("???_13"));
+	mResStrings.insert(&String("GROUP_ICON"));
+	mResStrings.insert(&String("???_15"));
+	mResStrings.insert(&String("VERSION"));
+
+
+
+	vxdView.seek(vxdHeader.neHeaderAddress()+vxdHeader.objectTableOffset(),PureViewOfFile::SeekSet);
+	for(int 
+
+
+	VxDObject vxdObj;
+	for(int objIndex=0;objIndex<vxdHeader.objectCount();objIndex++)
+	{
+	  vxdObj<<vxdView;
+		String strFlags;
+		::sprintf(strFlags,"virt. size:%08lx reloc. base:%08lx table index:%08lx table entries:%08lx",
+		  vxdObj.virtualSize(),vxdObj.relocationBaseAddress(),vxdObj.pageTableIndex(),vxdObj.pageTableEntries());
+		strFlags+=String(" ")+(String)vxdObj;
+		::OutputDebugString(strFlags+String("\n"));
+	}
+
+
+	pureView.seek(neHeaderAddress()+objectTableOffset(),PureViewOfFile::SeekSet);
+	for(int objIndex=0;objIndex<objectCount();objIndex++){VxDObjects::insert(&VxDObject());VxDObjects::operator[](objIndex)<<pureView;}
+	getNames(pureView);
+
+
+
+class DirectoryEntryKey
+{
+public:
+	enum Key{ExportDirectory=IMAGE_DIRECTORY_ENTRY_EXPORT,
+			 ImportDirectory=IMAGE_DIRECTORY_ENTRY_IMPORT,
+			 ResourceDirectory=IMAGE_DIRECTORY_ENTRY_RESOURCE,
+			 ExceptionDirectory=IMAGE_DIRECTORY_ENTRY_EXCEPTION,
+			 SecurityDirectory=IMAGE_DIRECTORY_ENTRY_SECURITY,
+			 BaseRelocationTableDirectory=IMAGE_DIRECTORY_ENTRY_BASERELOC,
+			 DebugDirectory=IMAGE_DIRECTORY_ENTRY_DEBUG,
+			 DescriptionStringDirectory=IMAGE_DIRECTORY_ENTRY_COPYRIGHT,
+			 MachineValueDirectory=IMAGE_DIRECTORY_ENTRY_GLOBALPTR,
+			 ThreadLocalStorageDirectory=IMAGE_DIRECTORY_ENTRY_TLS,
+			 LoadConfigurationDirectory=IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG,
+			 BoundImportDirectory=IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT,
+			 ImportAddressTableDirectory=IMAGE_DIRECTORY_ENTRY_IAT
+			 };
+	DirectoryEntryKey(Key entryEntry=ImportDirectory);
+	DirectoryEntryKey(const DirectoryEntryKey &someDirectoryEntryKey);
+	virtual ~DirectoryEntryKey();
+	DirectoryEntryKey &operator=(const DirectoryEntryKey &someDirectoryEntryKey);
+	WORD operator==(const DirectoryEntryKey &someDirectoryEntryKey);
+	Key entryKey(void)const;
+	void entryKey(Key entryKey);
+
+
+
+// development of this method is currently in progress
+BOOL PEHeader::loadImageRelocationDirectory(ImageRelocations &imageRelocations,PureViewOfFile &pureView,BOOL isMemoryImage)
+{
+  DirectoryEntryKey sectionKey;
+	ImageDataDirectory imageSectionDirectory;
+	ImageSectionHeader relocationSectionHeader;
+	DWORD deltaOffset;
+	BOOL msImage(FALSE);
+  
+  imageRelocations.remove();
+  if(!isOkay())return FALSE;
+  sectionKey.entryKey(DirectoryEntryKey::ResourceDirectory);
+	imageSectionDirectory=((ImageOptionalHeader&)*this)[sectionKey];
+	if(!enclosingSectionHeader(imageSectionDirectory.virtualAddress(),relocationSectionHeader,deltaOffset))return FALSE;
+	for(short sectionIndex=0;sectionIndex<size();sectionIndex++)if(((PureVector<ImageSectionHeader>&)*this)[sectionIndex].name()==String(".reloc")){msImage=TRUE;break;}
+	return imageRelocations.size()?TRUE:FALSE;
+}

image/SCTNHDR.HPP

@@ -0,0 +1,211 @@
+#ifndef _IMAGE_IMAGESECTIONHEADER_HPP_
+#define _IMAGE_IMAGESECTIONHEADER_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+#include <common/pview.hpp>
+#endif
+
+class ImageSectionHeader : private _IMAGE_SECTION_HEADER
+{
+public:
+	ImageSectionHeader(void);
+	ImageSectionHeader(const ImageSectionHeader &someImageSectionHeader);
+	~ImageSectionHeader();
+	ImageSectionHeader &operator=(const ImageSectionHeader &someImageSectionHeader);
+	WORD operator==(const ImageSectionHeader &someImageSectionHeader);
+	WORD operator<<(PureViewOfFile &pureView);
+	String name(void)const;
+	DWORD physicalAddress(void)const;
+	void physicalAddress(DWORD physicalAddress);
+	DWORD virtualSize(void)const;
+	void virtualSize(DWORD virtualSize);
+	DWORD virtualAddress(void)const;
+	void virtualAddress(DWORD virtualAddress);
+	DWORD sizeofRawData(void)const;
+	void sizeofRawData(DWORD sizeofRawData);
+	DWORD pointerRawData(void)const;
+	void pointerRawData(WORD pointerRawData);
+	DWORD pointerRelocations(void)const;
+	void pointerRelocations(DWORD pointerRelocations);
+	DWORD pointerLineNumbers(void)const;
+	void pointerLineNumbers(DWORD pointerLineNumbers);
+	WORD relocationsCount(void)const;
+	void relocationsCount(WORD relocationsCount);
+	WORD lineNumbersCount(void)const;
+	void lineNumbersCount(WORD lineNumbersCount);
+	DWORD characteristics(void)const;
+	void characteristics(DWORD characteristics);
+private:
+};
+
+inline
+ImageSectionHeader::ImageSectionHeader(void)
+{
+	::memset((char*)&((_IMAGE_SECTION_HEADER&)*this),0,sizeof(_IMAGE_SECTION_HEADER));
+}
+
+inline
+ImageSectionHeader::ImageSectionHeader(const ImageSectionHeader &someImageSectionHeader)
+{
+  *this=someImageSectionHeader;
+}
+
+inline
+ImageSectionHeader::~ImageSectionHeader()
+{
+}
+
+inline
+ImageSectionHeader &ImageSectionHeader::operator=(const ImageSectionHeader &someImageSectionHeader)
+{
+	::memcpy((char*)&((_IMAGE_SECTION_HEADER&)*this),(char*)&((_IMAGE_SECTION_HEADER&)someImageSectionHeader),sizeof(_IMAGE_SECTION_HEADER));
+  return *this;
+}
+
+inline
+WORD ImageSectionHeader::operator==(const ImageSectionHeader &someImageSectionHeader)
+{
+  return ::memcmp((char*)&((_IMAGE_SECTION_HEADER&)*this),(char*)&((_IMAGE_SECTION_HEADER&)someImageSectionHeader),sizeof(_IMAGE_SECTION_HEADER));
+}
+
+inline
+WORD ImageSectionHeader::operator<<(PureViewOfFile &pureView)
+{
+  return sizeof(_IMAGE_SECTION_HEADER)==pureView.read((char*)&((_IMAGE_SECTION_HEADER&)*this),sizeof(_IMAGE_SECTION_HEADER));
+}
+
+inline
+String ImageSectionHeader::name(void)const
+{
+	String sectionName;
+
+	sectionName.reserve(sizeof(_IMAGE_SECTION_HEADER::Name)+1);
+	::memcpy(sectionName,_IMAGE_SECTION_HEADER::Name,sizeof(_IMAGE_SECTION_HEADER::Name));
+  return sectionName;
+}
+
+inline
+DWORD ImageSectionHeader::physicalAddress(void)const
+{
+  return _IMAGE_SECTION_HEADER::Misc.PhysicalAddress;
+}
+
+inline
+void ImageSectionHeader::physicalAddress(DWORD physicalAddress)
+{
+	_IMAGE_SECTION_HEADER::Misc.PhysicalAddress=physicalAddress;
+}
+
+inline
+DWORD ImageSectionHeader::virtualSize(void)const
+{
+	return _IMAGE_SECTION_HEADER::Misc.VirtualSize;
+}
+
+inline
+void ImageSectionHeader::virtualSize(DWORD virtualSize)
+{
+	_IMAGE_SECTION_HEADER::Misc.VirtualSize=virtualSize;
+}
+
+inline
+DWORD ImageSectionHeader::virtualAddress(void)const
+{
+	return _IMAGE_SECTION_HEADER::VirtualAddress;
+}
+
+inline
+void ImageSectionHeader::virtualAddress(DWORD virtualAddress)
+{
+	_IMAGE_SECTION_HEADER::VirtualAddress=virtualAddress;
+}
+
+inline
+DWORD ImageSectionHeader::sizeofRawData(void)const
+{
+	return _IMAGE_SECTION_HEADER::SizeOfRawData;
+}
+
+inline
+void ImageSectionHeader::sizeofRawData(DWORD sizeofRawData)
+{
+	_IMAGE_SECTION_HEADER::SizeOfRawData=sizeofRawData;
+}
+
+inline
+DWORD ImageSectionHeader::pointerRawData(void)const
+{
+	return _IMAGE_SECTION_HEADER::PointerToRawData;
+}
+
+inline
+void ImageSectionHeader::pointerRawData(WORD pointerRawData)
+{
+	_IMAGE_SECTION_HEADER::PointerToRawData=pointerRawData;
+}
+
+inline
+DWORD ImageSectionHeader::pointerRelocations(void)const
+{
+	return _IMAGE_SECTION_HEADER::PointerToRelocations;
+}
+
+inline
+void ImageSectionHeader::pointerRelocations(DWORD pointerRelocations)
+{
+	_IMAGE_SECTION_HEADER::PointerToRelocations=pointerRelocations;
+}
+
+inline
+DWORD ImageSectionHeader::pointerLineNumbers(void)const
+{
+	return _IMAGE_SECTION_HEADER::PointerToLinenumbers;
+}
+
+inline
+void ImageSectionHeader::pointerLineNumbers(DWORD pointerLineNumbers)
+{
+	_IMAGE_SECTION_HEADER::PointerToLinenumbers=pointerLineNumbers;
+}
+
+inline
+WORD ImageSectionHeader::relocationsCount(void)const
+{
+	return _IMAGE_SECTION_HEADER::NumberOfRelocations;
+}
+
+inline
+void ImageSectionHeader::relocationsCount(WORD relocationsCount)
+{
+	_IMAGE_SECTION_HEADER::NumberOfRelocations=relocationsCount;
+}
+
+inline
+WORD ImageSectionHeader::lineNumbersCount(void)const
+{
+	return _IMAGE_SECTION_HEADER::NumberOfLinenumbers;
+}
+
+inline
+void ImageSectionHeader::lineNumbersCount(WORD lineNumbersCount)
+{
+	_IMAGE_SECTION_HEADER::NumberOfLinenumbers=lineNumbersCount;
+}
+
+inline
+DWORD ImageSectionHeader::characteristics(void)const
+{
+	return _IMAGE_SECTION_HEADER::Characteristics;
+}
+
+inline
+void ImageSectionHeader::characteristics(DWORD characteristics)
+{
+	_IMAGE_SECTION_HEADER::Characteristics=characteristics;
+}
+#endif

image/SCTNHDRS.CPP

@@ -0,0 +1,23 @@
+#include <image/sctnhdrs.hpp>
+
+WORD ImageSectionHeaders::enclosingSectionHeader(DWORD virtualAddress,ImageSectionHeader &someImageSectionHeader,DWORD &deltaOffset)
+{
+	DWORD sectionCount(((Array<ImageSectionHeader>&)*this).size());
+
+	deltaOffset=0;
+	for(short sectionIndex=0;sectionIndex<sectionCount;sectionIndex++)
+	{
+		ImageSectionHeader &imageSectionHeader=((Array<ImageSectionHeader>&)*this)[sectionIndex];
+		if(virtualAddress>=imageSectionHeader.virtualAddress()&&
+			 virtualAddress<imageSectionHeader.virtualAddress()+imageSectionHeader.virtualSize())
+		{
+			someImageSectionHeader=imageSectionHeader;
+			if(!isMemImage())deltaOffset=imageSectionHeader.virtualAddress()-imageSectionHeader.pointerRawData();
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+
+
+

image/SCTNHDRS.HPP

@@ -0,0 +1,67 @@
+#ifndef _IMAGE_IMAGESECTIONHEADERS_HPP_
+#define _IMAGE_IMAGESECTIONHEADERS_HPP_
+#ifndef _COMMON_ARRAY_HPP_
+#include <common/array.hpp>
+#endif
+#ifndef _IMAGE_IMAGESECTIONHEADER_HPP_
+#include <image/sctnhdr.hpp>
+#endif
+
+class ImageSectionHeaders : public Array<ImageSectionHeader>
+{
+public:
+	ImageSectionHeaders(void);
+	ImageSectionHeaders(const ImageSectionHeaders &someImageSectionHeaders);
+	virtual ~ImageSectionHeaders();
+	ImageSectionHeaders &operator=(const ImageSectionHeaders &someImageSectionHeaders);
+	WORD operator==(const ImageSectionHeaders &someImageSectionHeaders)const;
+	WORD enclosingSectionHeader(DWORD virtualAddress,ImageSectionHeader &someImageSectionHeader,DWORD &deltaOffset);
+	WORD isMemImage(void)const;
+	void isMemImage(WORD isMemImage);
+private:
+  WORD mIsMemImage;
+};
+
+inline
+ImageSectionHeaders::ImageSectionHeaders(void)
+: mIsMemImage(FALSE)
+{
+}
+
+inline
+ImageSectionHeaders::ImageSectionHeaders(const ImageSectionHeaders &someImageSectionHeaders)
+{
+	*this=someImageSectionHeaders;
+}
+
+inline
+ImageSectionHeaders::~ImageSectionHeaders()
+{
+}
+
+inline
+ImageSectionHeaders &ImageSectionHeaders::operator=(const ImageSectionHeaders &someImageSectionHeaders)
+{
+	(Array<ImageSectionHeader>&)*this=(Array<ImageSectionHeader>&)someImageSectionHeaders;
+  isMemImage(someImageSectionHeaders.isMemImage());
+  return *this;
+}
+
+inline
+WORD ImageSectionHeaders::operator==(const ImageSectionHeaders &someImageSectionHeaders)const
+{
+	return (Array<ImageSectionHeader>&)*this==(Array<ImageSectionHeader>&)someImageSectionHeaders;
+}
+
+inline
+WORD ImageSectionHeaders::isMemImage(void)const
+{
+	return mIsMemImage;
+}
+
+inline
+void ImageSectionHeaders::isMemImage(WORD isMemImage)
+{
+  mIsMemImage=isMemImage;
+}
+#endif

image/STDTMPL.CPP

@@ -0,0 +1,32 @@
+#ifndef _MSC_VER
+#define _EXPAND_VECTOR_TEMPLATES_
+#define _EXPAND_BLOCK_TEMPLATES_
+#include <common/point.hpp>
+#include <common/rgbcolor.hpp>
+#include <common/pvector.hpp>
+#include <common/pvector.tpp>
+#include <common/callback.hpp>
+#include <common/callback.tpp>
+#include <common/block.hpp>
+#include <common/block.tpp>
+#include <common/qsort.hpp>
+#include <common/qsort.tpp>
+#include <common/string.hpp>
+#include <common/filemap.hpp>
+#include <image/sctnhdr.hpp>
+#include <image/import.hpp>
+#include <image/expdsc.hpp>
+#include <image/export.hpp>
+#include <image/thnkdata.hpp>
+#include <image/thnkname.hpp>
+#include <image/dbgdir.hpp>
+
+typedef PureVector<ImageSectionHeader> a;
+typedef PureVector<ImageImportDescriptor> b;
+typedef Block<ImageImportDescriptor> c;
+typedef Block<ImageExportDescriptor> d;
+typedef Block<ImageThunkData> e;
+typedef Block<ImageThunkName> f;
+typedef QuickSort<ImageExportDescriptor> g;
+typedef Block<ImageDebugDirectory> h;
+#endif

image/STRPTR.HPP

@@ -0,0 +1,37 @@
+#ifndef _IMAGE_STRPOINTER_HPP_
+#define _IMAGE_STRPOINTER_HPP_
+
+class StrPointer
+{
+public:
+	StrPointer(void);
+  StrPointer(char *ptrString);
+	virtual ~StrPointer();
+	operator char *(void);
+private:
+  char *mpString;
+};
+
+inline
+StrPointer::StrPointer(void)
+: mpString(0)
+{
+}
+
+inline
+StrPointer::StrPointer(char *ptrString)
+: mpString(ptrString)
+{
+}
+
+inline
+StrPointer::~StrPointer()
+{
+}
+
+inline
+StrPointer::operator char *(void)
+{
+  return mpString;
+}
+#endif

image/THNKDATA.HPP

@@ -0,0 +1,151 @@
+#ifndef _ENGINEER_IMAGETHUNKDATA_HPP_
+#define _ENGINEER_IMAGETHUNKDATA_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+#include <common/pview.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+
+class ImageThunkData : private IMAGE_THUNK_DATA
+{
+public:
+	ImageThunkData(void);
+	ImageThunkData(const ImageThunkData &someImageThunkData);
+	virtual ~ImageThunkData();
+	ImageThunkData &operator=(const ImageThunkData &someImageThunkData);
+	WORD operator==(const ImageThunkData &someImageThunkData)const;
+	ImageThunkData &operator<<(PureViewOfFile &pureView);
+	operator IMAGE_THUNK_DATA&(void);
+	DWORD forwarderStringRVA(void)const;
+	void forwarderStringRVA(DWORD forwarderStringRVA);
+	DWORD functionRVA(void)const;
+	void functionRVA(DWORD functionRVA);
+	DWORD ordinal(void)const;
+	void ordinal(DWORD ordinal);
+	DWORD addressOfDataRVA(void)const;
+	void addressOfDataRVA(DWORD addressOfDataRVA);
+	WORD isOkay(void)const;
+	WORD isOrdinalImport(void)const;
+private:
+	void setZero(void);
+};
+
+inline
+ImageThunkData::ImageThunkData(void)
+{
+	setZero();
+}
+
+inline
+ImageThunkData::ImageThunkData(const ImageThunkData &someImageThunkData)
+{
+	*this=someImageThunkData;
+}
+
+inline
+ImageThunkData::~ImageThunkData()
+{
+}
+
+inline
+ImageThunkData::operator IMAGE_THUNK_DATA&(void)
+{
+	return *this;
+}
+
+inline
+ImageThunkData &ImageThunkData::operator=(const ImageThunkData &someImageThunkData)
+{
+	forwarderStringRVA(someImageThunkData.forwarderStringRVA());
+	functionRVA(someImageThunkData.functionRVA());
+	ordinal(someImageThunkData.ordinal());
+	addressOfDataRVA(someImageThunkData.addressOfDataRVA());
+	return *this;
+}
+
+inline
+WORD ImageThunkData::operator==(const ImageThunkData &someImageThunkData)const
+{
+	return (forwarderStringRVA()==someImageThunkData.forwarderStringRVA()&&
+					functionRVA()==someImageThunkData.functionRVA()&&
+					ordinal()==someImageThunkData.ordinal()&&
+					addressOfDataRVA()==someImageThunkData.addressOfDataRVA());
+}
+
+inline
+ImageThunkData &ImageThunkData::operator<<(PureViewOfFile &pureView)
+{
+	pureView.read((char*)&((IMAGE_THUNK_DATA&)*this),sizeof(IMAGE_THUNK_DATA));
+	return *this;
+}
+
+inline
+DWORD ImageThunkData::forwarderStringRVA(void)const
+{
+	return (DWORD)IMAGE_THUNK_DATA::u1.ForwarderString;
+}
+
+inline
+void ImageThunkData::forwarderStringRVA(DWORD forwarderStringRVA)
+{
+	IMAGE_THUNK_DATA::u1.ForwarderString=(PBYTE)forwarderStringRVA;
+}
+
+inline
+DWORD ImageThunkData::functionRVA(void)const
+{
+	return (DWORD)IMAGE_THUNK_DATA::u1.Function;
+}
+
+inline
+void ImageThunkData::functionRVA(DWORD functionRVA)
+{
+	IMAGE_THUNK_DATA::u1.Function=(PDWORD)functionRVA;
+}
+
+inline
+DWORD ImageThunkData::ordinal(void)const
+{
+	return IMAGE_ORDINAL(IMAGE_THUNK_DATA::u1.Ordinal);
+}
+
+inline
+void ImageThunkData::ordinal(DWORD ordinal)
+{
+	IMAGE_THUNK_DATA::u1.Ordinal=ordinal;
+}
+
+inline
+DWORD ImageThunkData::addressOfDataRVA(void)const
+{
+	return (DWORD)IMAGE_THUNK_DATA::u1.AddressOfData;
+}
+
+inline
+void ImageThunkData::addressOfDataRVA(DWORD addressOfDataRVA)
+{
+	IMAGE_THUNK_DATA::u1.AddressOfData=(PIMAGE_IMPORT_BY_NAME)addressOfDataRVA;
+}
+
+inline
+void ImageThunkData::setZero(void)
+{
+	::memset(&((IMAGE_THUNK_DATA&)*this),0,sizeof(IMAGE_THUNK_DATA));
+}
+
+inline
+WORD ImageThunkData::isOkay(void)const
+{
+	return (functionRVA()?TRUE:FALSE);
+}
+
+inline
+WORD ImageThunkData::isOrdinalImport(void)const
+{
+  return (IMAGE_THUNK_DATA::u1.Ordinal&IMAGE_ORDINAL_FLAG)==IMAGE_ORDINAL_FLAG;
+}
+#endif

image/THNKNAME.HPP

@@ -0,0 +1,174 @@
+#ifndef _IMAGE_IMAGETHUNKNAME_HPP_
+#define _IMAGE_IMAGETHUNKNAME_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_PUREVIEWOFFILE_HPP_
+#include <common/pview.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+
+class ImageThunkNameExpand
+{
+public:
+	ImageThunkNameExpand(void);
+	ImageThunkNameExpand(const ImageThunkNameExpand &someImageThunkNameExpand);
+	ImageThunkNameExpand(const String &importName);
+	~ImageThunkNameExpand();
+	ImageThunkNameExpand &operator=(const ImageThunkNameExpand &someImageThunkNameExpand);
+	WORD operator==(const ImageThunkNameExpand &someImageThunkNameExpand)const;
+	String importName(void)const;
+	void importName(const String &importName);
+private:
+	String mImportName;
+};
+
+inline
+ImageThunkNameExpand::ImageThunkNameExpand(void)
+{
+}
+
+inline
+ImageThunkNameExpand::ImageThunkNameExpand(const ImageThunkNameExpand &someImageThunkNameExpand)
+{
+	*this=someImageThunkNameExpand;
+}
+
+inline
+ImageThunkNameExpand::ImageThunkNameExpand(const String &importName)
+: mImportName(importName)
+{
+}
+
+inline
+ImageThunkNameExpand::~ImageThunkNameExpand()
+{
+}
+
+inline
+ImageThunkNameExpand &ImageThunkNameExpand::operator=(const ImageThunkNameExpand &someImageThunkNameExpand)
+{
+	importName(someImageThunkNameExpand.importName());
+	return *this;
+}
+
+inline
+WORD ImageThunkNameExpand::operator==(const ImageThunkNameExpand &someImageThunkNameExpand)const
+{
+	return importName()==someImageThunkNameExpand.importName();
+}
+
+inline
+String ImageThunkNameExpand::importName(void)const
+{
+	return mImportName;
+}
+
+inline
+void ImageThunkNameExpand::importName(const String &importName)
+{
+	mImportName=importName;
+}
+
+// ******************************************
+
+class ImageThunkName : public ImageThunkNameExpand, private IMAGE_IMPORT_BY_NAME
+{
+public:
+	ImageThunkName(void);
+	ImageThunkName(const ImageThunkName &someImageThunkName);
+	~ImageThunkName();
+	ImageThunkName &operator=(const ImageThunkName &someImageThunName);
+	WORD operator==(const ImageThunkName &someImageThunkName)const;
+	ImageThunkName &operator<<(PureViewOfFile &pureView);
+  operator IMAGE_IMPORT_BY_NAME &(void);
+	WORD hint(void)const;
+	void hint(WORD hint);
+	BYTE name(void)const;
+  void name(BYTE name);
+private:
+  void setZero(void);
+};
+
+inline
+ImageThunkName::ImageThunkName(void)
+{
+  setZero();
+}
+
+inline
+ImageThunkName::ImageThunkName(const ImageThunkName &someImageThunkName)
+{
+	*this=someImageThunkName;
+}
+
+inline
+ImageThunkName::~ImageThunkName()
+{
+}
+
+inline
+ImageThunkName &ImageThunkName::operator=(const ImageThunkName &someImageThunkName)
+{
+	hint(someImageThunkName.hint());
+	name(someImageThunkName.name());
+	(ImageThunkNameExpand&)*this=(ImageThunkNameExpand&)someImageThunkName;
+	return *this;
+}
+
+inline
+WORD ImageThunkName::operator==(const ImageThunkName &someImageThunkName)const
+{
+	return (hint()==someImageThunkName.hint()&&
+					name()==someImageThunkName.name());
+}
+
+inline
+ImageThunkName &ImageThunkName::operator<<(PureViewOfFile &pureView)
+{
+	String moduleImportName;
+	pureView.read(IMAGE_IMPORT_BY_NAME::Hint);
+	pureView.getLine(moduleImportName);
+	importName(moduleImportName);
+	return *this;
+}
+
+inline
+ImageThunkName::operator IMAGE_IMPORT_BY_NAME &(void)
+{
+	return *this;
+}
+
+inline
+WORD ImageThunkName::hint(void)const
+{
+	return IMAGE_IMPORT_BY_NAME::Hint;
+}
+
+inline
+void ImageThunkName::hint(WORD hint)
+{
+	IMAGE_IMPORT_BY_NAME::Hint=hint;
+}
+
+inline
+BYTE ImageThunkName::name(void)const
+{
+	return IMAGE_IMPORT_BY_NAME::Name[0];
+}
+
+inline
+void ImageThunkName::name(BYTE name)
+{
+	IMAGE_IMPORT_BY_NAME::Name[0]=name;
+}
+
+inline
+void ImageThunkName::setZero(void)
+{
+	IMAGE_IMPORT_BY_NAME::Hint=0;
+	IMAGE_IMPORT_BY_NAME::Name[0]=0;
+}
+#endif

image/VXDHDR.CPP

@@ -0,0 +1,111 @@
+#include <image/vxdhdr.hpp>
+
+VxDHeader::~VxDHeader()
+{
+}
+
+VxDHeader &VxDHeader::operator=(const VxDHeader &someVxDHeader)
+{
+	::memcpy((char*)&((_IMAGE_VXD_HEADER&)*this),(char*)&((_IMAGE_VXD_HEADER&)someVxDHeader),sizeof(_IMAGE_VXD_HEADER));
+  (DOSHeader&)*this=(DOSHeader&)someVxDHeader;
+	return *this;
+}
+
+WORD VxDHeader::operator==(const VxDHeader &someVxDHeader)
+{
+	return ((DOSHeader&)*this==(DOSHeader&)someVxDHeader&&
+	magic()==someVxDHeader.magic()&&
+	byteOrdering()==someVxDHeader.byteOrdering()&&
+	wordOrdering()==someVxDHeader.wordOrdering()&&
+	exeFormatLevel()==someVxDHeader.exeFormatLevel()&&
+	cpuType()==someVxDHeader.cpuType()&&
+	osType()==someVxDHeader.osType()&&
+	moduleVersion()==someVxDHeader.moduleVersion()&&
+	moduleFlags()==someVxDHeader.moduleFlags()&&
+	moduleNumPages()==someVxDHeader.moduleNumPages()&&
+	startObjectNumberForIP()==someVxDHeader.startObjectNumberForIP()&&
+	eip()==someVxDHeader.eip()&&
+	startObjectNumberForSP()==someVxDHeader.startObjectNumberForSP()&&
+	esp()==someVxDHeader.esp()&&
+	vxdPageSize()==someVxDHeader.vxdPageSize()&&
+	vxdLastPageSize()==someVxDHeader.vxdLastPageSize()&&
+	fixupSectionSize()==someVxDHeader.fixupSectionSize()&&
+	fixupSectionChecksum()==someVxDHeader.fixupSectionChecksum()&&
+	loaderSectionSize()==someVxDHeader.loaderSectionSize()&&
+	loaderSectionChecksum()==someVxDHeader.loaderSectionChecksum()&&
+	objectTableOffset()==someVxDHeader.objectTableOffset()&&
+	objectCount()==someVxDHeader.objectCount()&&
+	objectPageMapOffset()==someVxDHeader.objectPageMapOffset()&&
+	objectIteratedDataMapOffset()==someVxDHeader.objectIteratedDataMapOffset()&&
+	resourceTableOffset()==someVxDHeader.resourceTableOffset()&&
+	resourceEntryCount()==someVxDHeader.resourceEntryCount()&&
+	residentNameTableOffset()==someVxDHeader.residentNameTableOffset()&&
+	entryTableOffset()==someVxDHeader.entryTableOffset()&&
+	moduleDirectiveTableOffset()==someVxDHeader.moduleDirectiveTableOffset()&&
+	moduleDirectivesCount()==someVxDHeader.moduleDirectivesCount()&&
+	fixupPageTableOffset()==someVxDHeader.fixupPageTableOffset()&&
+	fixupRecordTableOffset()==someVxDHeader.fixupRecordTableOffset()&&
+	importModuleNameTableOffset()==someVxDHeader.importModuleNameTableOffset()&&
+	importModuleNameTableCount()==someVxDHeader.importModuleNameTableCount()&&
+	importProcedureNameTableOffset()==someVxDHeader.importProcedureNameTableOffset()&&
+	perPageChecksumTableOffset()==someVxDHeader.perPageChecksumTableOffset()&&
+	enumeratedDataPagesOffset()==someVxDHeader.enumeratedDataPagesOffset()&&
+	preloadPagesCount()==someVxDHeader.preloadPagesCount()&&
+	nonResidentNameTableOffset()==someVxDHeader.nonResidentNameTableOffset()&&
+	nonResidentNameTableChecksum()==someVxDHeader.nonResidentNameTableChecksum()&&
+	automaticDataObjectNumber()==someVxDHeader.automaticDataObjectNumber()&&
+	debugInfoOffset()==someVxDHeader.debugInfoOffset()&&
+	debugInfoLengthBytes()==someVxDHeader.debugInfoLengthBytes()&&
+	preloadSectionInstancePageCount()==someVxDHeader.preloadSectionInstancePageCount()&&
+	demandLoadSectionInstancePageCount()==someVxDHeader.demandLoadSectionInstancePageCount()&&
+	sizeHeap()==someVxDHeader.sizeHeap()&&
+	windowsResourceOffset()==someVxDHeader.windowsResourceOffset()&&
+	windowsResourceLength()==someVxDHeader.windowsResourceLength()&&
+	vxdID()==someVxDHeader.vxdID()&&
+	ddkVersion()==someVxDHeader.ddkVersion());
+}
+
+WORD VxDHeader::operator<<(PureViewOfFile &pureView)
+{
+  VxDObjects::remove();
+  VxDNames::remove();
+	pureView.rewind();
+  if(!(((DOSHeader&)*this)<<pureView))return FALSE;
+	pureView.seek(neHeaderAddress(),PureViewOfFile::SeekSet);
+	if(sizeof(_IMAGE_VXD_HEADER)!=pureView.read((char*)&((_IMAGE_VXD_HEADER&)*this),sizeof(_IMAGE_VXD_HEADER)))return FALSE;
+	if(!isOkay())return FALSE;
+	getObjects(pureView);
+	getNames(pureView);
+	return TRUE;
+}
+
+void VxDHeader::getObjects(PureViewOfFile &pureView)
+{
+  VxDObjects::remove();
+	pureView.seek(neHeaderAddress()+objectTableOffset(),PureViewOfFile::SeekSet);
+	for(int objIndex=0;objIndex<objectCount();objIndex++)
+	{
+	  VxDObjects::insert(&VxDObject());
+		VxDObjects::operator[](VxDObjects::size()-1)<<pureView;
+	}
+}
+
+void VxDHeader::getNames(PureViewOfFile &pureView)
+{
+  BYTE strLength;	
+	String entryName;
+	WORD entryOrdinal;
+
+  VxDNames::remove();
+	pureView.seek(neHeaderAddress()+residentNameTableOffset(),PureViewOfFile::SeekSet);
+	while(TRUE)
+	{
+	  pureView.read(strLength);
+		strLength&=0x7F;
+		if(!strLength)break;
+		entryName.reserve(strLength+1);
+		pureView.read((char*)entryName,strLength);
+		pureView.read(entryOrdinal);
+		VxDNames::insert(&VxDName(entryName,entryOrdinal));
+	}
+}

image/VXDHDR.HPP

@@ -0,0 +1,394 @@
+#ifndef _IMAGE_VXDHEADER_HPP_
+#define _IMAGE_VXDHEADER_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _IMAGE_DOSHEADER_HPP_
+#include <image/doshdr.hpp>
+#endif
+#ifndef _IMAGE_VXDOBJECTS_HPP_
+#include <image/vxdobjs.hpp>
+#endif
+#ifndef _IMAGE_VXDNAMES_HPP_
+#include <image/vxdnames.hpp>
+#endif
+
+class PureViewOfFile;
+
+class VxDHeader: private _IMAGE_VXD_HEADER, public DOSHeader, public VxDObjects, public VxDNames
+{
+public:
+	enum {LESignature=IMAGE_VXD_SIGNATURE};
+	VxDHeader(void);
+	VxDHeader(const VxDHeader &someVxDHeader);
+	virtual ~VxDHeader();
+	VxDHeader &operator=(const VxDHeader &someVxDHeader);
+	WORD operator==(const VxDHeader &someVxDHeader);
+  WORD operator<<(PureViewOfFile &pureView);
+	WORD magic(void)const;
+	BYTE byteOrdering(void)const;
+	BYTE wordOrdering(void)const;
+	DWORD exeFormatLevel(void)const;
+	WORD cpuType(void)const;
+	WORD osType(void)const;
+	DWORD moduleVersion(void)const;
+	DWORD moduleFlags(void)const;
+	DWORD moduleNumPages(void)const;
+	DWORD startObjectNumberForIP(void)const;
+	DWORD eip(void)const;
+	DWORD startObjectNumberForSP(void)const;
+	DWORD esp(void)const;
+	DWORD vxdPageSize(void)const;
+	DWORD vxdLastPageSize(void)const;
+	DWORD fixupSectionSize(void)const;
+	DWORD fixupSectionChecksum(void)const;
+	DWORD loaderSectionSize(void)const;
+	DWORD loaderSectionChecksum(void)const;
+	DWORD objectTableOffset(void)const;
+	DWORD objectCount(void)const;
+	DWORD objectPageMapOffset(void)const;
+	DWORD objectIteratedDataMapOffset(void)const;
+	DWORD resourceTableOffset(void)const;
+	DWORD resourceEntryCount(void)const;
+	DWORD residentNameTableOffset(void)const;
+	DWORD entryTableOffset(void)const;
+	DWORD moduleDirectiveTableOffset(void)const;
+	DWORD moduleDirectivesCount(void)const;
+	DWORD fixupPageTableOffset(void)const;
+	DWORD fixupRecordTableOffset(void)const;
+	DWORD importModuleNameTableOffset(void)const;
+	DWORD importModuleNameTableCount(void)const;
+	DWORD importProcedureNameTableOffset(void)const;
+	DWORD perPageChecksumTableOffset(void)const;
+	DWORD enumeratedDataPagesOffset(void)const;
+	DWORD preloadPagesCount(void)const;
+	DWORD nonResidentNameTableOffset(void)const;
+	DWORD nonResidentNameTableChecksum(void)const;
+	DWORD automaticDataObjectNumber(void)const;
+	DWORD debugInfoOffset(void)const;
+	DWORD debugInfoLengthBytes(void)const;
+	DWORD preloadSectionInstancePageCount(void)const;
+	DWORD demandLoadSectionInstancePageCount(void)const;
+	DWORD sizeHeap(void)const;
+	DWORD windowsResourceOffset(void)const;
+	DWORD windowsResourceLength(void)const;
+	WORD vxdID(void)const;
+	WORD ddkVersion(void)const;
+  WORD isOkay(void)const;
+private:
+  void getNames(PureViewOfFile &pureView);
+	void getObjects(PureViewOfFile &pureView);
+};
+
+inline
+VxDHeader::VxDHeader(void)
+{
+  ::memset((char*)&((_IMAGE_VXD_HEADER&)*this),0,sizeof(_IMAGE_VXD_HEADER));
+}
+
+inline
+VxDHeader::VxDHeader(const VxDHeader &someVxDHeader)
+{
+	*this=someVxDHeader;
+}
+
+inline
+WORD VxDHeader::magic(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_magic;
+}
+
+inline
+BYTE VxDHeader::byteOrdering(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_border;
+}
+
+inline
+BYTE VxDHeader::wordOrdering(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_worder;
+}
+
+inline
+DWORD VxDHeader::exeFormatLevel(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_level;
+}
+
+inline
+WORD VxDHeader::cpuType(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_cpu;
+}
+
+inline
+WORD VxDHeader::osType(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_os;
+}
+
+inline
+DWORD VxDHeader::moduleVersion(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_ver;
+}
+
+inline
+DWORD VxDHeader::moduleFlags(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_mflags;
+}
+
+inline
+DWORD VxDHeader::moduleNumPages(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_mpages;
+}
+
+inline
+DWORD VxDHeader::startObjectNumberForIP(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_startobj;
+}
+
+inline
+DWORD VxDHeader::eip(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_eip;
+}
+
+inline
+DWORD VxDHeader::startObjectNumberForSP(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_stackobj;
+}
+
+inline
+DWORD VxDHeader::esp(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_esp;
+}
+
+inline
+DWORD VxDHeader::vxdPageSize(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_pagesize;
+}
+
+inline
+DWORD VxDHeader::vxdLastPageSize(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_lastpagesize;
+}
+
+inline
+DWORD VxDHeader::fixupSectionSize(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_fixupsize;
+}
+
+inline
+DWORD VxDHeader::fixupSectionChecksum(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_fixupsum;
+}
+
+inline
+DWORD VxDHeader::loaderSectionSize(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_ldrsize;
+}
+
+inline
+DWORD VxDHeader::loaderSectionChecksum(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_ldrsum;
+}
+
+inline
+DWORD VxDHeader::objectTableOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_objtab;
+}
+
+inline
+DWORD VxDHeader::objectCount(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_objcnt;
+}
+
+inline
+DWORD VxDHeader::objectPageMapOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_objmap;
+}
+
+inline
+DWORD VxDHeader::objectIteratedDataMapOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_itermap;
+}
+
+inline
+DWORD VxDHeader::resourceTableOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_rsrctab;
+}
+
+inline
+DWORD VxDHeader::resourceEntryCount(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_rsrccnt;
+}
+
+inline
+DWORD VxDHeader::residentNameTableOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_restab;
+}
+
+inline
+DWORD VxDHeader::entryTableOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_enttab;
+}
+
+inline
+DWORD VxDHeader::moduleDirectiveTableOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_dirtab;
+}
+
+inline
+DWORD VxDHeader::moduleDirectivesCount(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_dircnt;
+}
+
+inline
+DWORD VxDHeader::fixupPageTableOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_fpagetab;
+}
+
+inline
+DWORD VxDHeader::fixupRecordTableOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_frectab;
+}
+
+inline
+DWORD VxDHeader::importModuleNameTableOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_impmod;
+}
+
+inline
+DWORD VxDHeader::importModuleNameTableCount(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_impmodcnt;
+}
+
+inline
+DWORD VxDHeader::importProcedureNameTableOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_impproc;
+}
+
+inline
+DWORD VxDHeader::perPageChecksumTableOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_pagesum;
+}
+
+inline
+DWORD VxDHeader::enumeratedDataPagesOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_datapage;
+}
+
+inline
+DWORD VxDHeader::preloadPagesCount(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_preload;
+}
+
+inline
+DWORD VxDHeader::nonResidentNameTableOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_nrestab;
+}
+
+inline
+DWORD VxDHeader::nonResidentNameTableChecksum(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_cbnrestab;
+}
+
+inline
+DWORD VxDHeader::automaticDataObjectNumber(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_nressum;
+}
+
+inline
+DWORD VxDHeader::debugInfoOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_autodata;
+}
+
+inline
+DWORD VxDHeader::debugInfoLengthBytes(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_debuginfo;
+}
+
+inline
+DWORD VxDHeader::preloadSectionInstancePageCount(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_instpreload;
+}
+
+inline
+DWORD VxDHeader::demandLoadSectionInstancePageCount(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_instdemand;
+}
+
+inline
+DWORD VxDHeader::sizeHeap(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_heapsize;
+}
+
+inline
+DWORD VxDHeader::windowsResourceOffset(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_winresoff;
+}
+
+inline
+DWORD VxDHeader::windowsResourceLength(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_winreslen;
+}
+
+inline
+WORD VxDHeader::vxdID(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_devid;
+}
+
+inline
+WORD VxDHeader::ddkVersion(void)const
+{
+	return _IMAGE_VXD_HEADER::e32_ddkver;
+}
+
+inline
+WORD VxDHeader::isOkay(void)const
+{
+  return LESignature==magic();
+}
+#endif

image/VXDNAME.CPP

@@ -0,0 +1,42 @@
+#include <image/vxdname.hpp>
+
+VxDName::VxDName(void)
+{
+}
+
+VxDName::VxDName(const VxDName &someVxDName)
+{
+  *this=someVxDName;
+}
+
+VxDName::VxDName(const String &entryName,WORD entryOrdinal)
+: mEntryName(entryName), mEntryOrdinal(entryOrdinal)
+{
+}
+
+VxDName &VxDName::operator=(const VxDName &someVxDName)
+{
+  entryName(someVxDName.entryName());
+  entryOrdinal(someVxDName.entryOrdinal());
+	return *this;
+}
+
+const String &VxDName::entryName(void)const
+{
+  return mEntryName;
+}
+
+void VxDName::entryName(const String &entryName)
+{
+  mEntryName=entryName;
+}
+
+WORD VxDName::entryOrdinal(void)const
+{
+  return mEntryOrdinal;
+}
+
+void VxDName::entryOrdinal(WORD entryOrdinal)
+{
+  mEntryOrdinal=entryOrdinal;
+}

image/VXDNAME.HPP

@@ -0,0 +1,22 @@
+#ifndef _IMAGE_VXDNAME_HPP_
+#define _IMAGE_VXDNAME_HPP_
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+
+class VxDName
+{
+public:
+  VxDName(void);;
+	VxDName(const VxDName &someVxDName);
+	VxDName(const String &entryName,WORD entryOrdinal);
+	VxDName &operator=(const VxDName &someVxDName);
+	const String &entryName(void)const;
+	void entryName(const String &entryName);
+	WORD entryOrdinal(void)const;
+	void entryOrdinal(WORD entryOrdinal);
+private:
+  String mEntryName;
+	WORD mEntryOrdinal;
+};
+#endif

image/VXDNAMES.HPP

@@ -0,0 +1,11 @@
+#ifndef _IMAGE_VXDNAMES_HPP_
+#define _IMAGE_VXDNAMES_HPP_
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _IMAGE_VXDNAME_HPP_
+#include <image/vxdname.hpp>
+#endif
+
+typedef Block<VxDName> VxDNames;
+#endif

image/VXDOBJ.CPP

@@ -0,0 +1,137 @@
+#include <image/vxdobj.hpp>
+#include <common/pview.hpp>
+
+VxDObject::VxDObject(void)
+{
+  zeroInit();
+}
+
+VxDObject::VxDObject(const VxDObject &someVxDObject)
+{
+  *this=someVxDObject;
+}
+
+VxDObject::~VxDObject()
+{
+}
+
+VxDObject &VxDObject::operator=(const VxDObject &someVxDObject)
+{
+  virtualSize(someVxDObject.virtualSize());
+	relocationBaseAddress(someVxDObject.relocationBaseAddress());
+	flags(someVxDObject.flags());
+	pageTableIndex(someVxDObject.pageTableIndex());
+	pageTableEntries(someVxDObject.pageTableEntries());
+	reserved(someVxDObject.reserved());
+	return *this;
+}
+
+BOOL VxDObject::operator<<(PureViewOfFile &pureView)
+{
+	if(!pureView.read(mVirtualSize))return FALSE;
+	if(!pureView.read(mRelocationBaseAddress))return FALSE;
+	if(!pureView.read(mFlags))return FALSE;
+	if(!pureView.read(mPageTableIndex))return FALSE;
+	if(!pureView.read(mPageTableEntries))return FALSE;
+	if(!pureView.read(mReserved))return FALSE;
+	return TRUE;
+}
+
+VxDObject::operator String(void)const
+{
+  String strFlags;
+
+	if(has(Readable))strFlags+="Readable";
+	if(has(Writeable)){if(!strFlags.isNull())strFlags+=",";strFlags+="Writeable";}
+	if(has(Executable)){if(!strFlags.isNull())strFlags+=",";strFlags+="Executable";}
+	if(has(Resource)){if(!strFlags.isNull())strFlags+=",";strFlags+="Resource";}
+	if(has(Discardable)){if(!strFlags.isNull())strFlags+=",";strFlags+="Discardable";}
+	if(has(Shared)){if(!strFlags.isNull())strFlags+=",";strFlags+="Shared";}
+	if(has(HasPreloadPages)){if(!strFlags.isNull())strFlags+=",";strFlags+="HasPreloadPages";}
+	if(has(HasInvalidPages)){if(!strFlags.isNull())strFlags+=",";strFlags+="HasInvalidPages";}
+	if(has(HasZeroFilledPages)){if(!strFlags.isNull())strFlags+=",";strFlags+="HasZeroFilledPages";}
+	if(has(IsResident)){if(!strFlags.isNull())strFlags+=",";strFlags+="IsResident";}
+	if(has(IsResidentAndContiguous)){if(!strFlags.isNull())strFlags+=",";strFlags+="IsResidentAndContiguous";}
+	if(has(IsResidentAndLongLockable)){if(!strFlags.isNull())strFlags+=",";strFlags+="IsResidentAndLongLockable";}
+	if(has(Reserved)){if(!strFlags.isNull())strFlags+=",";strFlags+="Reserved";}
+	if(has(Alias1616Required)){if(!strFlags.isNull())strFlags+=",";strFlags+="Alias1616Required";}
+	if(has(Big)){if(!strFlags.isNull())strFlags+=",";strFlags+="Big";}
+	if(has(IsCodeConforming)){if(!strFlags.isNull())strFlags+=",";strFlags+="IsCodeConforming";}
+	if(has(IOPrivilegeLevel)){if(!strFlags.isNull())strFlags+=",";strFlags+="IOPrivilegeLevel";}
+	return strFlags;
+}
+
+DWORD VxDObject::virtualSize(void)const
+{
+  return mVirtualSize;
+}
+
+void VxDObject::virtualSize(DWORD virtualSize)
+{
+  mVirtualSize=virtualSize;
+}
+
+DWORD VxDObject::relocationBaseAddress(void)const
+{
+  return mRelocationBaseAddress;
+}
+
+void VxDObject::relocationBaseAddress(DWORD relocationBaseAddress)
+{
+  mRelocationBaseAddress=relocationBaseAddress;
+}
+
+DWORD VxDObject::flags(void)const
+{
+  return mFlags;
+}
+
+void VxDObject::flags(DWORD flags)
+{
+  mFlags=flags;
+}
+
+DWORD VxDObject::pageTableIndex(void)const
+{
+  return mPageTableIndex;
+}
+
+void VxDObject::pageTableIndex(DWORD pageTableIndex)
+{
+  mPageTableIndex=pageTableIndex;
+}
+
+DWORD VxDObject::pageTableEntries(void)const
+{
+  return mPageTableEntries;
+}
+
+void VxDObject::pageTableEntries(DWORD pageTableEntries)
+{
+  mPageTableEntries=pageTableEntries;
+}
+
+DWORD VxDObject::reserved(void)const
+{
+  return mReserved;
+}
+
+void VxDObject::reserved(DWORD reserved)
+{
+  mReserved=reserved;
+}
+
+BOOL VxDObject::has(Flags flagBit)const
+{
+  return mFlags&(DWORD)flagBit;
+}
+
+void VxDObject::zeroInit(void)
+{
+  mVirtualSize=0;
+	mRelocationBaseAddress=0;
+	mFlags=0;
+	mPageTableIndex=0;
+	mPageTableEntries=0;
+	mReserved=0;
+}

image/VXDOBJ.HPP

@@ -0,0 +1,49 @@
+#ifndef _IMAGE_VXDOBJECT_HPP_
+#define _IMAGE_VXDOBJECT_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+
+class PureViewOfFile;
+
+class VxDObject
+{
+public:
+  enum Flags{Readable=0x0001,Writeable=0x0002,Executable=0x0004,Resource=0x0008,Discardable=0x0010,
+	           Shared=0x0020,HasPreloadPages=0x0040,HasInvalidPages=0x0080,HasZeroFilledPages=0x0100,
+						 IsResident=0x0200,IsResidentAndContiguous=0x0300,IsResidentAndLongLockable=0x0400,
+						 Reserved=0x0800,Alias1616Required=0x1000,Big=0x2000,IsCodeConforming=0x4000,
+						 IOPrivilegeLevel=0x8000};
+  VxDObject(void);
+	VxDObject(const VxDObject &someVxDObject);
+	virtual ~VxDObject();
+	VxDObject &operator=(const VxDObject &someVxDObject);
+  BOOL operator<<(PureViewOfFile &pureView);
+	operator String(void)const;
+	DWORD virtualSize(void)const;
+	void virtualSize(DWORD virtualSize);
+	DWORD relocationBaseAddress(void)const;
+	void relocationBaseAddress(DWORD relocationBaseAddress);
+	DWORD flags(void)const;
+	void flags(DWORD flags);
+	DWORD pageTableIndex(void)const;
+	void pageTableIndex(DWORD pageTableIndex);
+	DWORD pageTableEntries(void)const;
+	void pageTableEntries(DWORD pageTableEntries);
+	DWORD reserved(void)const;
+	void reserved(DWORD reserved);
+	BOOL has(Flags flagBit)const;
+private:
+  void zeroInit(void);
+
+  DWORD mVirtualSize;
+	DWORD mRelocationBaseAddress;
+	DWORD mFlags;
+	DWORD mPageTableIndex;
+	DWORD mPageTableEntries;
+	DWORD mReserved;
+};
+#endif

image/VXDOBJS.HPP

@@ -0,0 +1,11 @@
+#ifndef _IMAGE_VXDOBJECTS_HPP_
+#define _IMAGE_VXDOBJECTS_HPP_
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _IMAGE_VXDOBJ_HPP_
+#include <image/vxdobj.hpp>
+#endif
+
+typedef Block<VxDObject> VxDObjects;
+#endif

image/VXDPAGE.CPP

@@ -0,0 +1,72 @@
+#include <vxdpage.hpp>
+
+VxDPage::VxDPage(void)
+{
+  zeroInit();
+}
+
+VxDPage::VxDPage(const VxDPage &someVxDPage)
+{
+  *this=someVxDPage;
+}
+
+VxDPage::~VxDPage()
+{
+}
+
+VxDPage &VxDPage::operator=(const VxDPage &someVxDPage)
+{
+  pageDataOffset(someVxDPage.pageDataOffset());
+	dataSize(someVxDPage.dataSize());
+	flags(someVxDPage.flags());
+	return *this;
+}
+
+BOOL VxDPage::operator<<(PureViewOfFile &pureView)
+{
+  if(!pureView.read(mPageDataOffset))return FALSE;
+	if(!pureView.read(mDataSize))return FALSE;
+	if(!pureView.read(mFlags))return FALSE;
+}
+
+DWORD VxDPage::pageDataOffset(void)const
+{
+  return mPageDataOffset;
+}
+
+void VxDPage::pageDataOffset(DWORD pageDataOffset)
+{
+  mPageDataOffset=pageDataOffset;
+}
+
+DWORD VxDPage::dataSize(void)const
+{
+  return mDataSize;
+}
+
+void VxDPage::dataSize(DWORD dataSize)
+{
+  mDataSize=dataSize;
+}
+
+WORD VxDPage::flags(void)const
+{
+  return mFlags;
+}
+
+void VxDPage::flags(WORD flags)
+{
+  mFlags=flags;
+}
+
+BOOL VxDPage::has(Flags pageFlags)
+{
+  return flags()&pageFlags;
+}
+
+void VxDPage::zeroInit(void)
+{
+  mPageDataOffset=0;
+	mDataSize=0;
+	mFlags=0;
+}

image/VXDPAGE.HPP

@@ -0,0 +1,32 @@
+#ifndef _IMAGE_VXDPAGE_HPP_
+#define _IMAGE_VXDPAGE_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class PureViewOfFile;
+
+class VxDPage
+{
+public:
+  enum Flags{LegalPhysical=0x00,IteratedData=0x01,Invalid=0x02,ZeroFilled=0x03,Range=0x04};
+  VxDPage(void);
+	VxDPage(const VxDPage &someVxDPage);
+	virtual ~VxDPage();
+	VxDPage &operator=(const VxDPage &someVxDPage);
+	BOOL operator<<(PureViewOfFile &pureView);
+	DWORD pageDataOffset(void)const;
+	void pageDataOffset(DWORD pageDataOffset);
+	DWORD dataSize(void)const;
+	void dataSize(DWORD dataSize);
+	WORD flags(void)const;
+	void flags(WORD flags);
+	BOOL has(Flags pageFlags);
+private:
+  void zeroInit(void);
+
+  DWORD mPageDataOffset;
+	WORD mDataSize;
+	WORD mFlags;
+};
+#endif

image/image.001

@@ -0,0 +1,258 @@
+# Microsoft Developer Studio Project File - Name="image" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 5.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=image - 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 "image.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 "image.mak" CFG="image - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "image - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "image - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+
+!IF  "$(CFG)" == "image - 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 /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)" == "image - 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 /c
+# ADD CPP /nologo /G4 /Zp1 /MTd /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /Fp"..\exe\msvc42.pch" /YX"windows.h" /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\msimage.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "image - Win32 Release"
+# Name "image - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\Direntry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Dtaentry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Export.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Hardware.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Import.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Imresdir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Pehdr.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Sctnhdrs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Stdtmpl.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Vxdhdr.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\vxdname.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\vxdobj.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\Dbgdir.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Direntry.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Dllflags.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Doshdr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Dtaentry.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Expdir.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Expdsc.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Export.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Hardware.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Iflags.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Imagedir.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Imagehdr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Impexp.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Import.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Imresdir.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Keydir.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Ntsubsys.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Optlhdr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Pehdr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Resdrstr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Sctnhdr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Sctnhdrs.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Strptr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Thnkdata.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Thnkname.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Vxdhdr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\vxdname.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\vxdnames.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\vxdobj.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\vxdobjs.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

image/image.dsp

@@ -0,0 +1,264 @@
+# Microsoft Developer Studio Project File - Name="image" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=image - 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 "image.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 "image.mak" CFG="image - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "image - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "image - 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)" == "image - 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 /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /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
+
+!ELSEIF  "$(CFG)" == "image - 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 /c
+# ADD CPP /nologo /Gz /MTd /GX /Z7 /Od /I "\work" /I "\parts" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "__FLAT__" /D "STRICT" /Fp"..\exe\msvc42.pch" /YX"windows.h" /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\msimage.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "image - Win32 Release"
+# Name "image - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\Direntry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Dtaentry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Export.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Hardware.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Import.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Imresdir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Pehdr.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Sctnhdrs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Stdtmpl.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Vxdhdr.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\vxdname.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\vxdobj.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\Dbgdir.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Direntry.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Dllflags.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Doshdr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Dtaentry.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Expdir.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Expdsc.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Export.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Hardware.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Iflags.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Imagedir.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Imagehdr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Impexp.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Import.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Imresdir.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Keydir.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Ntsubsys.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Optlhdr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Pehdr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Resdrstr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Sctnhdr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Sctnhdrs.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Strptr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Thnkdata.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Thnkname.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Vxdhdr.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\vxdname.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\vxdnames.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\vxdobj.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\vxdobjs.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

image/image.dsw

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