#include "RawImage.h"

#include <cstring>
#include <iostream>

#include "vm/GlobalMetadata.h"

#include "MetadataUtil.h"

namespace hybridclr
{
namespace metadata
{

	bool RawImage::TranslateRVAToImageOffset(uint32_t rvaOffset, uint32_t& imageOffset)
	{
		const PESectionHeader* targetSection = nullptr;
		for (size_t i = 0; i < _PEHeader->sections; i++)
		{
			const PESectionHeader* ph = _PESectionHeaders + i;
			if ((byte*)ph >= _ptrRawDataEnd)
			{
				return false;
			}
			if (ph->virtualAddress <= rvaOffset && rvaOffset < ph->virtualAddress + ph->virtualSize)
			{
				imageOffset = ph->ptrRawData + rvaOffset - ph->virtualAddress;
				return true;
			}
		}
		return false;
	}

	const int kOptionalHeaderSize32 = 224;
	const int kOptionalHeaderSize64 = 240;
	const int kCliHeaderOffset32 = 208;
	const int kCliHeaderOffset64 = 224;

	LoadImageErrorCode RawImage::Load(const void* rawImageData, size_t length)
	{
		const byte* imageData = _ptrRawData = (const byte*)rawImageData;
		_imageLength = uint32_t(length);
		_ptrRawDataEnd = imageData + length;

		const byte* imageDataEnd = imageData + length;
		const byte* ptr_lfanew = imageData + 0x3c;
		uint32_t lfanew = *(uint32_t*)ptr_lfanew;
		if (lfanew >= length)
		{
			return LoadImageErrorCode::BAD_IMAGE;
		}

		const byte* ptrSig = imageData + lfanew;
		/*if (ptr_sig[0] != 'P' || ptr_sig[1] != 'E' || ptr_sig[2] != 0 || ptr_sig[3] != 0)*/
		if (std::strncmp((const char*)ptrSig, "PE\0\0", 4))
		{
			return LoadImageErrorCode::BAD_IMAGE;
		}

		_PEHeader = (PEHeader*)(ptrSig + 4);

		_isDll = (_PEHeader->characteristics & 0x2000);
		// std::cout << "load " << (_isDll ? "dll" : "exe") << std::endl;

		// optional size may be 224(32bit matchine) or 240 (64bit)
		if (_PEHeader->optionalHeadersize != kOptionalHeaderSize32 && _PEHeader->optionalHeadersize != kOptionalHeaderSize64)
		{
			return LoadImageErrorCode::BAD_IMAGE;
		}
		bool is32BitFormat = _PEHeader->optionalHeadersize == kOptionalHeaderSize32;

		const PEDirEntry* ptrCLIHeaderEntry = (PEDirEntry*)(((byte*)_PEHeader)
			+ 20 /* pe header size */
			+ (is32BitFormat ? kCliHeaderOffset32 : kCliHeaderOffset64) /* pe optional header -> pe header data directories -> cli header */);


		_PESectionHeaders = (PESectionHeader*)((byte*)_PEHeader + 20 + _PEHeader->optionalHeadersize);

		uint32_t cLIHeaderOffset;
		if (!TranslateRVAToImageOffset(ptrCLIHeaderEntry->rva, cLIHeaderOffset))
		{
			return LoadImageErrorCode::BAD_IMAGE;
		}
		if (cLIHeaderOffset >= length)
		{
			return LoadImageErrorCode::BAD_IMAGE;
		}

		const CLIHeader* ptrCLIHeader = _CLIHeader = (const CLIHeader*)(imageData + cLIHeaderOffset);

		uint32_t metaOffset;
		if (!TranslateRVAToImageOffset(ptrCLIHeader->metaData.rva, metaOffset))
		{
			return LoadImageErrorCode::BAD_IMAGE;
		}
		if (metaOffset >= length)
		{
			return LoadImageErrorCode::BAD_IMAGE;
		}

		_ptrMetaRoot = (const MetadataRootPartial*)(imageData + metaOffset);
		if (_ptrMetaRoot->signature != 0x424A5342)
		{
			return LoadImageErrorCode::BAD_IMAGE;
		}
		//std::cout << "version:" << (const char*)&(_ptrMetaRoot->versionFirstByte) << std::endl;
		_ptrMetaData = (const byte*)_ptrMetaRoot;

		uint16_t numStreamHeader = *(uint16_t*)(_ptrMetaData + 16 + _ptrMetaRoot->length + 2);
		const StreamHeader* ptrStreamHeaders = (const StreamHeader*)(_ptrMetaData + 16 + _ptrMetaRoot->length + 4);

		const StreamHeader* curSH = ptrStreamHeaders;
		const size_t maxStreamNameSize = 16;
		for (int i = 0; i < numStreamHeader; i++)
		{
			//std::cout << "name:" << (char*)curSH->name << ", offset:" << curSH->offset << ", size:" << curSH->size << std::endl;

			if (curSH->offset >= ptrCLIHeader->metaData.size)
			{
				return LoadImageErrorCode::BAD_IMAGE;
			}
			CliStream* rs = nullptr;
			CliStream nonStandardStream;
			CliStream pdbStream;
			if (!std::strncmp(curSH->name, "#~", maxStreamNameSize))
			{
				rs = &_streamTables;
			}
			else if (!std::strncmp(curSH->name, "#Strings", maxStreamNameSize))
			{
				rs = &_streamStringHeap;
			}
			else if (!std::strncmp(curSH->name, "#US", maxStreamNameSize))
			{
				rs = &_streamUS;
			}
			else if (!std::strncmp(curSH->name, "#GUID", maxStreamNameSize))
			{
				rs = &_streamGuidHeap;
				if (curSH->size % 16 != 0)
				{
					return LoadImageErrorCode::BAD_IMAGE;
				}
			}
			else if (!std::strncmp(curSH->name, "#Blob", maxStreamNameSize))
			{
				rs = &_streamBlobHeap;
			}
			else if (!std::strncmp(curSH->name, "#-", maxStreamNameSize))
			{
				rs = &nonStandardStream;
			}
			else if (!std::strncmp(curSH->name, "#Pdb", maxStreamNameSize))
			{
				rs = &pdbStream;
			}
			else
			{
				std::cerr << "unknown stream name:" << curSH->name << std::endl;
				return LoadImageErrorCode::BAD_IMAGE;
			}
			rs->data = _ptrMetaData + curSH->offset;
			rs->size = curSH->size;
			rs->name = curSH->name;
			size_t sizeOfStream = 8 + (std::strlen(curSH->name) / 4 + 1) * 4;
			curSH = (const StreamHeader*)((byte*)curSH + sizeOfStream);
		}
		auto err = LoadStreams();
		if (err != LoadImageErrorCode::OK)
		{
			return err;
		}
		err = LoadTables();
		if (err != LoadImageErrorCode::OK)
		{
			return err;
		}
		return LoadImageErrorCode::OK;
	}

	LoadImageErrorCode RawImage::LoadTables()
	{
		const TableStreamHeader* ptrTableHeader = (const TableStreamHeader*)_streamTables.data;
		if (ptrTableHeader->reserved != 0 || ptrTableHeader->majorVersion != 2 || ptrTableHeader->minorVersion != 0)
		{
			return LoadImageErrorCode::BAD_IMAGE;
		}
		if ((ptrTableHeader->heapSizes & ~0x7))
		{
			return LoadImageErrorCode::BAD_IMAGE;
		}
		_4byteStringIndex = ptrTableHeader->heapSizes & 0x1;
		_4byteGUIDIndex = ptrTableHeader->heapSizes & 0x2;
		_4byteBlobIndex = ptrTableHeader->heapSizes & 0x4;

		uint64_t validMask = ((uint64_t)1 << TABLE_NUM) - 1;
		if (ptrTableHeader->valid & ~validMask)
		{
			return LoadImageErrorCode::BAD_IMAGE;
		}
		// sorted include not exist table, so check is not need.
		//if (ptrTableHeader->sorted & ~validMask)
		//{
		//	return LoadImageErrorCode::BAD_IMAGE;
		//}

		uint32_t validTableNum = GetNotZeroBitCount(ptrTableHeader->valid);
		//std::cout << "valid table num:" << validTableNum << std::endl;
		//printf("#~ size:%0x\n", _streamTables.size);
		const uint32_t* tableRowNums = (uint32_t*)(_streamTables.data + 24);
		const byte* tableDataBegin = _streamTables.data + 24 + 4 * validTableNum;

		{
			int curValidTableIndex = 0;
			for (int i = 0; i <= MAX_TABLE_INDEX; i++)
			{
				uint64_t mask = (uint64_t)1 << i;
				_tables[i] = {};
				if (ptrTableHeader->valid & mask)
				{
					uint32_t rowNum = tableRowNums[curValidTableIndex];
					_tables[i].rowNum = rowNum;
					++curValidTableIndex;
				}
			}
		}

		BuildTableRowMetas();

		int curValidTableIndex = 0;
		const byte* curTableData = tableDataBegin;
		for (int i = 0; i <= MAX_TABLE_INDEX; i++)
		{
			uint64_t mask = (uint64_t)1 << i;
			bool sorted = ptrTableHeader->sorted & mask;
			if (ptrTableHeader->valid & mask)
			{
				uint32_t rowNum = tableRowNums[curValidTableIndex];
				uint32_t metaDataRowSize = ComputTableRowMetaDataSize((TableType)i);
				uint64_t offset = curTableData - _ptrRawData;
				_tables[i] = { curTableData, metaDataRowSize, rowNum, true, sorted };
				curTableData += metaDataRowSize * rowNum;
				//std::cout << "table:" << i << " ," << curValidTableIndex << ", row_size:" << metaDataRowSize << ", row_num:" << rowNum << std::endl;
				//printf("table:[%d][%d] offset:%0llx row_size:%d row_count:%d\n", i, curValidTableIndex, offset, metaDataRowSize, rowNum);
				++curValidTableIndex;
			}
			else
			{
				_tables[i] = { nullptr, 0, 0, false, sorted };
			}
		}

		return LoadImageErrorCode::OK;
	}

	void RawImage::BuildTableRowMetas()
	{
		{
			auto& table = _tableRowMetas[(int)TableType::MODULE];
			table.push_back({ 2 });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputGUIDIndexByte() });
			table.push_back({ ComputGUIDIndexByte() });
			table.push_back({ ComputGUIDIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::TYPEREF];
			table.push_back({ ComputTableIndexByte(TableType::MODULE, TableType::MODULEREF, TableType::ASSEMBLYREF, TableType::TYPEREF, TagBits::ResoulutionScope) });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputStringIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::TYPEDEF];
			table.push_back({ 4 });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputTableIndexByte(TableType::TYPEDEF, TableType::TYPEREF, TableType::TYPESPEC, TagBits::TypeDefOrRef) });
			table.push_back({ ComputTableIndexByte(TableType::FIELD) });
			table.push_back({ ComputTableIndexByte(TableType::METHOD) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::FIELD_POINTER];
			table.push_back({ ComputTableIndexByte(TableType::FIELD) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::FIELD];
			table.push_back({ 2 });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputBlobIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::METHOD_POINTER];
			table.push_back({ ComputTableIndexByte(TableType::METHOD) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::METHOD];
			table.push_back({ 4 });
			table.push_back({ 2 });
			table.push_back({ 2 });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputBlobIndexByte() });
			table.push_back({ ComputTableIndexByte(TableType::PARAM) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::PARAM_POINTER];
			table.push_back({ ComputTableIndexByte(TableType::PARAM) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::PARAM];
			table.push_back({ 2 });
			table.push_back({ 2 });
			table.push_back({ ComputStringIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::INTERFACEIMPL];
			table.push_back({ ComputTableIndexByte(TableType::TYPEDEF) });
			table.push_back({ ComputTableIndexByte(TableType::TYPEDEF, TableType::TYPEREF, TableType::TYPESPEC, TagBits::TypeDefOrRef) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::MEMBERREF];
			table.push_back({ ComputTableIndexByte(TableType::METHOD, TableType::MODULEREF, TableType::TYPEDEF, TableType::TYPEREF, TagBits::MemberRefParent) });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputBlobIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::CONSTANT];
			table.push_back({ 2 });
			table.push_back({ ComputTableIndexByte(TableType::PARAM, TableType::FIELD, TableType::PROPERTY, TagBits::HasConstant) });
			table.push_back({ ComputBlobIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::CUSTOMATTRIBUTE];
			table.push_back({ ComputTableIndexByte(HasCustomAttributeAssociateTables, sizeof(HasCustomAttributeAssociateTables) / sizeof(TableType), TagBits::HasCustomAttribute) });
			table.push_back({ ComputTableIndexByte(TableType::METHOD, TableType::MEMBERREF, TagBits::CustomAttributeType) });
			table.push_back({ ComputBlobIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::FIELDMARSHAL];
			table.push_back({ ComputTableIndexByte(TableType::FIELD, TableType::PARAM, TagBits::HasFieldMarshal) });
			table.push_back({ ComputBlobIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::DECLSECURITY];
			table.push_back({ 2 });
			table.push_back({ ComputTableIndexByte(TableType::TYPEDEF, TableType::METHOD, TableType::ASSEMBLY, TagBits::HasDeclSecurity) });
			table.push_back({ ComputBlobIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::CLASSLAYOUT];
			table.push_back({ 2 });
			table.push_back({ 4 });
			table.push_back({ ComputTableIndexByte(TableType::TYPEDEF) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::FIELDLAYOUT];
			table.push_back({ 4 });
			table.push_back({ ComputTableIndexByte(TableType::FIELD) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::STANDALONESIG];
			table.push_back({ ComputBlobIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::EVENTMAP];
			table.push_back({ ComputTableIndexByte(TableType::TYPEDEF) });
			table.push_back({ ComputTableIndexByte(TableType::EVENT) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::EVENT_POINTER];
			table.push_back({ ComputTableIndexByte(TableType::EVENT) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::EVENT];
			table.push_back({ 2 });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputTableIndexByte(TableType::TYPEDEF, TableType::TYPEREF, TableType::TYPESPEC, TagBits::TypeDefOrRef) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::PROPERTYMAP];
			table.push_back({ ComputTableIndexByte(TableType::TYPEDEF) });
			table.push_back({ ComputTableIndexByte(TableType::PROPERTY) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::PROPERTY_POINTER];
			table.push_back({ ComputTableIndexByte(TableType::PROPERTY) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::PROPERTY];
			table.push_back({ 2 });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputBlobIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::METHODSEMANTICS];
			table.push_back({ 2 });
			table.push_back({ ComputTableIndexByte(TableType::METHOD) });
			table.push_back({ ComputTableIndexByte(TableType::EVENT, TableType::PROPERTY, TagBits::HasSemantics) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::METHODIMPL];
			table.push_back({ ComputTableIndexByte(TableType::TYPEDEF) });
			table.push_back({ ComputTableIndexByte(TableType::METHOD, TableType::MEMBERREF, TagBits::MethodDefOrRef) });
			table.push_back({ ComputTableIndexByte(TableType::METHOD, TableType::MEMBERREF, TagBits::MethodDefOrRef) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::MODULEREF];
			table.push_back({ ComputStringIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::TYPESPEC];
			table.push_back({ ComputBlobIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::IMPLMAP];
			table.push_back({ 2 });
			table.push_back({ ComputTableIndexByte(TableType::FIELD, TableType::METHOD, TagBits::MemberForwarded) });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputTableIndexByte(TableType::MODULEREF) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::FIELDRVA];
			table.push_back({ 4 });
			table.push_back({ ComputTableIndexByte(TableType::FIELD) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::ASSEMBLY];
			table.push_back({ 4 });
			table.push_back({ 2 });
			table.push_back({ 2 });
			table.push_back({ 2 });
			table.push_back({ 2 });
			table.push_back({ 4 });
			table.push_back({ ComputBlobIndexByte() });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputStringIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::ASSEMBLYPROCESSOR];
			table.push_back({ 4 });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::ASSEMBLYOS];
			table.push_back({ 4 });
			table.push_back({ 4 });
			table.push_back({ 4 });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::ASSEMBLYREF];
			table.push_back({ 2 });
			table.push_back({ 2 });
			table.push_back({ 2 });
			table.push_back({ 2 });
			table.push_back({ 4 });
			table.push_back({ ComputBlobIndexByte() });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputBlobIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::ASSEMBLYREFPROCESSOR];
			table.push_back({ 4 });
			table.push_back({ ComputTableIndexByte(TableType::ASSEMBLYREF) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::ASSEMBLYREFOS];
			table.push_back({ 4 });
			table.push_back({ 4 });
			table.push_back({ 4 });
			table.push_back({ ComputTableIndexByte(TableType::ASSEMBLYREF) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::FILE];
			table.push_back({ 4 });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputBlobIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::EXPORTEDTYPE];
			table.push_back({ 4 });
			table.push_back({ 4 });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputTableIndexByte(TableType::FILE, TableType::EXPORTEDTYPE, TableType::ASSEMBLY, TagBits::Implementation) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::MANIFESTRESOURCE];
			table.push_back({ 4 });
			table.push_back({ 4 });
			table.push_back({ ComputStringIndexByte() });
			table.push_back({ ComputTableIndexByte(TableType::FILE, TableType::ASSEMBLYREF, TagBits::Implementation) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::NESTEDCLASS];
			table.push_back({ ComputTableIndexByte(TableType::TYPEDEF) });
			table.push_back({ ComputTableIndexByte(TableType::TYPEDEF) });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::GENERICPARAM];
			table.push_back({ 2 });
			table.push_back({ 2 });
			table.push_back({ ComputTableIndexByte(TableType::TYPEDEF, TableType::METHOD, TagBits::TypeOrMethodDef) });
			table.push_back({ ComputStringIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::METHODSPEC];
			table.push_back({ ComputTableIndexByte(TableType::METHOD, TableType::MEMBERREF, TagBits::MethodDefOrRef) });
			table.push_back({ ComputBlobIndexByte() });
		}
		{
			auto& table = _tableRowMetas[(int)TableType::GENERICPARAMCONSTRAINT];
			table.push_back({ ComputTableIndexByte(TableType::GENERICPARAM) });
			table.push_back({ ComputTableIndexByte(TableType::TYPEDEF, TableType::TYPEREF, TableType::TYPESPEC, TagBits::TypeDefOrRef) });
		}


		for (int i = 0; i < TABLE_NUM; i++)
		{
			auto& table = _tableRowMetas[i];
			if (table.empty())
			{
				IL2CPP_ASSERT(_tables[i].rowNum == 0 && _tables[i].rowMetaDataSize == 0);
			}
			else
			{
				uint32_t totalSize = 0;
				for (auto& col : table)
				{
					col.offset = totalSize;
					totalSize += col.size;
				}
				uint32_t computSize = ComputTableRowMetaDataSize((TableType)i);
				if (computSize != totalSize)
				{
					IL2CPP_ASSERT(totalSize == computSize);
				}
			}
		}
	}

	LoadImageErrorCode RawImage::LoadStreams()
	{
		{
			uint32_t stringNum = 0;
			const byte* cur;
			for (cur = _streamStringHeap.data; cur < _streamStringHeap.data + _streamStringHeap.size; )
			{
				++stringNum;
				//std::cout << "#strings.[" << stringNum << "]  " << cur << std::endl;
				cur += std::strlen((const char*)cur) + 1;
			}
			if (cur != _streamStringHeap.data + _streamStringHeap.size)
			{
				//std::cerr << "bad #strings" << std::endl;
				return LoadImageErrorCode::BAD_IMAGE;
			}
			//std::cout << "=== #String. num:" << stringNum << std::endl;

			_stringHeapStrNum = stringNum;
		}


		{
			//std::cout << "=== #GUID. num:" << _streamGuidHeap.size / 16 << std::endl;
		}
		{
			const byte* cur;
			uint32_t usNum = 0;
			uint32_t lengthSize;
			for (cur = _streamUS.data; cur < _streamUS.data + _streamUS.size;)
			{
				++usNum;
				uint32_t stringLength = BlobReader::ReadCompressedUint32(cur, lengthSize);
				cur += lengthSize;
				//std::cout << "#us.[" << usNum << "].size:" << stringLength << std::endl;
				cur += stringLength;
			}
			if (cur != _streamUS.data + _streamUS.size)
			{
				//std::cerr << "bad #US" << std::endl;
				return LoadImageErrorCode::BAD_IMAGE;
			}
			//std::cout << "=== #US. num:" << usNum << std::endl;

			_userStringStrNum = usNum;
		}

		{
			const byte* cur;
			uint32_t blobNum = 0;
			uint32_t lengthSize;
			for (cur = _streamBlobHeap.data; cur < _streamBlobHeap.data + _streamBlobHeap.size;)
			{
				++blobNum;
				uint32_t stringLength = BlobReader::ReadCompressedUint32(cur, lengthSize);
				cur += lengthSize;
				//std::cout << "#blob.[" << blobNum << "].size:" << stringLength << std::endl;
				cur += stringLength;
			}
			if (cur != _streamBlobHeap.data + _streamBlobHeap.size)
			{
				//std::cerr << "bad #Blob" << std::endl;
				return LoadImageErrorCode::BAD_IMAGE;
			}
			//std::cout << "=== #Blob. num:" << blobNum << std::endl;
			_blobNum = blobNum;
			return LoadImageErrorCode::OK;
		}

	}


	uint32_t RawImage::ComputTableRowMetaDataSize(TableType tableIndex) const
	{
		switch (tableIndex)
		{
		case TableType::MODULE: return 2 + ComputStringIndexByte() + ComputGUIDIndexByte() * 3;
		case TableType::TYPEREF: return ComputTableIndexByte(TableType::MODULE, TableType::MODULEREF, TableType::ASSEMBLYREF, TableType::TYPEREF, TagBits::ResoulutionScope)
			+ ComputStringIndexByte() * 2;
		case TableType::TYPEDEF: return 4 + ComputStringIndexByte() * 2
			+ ComputTableIndexByte(TableType::TYPEDEF, TableType::TYPEREF, TableType::TYPESPEC, TagBits::TypeDefOrRef)
			+ ComputTableIndexByte(TableType::FIELD)
			+ ComputTableIndexByte(TableType::METHOD);
		case TableType::FIELD_POINTER: return ComputTableIndexByte(TableType::FIELD);
		case TableType::FIELD: return 2 + ComputStringIndexByte() + ComputBlobIndexByte();
		case TableType::METHOD_POINTER: return ComputTableIndexByte(TableType::METHOD);
		case TableType::METHOD: return 4 + 2 + 2 + ComputStringIndexByte() + ComputBlobIndexByte() + ComputTableIndexByte(TableType::PARAM);
		case TableType::PARAM_POINTER: return ComputTableIndexByte(TableType::PARAM);
		case TableType::PARAM: return 2 + 2 + ComputStringIndexByte();
		case TableType::INTERFACEIMPL: return ComputTableIndexByte(TableType::TYPEDEF)
			+ ComputTableIndexByte(TableType::TYPEDEF, TableType::TYPEREF, TableType::TYPESPEC, TagBits::TypeDefOrRef);
		case TableType::MEMBERREF: return ComputTableIndexByte(TableType::METHOD, TableType::MODULEREF, TableType::TYPEDEF, TableType::TYPEREF, TagBits::MemberRefParent)
			+ ComputStringIndexByte() + ComputBlobIndexByte();
		case TableType::CONSTANT: return 2
			+ ComputTableIndexByte(TableType::PARAM, TableType::FIELD, TableType::PROPERTY, TagBits::HasConstant)
			+ ComputBlobIndexByte();
		case TableType::CUSTOMATTRIBUTE: return ComputTableIndexByte(HasCustomAttributeAssociateTables, sizeof(HasCustomAttributeAssociateTables) / sizeof(TableType), TagBits::HasCustomAttribute)
			+ ComputTableIndexByte(TableType::METHOD, TableType::MEMBERREF, TagBits::CustomAttributeType)
			+ ComputBlobIndexByte();
		case TableType::FIELDMARSHAL: return ComputTableIndexByte(TableType::FIELD, TableType::PARAM, TagBits::HasFieldMarshal)
			+ ComputBlobIndexByte();
		case TableType::DECLSECURITY: return 2 + ComputTableIndexByte(TableType::TYPEDEF, TableType::METHOD, TableType::ASSEMBLY, TagBits::HasDeclSecurity)
			+ ComputBlobIndexByte();
		case TableType::CLASSLAYOUT: return 2 + 4 + ComputTableIndexByte(TableType::TYPEDEF);
		case TableType::FIELDLAYOUT: return 4 + ComputTableIndexByte(TableType::FIELD);
		case TableType::STANDALONESIG: return ComputBlobIndexByte();
		case TableType::EVENTMAP: return ComputTableIndexByte(TableType::TYPEDEF) + ComputTableIndexByte(TableType::EVENT);
		case TableType::EVENT_POINTER: return ComputTableIndexByte(TableType::EVENT);
		case TableType::EVENT: return 2
			+ ComputStringIndexByte()
			+ ComputTableIndexByte(TableType::TYPEDEF, TableType::TYPEREF, TableType::TYPESPEC, TagBits::TypeDefOrRef);
		case TableType::PROPERTYMAP: return ComputTableIndexByte(TableType::TYPEDEF)
			+ ComputTableIndexByte(TableType::PROPERTY);
		case TableType::PROPERTY_POINTER: return ComputTableIndexByte(TableType::PROPERTY);
		case TableType::PROPERTY: return 2 + ComputStringIndexByte() + ComputBlobIndexByte();
		case TableType::METHODSEMANTICS: return 2
			+ ComputTableIndexByte(TableType::METHOD)
			+ ComputTableIndexByte(TableType::EVENT, TableType::PROPERTY, TagBits::HasSemantics);
		case TableType::METHODIMPL: return ComputTableIndexByte(TableType::TYPEDEF)
			+ ComputTableIndexByte(TableType::METHOD, TableType::MEMBERREF, TagBits::MethodDefOrRef)
			+ ComputTableIndexByte(TableType::METHOD, TableType::MEMBERREF, TagBits::MethodDefOrRef);
		case TableType::MODULEREF: return ComputStringIndexByte();
		case TableType::TYPESPEC: return ComputBlobIndexByte();
		case TableType::IMPLMAP: return 2
			+ ComputTableIndexByte(TableType::FIELD, TableType::METHOD, TagBits::MemberForwarded)
			+ ComputStringIndexByte()
			+ ComputTableIndexByte(TableType::MODULEREF);
		case TableType::FIELDRVA: return 4 + ComputTableIndexByte(TableType::FIELD);
		case TableType::UNUSED6:
		case TableType::UNUSED7:
			LogPanic("unused table type");
			return 0;
		case TableType::ASSEMBLY: return 4 + 4 * 2 + 4
			+ ComputBlobIndexByte()
			+ ComputStringIndexByte() * 2;
		case TableType::ASSEMBLYPROCESSOR: return 4;
		case TableType::ASSEMBLYOS: return 4 + 4 + 4;
		case TableType::ASSEMBLYREF: return 2 * 4 + 4
			+ ComputBlobIndexByte()
			+ ComputStringIndexByte() * 2
			+ ComputBlobIndexByte();
		case TableType::ASSEMBLYREFPROCESSOR: return 4 + ComputTableIndexByte(TableType::ASSEMBLYREF);
		case TableType::ASSEMBLYREFOS: return 4 * 3 + ComputTableIndexByte(TableType::ASSEMBLYREF);
		case TableType::FILE: return 4 + ComputStringIndexByte() + ComputBlobIndexByte();
		case TableType::EXPORTEDTYPE: return 4 + 4
			+ ComputStringIndexByte() * 2
			+ ComputTableIndexByte(TableType::FILE, TableType::EXPORTEDTYPE, TableType::ASSEMBLY, TagBits::Implementation);
		case TableType::MANIFESTRESOURCE: return 4 + 4
			+ ComputStringIndexByte()
			+ ComputTableIndexByte(TableType::FILE, TableType::ASSEMBLYREF, TagBits::Implementation);
		case TableType::NESTEDCLASS: return ComputTableIndexByte(TableType::TYPEDEF) * 2;
		case TableType::GENERICPARAM: return 2 + 2
			+ ComputTableIndexByte(TableType::TYPEDEF, TableType::METHOD, TagBits::TypeOrMethodDef)
			+ ComputStringIndexByte();
		case TableType::METHODSPEC: return ComputTableIndexByte(TableType::METHOD, TableType::MEMBERREF, TagBits::MethodDefOrRef)
			+ ComputBlobIndexByte();
		case TableType::GENERICPARAMCONSTRAINT: return ComputTableIndexByte(TableType::GENERICPARAM)
			+ ComputTableIndexByte(TableType::TYPEDEF, TableType::TYPEREF, TableType::TYPESPEC, TagBits::TypeDefOrRef);
		case TableType::UNUSED8:
		case TableType::UNUSED9:
		case TableType::UNUSED10:
			LogPanic("unused table type");
			return 0;
		case TableType::DOCUMENT: // return 84;
		case TableType::METHODBODY: // return 52;
		case TableType::LOCALSCOPE:  // return 20;
		case TableType::LOCALVARIABLE: // return 56;
		case TableType::LOCALCONSTANT: // return 24;
		case TableType::IMPORTSCOPE: // return 8;
		case TableType::STATEMACHINEMETHOD:
		case TableType::CUSTOMDEBUGINFORMATION:
			LogPanic("not support pdb table");
			return 0;
		default:
			LogPanic("unknown table type");
			return 0;
		}
	}

}
}