--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bridge/bridge.cpp	Sat Oct 24 08:42:06 2009 +0400
@@ -0,0 +1,181 @@
+struct Symbol;
+struct dt_t;
+struct TYPE;
+struct elem;
+struct Blockx;
+struct block;
+
+typedef TYPE type;
+
+int reftoident(int a, unsigned long b, Symbol* c, unsigned long d, int e);
+
+int reftoident(int a, unsigned int b, Symbol* c, unsigned int d, int e)
+{
+	return reftoident(a, (unsigned long)b, c, (unsigned long)d, e);
+}
+
+dt_t** dtnzeros(dt_t**, unsigned long);
+
+dt_t** dtnzeros(dt_t** a, unsigned int b)
+{
+	return dtnzeros(a, (unsigned long)b);
+}
+
+TYPE* type_fake(unsigned long a);
+
+TYPE* type_fake(unsigned int a)
+{
+	return type_fake((unsigned long)a);
+}
+
+elem* el_long(unsigned long a, long long b);
+
+elem* el_long(unsigned int a, long long b)
+{
+	return el_long((unsigned long)a, b);
+}
+
+type* type_alloc(unsigned long a);
+
+type* type_alloc(unsigned int a)
+{
+	return type_alloc((unsigned long)a);
+}
+
+elem* el_bin(unsigned int a, unsigned long b, elem* c, elem* d);
+
+elem* el_bin(unsigned int a, unsigned int b, elem* c, elem* d)
+{
+	return el_bin(a, (unsigned long)b, c, d);
+}
+
+dt_t** dtnbytes(dt_t** a, unsigned long b, const char* c);
+
+dt_t** dtnbytes(dt_t** a, unsigned int b, const char* c)
+{
+	return dtnbytes(a, (unsigned long)b, c);
+}
+
+extern unsigned char tytab[];
+unsigned char* get_tytab()
+{
+	return tytab;
+}
+
+extern unsigned char tytab2[];
+unsigned char* get_tytab2()
+{
+	return tytab2;
+}
+
+extern signed char tysize[];
+signed char* get_tysize()
+{
+	return tysize;
+}
+
+type* type_setcv(type** pt, unsigned long cv);
+
+type* type_setcv(type** pt, unsigned int cv)
+{
+	return type_setcv(pt, (unsigned long) cv);
+}
+
+elem* el_una(unsigned int op, unsigned long ty, elem* e1);
+
+elem* el_una(unsigned int op, unsigned int ty, elem* e1)
+{
+	return el_una(op, (unsigned long) ty, e1);
+}
+
+type* type_allocn(unsigned long a, type* b);
+
+type* type_allocn(unsigned int a, type* b)
+{
+	return type_allocn((unsigned long)a, b);
+}
+
+void block_next(Blockx* bctx, enum BC bc, block* bn);
+
+void block_next(Blockx* bctx, int bc, block* bn)
+{
+	block_next(bctx, (enum BC)bc, bn);
+}
+
+block* block_goto(Blockx* bctx, enum BC bc, block* bn);
+
+block* block_goto(Blockx* bctx, int bc, block* bn)
+{
+	return block_goto(bctx, (enum BC)bc, bn);
+}
+
+dt_t** dtxoff(dt_t** pdtend, Symbol* s, unsigned long offset, unsigned long ty);
+
+dt_t** dtxoff(dt_t** pdtend, Symbol* s, unsigned int offset, unsigned int ty)
+{
+	return dtxoff(pdtend, s, (unsigned long)offset, (unsigned long)ty);
+}
+
+dt_t** dtabytes(dt_t** pdtend,  unsigned long ty, unsigned long offset, unsigned long size, const char* ptr);
+
+dt_t** dtabytes(dt_t** pdtend,  unsigned int ty, unsigned int offset, unsigned int size, const char* ptr)
+{
+	return dtabytes(pdtend,  (unsigned long)ty, (unsigned long)offset, (unsigned long)size, ptr);
+}
+
+dt_t** dtdword(dt_t** pdtend, long value);
+
+dt_t** dtdword(dt_t** pdtend, int value)
+{
+	return dtdword(pdtend, (long)value);
+}
+
+type* type_setty(type** a, long b);
+
+type* type_setty(type** a, int b)
+{
+	return type_setty(a, (long)b);
+}
+
+elem* el_pair(unsigned long a, elem* b, elem* c);
+
+elem* el_pair(unsigned int a, elem* b, elem* c)
+{
+	return el_pair((unsigned long)a, b, c);
+}
+
+extern unsigned char rel_not[];
+extern unsigned char rel_swap[];
+extern unsigned char rel_integral[];
+extern unsigned char rel_exception[];
+extern unsigned char rel_unord[];
+
+unsigned char* get_rel_not() { return rel_not; }
+unsigned char* get_rel_swap() { return rel_swap; }
+unsigned char* get_rel_integral() { return rel_integral; }
+unsigned char* get_rel_exception() { return rel_exception; }
+unsigned char* get_rel_unord() { return rel_unord; }
+
+unsigned long type_paramsize(type* t);
+unsigned int type_paramsize_i(type* t)
+{
+	return (unsigned int)type_paramsize(t);
+}
+
+void cod3_thunk(Symbol* sthunk, Symbol* sfunc, unsigned int p, unsigned long thisty, unsigned long d, int i, unsigned long d2);
+void cod3_thunk(Symbol* sthunk, Symbol* sfunc, unsigned int p, unsigned int  thisty, unsigned int  d, int i, unsigned int  d2)
+{
+	return cod3_thunk(sthunk, sfunc, p, (unsigned long)thisty, (unsigned long)d, i, (unsigned long)d2);
+}
+
+elem* el_const(unsigned long a, union eve* b);
+elem* el_const(unsigned int a, union eve* b)
+{
+	return el_const((unsigned long)a, b);
+}
+
+extern const unsigned long tytouns[];
+unsigned int* get_tytouns()
+{
+	return (unsigned int*)tytouns;
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/build.bat	Sat Oct 24 08:42:06 2009 +0400
@@ -0,0 +1,2 @@
+@echo off
+cls && c:\dm\bin\dmc.exe bridge\bridge.cpp -c && c:\dmd_2.031\windows\bin\dmd.exe @commands.txt
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/commands.txt	Sat Oct 24 08:42:06 2009 +0400
@@ -0,0 +1,382 @@
+-g
+-debug
+-version=DMDV2
+-version=TX86
+-version=MARS
+-version=TARGET_WINDOS
+-version=_WIN32
+-version=WindowsXP
+-version=DumbClone
+-version=STRUCTTHISREF
+-version=CCASTSYNTAX
+-version=CARRAYDECL
+-version=BREAKABI
+-version=SEH
+-version=OMFOBJ
+-version=SNAN_DEFAULT_INIT
+-ofc:\dmd_2.032\windows\bin\dmd.exe
+bridge.obj
+ddmd.def
+c:\dmd_2.032\src\dmd\dmd.lib
+main.d
+win32\windef.d
+win32\winuser.d
+win32\wingdi.d
+dlib\CrashHandler.d
+dbg\ui\CrashWindow.d
+dbg\Debug.d
+dbg\symbol\CodeView.d
+dbg\image\PE.d
+dmd\AggregateDeclaration.d
+dmd\VarExp.d
+dmd\Tuple.d
+dmd\UnrolledLoopStatement.d
+dmd\SwitchErrorStatement.d
+dmd\NewAnonClassExp.d
+dmd\StructLiteralExp.d
+dmd\StaticIfCondition.d
+dmd\BoolExp.d
+dmd\ShlAssignExp.d
+dmd\ShrAssignExp.d
+dmd\UshrAssignExp.d
+dmd\CatAssignExp.d
+dmd\Port.d
+dmd\declaration\MATCH.d
+dmd\expression\Util.d
+dmd\expression\Add.d
+dmd\expression\Xor.d
+dmd\expression\Ptr.d
+dmd\expression\Min.d
+dmd\expression\And.d
+dmd\expression\Shr.d
+dmd\expression\Not.d
+dmd\expression\Mod.d
+dmd\expression\Mul.d
+dmd\expression\Com.d
+dmd\expression\Ushr.d
+dmd\expression\Shl.d
+dmd\expression\Div.d
+dmd\expression\Cmp.d
+dmd\expression\Identity.d
+dmd\expression\ArrayLength.d
+dmd\expression\Equal.d
+dmd\expression\Or.d
+dmd\expression\Neg.d
+dmd\expression\Cat.d
+dmd\expression\Slice.d
+dmd\expression\Index.d
+dmd\expression\shift_optimize.d
+dmd\expression\util\arrayTypeCompatible.d
+dmd\condition\util\findCondition.d
+dmd\OverExp.d
+dmd\Cast.d
+dmd\TupleExp.d
+dmd\ArrayLengthExp.d
+dmd\TypeInfoConstDeclaration.d
+dmd\TypeInfoInvariantDeclaration.d
+dmd\TypeInfoSharedDeclaration.d
+dmd\TypeInfoStructDeclaration.d
+dmd\TypeInfoInterfaceDeclaration.d
+dmd\TypeInfoEnumDeclaration.d
+dmd\TypeInfoClassDeclaration.d
+dmd\TypeInfoArrayDeclaration.d
+dmd\TypeInfoDelegateDeclaration.d
+dmd\TypeInfoTypedefDeclaration.d
+dmd\TypeInfoPointerDeclaration.d
+dmd\DsymbolExp.d
+dmd\GlobalExpressions.d
+dmd\NewExp.d
+dmd\PeelStatement.d
+dmd\HaltExp.d
+dmd\SymOffExp.d
+dmd\type\Util.d
+dmd\SymbolExp.d
+dmd\Optimize.d
+dmd\DotVarExp.d
+dmd\DeclarationExp.d
+dmd\TraitsExp.d
+dmd\ComplexExp.d
+dmd\ErrorExp.d
+dmd\AssignExp.d
+dmd\DotExp.d
+dmd\AliasDeclaration.d
+dmd\DefaultInitExp.d
+dmd\FileInitExp.d
+dmd\LineInitExp.d
+dmd\AnonDeclaration.d
+dmd\AliasThis.d
+dmd\AlignDeclaration.d
+dmd\AnonymousAggregateDeclaration.d
+dmd\Argument.d
+dmd\FuncExp.d
+dmd\ArrayLiteralExp.d
+dmd\AssocArrayLiteralExp.d
+dmd\AssertExp.d
+dmd\IsExp.d
+dmd\TypeExp.d
+dmd\StringExp.d
+dmd\NullExp.d
+dmd\RealExp.d
+dmd\ThisExp.d
+dmd\ScopeExp.d
+dmd\Array.d
+dmd\DotIdExp.d
+dmd\FileExp.d
+dmd\SuperExp.d
+dmd\TypeidExp.d
+dmd\CompileExp.d
+dmd\IdentifierExp.d
+dmd\DollarExp.d
+dmd\ArrayT.d
+dmd\AndAndExp.d
+dmd\DotTemplateInstanceExp.d
+dmd\OrExp.d
+dmd\PostExp.d
+dmd\CallExp.d
+dmd\SliceExp.d
+dmd\ArrayExp.d
+dmd\AddrExp.d
+dmd\UAddExp.d
+dmd\XorExp.d
+dmd\CommaExp.d
+dmd\BinExp.d
+dmd\CondExp.d
+dmd\OrOrExp.d
+dmd\AndExp.d
+dmd\InExp.d
+dmd\EqualExp.d
+dmd\CmpExp.d
+dmd\ShlExp.d
+dmd\AddExp.d
+dmd\CatExp.d
+dmd\MinExp.d
+dmd\MulExp.d
+dmd\ModExp.d
+dmd\DivExp.d
+dmd\ShrExp.d
+dmd\UshrExp.d
+dmd\CastExp.d
+dmd\DeleteExp.d
+dmd\ComExp.d
+dmd\NotExp.d
+dmd\UnaExp.d
+dmd\NegExp.d
+dmd\PtrExp.d
+dmd\IntegerExp.d
+dmd\AddAssignExp.d
+dmd\AndAssignExp.d
+dmd\DivAssignExp.d
+dmd\MinAssignExp.d
+dmd\ModAssignExp.d
+dmd\MulAssignExp.d
+dmd\OrAssignExp.d
+dmd\XorAssignExp.d
+dmd\IdentityExp.d
+dmd\ArrayInitializer.d
+dmd\ArrayScopeSymbol.d
+dmd\ArrayTypes.d
+dmd\AsmStatement.d
+dmd\AttribDeclaration.d
+dmd\BUILTIN.d
+dmd\BaseClass.d
+dmd\BreakStatement.d
+dmd\CaseRangeStatement.d
+dmd\CaseStatement.d
+dmd\Catch.d
+dmd\ClassDeclaration.d
+dmd\ClassInfoDeclaration.d
+dmd\CompileDeclaration.d
+dmd\CompileStatement.d
+dmd\CompoundDeclarationStatement.d
+dmd\CompoundStatement.d
+dmd\Condition.d
+dmd\ConditionalDeclaration.d
+dmd\ConditionalStatement.d
+dmd\ContinueStatement.d
+dmd\CppMangleState.d
+dmd\CtorDeclaration.d
+dmd\DVCondition.d
+dmd\Dchar.d
+dmd\DebugCondition.d
+dmd\DebugSymbol.d
+dmd\Declaration.d
+dmd\DeclarationStatement.d
+dmd\DefaultStatement.d
+dmd\DeleteDeclaration.d
+dmd\DoStatement.d
+dmd\DocComment.d
+dmd\Dsymbol.d
+dmd\DsymbolTable.d
+dmd\DtorDeclaration.d
+dmd\EnumDeclaration.d
+dmd\EnumMember.d
+dmd\Escape.d
+dmd\ExpInitializer.d
+dmd\ExpStatement.d
+dmd\Expression.d
+dmd\File.d
+dmd\FileName.d
+dmd\ForStatement.d
+dmd\ForeachRangeStatement.d
+dmd\ForeachStatement.d
+dmd\FuncAliasDeclaration.d
+dmd\FuncDeclaration.d
+dmd\FuncLiteralDeclaration.d
+dmd\Global.d
+dmd\GotoCaseStatement.d
+dmd\GotoDefaultStatement.d
+dmd\GotoStatement.d
+dmd\HdrGenState.d
+dmd\ILS.d
+dmd\IRState.d
+dmd\Id.d
+dmd\Identifier.d
+dmd\IfStatement.d
+dmd\Import.d
+dmd\Initializer.d
+dmd\InlineCostState.d
+dmd\InlineDoState.d
+dmd\InlineScanState.d
+dmd\IntRange.d
+dmd\InterState.d
+dmd\InterfaceDeclaration.d
+dmd\InvariantDeclaration.d
+dmd\LINK.d
+dmd\LabelDsymbol.d
+dmd\LabelStatement.d
+dmd\Lexer.d
+dmd\Library.d
+dmd\LinkDeclaration.d
+dmd\Loc.d
+dmd\Lstring.d
+dmd\MATCH.d
+dmd\Macro.d
+dmd\Module.d
+dmd\ModuleDeclaration.d
+dmd\ModuleInfoDeclaration.d
+dmd\NewDeclaration.d
+dmd\ObjModule.d
+dmd\OnScopeStatement.d
+dmd\OutBuffer.d
+dmd\OverloadSet.d
+dmd\PREC.d
+dmd\PROT.d
+dmd\Package.d
+dmd\Param.d
+dmd\Parser.d
+dmd\PostBlitDeclaration.d
+dmd\PragmaDeclaration.d
+dmd\PragmaStatement.d
+dmd\ProtDeclaration.d
+dmd\RET.d
+dmd\ReturnStatement.d
+dmd\STC.d
+dmd\Scope.d
+dmd\ScopeDsymbol.d
+dmd\ScopeStatement.d
+dmd\Section.d
+dmd\Statement.d
+dmd\StaticAssert.d
+dmd\StaticAssertStatement.d
+dmd\StaticCtorDeclaration.d
+dmd\StaticDtorDeclaration.d
+dmd\StaticIfDeclaration.d
+dmd\StorageClassDeclaration.d
+dmd\String.d
+dmd\StringEntry.d
+dmd\StringTable.d
+dmd\StringValue.d
+dmd\StructDeclaration.d
+dmd\StructInitializer.d
+dmd\SwitchStatement.d
+dmd\SymbolDeclaration.d
+dmd\SynchronizedStatement.d
+dmd\TOK.d
+dmd\TY.d
+dmd\TemplateAliasParameter.d
+dmd\TemplateDeclaration.d
+dmd\TemplateInstance.d
+dmd\TemplateMixin.d
+dmd\TemplateParameter.d
+dmd\TemplateThisParameter.d
+dmd\TemplateTupleParameter.d
+dmd\TemplateTypeParameter.d
+dmd\TemplateValueParameter.d
+dmd\ThisDeclaration.d
+dmd\ThrowStatement.d
+dmd\Token.d
+dmd\TryCatchStatement.d
+dmd\TryFinallyStatement.d
+dmd\TupleDeclaration.d
+dmd\Type.d
+dmd\TypeAArray.d
+dmd\TypeArray.d
+dmd\TypeBasic.d
+dmd\TypeClass.d
+dmd\TypeDArray.d
+dmd\TypeDelegate.d
+dmd\TypeEnum.d
+dmd\TypeFunction.d
+dmd\TypeIdentifier.d
+dmd\TypeInfoDeclaration.d
+dmd\TypeInstance.d
+dmd\TypeNext.d
+dmd\TypePointer.d
+dmd\TypeQualified.d
+dmd\TypeReference.d
+dmd\TypeReturn.d
+dmd\TypeSArray.d
+dmd\EnumUtils.d
+dmd\TypeSlice.d
+dmd\TypeStruct.d
+dmd\TypeTuple.d
+dmd\TypeTypedef.d
+dmd\TypeTypeof.d
+dmd\TypedefDeclaration.d
+dmd\UnionDeclaration.d
+dmd\UnitTestDeclaration.d
+dmd\Utf.d
+dmd\Util.d
+dmd\DotTemplateExp.d
+dmd\DelegateExp.d
+dmd\RemoveExp.d
+dmd\TemplateExp.d
+dmd\DotTypeExp.d
+dmd\IndexExp.d
+dmd\VarDeclaration.d
+dmd\VersionCondition.d
+dmd\VersionSymbol.d
+dmd\VoidInitializer.d
+dmd\VolatileStatement.d
+dmd\WhileStatement.d
+dmd\WithScopeSymbol.d
+dmd\WithStatement.d
+dmd\backend\Blockx.d
+dmd\backend\enum_t.d
+dmd\backend\Symbol.d
+dmd\backend\Util.d
+dmd\backend\TYPE.d
+dmd\backend\TYM.d
+dmd\backend\mTY.d
+dmd\backend\block.d
+dmd\backend\code.d
+dmd\backend\glue.d
+dmd\backend\dt_t.d
+dmd\backend\elem.d
+dmd\backend\func_t.d
+dmd\backend\Cstate.d
+dmd\backend\TYFL.d
+dmd\backend\RTLSYM.d
+dmd\backend\symtab_t.d
+dmd\backend\Classsym.d
+dmd\backend\con_t.d
+dmd\backend\cse_t.d
+dmd\backend\struct_t.d
+dmd\backend\OPER.d
+dmd\backend\StringTab.d
+dmd\backend\DT.d
+dmd\backend\Configv.d
+dmd\backend\iasm.d
+dmd\backend\rel.d
+dmd\backend\LIST.d
+dmd\codegen\Util.d
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dbg/Debug.d	Sat Oct 24 08:42:06 2009 +0400
@@ -0,0 +1,33 @@
+/**
+ Common interfaces for the debugging package.
+
+ Authors:
+	Jeremie Pelletier
+*/
+module dbg.Debug;
+
+interface IExecutableImage {
+	uint codeOffset() const;
+
+	ISymbolicDebugInfo debugInfo();
+}
+
+interface ISymbolicDebugInfo {
+	SymbolInfo ResolveSymbol(size_t rva) const;
+	FileLineInfo ResolveFileLine(size_t rva) const;
+}
+
+struct SymbolInfo {
+	string	name;
+	uint	offset;
+}
+
+struct FileLineInfo {
+	string	file;
+	uint	line;
+}
+
+void SystemException()
+{
+	throw new Exception("SystemException");
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dbg/image/PE.d	Sat Oct 24 08:42:06 2009 +0400
@@ -0,0 +1,361 @@
+/**
+ A simple PE/COFF image format reader.
+
+ Authors:
+	Jeremie Pelletier
+
+ References:
+	$(LINK http://www.csn.ul.ie/~caolan/publink/winresdump/winresdump/doc/pefile.html)
+
+ License:
+	Public Domain
+*/
+module dbg.image.PE;
+
+version(Windows) {
+
+import std.c.string : strncmp;
+import dbg.Debug;
+import dbg.symbol.CodeView;
+//import dbg.symbol.COFF;
+//import sys.windows.FileSystem;
+//import sys.windows.Memory;
+//import sys.windows.Security : GENERIC_READ;
+//import sys.windows.Information : CloseHandle;
+//import sys.windows.Image;
+
+import win32.windows;
+import win32.winbase;
+
+enum IMAGE_SIZEOF_NT_OPTIONAL64_HEADER = 240;
+
+struct IMAGE_NT_HEADERS64 {
+    DWORD Signature;
+    IMAGE_FILE_HEADER FileHeader;
+    IMAGE_OPTIONAL_HEADER64 OptionalHeader;
+}
+
+auto IMAGE_FIRST_SECTION64( const(IMAGE_NT_HEADERS64*) ntheader ) {
+	return cast(PIMAGE_SECTION_HEADER) ((cast(UINT_PTR)ntheader) + IMAGE_NT_HEADERS64.OptionalHeader.offsetof + (cast(PIMAGE_NT_HEADERS64)(ntheader)).FileHeader.SizeOfOptionalHeader);
+}
+
+auto IMAGE_FIRST_SECTION32( const(IMAGE_NT_HEADERS32*) ntheader ) {
+	return cast(PIMAGE_SECTION_HEADER)((cast(UINT_PTR)ntheader) + IMAGE_NT_HEADERS32.OptionalHeader.offsetof + (cast(PIMAGE_NT_HEADERS32)ntheader).FileHeader.SizeOfOptionalHeader);
+}
+
+class PEImage : IExecutableImage {
+	/**
+	 Loads and validate the image file.
+
+	 Params:
+		fileName =	Path to the image file.
+	*/
+	this(string fileName)
+	in {
+		assert(fileName.length && fileName.ptr);
+	}
+	body {
+		_filename = fileName;
+
+		// Create the file mapping
+		_file = CreateFileA((fileName ~ '\0').ptr, GENERIC_READ, FILE_SHARE_READ,
+			null, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, null);
+		if(_file == INVALID_HANDLE_VALUE) SystemException();
+
+		GetFileSizeEx(_file, &_fileSize);
+
+		_map = CreateFileMapping(_file, null, PAGE_READONLY, 0, 0, null);
+		if(!_map) SystemException();
+
+		_view = cast(const(ubyte)*)MapViewOfFile(_map, FILE_MAP_READ, 0, 0, 0);
+		if(!_view) SystemException();
+
+		// Verify image headers
+		if(_dos.e_magic != IMAGE_DOS_SIGNATURE) goto Error;
+		CheckOffset(_dos.e_lfanew);
+
+		_nt = cast(IMAGE_NT_HEADERS32*)(_view + _dos.e_lfanew);
+		if(_nt.Signature != IMAGE_NT_SIGNATURE) goto Error;
+
+		_is64 = _nt.FileHeader.SizeOfOptionalHeader == IMAGE_SIZEOF_NT_OPTIONAL64_HEADER;
+
+		if(_is64) {
+			if(_nt64.OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR64_MAGIC)
+				goto Error;
+		}
+		else {
+			if(_nt.OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC)
+				goto Error;
+		}
+
+		// Create the RVA lookup table
+		auto sections = this.sections;
+		RVAEntry* e = void;
+		_rvaTable.length = sections.length;
+		foreach(i, ref s; sections) with(s) {
+			e = &_rvaTable[i];
+			e.start = VirtualAddress;
+			e.end = VirtualAddress + SizeOfRawData;
+			e.base = PointerToRawData;
+		}
+
+		return;
+
+	Error:
+		throw new PEInvalidException(this);
+	}
+
+	/**
+	 Unloads the PE file.
+	*/
+	~this() {
+		if(_dos && !UnmapViewOfFile(cast(void*)_dos)) SystemException();
+		if(_map && !CloseHandle(_map)) SystemException();
+		if(_file && !CloseHandle(_file)) SystemException();
+	}
+
+	/**
+	 Get the filename of the image
+	*/
+	string filename() const {
+		return _filename;
+	}
+
+	/**
+	 Get whether the image uses the 64bit structures or not
+	*/
+	bool is64() const {
+		return _is64;
+	}
+
+	/**
+	 Get the base address of the image
+	*/
+	long imageBase() const {
+		return _is64 ? _nt64.OptionalHeader.ImageBase : _nt.OptionalHeader.ImageBase;
+	}
+
+	/**
+	 Get the raw image data
+	*/
+	const(ubyte)[] data() const {
+		return _view[0 .. cast(size_t)_fileSize.QuadPart];
+	}
+
+	/**
+	 Get the dos, nt or nt64 headers
+	*/
+	const(IMAGE_DOS_HEADER)* dosHeader() const { return _dos; }
+	const(IMAGE_NT_HEADERS32)* ntHeaders32() const { return _nt; }
+	const(IMAGE_NT_HEADERS64)* ntHeaders64() const { return _nt64; }
+
+	/**
+	 Get the array of data directories
+	*/
+	const(IMAGE_DATA_DIRECTORY)[] dataDirectory() const {
+		return _is64 ? _nt64.OptionalHeader.DataDirectory : _nt.OptionalHeader.DataDirectory;
+	}
+
+	/**
+	 Get the array of section headers
+	*/
+	const(IMAGE_SECTION_HEADER)[] sections() const {
+		return (_is64 ? IMAGE_FIRST_SECTION64(_nt64) : IMAGE_FIRST_SECTION32(_nt))
+			[0 .. _nt.FileHeader.NumberOfSections];
+	}
+
+	/**
+	 Translate the given Virtual Address to its corresponding data offset.
+	*/
+	long LookupVA(long va) const {
+		return LookupRVA(va - imageBase);
+	}
+
+	/**
+	 Translate the given Relative Virtual Address to its corresponding
+	 data offset.
+	*/
+	long LookupRVA(long rva) const {
+		foreach(ref e; _rvaTable) with(e) {
+			if(rva >= start && rva < end) {
+				long offset = base + (rva - start);
+				CheckOffset(offset);
+				return offset;
+			}
+		}
+
+		return 0;
+	}
+
+	/**
+	 Get a data structure in the image from its RVA
+	*/
+	const(T)* GetDataFromRVA(T : T*)(long rva) const {
+		long offset = LookupRVA(rva);
+		return offset ? cast(T*)(_view + offset) : null;
+	}
+
+	/**
+	 Get a data directory in the image from its ID
+	*/
+	const(T)* GetDirectory(T)(uint id) const {
+		const IMAGE_DATA_DIRECTORY* dir = &dataDirectory[id];
+		return dir.VirtualAddress && dir.Size ?
+			GetDataFromRVA!(T*)(dir.VirtualAddress) : null;
+	}
+
+	/**
+	 Find the first section matching the given flags mask
+	*/
+	const(IMAGE_SECTION_HEADER)* FindSection(uint mask) const
+	in {
+		assert(mask);
+	}
+	body {
+		foreach(ref section; sections)
+			if(section.Characteristics & mask)
+				return &section;
+
+		return null;
+	}
+
+	/**
+	 Find a section by its name
+	*/
+	const(IMAGE_SECTION_HEADER)* FindSection(string name) const
+	in {
+		assert(name.length && name.ptr);
+	}
+	body {
+		foreach(ref section; sections)
+			if(strncmp(cast(char*)section.Name.ptr, name.ptr, section.Name.length) == 0)
+				return &section;
+
+		return null;
+	}
+
+	/**
+	 Get the offset to the code segment
+	*/
+	uint codeOffset() const {
+		const(IMAGE_SECTION_HEADER)* section = FindSection(IMAGE_SCN_MEM_EXECUTE);
+		return section ? section.VirtualAddress : 0;
+	}
+
+	/**
+	 Get the symbolic debug info object for this image
+	*/
+	ISymbolicDebugInfo debugInfo() {
+		uint va = _nt.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress;
+		if(!va) return null;
+
+		const(IMAGE_DEBUG_DIRECTORY)* dir = void;
+		uint size = _nt.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size;
+		uint offset = void;
+
+		// Borland directory
+		const(IMAGE_SECTION_HEADER)* section = FindSection(".debug");
+		if(section && section.VirtualAddress == va) {
+			CheckOffset(section.PointerToRawData);
+
+			dir = cast(IMAGE_DEBUG_DIRECTORY*)(_view + section.PointerToRawData);
+		}
+		// Microsoft directory
+		else {
+			section = FindSection(".rdata");
+			if(!section) goto NoDebug;
+
+			offset = section.PointerToRawData + (va - section.VirtualAddress);
+			CheckOffset(offset);
+
+			dir = cast(IMAGE_DEBUG_DIRECTORY*)(_view + offset);
+		}
+
+		const(void)* end = cast(void*)dir + size;
+		Scan: for(; dir < end; dir++) {
+			switch(dir.Type) {
+			//case IMAGE_DEBUG_TYPE_COFF:
+			case IMAGE_DEBUG_TYPE_CODEVIEW:
+			// TODO: support more types
+				break Scan;
+
+			default:
+			}
+		}
+
+		if(dir >= end) goto NoDebug;
+
+		offset = dir.PointerToRawData + dir.SizeOfData;
+		CheckOffset(offset);
+		auto debugView = _view[dir.PointerToRawData .. offset];
+
+		switch(dir.Type) {
+		//case IMAGE_DEBUG_TYPE_COFF:
+		//	return new COFFDebugInfo(debugView);
+		case IMAGE_DEBUG_TYPE_CODEVIEW:
+			return new CodeViewDebugInfo(debugView);
+		default:
+			assert(0);
+		}
+
+	NoDebug:
+		// TODO: we have no debug section or directory, but there csould still
+		// be external symbol files we can use.
+		return null;
+	}
+
+private:
+
+	/**
+	 Verify a file offset before accessing it
+	*/
+	void CheckOffset(long offset) const {
+		if(offset > _fileSize.QuadPart) throw new PECorruptedException(this);
+	}
+
+	string							_filename;
+	HANDLE							_file;
+	HANDLE							_map;
+	LARGE_INTEGER					_fileSize;
+	bool							_is64;
+
+	union {
+		const(ubyte)*				_view;
+		const(IMAGE_DOS_HEADER)*	_dos;
+	}
+	union {
+		const(IMAGE_NT_HEADERS32)*	_nt;
+		const(IMAGE_NT_HEADERS64)*	_nt64;
+	}
+
+	struct RVAEntry {
+		uint start;
+		uint end;
+		uint base;
+	}
+
+	RVAEntry[] _rvaTable;
+}
+
+/// Thrown if file open failed.
+class PEException : Exception {
+	this(string msg) {
+		super("PEImage: " ~ msg);
+	}
+}
+
+/// Thrown if not a valid module file
+class PEInvalidException : PEException {
+	this(in PEImage img) {
+		super("Invalid PE file.");
+	}
+}
+
+/// Thrown on corrupted module file.
+class PECorruptedException : PEException {
+	this(in PEImage img) {
+		super("Corrupted PE file.");
+	}
+}
+
+} // version(Windows)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dbg/symbol/CodeView.d	Sat Oct 24 08:42:06 2009 +0400
@@ -0,0 +1,1759 @@
+/**
+ This module is used to extract CodeView symbolic debugging information and to
+ perform queries upon that information.
+
+ TODO:
+	* Add support for CodeView 5.0 and PDB formats.
+	* Add support to extract type information.
+
+ Authors:
+	Jeremie Pelletier
+
+ References:
+	$(LINK http://www.x86.org/ftp/manuals/tools/sym.pdf)
+	$(LINK http://undocumented.rawol.com/sbs-w2k-1-windows-2000-debugging-support.pdf)
+	$(LINK http://www.microsoft.com/msj/0399/hood/hood0399.aspx)
+	$(LINK http://source.winehq.org/source/include/wine/mscvpdb.h)
+	$(LINK http://www.digitalmars.com/d/2.0/abi.html)
+
+ License:
+	Public Domain
+*/
+module dbg.symbol.CodeView;
+
+import dbg.Debug;
+
+class CodeViewDebugInfo : ISymbolicDebugInfo {
+	/**
+	 Load CodeView data from the given memory view.
+	*/
+	this(in void[] view)
+	in {
+		assert(view.length && view.ptr);
+	}
+	body {
+		_view = view;
+
+		auto header = cast(CV_HEADER*)_view.ptr;
+		CheckOffset(header.offset);
+
+		// TODO: Only supporting NB09 (CodeView 4.10) right now
+		if(!header.signature == CV_SIGNATURE_NB09)
+			throw new CodeViewUnsupportedException(this);
+
+		auto dir = cast(CV_DIRECTORY*)(view.ptr + header.offset);
+		if(dir.dirSize != CV_DIRECTORY.sizeof || dir.entrySize != CV_ENTRY.sizeof)
+			throw new CodeViewCorruptedException(this);
+
+		CvModule globalModule;
+		_modules ~= globalModule;
+
+		foreach(ref e; dir.entries) {
+			CheckOffset(e.offset);
+
+			switch(e.sst) {
+			case sstModule:			ParseModule(&e);		break;
+			case sstLibraries:		ParseLibraries(&e);		break;
+			case sstAlignSym:		ParseAlignSymbols(&e);	break;
+			case sstSrcModule:		ParseSrcModule(&e);		break;
+			case sstGlobalPub:
+			case sstStaticSym:
+			case sstGlobalSym:		ParseHashSymbols(&e);	break;
+			case sstGlobalTypes:	ParseGlobalTypes(&e);	break;
+
+			// TODO:
+			/*case sstFileIndex:
+			case sstSegMap:
+			case sstSegName:*/
+
+			default:
+			}
+		}
+	}
+
+	/**
+	 Get the procedure symbol matching the given address.
+	*/
+	SymbolInfo ResolveSymbol(size_t rva) const
+	in {
+		assert(rva);
+	}
+	body {
+		SymbolInfo symbol;
+
+		foreach(ref m; _modules[0 .. _maxSymModule + 1])
+			if(m.symbols.QueryProc(rva, &symbol))
+				goto Found;
+
+		foreach(ref m; _modules[0 .. _maxSymModule + 1])
+			if(m.symbols.QueryCodeData(rva, &symbol))
+				goto Found;
+
+	Found:
+		return symbol;
+	}
+
+	/**
+	 Get the file/line mapping corresponding to the given relative address.
+	*/
+	FileLineInfo ResolveFileLine(size_t rva) const
+	in {
+		assert(rva);
+	}
+	body {
+		FileLineInfo fileLine;
+
+		if(_maxSrcModule)
+			foreach(m; _modules[1 .. _maxSrcModule + 1])
+				if(m.src.Query(rva, &fileLine))
+					break;
+
+		return fileLine;
+	}
+
+private:
+
+	void ParseModule(in CV_ENTRY* e) {
+		auto mod = cast(CV_MODULE*)(_view.ptr + e.offset);
+
+		if(e.modIndex != _modules.length || mod.style != CV_MOD_STYLE)
+			throw new CodeViewCorruptedException(this);
+
+		with(*mod)
+		_modules ~= CvModule(overlay, lib, segments, name.name);
+	}
+
+	void ParseLibraries(in CV_ENTRY* e) {
+		if(e.modIndex != ushort.max) throw new CodeViewCorruptedException(this);
+
+		auto name = cast(OMF_NAME*)(_view.ptr + e.offset);
+		auto end = cast(const(void)*)name + e.size;
+
+		while(name < end) {
+			if(name.len) _libraries ~= name.name;
+
+			name = cast(OMF_NAME*)(cast(void*)name + 1 + name.len);
+		}
+	}
+
+	void ParseAlignSymbols(in CV_ENTRY* e) {
+		if(e.modIndex == ushort.max || e.modIndex <= 0 || e.modIndex >= _modules.length)
+			throw new CodeViewCorruptedException(this);
+
+		if(e.modIndex > _maxSymModule) _maxSymModule = e.modIndex;
+
+		auto sym = cast(CV_SYMBOL*)(_view.ptr + e.offset);
+
+		if(sym.header.type == 0) sym = cast(CV_SYMBOL*)(cast(void*)sym + 4);
+
+		_modules[e.modIndex].symbols.Init(sym, cast(void*)sym + e.size);
+	}
+
+	void ParseHashSymbols(in CV_ENTRY* e) {
+		if(e.modIndex != ushort.max) throw new CodeViewCorruptedException(this);
+
+		auto hash = cast(CV_SYMHASH*)(_view.ptr + e.offset);
+		auto p = cast(void*)hash + CV_SYMHASH.sizeof;
+
+		_modules[0].symbols.Init(cast(CV_SYMBOL*)p, p + hash.symInfoSize);
+	}
+
+	void ParseSrcModule(in CV_ENTRY* e) {
+		if(e.modIndex == ushort.max || e.modIndex <= 0 || e.modIndex >= _modules.length)
+			throw new CodeViewCorruptedException(this);
+
+		if(e.modIndex > _maxSrcModule) _maxSrcModule = e.modIndex;
+
+		auto src = cast(CV_SRCMODULE*)(_view.ptr + e.offset);
+
+		with(_modules[e.modIndex].src) {
+			data = src;
+			fileOffsets = src.fileOffsets;
+			codeOffsets = src.codeOffsets;
+			segmentIds = src.segmentIds;
+		}
+	}
+
+	void ParseGlobalTypes(in CV_ENTRY* e) {
+		if(e.modIndex != ushort.max) throw new CodeViewCorruptedException(this);
+
+		// TODO: this currently crash stuff randomly
+		/*auto header = cast(CV_GLOBALTYPES*)(_view.ptr + e.offset);
+		_types.Init(header, cast(void*)header + e.size);*/
+	}
+
+	void CheckOffset(int offset) {
+		if(offset > _view.length) throw new CodeViewCorruptedException(this);
+	}
+
+	const(void)[]	_view;
+
+	CvModule[]		_modules;
+	uint			_maxSymModule;
+	uint			_maxSrcModule;
+	string[]		_libraries;
+	CvTypes			_types;
+}
+
+abstract class CodeViewException : Exception {
+	this(string msg) {
+		super(msg);
+	}
+}
+
+class CodeViewUnsupportedException : CodeViewException {
+	this(in CodeViewDebugInfo cv) {
+		super("CodeView version unsupported.");
+	}
+}
+
+class CodeViewCorruptedException : CodeViewException {
+	this(in CodeViewDebugInfo cv) {
+		super("Corrupted CodeView data.");
+	}
+}
+
+private:
+alias int cmp_t;
+uint BinarySearch(scope cmp_t delegate(uint i) dg, uint low, uint high) {
+	if(high < low) return uint.max;
+
+	uint mid = low + ((high - low) / 2);
+	cmp_t cmp = dg(mid);
+
+	if(cmp > 0) return BinarySearch(dg, low, mid - 1);
+	if(cmp < 0) return BinarySearch(dg, mid + 1, high);
+	return mid;
+}
+
+uint BinarySearch(in uint[] a, uint value, uint low, uint high) {
+	if(high < low) return uint.max;
+
+	uint mid = low + ((high - low) / 2);
+
+	if(a[mid] > value) return BinarySearch(a, value, low, mid - 1);
+	if(a[mid] < value) return BinarySearch(a, value, mid + 1, high);
+	return mid;
+}
+
+struct CvModule {
+	ushort			overlay;
+	ushort			lib;
+	CV_SEGMENT[]	segments;
+	string			name;
+
+	CvSymbols		symbols;
+	CvSrcModule		src;
+}
+
+struct CvSymbols {
+	ubyte		compileMachine;
+	ubyte		compileLanguage;
+	ushort		compileFlags;
+	string		compileName;
+	ushort		segment;
+
+	CvProc[]	procSymbols;
+	CvData[]	codeSymbols;
+
+	void Init(const(CV_SYMBOL)* sym, in void* end) {
+		int i = 0;
+		while(sym < end && i < 100) {
+			++i;
+			switch(sym.header.type) {
+			case S_COMPILE_V1:
+				with(sym.compile_v1) {
+					compileMachine = machine;
+					compileLanguage = language;
+					compileFlags = flags;
+					compileName = name.name;
+				}
+				break;
+
+			case S_SSEARCH_V1:
+				if(!segment) segment = sym.ssearch.segment;
+				break;
+
+			case S_UDT_V1:
+				break;
+
+			case S_BPREL_V1:
+				break;
+
+			case S_LDATA_V1:
+			case S_GDATA_V1:
+			case S_PUB_V1:
+				CvData data = void;
+
+				with(sym.data_v1) {
+					// TODO: its bad to assume 2 to always be the only code segment!
+					if(segment != 2) break;
+
+					data.offset = offset;
+					data.name = name.name;
+				}
+
+				codeSymbols ~= data;
+				break;
+
+			case S_LPROC_V1:
+			case S_GPROC_V1:
+				CvProc proc = void;
+
+				with(sym.proc_v1) {
+					proc.offset = offset;
+					proc.length = procLength;
+					proc.name = name.name;
+				}
+
+				procSymbols ~= proc;
+				break;
+
+			case S_PROCREF_V1:
+			case S_DATAREF_V1:
+			case S_ALIGN_V1:
+				break;
+
+			case S_END_V1:
+			case S_ENDARG_V1:
+			case S_RETURN_V1:
+				break;
+
+			default:
+			}
+
+			sym = cast(CV_SYMBOL*)(cast(void*)sym + sym.header.size + 2);
+		}
+
+		codeSymbols.sort;
+	}
+
+	bool QueryProc(uint rva, SymbolInfo* symbol) const {
+		if(!procSymbols.length) return false;
+
+		cmp_t CmpProc(uint i) {
+			if(i >= procSymbols.length) return 0;
+
+			uint offset = procSymbols[i].offset;
+			if(offset > rva) return 1;
+			if(offset + procSymbols[i].length < rva) return -1;
+			return 0;
+		}
+
+		uint index = BinarySearch(&CmpProc, 0, procSymbols.length - 1);
+
+		if(index < procSymbols.length) with(procSymbols[index]) {
+			symbol.name = name.idup;
+			symbol.offset = rva - offset;
+			return true;
+		}
+
+		return false;
+	}
+
+	bool QueryCodeData(uint rva, SymbolInfo* symbol) const {
+		if(!codeSymbols.length) return false;
+
+		cmp_t CmpData(uint i) {
+			if(i >= codeSymbols.length) return 0;
+
+			if(codeSymbols[i].offset > rva) return 1;
+			if(i + 1 != codeSymbols.length && codeSymbols[i + 1].offset < rva) return -1;
+			return 0;
+		}
+
+		uint index = BinarySearch(&CmpData, 0, codeSymbols.length - 1);
+
+		if(index < codeSymbols.length) with(codeSymbols[index]) {
+			symbol.name = name.idup;
+			symbol.offset = rva - offset;
+			return true;
+		}
+
+		return false;
+	}
+}
+
+struct CvProc {
+	uint	offset;
+	uint	length;
+	string	name;
+}
+
+struct CvData {
+	uint offset;
+	string name;
+
+	cmp_t opCmp(ref const CvData data) const {
+		if(data.offset < offset) return -1;
+		return data.offset > offset;
+	}
+}
+
+struct CvSrcModule {
+	bool Query(uint rva, FileLineInfo* fileLine) const {
+		if(!codeOffsets.length || rva < codeOffsets[0][0] || rva > codeOffsets[$ - 1][1])
+			return false;
+
+		uint fIndex;
+
+		// Get the next CV_SRCFILE record having rva within it's code range
+		// The code offsets here may overlap over file records, we have to walk
+		// through them and possibly keep walking if the next section doesn't
+		// find a matching line record.
+	NextFile:
+		if(fIndex == fileOffsets.length) return false;
+
+		CV_SRCFILE* srcFile = cast(CV_SRCFILE*)(data + fileOffsets[fIndex++]);
+		uint[2][] offsets = srcFile.codeOffsets;
+
+		if(rva < offsets[0][0] || rva > offsets[$ - 1][1])
+			goto NextFile;
+
+		CV_SRCSEGMENT* srcSeg;
+
+		// Address is possibly within this file, now get the CV_SEGMENT record.
+		cmp_t CmpFile(uint i) {
+			if(i >= offsets.length) return 0;
+
+			if(offsets[i][0] > rva) return 1;
+			if(offsets[i][1] < rva) return -1;
+
+			srcSeg = cast(CV_SRCSEGMENT*)(data + srcFile.lineOffsets[i]);
+			return 0;
+		}
+
+		// Ignore the return value from BinarySearch, if CmpSegment matched, we
+		// already have srcSeg set. In some rare cases there may not be a
+		// matching segment record even if the file's segment range said so.
+		BinarySearch(&CmpFile, 0, offsets.length - 1);
+		if(!srcSeg) goto NextFile;
+
+		// Finally look within the segment's offsets for a matching record.
+		uint[] segOffsets = srcSeg.offsets;
+		ushort[] lineNumbers = srcSeg.lineNumbers;
+
+		cmp_t CmpSegment(uint i) {
+			if(i >= segOffsets.length) return 0;
+
+			if(segOffsets[i] > rva) return 1;
+			if(i + 1 < segOffsets.length && segOffsets[i + 1] < rva) return -1;
+
+			return 0;
+		}
+
+		uint sIndex = BinarySearch(&CmpSegment, 0, segOffsets.length - 1);
+		if(sIndex >= lineNumbers.length) goto NextFile;
+
+		// Found our record
+		fileLine.file = srcFile.name.name.idup;
+		fileLine.line = srcSeg.lineNumbers[sIndex];
+
+		return true;
+	}
+
+	const(void)*		data;
+	const(uint)[]		fileOffsets;
+	const(uint[2])[]	codeOffsets;
+	const(ushort)[]		segmentIds;
+}
+
+// TODO!
+struct CvTypes {
+	void Init(in CV_GLOBALTYPES* gtypes, in void* end) {
+		debug(CodeView) TraceA("CvTypes[%p].Init(gtypes=%p, end=%p)",
+			&this, gtypes, end);
+
+		offsets = gtypes.typeOffsets[0 .. gtypes.nTypes].idup;
+
+		void* dataStart = gtypes.types;
+		data = dataStart[0 .. end - dataStart].idup;
+	}
+
+	void GetType(ushort index) {
+		/+
+		CheckOffset(typeOffsets[index]);
+
+		CV_TYPE* type = cast(CV_TYPE*)(p + typeOffsets[i]);
+
+		switch(type.header.type) {
+		case LF_MODIFIER_V1:
+			break;
+
+		case LF_POINTER_V1:
+			break;
+
+		case LF_ARRAY_V1:
+			break;
+
+		case LF_CLASS_V1:
+			break;
+
+		case LF_STRUCTURE_V1:
+			break;
+
+		case LF_UNION_V1:
+			break;
+
+		case LF_ENUM_V1:
+			break;
+
+		case LF_PROCEDURE_V1:
+			break;
+
+		case LF_MFUNCTION_V1:
+			break;
+
+		case LF_VTSHAPE_V1:
+			break;
+
+		case LF_OEM_V1:
+			with(type.oem_v1) {
+				// Ignore unknown OEMs
+				if(oem != OEM_DIGITALMARS || nIndices != 2) break;
+
+				switch(rec) {
+				case D_DYN_ARRAY:
+					break;
+
+				case D_ASSOC_ARRAY:
+					break;
+
+				case D_DELEGATE:
+					break;
+
+				default:
+				}
+			}
+			break;
+
+		case LF_ARGLIST_V1:
+			break;
+
+		case LF_FIELDLIST_V1:
+			break;
+
+		case LF_DERIVED_V1:
+			break;
+
+		case LF_METHODLIST_V1:
+			break;
+
+		default:
+			TraceA("New leaf %x", cast(uint)type.header.type);
+			Pause;
+		}
+		+/
+	}
+
+	const(uint)[]	offsets;
+	const(void)[]	data;
+}
+
+// ----------------------------------------------------------------------------
+// O M F  S t r u c t u r e s
+// ----------------------------------------------------------------------------
+
+align(1):
+
+/**
+ Packed variant header
+*/
+struct OMF_HEADER {
+	short size;
+	short type;
+}
+
+/**
+ Packed name, may be 0 padded to maintain alignment
+*/
+struct OMF_NAME {
+	ubyte len;
+	//char[1] name;
+
+	string name() const {
+		return (cast(immutable(char)*)(&len + 1))[0 .. len];
+	}
+}
+
+// ----------------------------------------------------------------------------
+// C o d e V i e w  C o m m o n  S t r u c t u r e s
+// ----------------------------------------------------------------------------
+
+/**
+ Version signatures
+*/
+enum : uint {
+	CV_SIGNATURE_NB09	= 0x3930424E,	/// CodeView 4.10
+	CV_SIGNATURE_NB11	= 0x3131424E,	/// CodeView 5.0
+	CV_SIGNATURE_NB10	= 0x3130424E,	/// CodeView PDB 2.0
+	CV_SIGNATURE_RSDS	= 0x53445352	/// CodeView PDB 7.0
+}
+
+/**
+ SubSection Types
+*/
+enum : ushort {
+	sstModule 		= 0x0120,
+	sstTypes 		= 0x0121,
+	sstPublic 		= 0x0122,
+	sstPublicSym 	= 0x0123,
+	sstSymbols 		= 0x0124,
+	sstAlignSym 	= 0x0125,
+	sstSrcLnSeg 	= 0x0126,
+	sstSrcModule 	= 0x0127,
+	sstLibraries 	= 0x0128,
+	sstGlobalSym 	= 0x0129,
+	sstGlobalPub 	= 0x012A,
+	sstGlobalTypes 	= 0x012B,
+	sstMPC 			= 0x012C,
+	sstSegMap 		= 0x012D,
+	sstSegName 		= 0x012E,
+	sstPreComp 		= 0x012F,
+	sstPreCompMap 	= 0x0130,
+	sstOffsetMap16 	= 0x0131,
+	sstOffsetMap32 	= 0x0132,
+	sstFileIndex 	= 0x0133,
+	sstStaticSym 	= 0x0134
+}
+
+/**
+ Header used with "NB09" and "NB11"
+*/
+struct CV_HEADER {
+	uint	signature;
+	int		offset;
+}
+
+/**
+ Header used with "NB10"
+*/
+struct CV_HEADER_NB10 {
+	uint			signature;
+	int				offset;
+	uint			timestamp;
+	uint			age;
+	OMF_NAME		name;
+}
+
+/**
+ Header used with "RSDS"
+*/
+/*struct CV_HEADER_RSDS {
+	uint			signature;
+	GUID			guid;
+	uint			age;
+	OMF_NAME		name;
+}*/
+
+/**
+ Directory header
+*/
+struct CV_DIRECTORY {
+	ushort			dirSize;
+	ushort			entrySize;
+	uint			nEntries;
+	int				offset;
+	uint			flags;
+	//CV_ENTRY[1]	entries;
+
+	CV_ENTRY[] entries() const {
+		return (cast(CV_ENTRY*)(&this + 1))[0 .. nEntries];
+	}
+}
+
+/**
+ Subsection record
+*/
+struct CV_ENTRY {
+	ushort			sst;
+	ushort			modIndex;
+	int				offset;
+	uint			size;
+}
+
+// ----------------------------------------------------------------------------
+// sstModule
+// ----------------------------------------------------------------------------
+
+/**
+ Module style, always "CV"
+*/
+enum CV_MOD_STYLE = 0x5643;
+
+/**
+ Module
+*/
+struct CV_MODULE {
+	ushort			overlay;
+	ushort			lib;
+	ushort			nSegments;
+	ushort			style;
+	//CV_SEGMENT[1]	segments;
+	//OMF_NAME		name;
+
+	CV_SEGMENT[] segments() const {
+		return (cast(CV_SEGMENT*)(&style + 1))[0 .. nSegments];
+	}
+
+	OMF_NAME name() const {
+		return *cast(OMF_NAME*)(cast(void*)segments + nSegments * CV_SEGMENT.sizeof);
+	}
+}
+
+/**
+ Module segment
+*/
+struct CV_SEGMENT {
+	ushort			segIndex;
+	ushort			padding;
+	uint			offset;
+	uint			size;
+}
+
+// ----------------------------------------------------------------------------
+// sstGlobalPub, sstStaticSym, sstGlobalSym, sstAlignSym
+// ----------------------------------------------------------------------------
+
+/**
+ Symbol IDs, used by CV_SYMBOL.header.type
+*/
+enum : ushort {
+	S_COMPILE_V1	= 0x0001,
+	S_REGISTER_V1	= 0x0002,
+	S_CONSTANT_V1	= 0x0003,
+	S_UDT_V1		= 0x0004,
+	S_SSEARCH_V1	= 0x0005,
+	S_END_V1		= 0x0006,
+	S_SKIP_V1		= 0x0007,
+	S_CVRESERVE_V1	= 0x0008,
+	S_OBJNAME_V1	= 0x0009,
+	S_ENDARG_V1		= 0x000A,
+	S_COBOLUDT_V1	= 0x000B,
+	S_MANYREG_V1	= 0x000C,
+	S_RETURN_V1		= 0x000D,
+	S_ENTRYTHIS_V1	= 0x000E,
+
+	S_BPREL_V1 		= 0x0200,
+	S_LDATA_V1 		= 0x0201,
+	S_GDATA_V1 		= 0x0202,
+	S_PUB_V1 		= 0x0203,
+	S_LPROC_V1 		= 0x0204,
+	S_GPROC_V1 		= 0x0205,
+	S_THUNK_V1 		= 0x0206,
+	S_BLOCK_V1 		= 0x0207,
+	S_WITH_V1 		= 0x0208,
+	S_LABEL_V1 		= 0x0209,
+	S_CEXMODEL_V1 	= 0x020A,
+	S_VFTPATH_V1 	= 0x020B,
+	S_REGREL_V1 	= 0x020C,
+	S_LTHREAD_V1 	= 0x020D,
+	S_GTHREAD_V1 	= 0x020E,
+
+	S_PROCREF_V1	= 0x0400,
+	S_DATAREF_V1	= 0x0401,
+	S_ALIGN_V1		= 0x0402,
+	S_LPROCREF_V1	= 0x0403,
+
+	// Variants with 32bit type indices
+	S_REGISTER_V2	= 0x1001,	/// CV_REGISTER_V2
+	S_CONSTANT_V2	= 0x1002,	/// CV_CONSTANT_V2
+	S_UDT_V2		= 0x1003,	/// CV_UDT_V2
+	S_COBOLUDT_V2	= 0x1004,
+	S_MANYREG_V2	= 0x1005,
+	S_BPREL_V2		= 0x1006,	/// CV_BPREL_V2
+	S_LDATA_V2		= 0x1007,	/// CV_DATA_V2
+	S_GDATA_V2		= 0x1008,	/// CV_DATA_V2
+	S_PUB_V2		= 0x1009,	/// CV_DATA_V2
+	S_LPROC_V2		= 0x100A,	/// CV_PROC_V2
+	S_GPROC_V2		= 0x100B,	/// CV_PROC_V2
+	S_VFTTABLE_V2	= 0x100C,
+	S_REGREL_V2		= 0x100D,
+	S_LTHREAD_V2	= 0x100E,
+	S_GTHREAD_V2	= 0x100F,
+	S_FUNCINFO_V2	= 0x1012,
+	S_COMPILAND_V2	= 0x1013,	/// CV_COMPILE_V2
+
+	S_COMPILAND_V3	= 0x1101,
+	S_THUNK_V3		= 0x1102,
+	S_BLOCK_V3		= 0x1103,
+	S_LABEL_V3		= 0x1105,
+	S_REGISTER_V3	= 0x1106,
+	S_CONSTANT_V3	= 0x1107,
+	S_UDT_V3		= 0x1108,
+	S_BPREL_V3		= 0x110B,
+	S_LDATA_V3		= 0x110C,
+	S_GDATA_V3		= 0x110D,
+	S_PUB_V3		= 0x110E,
+	S_LPROC_V3		= 0x110F,
+	S_GPROC_V3		= 0x1110,
+	S_BPREL_XXXX_V3	= 0x1111,  /* not really understood, but looks like bprel... */
+	S_MSTOOL_V3		= 0x1116,  /* compiler command line options and build information */
+	S_PUB_FUNC1_V3	= 0x1125,  /* didn't get the difference between the two */
+	S_PUB_FUNC2_V3	= 0x1127,
+	S_SECTINFO_V3	= 0x1136,
+	S_SUBSECTINFO_V3= 0x1137,
+	S_ENTRYPOINT_V3	= 0x1138,
+	S_SECUCOOKIE_V3	= 0x113A,
+	S_MSTOOLINFO_V3	= 0x113C,
+	S_MSTOOLENV_V3	= 0x113D
+}
+
+/**
+ Packed symbols header
+*/
+struct CV_SYMHASH {
+	ushort			symIndex;
+	ushort			addrIndex;
+	uint			symInfoSize;
+	uint			symHashSize;
+	uint			addrHashSize;
+}
+
+/**
+ Symbol variant record
+*/
+struct CV_SYMBOL {
+	OMF_HEADER			header;
+	union {
+		CV_COMPILE_V1	compile_v1;
+		CV_COMPILE_V2	compile_v2;
+		CV_REGISTER_V1	register_v1;
+		CV_REGISTER_V2	register_v2;
+		CV_CONSTANT_V1	constant_v1;
+		CV_CONSTANT_V2	constant_v2;
+		CV_UDT_V1		udt_v1;
+		CV_UDT_V2		udt_v2;
+		CV_SSEARCH		ssearch;
+		CV_STACK_V1		stack_v1;
+		CV_STACK_V2		stack_v2;
+		CV_DATA_V1		data_v1;
+		CV_DATA_V2		data_v2;
+		CV_PROC_V1		proc_v1;
+		CV_PROC_V2		proc_v2;
+		CV_THUNK		thunk;
+		CV_BLOCK		block;
+		CV_LABEL		label;
+	}
+}
+
+/**
+ Compiler information symbol
+*/
+struct CV_COMPILE_V1 {
+	ubyte			machine;
+	ubyte			language;
+	ushort			flags;
+	OMF_NAME		name;
+}
+struct CV_COMPILE_V2 {
+	uint[4]			unknown1;
+	ushort			unknown2;
+	OMF_NAME		name;
+}
+
+/**
+ Register data symbol
+*/
+struct CV_REGISTER_V1 {
+	ushort			typeIndex;
+	ushort			reg;
+	OMF_NAME		name;
+}
+struct CV_REGISTER_V2 {
+	uint			typeIndex;
+	ushort			reg;
+	OMF_NAME		name;
+}
+
+/**
+ Constant data symbol
+*/
+struct CV_CONSTANT_V1 {
+	ushort			typeIndex;
+	ushort			value;
+	OMF_NAME		name;
+}
+struct CV_CONSTANT_V2 {
+	uint			typeIndex;
+	ushort			value;
+	OMF_NAME		name;
+}
+
+/**
+ User defined type Symbol
+*/
+struct CV_UDT_V1 {
+	ushort			typeIndex;
+	OMF_NAME		name;
+}
+struct CV_UDT_V2 {
+	uint			typeIndex;
+	OMF_NAME		name;
+}
+
+/**
+ Start of Search symbol
+*/
+struct CV_SSEARCH {
+	uint			offset;
+	ushort			segment;
+}
+
+/**
+ Object name symbol
+*/
+struct CV_OBJNAME {
+	uint			signature;
+	OMF_NAME		name;
+}
+
+/**
+ Stack data symbol
+*/
+struct CV_STACK_V1 {
+	uint			offset;
+	ushort			typeIndex;
+	OMF_NAME		name;
+}
+struct CV_STACK_V2 {
+	uint			offset;
+	uint			typeIndex;
+	OMF_NAME		name;
+}
+
+/**
+ Data symbol
+*/
+struct CV_DATA_V1 {
+	uint			offset;
+	short			segment;
+	short			typeIndex;
+	OMF_NAME		name;
+}
+struct CV_DATA_V2 {
+	uint			typeIndex;
+	uint			offset;
+	short			segment;
+	OMF_NAME		name;
+}
+
+/**
+ Procedure symbol
+*/
+struct CV_PROC_V1 {
+	uint			parent;
+	uint			end;
+	uint			next;
+	uint			procLength;
+	uint			dbgStart;
+	uint			dbgEnd;
+	uint			offset;
+	ushort			segment;
+	ushort			procType;
+	ubyte			flags;
+	OMF_NAME		name;
+}
+struct CV_PROC_V2 {
+	uint			parent;
+	uint			end;
+	uint			next;
+	uint			procLength;
+	uint			dbgStart;
+	uint			dbgEnd;
+	uint			procType;
+	uint			offset;
+	ushort			segment;
+	ubyte			flags;
+	OMF_NAME		name;
+}
+
+/**
+ Thunk symbol
+*/
+struct CV_THUNK {
+	uint 			parent;
+	uint			end;
+	uint			next;
+	uint			offset;
+	ushort			segment;
+	ushort			size;
+	ubyte			type;
+	OMF_NAME		name;
+}
+
+/**
+ Block symbol
+*/
+struct CV_BLOCK {
+	uint			parent;
+	uint			end;
+	uint			length;
+	uint			offset;
+	ushort			segment;
+	OMF_NAME		name;
+}
+
+/**
+ Label symbol
+*/
+struct CV_LABEL {
+	uint			offset;
+	ushort			segment;
+	ubyte			flags;
+	OMF_NAME		name;
+}
+
+// ----------------------------------------------------------------------------
+// sstSrcModule
+// ----------------------------------------------------------------------------
+
+/**
+ Source module header
+*/
+struct CV_SRCMODULE {
+	ushort			nFiles;			/// number of CV_SRCFILE records
+	ushort			nSegments;		/// number of segments in module
+	//uint[]		fileOffsets;
+	//uint[2][]		codeOffsets;
+	//ushort[]		segmentIds;
+
+	/// array of offsets to every CV_SRCFILE record
+	uint[] fileOffsets() const {
+		return (cast(uint*)(&nSegments + 1))[0 .. nFiles];
+	}
+
+	/// array of segment start/end pairs, length = nSegments
+	uint[2][] codeOffsets() const {
+		return (cast(uint[2]*)(cast(void*)fileOffsets + nFiles * uint.sizeof))[0 .. nSegments];
+	}
+
+	/// array of linker indices, length = nSegments
+	ushort[] segmentIds() const {
+		return (cast(ushort*)(cast(void*)codeOffsets + nSegments * (uint[2]).sizeof))[0 .. nSegments];
+	}
+}
+
+/**
+ Source file record
+*/
+struct CV_SRCFILE {
+	ushort			nSegments;		/// number of CV_SRCSEGMENT records
+	ushort			reserved;
+	//uint[]		lineOffsets;
+	//uint[2][]		codeOffsets;
+	//OMF_NAME		name;
+
+	// array of offsets to every CV_SRCSEGMENT record, length = nSegments
+	uint[] lineOffsets() const {
+		return (cast(uint*)(&reserved + 1))[0 .. nSegments];
+	}
+
+	/// array of segment start/end pairs, length = nSegments
+	uint[2][] codeOffsets() const {
+		return (cast(uint[2]*)(cast(void*)lineOffsets + nSegments * uint.sizeof))[0 .. nSegments];
+	}
+
+	/// name of file padded to long boundary
+	OMF_NAME* name() const {
+		return cast(OMF_NAME*)(cast(void*)codeOffsets + nSegments * (uint[2]).sizeof);
+	}
+}
+
+/**
+ Source segment record
+*/
+struct CV_SRCSEGMENT {
+	ushort			segment;		/// linker segment index
+	ushort			nPairs;			/// count of line/offset pairs
+	//uint[]		offsets;
+	//ushort[]		lineNumbers;
+
+	/// array of offsets in segment, length = nPairs
+	uint[] offsets() const {
+		return (cast(uint*)(&nPairs + 1))[0 .. nPairs];
+	}
+
+	/// array of line lumber in source, length = nPairs
+	ushort[] lineNumbers() const {
+		return (cast(ushort*)(cast(void*)offsets + nPairs * uint.sizeof))[0 .. nPairs];
+	}
+}
+
+// ----------------------------------------------------------------------------
+// sstGlobalTypes
+// ----------------------------------------------------------------------------
+
+/**
+ Basic types
+
+ Official MS documentation says that type (< 0x4000, so 12 bits) is made of:
+
+ +----------+------+------+----------+------+
+ |    11    | 10-8 | 7-4  |     3    | 2-0  |
+ +----------+------+------+----------+------+
+ | reserved | mode | type | reserved | size |
+ +----------+------+------+----------+------+
+*/
+
+/**
+ Basic type: Type bits
+*/
+enum : ubyte {
+	T_SPECIAL_BITS		= 0x00,	/// Special
+	T_SIGNED_BITS		= 0x10, /// Signed integral value
+	T_UNSIGNED_BITS		= 0x20, /// Unsigned integral value
+	T_BOOLEAN_BITS		= 0x30, /// Boolean
+	T_REAL_BITS			= 0x40, /// Real
+	T_COMPLEX_BITS		= 0x50, /// Complex
+	T_SPECIAL2_BITS		= 0x60, /// Special2
+	T_INT_BITS			= 0x70, /// Real int value
+}
+
+/**
+ Basic type: Size bits
+*/
+enum : ubyte {
+	// Special types
+	T_NOTYPE_BITS		= 0x00, /// No type
+	T_ABS_BITS			= 0x01, /// Absolute symbol
+	T_SEGMENT_BITS		= 0x02, /// Segment
+	T_VOID_BITS			= 0x03, /// Void
+	T_CURRENCY_BITS		= 0x04, /// Basic 8-byte currency value
+	T_NBASICSTR_BITS	= 0x05, /// Near Basic string
+	T_FBASICSTR_BITS	= 0x06, /// Far Basic string
+	T_NOTRANS_BITS		= 0x07, /// Untranslated type from previous Microsoft symbol formats
+
+	// Signed/Unsigned/Boolean types
+	T_INT08_BITS		= 0x00, /// 1 byte
+	T_INT16_BITS		= 0x01, /// 2 byte
+	T_INT32_BITS		= 0x02, /// 4 byte
+	T_INT64_BITS		= 0x03, /// 8 byte
+
+	// Real/Complex types
+	T_REAL32_BITS		= 0x00, /// 32 bit
+	T_REAL64_BITS		= 0x01, /// 64 bit
+	T_REAL80_BITS		= 0x02, /// 80 bit
+	T_REAL128_BITS		= 0x03, /// 128 bit
+	T_REAL48_BITS		= 0x04, /// 48 bit
+
+	// Special2 types
+	T_BIT_BITS			= 0x00, /// Bit
+	T_PASCHAR_BITS		= 0x01, /// Pascal CHAR
+
+	// Real Int types
+	T_CHAR_BITS			= 0x00, /// Char
+	T_WCHAR_BITS		= 0x01, /// Wide character
+	T_INT2_BITS			= 0x02, /// 2-byte signed integer
+	T_UINT2_BITS		= 0x03, /// 2-byte unsigned integer
+	T_INT4_BITS			= 0x04, /// 4-byte signed integer
+	T_UINT4_BITS		= 0x05, /// 4-byte unsigned integer
+	T_INT8_BITS			= 0x06, /// 8-byte signed integer
+	T_UINT8_BITS		= 0x07, /// 8-byte unsigned integer
+	T_DCHAR_BITS		= 0x08, /// dchar, DigitalMars D extension
+}
+
+/**
+ Basic type: Mode bits
+*/
+enum : ushort {
+	T_DIRECT_BITS		= 0x0000, /// Direct; not a pointer
+	T_NEARPTR_BITS		= 0x0100, /// Near pointer
+	T_FARPTR_BITS		= 0x0200, /// Far pointer
+	T_HUGEPTR_BITS		= 0x0300, /// Huge pointer
+	T_NEAR32PTR_BITS	= 0x0400, /// 32-bit near pointer
+	T_FAR32PTR_BITS		= 0x0500, /// 32-bit far pointer
+	T_NEAR64PTR_BITS	= 0x0600, /// 64-bit near pointer
+}
+
+/**
+ Basic type bit masks
+*/
+enum : ushort {
+	T_TYPE_MASK			= 0x00F0, /// type type mask (data treatment mode)
+	T_SIZE_MASK			= 0x000F, /// type size mask (depends on 'type' value)
+	T_MODE_MASK			= 0x0700, /// type mode mask (ptr/non-ptr)
+}
+
+/**
+ Leaf types, used by CV_TYPE.header.type
+*/
+enum : ushort {
+	// Can be referenced from symbols
+	LF_MODIFIER_V1		= 0x0001,
+	LF_POINTER_V1		= 0x0002,
+	LF_ARRAY_V1			= 0x0003,
+	LF_CLASS_V1			= 0x0004,
+	LF_STRUCTURE_V1		= 0x0005,
+	LF_UNION_V1			= 0x0006,
+	LF_ENUM_V1			= 0x0007,
+	LF_PROCEDURE_V1		= 0x0008,
+	LF_MFUNCTION_V1		= 0x0009,
+	LF_VTSHAPE_V1		= 0x000A,
+	LF_COBOL0_V1		= 0x000B,
+	LF_COBOL1_V1		= 0x000C,
+	LF_BARRAY_V1		= 0x000D,
+	LF_LABEL_V1			= 0x000E,
+	LF_NULL_V1			= 0x000F,
+	LF_NOTTRAN_V1		= 0x0010,
+	LF_DIMARRAY_V1		= 0x0011,
+	LF_VFTPATH_V1		= 0x0012,
+	LF_PRECOMP_V1		= 0x0013,
+	LF_ENDPRECOMP_V1	= 0x0014,
+	LF_OEM_V1			= 0x0015,
+	LF_TYPESERVER_V1	= 0x0016,
+
+	LF_MODIFIER_V2		= 0x1001,
+	LF_POINTER_V2		= 0x1002,
+	LF_ARRAY_V2			= 0x1003,
+	LF_CLASS_V2			= 0x1004,
+	LF_STRUCTURE_V2		= 0x1005,
+	LF_UNION_V2			= 0x1006,
+	LF_ENUM_V2			= 0x1007,
+	LF_PROCEDURE_V2		= 0x1008,
+	LF_MFUNCTION_V2		= 0x1009,
+	LF_COBOL0_V2		= 0x100A,
+	LF_BARRAY_V2		= 0x100B,
+	LF_DIMARRAY_V2		= 0x100C,
+	LF_VFTPATH_V2		= 0x100D,
+	LF_PRECOMP_V2		= 0x100E,
+	LF_OEM_V2			= 0x100F,
+
+	// Can be referenced from other type records
+	LF_SKIP_V1			= 0x0200,
+	LF_ARGLIST_V1		= 0x0201,
+	LF_DEFARG_V1		= 0x0202,
+	LF_LIST_V1			= 0x0203,
+	LF_FIELDLIST_V1		= 0x0204,
+	LF_DERIVED_V1		= 0x0205,
+	LF_BITFIELD_V1		= 0x0206,
+	LF_METHODLIST_V1	= 0x0207,
+	LF_DIMCONU_V1		= 0x0208,
+	LF_DIMCONLU_V1		= 0x0209,
+	LF_DIMVARU_V1		= 0x020A,
+	LF_DIMVARLU_V1		= 0x020B,
+	LF_REFSYM_V1		= 0x020C,
+
+	LF_SKIP_V2			= 0x1200,
+	LF_ARGLIST_V2		= 0x1201,
+	LF_DEFARG_V2		= 0x1202,
+	LF_FIELDLIST_V2		= 0x1203,
+	LF_DERIVED_V2		= 0x1204,
+	LF_BITFIELD_V2		= 0x1205,
+	LF_METHODLIST_V2	= 0x1206,
+	LF_DIMCONU_V2		= 0x1207,
+	LF_DIMCONLU_V2		= 0x1208,
+	LF_DIMVARU_V2		= 0x1209,
+	LF_DIMVARLU_V2		= 0x120A,
+
+	// Field lists
+	LF_BCLASS_V1		= 0x0400,
+	LF_VBCLASS_V1		= 0x0401,
+	LF_IVBCLASS_V1		= 0x0402,
+	LF_ENUMERATE_V1		= 0x0403,
+	LF_FRIENDFCN_V1		= 0x0404,
+	LF_INDEX_V1			= 0x0405,
+	LF_MEMBER_V1		= 0x0406,
+	LF_STMEMBER_V1		= 0x0407,
+	LF_METHOD_V1		= 0x0408,
+	LF_NESTTYPE_V1		= 0x0409,
+	LF_VFUNCTAB_V1		= 0x040A,
+	LF_FRIENDCLS_V1		= 0x040B,
+	LF_ONEMETHOD_V1		= 0x040C,
+	LF_VFUNCOFF_V1		= 0x040D,
+	LF_NESTTYPEEX_V1	= 0x040E,
+	LF_MEMBERMODIFY_V1	= 0x040F,
+
+	LF_BCLASS_V2		= 0x1400,
+	LF_VBCLASS_V2		= 0x1401,
+	LF_IVBCLASS_V2		= 0x1402,
+	LF_FRIENDFCN_V2		= 0x1403,
+	LF_INDEX_V2			= 0x1404,
+	LF_MEMBER_V2		= 0x1405,
+	LF_STMEMBER_V2		= 0x1406,
+	LF_METHOD_V2		= 0x1407,
+	LF_NESTTYPE_V2		= 0x1408,
+	LF_VFUNCTAB_V2		= 0x1409,
+	LF_FRIENDCLS_V2		= 0x140A,
+	LF_ONEMETHOD_V2		= 0x140B,
+	LF_VFUNCOFF_V2		= 0x140C,
+	LF_NESTTYPEEX_V2	= 0x140D,
+
+	LF_ENUMERATE_V3		= 0x1502,
+	LF_ARRAY_V3			= 0x1503,
+	LF_CLASS_V3			= 0x1504,
+	LF_STRUCTURE_V3		= 0x1505,
+	LF_UNION_V3			= 0x1506,
+	LF_ENUM_V3			= 0x1507,
+	LF_MEMBER_V3		= 0x150D,
+	LF_STMEMBER_V3		= 0x150E,
+	LF_METHOD_V3		= 0x150F,
+	LF_NESTTYPE_V3		= 0x1510,
+	LF_ONEMETHOD_V3		= 0x1511,
+
+	// Numeric leaf types
+	LF_NUMERIC			= 0x8000,
+	LF_CHAR				= 0x8000,
+	LF_SHORT			= 0x8001,
+	LF_USHORT			= 0x8002,
+	LF_LONG				= 0x8003,
+	LF_ULONG			= 0x8004,
+	LF_REAL32			= 0x8005,
+	LF_REAL64			= 0x8006,
+	LF_REAL80			= 0x8007,
+	LF_REAL128			= 0x8008,
+	LF_QUADWORD			= 0x8009,
+	LF_UQUADWORD		= 0x800A,
+	LF_REAL48			= 0x800B,
+	LF_COMPLEX32		= 0x800C,
+	LF_COMPLEX64		= 0x800D,
+	LF_COMPLEX80		= 0x800E,
+	LF_COMPLEX128		= 0x800F,
+	LF_VARSTRING		= 0x8010,
+	LF_DCHAR			= 0x8011
+}
+
+/**
+ Global types header
+*/
+struct CV_GLOBALTYPES {
+	ubyte[3]		unused;
+	ubyte			flags;
+	uint			nTypes;
+	//uint[1]		typeOffsets;
+	//CV_TYPE[1]	types;
+
+	/// array of offsets to CV_TYPE records
+	uint* typeOffsets() const {
+		return cast(uint*)(&nTypes + 1);
+	}
+
+	// Get the first CV_TYPE record
+	CV_TYPE* types() const {
+		return cast(CV_TYPE*)(cast(void*)(&nTypes + 1) + nTypes * uint.sizeof);
+	}
+}
+
+/**
+ Type variant record
+*/
+struct CV_TYPE {
+	OMF_HEADER			header;
+	union {
+		// Types
+		CV_MODIFIER_V1	modifier_v1;
+		CV_MODIFIER_V2	modifier_v2;
+		CV_POINTER_V1	pointer_v1;
+		CV_POINTER_V2	pointer_v2;
+		CV_ARRAY_V1		array_v1;
+		CV_ARRAY_V2		array_v2;
+		CV_STRUCT_V1	struct_v1;
+		CV_STRUCT_V2	struct_v2;
+		CV_UNION_V1		union_v1;
+		CV_UNION_V2		union_v2;
+		CV_ENUM_V1		enum_v1;
+		CV_ENUM_V2		enum_v2;
+		CV_PROCEDURE_V1	proc_v1;
+		CV_PROCEDURE_V2	proc_v2;
+		CV_MFUNCTION_V1	method_v1;
+		CV_MFUNCTION_V2	method_v2;
+		CV_OEM_V1		oem_v1;
+		CV_OEM_V2		oem_v2;
+
+		// Referenced types
+		CV_FIELDLIST	fieldlist;
+		CV_BITFIELD_V1	bitfield_v1;
+		CV_BITFIELD_V2	bitfield_v2;
+		CV_ARGLIST_V1	arglist_v1;
+		CV_ARGLIST_V2	arglist_v2;
+		CV_DERIVED_V1	derived_v1;
+		CV_DERIVED_V2	derived_v2;
+
+		// Field types
+	}
+}
+
+/**
+ Modifier type
+*/
+struct CV_MODIFIER_V1 {
+	ushort			attribute;
+	ushort			type;
+}
+struct CV_MODIFIER_V2 {
+	uint			type;
+	ushort			attribute;
+}
+
+/**
+ Pointer type
+*/
+struct CV_POINTER_V1 {
+	ushort			attribute;
+	ushort			type;
+	OMF_NAME		name;
+}
+struct CV_POINTER_V2 {
+	uint			type;
+	uint			attribute;
+	OMF_NAME		name;
+}
+
+/**
+ Array type
+*/
+struct CV_ARRAY_V1 {
+	ushort			elemType;
+	ushort			indexType;
+	ushort			length;		/// numeric leaf
+	OMF_NAME		name;
+}
+struct CV_ARRAY_V2 {
+	uint			elemType;
+	uint			indexType;
+	ushort			length;		/// numeric leaf
+	OMF_NAME		name;
+}
+
+/**
+ Struct type
+*/
+struct CV_STRUCT_V1 {
+	ushort			nElement;
+	ushort			fieldlist;
+	ushort			property;
+	ushort			derived;
+	ushort			vshape;
+	ushort			length;		/// numeric leaf
+	OMF_NAME		name;
+}
+struct CV_STRUCT_V2 {
+	ushort			nElement;
+	ushort			property;
+	uint			fieldlist;
+	uint			derived;
+	uint			vshape;
+	ushort			length;		/// numeric leaf
+	OMF_NAME		name;
+}
+
+/**
+ Union type
+*/
+struct CV_UNION_V1 {
+	ushort			count;
+	ushort			fieldlist;
+	ushort			property;
+	ushort			length;		/// numeric leaf
+	OMF_NAME		name;
+}
+struct CV_UNION_V2 {
+	ushort			count;
+	ushort			property;
+	uint			fieldlist;
+	ushort			length;		/// numeric leaf
+	OMF_NAME		name;
+}
+
+/**
+ Enumeration type
+*/
+struct CV_ENUM_V1 {
+	ushort			length;
+	ushort			id;
+	ushort			count;
+	ushort			type;
+	ushort			fieldlist;
+	ushort			property;
+	OMF_NAME		p_name;
+}
+struct CV_ENUM_V2 {
+	ushort			length;
+	ushort			id;
+	ushort			count;
+	ushort			property;
+	uint			type;
+	uint			fieldlist;
+	OMF_NAME		p_name;
+}
+
+/**
+ Procedure type
+*/
+struct CV_PROCEDURE_V1 {
+	ushort			retType;
+	ubyte			call;
+	ubyte			reserved;
+	ushort			nParams;
+	ushort			argList;
+}
+struct CV_PROCEDURE_V2 {
+	uint			retType;
+	ubyte			call;
+	ubyte			reserved;
+	ushort			nParams;
+	uint			argList;
+}
+
+/**
+ Method type
+*/
+struct CV_MFUNCTION_V1 {
+	ushort			retType;
+	ushort			classType;
+	ushort			thisType;
+	ubyte			call;
+	ubyte			reserved;
+	ushort			nParams;
+	ushort			arglist;
+	uint			thisAdjust;
+}
+struct CV_MFUNCTION_V2 {
+	uint			retType;
+	uint			classType;
+	uint			thisType;
+	ubyte			call;
+	ubyte			reserved;
+	ushort			nParams;
+	uint			arglist;
+	uint			thisAdjust;
+}
+
+/**
+ OEM type
+*/
+struct CV_OEM_V1 {
+	ushort			oem;
+	ushort			rec;
+	ushort			nIndices;
+	//ushort[1]		indices;
+
+	ushort* indices() const {
+		return cast(ushort*)(&nIndices + 1);
+	}
+}
+struct CV_OEM_V2 {
+	// UNKNOWN!
+}
+
+enum {
+	OEM_DIGITALMARS	= 0x0042,
+	D_DYN_ARRAY		= 0x0001,
+	D_ASSOC_ARRAY	= 0x0002,
+	D_DELEGATE		= 0x0003
+}
+
+struct CV_D_DYNARRAY {
+	ushort			indexType;
+	ushort			elemType;
+}
+
+struct CV_D_ASSOCARRAY {
+	ushort			keyType;
+	ushort			elemType;
+}
+
+struct CV_D_DELEGATE {
+	ushort			thisType;
+	ushort			funcType;
+}
+
+/**
+ Field list
+*/
+struct CV_FIELDLIST {
+	ubyte[1]		list;
+}
+
+/**
+ Bit field
+*/
+struct CV_BITFIELD_V1 {
+	ubyte			nBits;
+	ubyte			bitOffset;
+	ushort			type;
+}
+struct CV_BITFIELD_V2 {
+	uint			type;
+	ubyte			nBits;
+	ubyte			bitOffset;
+}
+
+/**
+ Arguments list
+*/
+struct CV_ARGLIST_V1 {
+	ushort			count;
+	ushort[1]		args;
+}
+struct CV_ARGLIST_V2 {
+	uint			count;
+	uint[1]			args;
+}
+
+/**
+ Derived
+*/
+struct CV_DERIVED_V1 {
+	ushort			count;
+	ushort[1]		derivedClasses;
+}
+struct CV_DERIVED_V2 {
+	uint			count;
+	uint[1]			derivedClasses;
+}
+
+/**
+ Class type
+*/
+struct CV_CLASS_V1 {
+	ushort			type;
+	ushort			attribute;
+	ushort			offset;		/// numeric leaf
+}
+struct CV_CLASS_V2 {
+	ushort			attribute;
+	uint			type;
+	ushort			offset;		/// numeric leaf
+}
+
+struct CvTypeClass {
+	ushort			count;
+	ushort			fieldList;
+	ushort			flags;
+	ushort			dList;
+	ushort			vShape;
+	// length
+	// name
+}
+
+// ----------------------------------------------------------------------------
+// sstSegMap
+// ----------------------------------------------------------------------------
+
+struct CV_SEGMAP {
+	ushort				total;
+	ushort				logical;
+	//CV_SEGMAPDESC[1]	descriptors;
+
+	CV_SEGMAPDESC* descriptors() const {
+		return cast(CV_SEGMAPDESC*)(&logical + 1);
+	}
+}
+
+struct CV_SEGMAPDESC {
+	ushort	flags;
+	ushort	overlay;
+	ushort	group;
+	ushort	frame;
+	ushort	name;
+	ushort	className;
+	uint	offset;
+	uint	size;
+}
+
+// ----------------------------------------------------------------------------
+// sstPreCompMap
+// ----------------------------------------------------------------------------
+
+struct OMFPreCompMap {
+	ushort			FirstType;		// first precompiled type index
+	ushort			cTypes;			// number of precompiled types
+	uint			signature;		// precompiled types signature
+	ushort			padding;
+	//CV_typ_t[]	map;			// mapping of precompiled types
+}
+
+// ----------------------------------------------------------------------------
+// sstOffsetMap16, sstOffsetMap32
+// ----------------------------------------------------------------------------
+
+struct OMFOffsetMap16 {
+	uint			csegment;	// Count of physical segments
+
+    // The next six items are repeated for each segment
+
+    //uint			crangeLog;	// Count of logical offset ranges
+    //ushort[]		rgoffLog;	// Array of logical offsets
+    //short[]		rgbiasLog;	// Array of logical->physical bias
+    //uint			crangePhys;	// Count of physical offset ranges
+    //ushort[]		rgoffPhys;	// Array of physical offsets
+    //short[]		rgbiasPhys;	// Array of physical->logical bias
+}
+
+struct OMFOffsetMap32 {
+	uint			csection;	// Count of physical sections
+
+    // The next six items are repeated for each section
+
+    //uint			crangeLog;	// Count of logical offset ranges
+    //uint[]		rgoffLog;	// Array of logical offsets
+    //int[]			rgbiasLog;	// Array of logical->physical bias
+    //uint			crangePhys;	// Count of physical offset ranges
+    //uint[]		rgoffPhys;	// Array of physical offsets
+    //int[]			rgbiasPhys;	// Array of physical->logical bias
+}
+
+// ----------------------------------------------------------------------------
+// sstFileIndex
+// ----------------------------------------------------------------------------
+
+struct OMFFileIndex {
+	ushort			cmodules;	// Number of modules
+	ushort			cfilerefs;	// Number of file references
+	//ushort[]		modulelist;	// Index to beginning of list of files
+								// for module i. (0 for module w/o files)
+	//ushort[]		cfiles;		// Number of file names associated
+								// with module i.
+	//uint[]		ulNames;	// Offsets from the beginning of this
+								// table to the file names
+	//char[]		Names;		// The length prefixed names of files
+}
+
+struct OMFMpcDebugInfo {
+	ushort			cSeg;		// number of segments in module
+	//ushort[]		mpSegFrame;	// map seg (zero based) to frame
+}
+
+
+
+
+
+
+
+// Procedure flags
+enum {
+	PROC_FPO		= 1 << 0, // Frame pointer omitted
+	PROC_INTERRUPT	= 1 << 1, // Interrupt
+	PROC_RETURN		= 1 << 2, // Far return
+	PROC_NEVER		= 1 << 3, // Never returns
+}
+
+// Procedure calling conventions
+enum {
+	CALL_C_NEAR			= 0x00,
+	CALL_C_FAR			= 0x01,
+	CALL_PASCAL_NEAR	= 0x02,
+	CALL_PASCAL_FAR		= 0x03,
+	CALL_FASTCALL_NEAR	= 0x04,
+	CALL_FASTCALL_FAR	= 0x05,
+	CALL_STDCALL_NEAR	= 0x07,
+	CALL_STDCALL_FAR	= 0x08,
+	CALL_SYSCALL_NEAR	= 0x09,
+	CALL_SYSCALL_FAR	= 0x10,
+	CALL_THIS			= 0x11,
+	CALL_MIPS			= 0x12,
+	CALL_GENERIC		= 0x13
+}
+
+enum {
+	STRUCT_PACKED		= 1 << 0,
+	STRUCT_CTOR			= 1 << 1,
+	STRUCT_OVERLOADS	= 1 << 2,
+	STRUCT_IS_NESTED	= 1 << 3,
+	STRUCT_HAS_NESTED	= 1 << 4,
+	STRUCT_OPASSIGN		= 1 << 5,
+	STRUCT_OPCAST		= 1 << 6,
+	STRUCT_FWDREF		= 1 << 7,
+	STRUCT_SCOPED		= 1 << 8
+}