VMProtect/core/dotnetfile.cc

#include "../runtime/crypto.h"
#include "objects.h"
#include "osutils.h"
#include "streams.h"
#include "files.h"
#include "pefile.h"
#include "processors.h"
#include "il.h"
#include "dotnet.h"
#include "dotnetfile.h"
#include "core.h"
#include "lang.h"
#include "script.h"

static AssemblyResolver resolver;

std::string ILName(const std::string &ret, const std::string &type, const std::string &method, const std::string &signature)
{
	std::string res;
	if (!ret.empty())
		res += ret + ' ';
	if (!type.empty())
		res += type + "::";
	return res + method + signature;
}

/**
 * ILData
 */

ILData::ILData()
	: std::vector<uint8_t>()
{

}

ILData::ILData(const uint8_t *data, size_t size)
	: std::vector<uint8_t>()
{
	insert(begin(), data, data + size);
}

uint32_t ILData::ReadEncoded(uint32_t &pos) const
{
	if (pos >= size())
		throw std::runtime_error("Invalid index for stream");

	uint32_t res;
	uint8_t b = at(pos);
	if ((b & 0x80) == 0) {
		res = at(pos) & 0x7f;
		pos++;
	} else if ((b & 0x40) == 0) {
		res = ((at(pos) & 0x3f) << 8) + at(pos + 1);
		pos += 2;
	} else {
		res = ((at(pos) & 0x1f) << 24) + (at(pos + 1) << 16) + (at(pos + 2) << 8) + at(pos + 3);
		pos += 4;
	}
	return res;
}

void ILData::WriteEncoded(uint32_t value)
{
	if (value < 0x80) {
		WriteByte(static_cast<uint8_t>(value));
	} else if (value < 0x4000) {
		WriteByte(static_cast<uint8_t>(value >> 8) | 0x80);
		WriteByte(static_cast<uint8_t>(value));
	} else if (value < 0x02000000) {
		WriteByte(static_cast<uint8_t>(value >> 24) | 0xc0);
		WriteByte(static_cast<uint8_t>(value >> 16));
		WriteByte(static_cast<uint8_t>(value >> 8));
		WriteByte(static_cast<uint8_t>(value));
	} else {
		throw std::runtime_error("Value can not be encoded");
	}
}

void ILData::Read(uint32_t &pos, void *buffer, uint32_t size) const
{
	if (pos + size > this->size())
		throw std::runtime_error("Invalid index for stream");
	memcpy(buffer, data() + pos, size);
	pos += size;
}

uint8_t ILData::ReadByte(uint32_t &pos) const
{
	uint8_t res;
	Read(pos, &res, sizeof(res));
	return res;
}

uint16_t ILData::ReadWord(uint32_t &pos) const
{
	uint16_t res;
	Read(pos, &res, sizeof(res));
	return res;
}

uint32_t ILData::ReadDWord(uint32_t &pos) const
{
	uint32_t res;
	Read(pos, &res, sizeof(res));
	return res;
}

uint64_t ILData::ReadQWord(uint32_t &pos) const
{
	uint64_t res;
	Read(pos, &res, sizeof(res));
	return res;
}

std::string ILData::ReadString(uint32_t &pos) const
{
	std::string res;
	uint32_t size = ReadEncoded(pos);
	for (size_t i = 0; i < size; i++) {
		res.push_back(ReadByte(pos));
	}
	return res;
}

void ILData::WriteByte(uint8_t value)
{
	push_back(value);
}

void ILData::WriteWord(uint16_t value)
{
	Write(&value, sizeof(value));
}

void ILData::WriteDWord(uint32_t value)
{
	Write(&value, sizeof(value));
}

void ILData::WriteQWord(uint64_t value)
{
	Write(&value, sizeof(value));
}

void ILData::Write(const void *buffer, size_t size)
{
	if (size) {
		const uint8_t *ptr = reinterpret_cast<const uint8_t *>(buffer);
		insert(end(), ptr, ptr + size);
	}
}

void ILData::WriteString(const std::string &value)
{
	WriteEncoded(static_cast<uint32_t>(value.size()));
	if (!value.empty())
		Write(value.data(), value.size());
}

/**
 * ILStream
 */

ILStream::ILStream(ILMetaData *owner, uint64_t address, uint32_t size, const std::string &name)
	: BaseLoadCommand(owner), address_(address), size_(size), name_(name)
{

}

ILStream::ILStream(ILMetaData *owner, const ILStream &src)
	: BaseLoadCommand(owner)
{
	address_ = src.address_;
	size_ = src.size_;
	name_ = src.name_;
}

ILStream *ILStream::Clone(ILoadCommandList *owner) const
{
	ILStream *stream = new ILStream(reinterpret_cast<ILMetaData *>(owner), *this);
	return stream;
}

void ILStream::WriteToFile(NETArchitecture &file)
{
	address_ = file.AddressTell();
}

void ILStream::Rebase(uint64_t delta_base)
{
	address_ += delta_base;
}

void ILStream::FreeByManager(MemoryManager &manager)
{
	manager.Add(address(), size());
}

/**
 * ILStringsStream
 */

ILStringsStream::ILStringsStream(ILMetaData *owner, uint64_t address, uint32_t size, const std::string &name)
	: ILStream(owner, address, size, name)
{

}

ILStringsStream::ILStringsStream(ILMetaData *owner, const ILStringsStream &src)
	: ILStream(owner, src)
{
	data_ = src.data_;
}

ILStream *ILStringsStream::Clone(ILoadCommandList *owner) const
{
	ILStringsStream *stream = new ILStringsStream(reinterpret_cast<ILMetaData *>(owner), *this);
	return stream;
}

void ILStringsStream::ReadFromFile(NETArchitecture &file)
{
	if (!file.AddressSeek(address()))
		throw std::runtime_error("Invalid stream address");

	data_.resize(size());
	file.Read(data_.data(), data_.size());
}

void ILStringsStream::WriteToFile(NETArchitecture &file)
{
	ILStream::WriteToFile(file);
	data_.resize(AlignValue(data_.size(), sizeof(uint32_t)), 0);
	set_size(static_cast<uint32_t>(file.Write(data_.data(), data_.size())));
}

void ILStringsStream::Prepare()
{
	data_.clear();
	map_.clear();
	AddString("");
}

std::string ILStringsStream::GetString(uint32_t pos) const
{
	if (pos >= data_.size())
		throw std::runtime_error("Invalid index for " + name());

	size_t len = data_.size() - pos;
	for (size_t i = 0; i < len; i++) {
		if (data_[pos + i] == 0) {
			len = i;
			break;
		}
	}
	if (len == data_.size() - pos)
		throw std::runtime_error("Invalid index for " + name());

	return std::string(reinterpret_cast<const char *>(data_.data() + pos), len);
}

uint32_t ILStringsStream::AddString(const std::string &str)
{
	std::map<std::string, uint32_t>::const_iterator it = map_.find(str);
	if (it != map_.end())
		return it->second;

	uint32_t res = static_cast<uint32_t>(data_.size());
	map_[str] = res;

	data_.insert(data_.end(), str.data(), str.data() + str.size() + 1);

	return res;
}

/**
 * ILUserStringsStream
 */

ILUserStringsStream::ILUserStringsStream(ILMetaData *owner, uint64_t address, uint32_t size, const std::string &name)
	: ILStream(owner, address, size, name)
{

}

ILUserStringsStream::ILUserStringsStream(ILMetaData *owner, const ILUserStringsStream &src)
	: ILStream(owner, src)
{
	data_ = src.data_;
}

ILUserStringsStream *ILUserStringsStream::Clone(ILoadCommandList *owner) const
{
	ILUserStringsStream *stream = new ILUserStringsStream(reinterpret_cast<ILMetaData *>(owner), *this);
	return stream;
}

void ILUserStringsStream::ReadFromFile(NETArchitecture &file)
{
	if (!file.AddressSeek(address()))
		throw std::runtime_error("Invalid stream address");

	data_.resize(size());
	file.Read(data_.data(), data_.size());
}

void ILUserStringsStream::WriteToFile(NETArchitecture &file)
{
	ILStream::WriteToFile(file);
	data_.resize(AlignValue(data_.size(), sizeof(uint32_t)), 0);
	set_size(static_cast<uint32_t>(file.Write(data_.data(), data_.size())));
}

void ILUserStringsStream::Prepare()
{
	data_.clear();
	data_.push_back(0);
	map_.clear();
}

std::string ILUserStringsStream::GetString(uint32_t pos) const
{
	uint32_t len = data_.ReadEncoded(pos);
	if (pos + len > data_.size())
		throw std::runtime_error("Invalid index for " + name());

	len >>= 1;
	if (!len)
		return std::string();

	os::unicode_string str;
	str.resize(len);
	memcpy(&str[0], &data_[pos], str.size() * sizeof(os::unicode_char));

	return os::ToUTF8(str);
}

ILData ILUserStringsStream::GetData(uint32_t pos, uint64_t *address) const
{
	uint32_t len = data_.ReadEncoded(pos);
	if (pos + len > data_.size())
		throw std::runtime_error("Invalid index for " + name());

	if (len & 1)
		len--;
	if (address)
		*address = this->address() + pos;
	return ILData(&data_[pos], len);
}

uint32_t ILUserStringsStream::AddString(const std::string &str)
{
	std::map<std::string, uint32_t>::const_iterator it = map_.find(str);
	if (it != map_.end())
		return it->second;

	uint32_t res = static_cast<uint32_t>(data_.size());
	map_[str] = res;

	os::unicode_string tmp = os::FromUTF8(str);
	size_t size = tmp.size() * sizeof(os::unicode_char) + 1;
	data_.WriteEncoded(static_cast<uint32_t>(size));
	data_.insert(data_.end(), reinterpret_cast<const uint8_t *>(tmp.data()), reinterpret_cast<const uint8_t *>(tmp.data()) + size);

	return res;
}

/**
 * ILBlobStream
 */

ILBlobStream::ILBlobStream(ILMetaData *owner, uint64_t address, uint32_t size, const std::string &name)
	: ILStream(owner, address, size, name)
{

}

ILBlobStream::ILBlobStream(ILMetaData *owner, const ILBlobStream &src)
	: ILStream(owner, src)
{
	data_ = src.data_;
}

ILStream *ILBlobStream::Clone(ILoadCommandList *owner) const
{
	ILBlobStream *stream = new ILBlobStream(reinterpret_cast<ILMetaData *>(owner), *this);
	return stream;
}

void ILBlobStream::ReadFromFile(NETArchitecture &file)
{
	if (!file.AddressSeek(address()))
		throw std::runtime_error("Invalid stream address");

	data_.resize(size());
	file.Read(data_.data(), data_.size());
}

void ILBlobStream::WriteToFile(NETArchitecture &file)
{
	ILStream::WriteToFile(file);
	data_.resize(AlignValue(data_.size(), sizeof(uint32_t)), 0);
	set_size(static_cast<uint32_t>(file.Write(data_.data(), data_.size())));
}

void ILBlobStream::Prepare()
{
	data_.clear();
	map_.clear();
	AddData(ILData());
}

ILData ILBlobStream::GetData(uint32_t pos) const
{
	uint32_t len = data_.ReadEncoded(pos);
	if (pos + len > data_.size())
		throw std::runtime_error("Invalid index for " + name());

	return ILData(&data_[pos], len);
}

uint32_t ILBlobStream::AddData(const ILData &value)
{
	std::map<ILData, uint32_t>::const_iterator it = map_.find(value);
	if (it != map_.end())
		return it->second;

	uint32_t res = static_cast<uint32_t>(data_.size());
	map_[value] = res;

	data_.WriteEncoded(static_cast<uint32_t>(value.size()));
	data_.insert(data_.end(), value.data(), value.data() + value.size());

	return res;
}

/**
 * ILGuidStream
 */

ILGuidStream::ILGuidStream(ILMetaData *owner, uint64_t address, uint32_t size, const std::string &name)
	: ILStream(owner, address, size, name)
{

}

ILGuidStream::ILGuidStream(ILMetaData *owner, const ILGuidStream &src)
	: ILStream(owner, src)
{
	data_ = src.data_;
}

ILStream *ILGuidStream::Clone(ILoadCommandList *owner) const
{
	ILGuidStream *stream = new ILGuidStream(reinterpret_cast<ILMetaData *>(owner), *this);
	return stream;
}

void ILGuidStream::Prepare()
{
	data_.clear();
	map_.clear();
}

void ILGuidStream::ReadFromFile(NETArchitecture &file)
{
	if (!file.AddressSeek(address()))
		throw std::runtime_error("Invalid stream address");

	data_.resize(size());
	file.Read(data_.data(), data_.size());
}

void ILGuidStream::WriteToFile(NETArchitecture &file)
{
	ILStream::WriteToFile(file);
	data_.resize(AlignValue(data_.size(), sizeof(uint32_t)), 0);
	set_size(static_cast<uint32_t>(file.Write(data_.data(), data_.size())));
}

ILData ILGuidStream::GetData(uint32_t pos) const
{
	uint32_t len = 16;
	if (pos + len > data_.size())
		throw std::runtime_error("Invalid index for " + name());

	return ILData(&data_[pos], len);
}

uint32_t ILGuidStream::AddData(const ILData &value)
{
	std::map<ILData, uint32_t>::const_iterator it = map_.find(value);
	if (it != map_.end())
		return it->second;

	uint32_t res = static_cast<uint32_t>(data_.size());
	map_[value] = res;

	data_.insert(data_.end(), value.data(), value.data() + value.size());

	return res;
}

/**
 * ILHeapStream
 */

ILHeapStream::ILHeapStream(ILMetaData *owner, uint64_t address, uint32_t size, const std::string &name)
	: ILStream(owner, address, size, name)
{

}

ILHeapStream::~ILHeapStream()
{
	for (size_t i = 0; i < table_list_.size(); i++) {
		delete table_list_[i];
	}
}

ILHeapStream::ILHeapStream(ILMetaData *owner, const ILHeapStream &src)
	: ILStream(owner, src)
{
	reserved_ = src.reserved_;
	major_version_ = src.major_version_;
	minor_version_ = src.minor_version_;
	heap_offset_sizes_ = src.heap_offset_sizes_;
	reserved2_ = src.reserved2_;
	mask_valid_ = src.mask_valid_;
	mask_sorted_ = src.mask_sorted_;
	extra_data_ = src.extra_data_;

	for (size_t i = 0; i < src.table_list_.size(); i++) {
		table_list_.push_back(src.table_list_[i]->Clone(owner));
	}
}

ILStream *ILHeapStream::Clone(ILoadCommandList *owner) const
{
	ILHeapStream *stream = new ILHeapStream(reinterpret_cast<ILMetaData *>(owner), *this);
	return stream;
}

ILTable *ILHeapStream::Add(ILTokenType type, uint32_t row_count)
{
	ILTable *table = new ILTable(reinterpret_cast<ILMetaData *>(owner()), type, row_count);
	table_list_.push_back(table);
	return table;
}

void ILHeapStream::ReadFromFile(NETArchitecture &file)
{
	if (!file.AddressSeek(address()))
		throw std::runtime_error("Invalid heap address");

	reserved_ = file.ReadDWord();
	major_version_ = file.ReadByte();
	minor_version_ = file.ReadByte();
	heap_offset_sizes_ = file.ReadByte();
	reserved2_ = file.ReadByte();
	mask_valid_ = file.ReadQWord();
	mask_sorted_ = file.ReadQWord();

	size_t i;
	uint64_t mask = mask_valid_;
	for (i = 0; i < 64; mask >>= 1, i++) {
		uint32_t token_count = (mask & 1) ? file.ReadDWord() : 0;
		Add(static_cast<ILTokenType>(i << 24), token_count);
	}

	if (heap_offset_sizes_ & 0x40) {
		extra_data_.resize(sizeof(uint32_t));
		file.Read(extra_data_.data(), extra_data_.size());
	}

	for (i = 0; i < count(); i++) {
		table(i)->ReadFromFile(file);
	}
}

void ILHeapStream::WriteToFile(NETArchitecture &file)
{
	ILStream::WriteToFile(file);

	size_t i;

	for (i = 0; i < count(); i++) {
		table(i)->WriteToStreams(*reinterpret_cast<ILMetaData*>(owner()));
	}

	heap_offset_sizes_ = 0;
	if (file.command_list()->string_data_size() > UINT16_MAX)
		heap_offset_sizes_ |= 1;
	if (file.command_list()->guid_data_size() > UINT16_MAX)
		heap_offset_sizes_ |= 2;
	if (file.command_list()->blob_data_size() > UINT16_MAX)
		heap_offset_sizes_ |= 4;
	if (!extra_data_.empty())
		heap_offset_sizes_ |= 0x40;

	uint64_t pos = file.Tell();

	file.WriteDWord(reserved_);
	file.WriteByte(major_version_);
	file.WriteByte(minor_version_);
	file.WriteByte(heap_offset_sizes_);
	file.WriteByte(reserved2_);

	mask_valid_ = 0;
	uint64_t mask = 1;
	for (i = 0; i < count(); mask <<= 1, i++) {
		ILTable *table = this->table(i);
		if (table->count())
			mask_valid_ |= mask;
	}

	file.WriteQWord(mask_valid_);
	file.WriteQWord(mask_sorted_);

	for (i = 0; i < count(); i++) {
		ILTable *table = this->table(i);
		if (table->count())
			file.WriteDWord(static_cast<uint32_t>(table->count()));
	}

	if (!extra_data_.empty())
		file.Write(extra_data_.data(), extra_data_.size());

	for (i = 0; i < count(); i++) {
		table(i)->WriteToFile(file);
	}

	size_t size, pad_size;
	for (size = static_cast<size_t>(file.Tell() - pos), pad_size = AlignValue(size, sizeof(uint32_t)); size < pad_size; size++) {
		file.WriteByte(0);
	}
	set_size(static_cast<uint32_t>(size));
}

void ILHeapStream::Rebase(uint64_t delta_base)
{
	ILStream::Rebase(delta_base);

	for (size_t i = 0; i < count(); i++) {
		table(i)->Rebase(delta_base);
	}
}

void ILHeapStream::UpdateTokens()
{
	size_t i, j;
	std::map<ILToken *, ILToken *> token_map;
	ILTable *table;
	ILToken *token;

	for (i = 0; i < count(); i++) {
		table = this->table(i);
		for (j = 0; j < table->count(); j++) {
			token = table->item(j);
			if (token->is_deleted())
				token_map[token] = NULL;
		}
	}
	if (!token_map.empty()) {
		for (i = 0; i < count(); i++) {
			table = this->table(i);
			for (j = 0; j < table->count(); j++) {
				token = table->item(j);
				if (token->is_deleted())
					continue;

				token->RemapTokens(token_map);
				if (token->is_deleted())
					token_map[token] = NULL;
			}
		}
	}

	std::vector<ILTable *> need_sort_list;
	for (i = 0; i < count(); i++) {
		table = this->table(i);
		switch (table->type()) {
		case ttConstant:
		case ttCustomAttribute:
		case ttGenericParam:
		case ttGenericParamConstraint:
		case ttImplMap:
		case ttInterfaceImpl:
		case ttMethodImpl:
		case ttMethodSemantics:
			need_sort_list.push_back(table);
			break;
		default:
			table->UpdateTokens();
			break;
		}
	}
	for (i = 0; i < need_sort_list.size(); i++) {
		table = need_sort_list[i];
		table->Sort();
		table->UpdateTokens();
	}
}

void ILHeapStream::Pack()
{
	for (size_t i = 0; i < count(); i++) {
		table(i)->Pack();
	}
}

/**
 * ILMetaData
 */

ILMetaData::ILMetaData(NETArchitecture *owner)
	: BaseCommandList(owner), strings_(NULL), user_strings_(NULL), blob_(NULL), guid_(NULL), heap_(NULL),
	address_(0), signature_(0), major_version_(0), minor_version_(0), reserved_(0), flags_(0), size_(0)
{
	us_table_ = new ILUserStringsTable(this);
}

ILMetaData::ILMetaData(NETArchitecture *owner, const ILMetaData &src)
	: BaseCommandList(owner, src), strings_(NULL), user_strings_(NULL), blob_(NULL), guid_(NULL), heap_(NULL), size_(0)
{
	address_ = src.address_;
	signature_ = src.signature_;
	major_version_ = src.major_version_;
	minor_version_ = src.minor_version_;
	reserved_ = src.reserved_;
	flags_ = src.flags_;
	version_ = src.version_;
	framework_ = src.framework_;
	us_table_ = src.us_table_->Clone(this);

	if (src.strings_)
		strings_ = reinterpret_cast<ILStringsStream *>(item(src.IndexOf(src.strings_)));
	if (src.user_strings_)
		user_strings_ = reinterpret_cast<ILUserStringsStream *>(item(src.IndexOf(src.user_strings_)));
	if (src.blob_)
		blob_ = reinterpret_cast<ILBlobStream *>(item(src.IndexOf(src.blob_)));
	if (src.guid_)
		guid_ = reinterpret_cast<ILGuidStream *>(item(src.IndexOf(src.guid_)));
	if (src.heap_) {
		heap_ = reinterpret_cast<ILHeapStream *>(item(src.IndexOf(src.heap_)));
		for (size_t i = 0; i < heap_->count(); i++) {
			ILTable *table = heap_->table(i);
			for (size_t j = 0; j < table->count(); j++) {
				table->item(j)->UpdateTokens();
			}
		}
	}
}

ILMetaData::~ILMetaData()
{
	delete us_table_;
}

ILMetaData *ILMetaData::Clone(NETArchitecture *owner) const
{
	ILMetaData *meta_data = new ILMetaData(owner, *this);
	return meta_data;
}

ILStream *ILMetaData::Add(uint64_t address, uint32_t size, const std::string &name)
{
	ILStream *stream = NULL;
	if (name == "#Strings") {
		if (!strings_) {
			strings_ = new ILStringsStream(this, address, size, name);
			stream = strings_;
		}
	} else if (name == "#US") {
		if (!user_strings_) {
			user_strings_ = new ILUserStringsStream(this, address, size, name);
			stream = user_strings_;
		}
	} else if (name == "#Blob") {
		if (!blob_) {
			blob_ = new ILBlobStream(this, address, size, name);
			stream = blob_;
		}
	} else if (name == "#GUID") {
		if (!guid_) {
			guid_ = new ILGuidStream(this, address, size, name);
			stream = guid_;
		}
	} else if (name == "#~") {
		if (!heap_) {
			heap_ = new ILHeapStream(this, address, size, name);
			stream = heap_;
		}
	}

	if (!stream)
		stream = new ILStream(this, address, size, name);
	AddObject(stream);
	return stream;
}

void ILMetaData::ReadFromFile(NETArchitecture &file, uint64_t address)
{
	if (!file.AddressSeek(address))
		throw std::runtime_error("Invalid meta data address");

	size_t i;
	address_ = address;
	signature_ = file.ReadDWord();
	if (signature_ != 'BJSB')
		throw std::runtime_error("Invalid meta data signature");

	major_version_ = file.ReadWord();
	minor_version_ = file.ReadWord();
	reserved_ = file.ReadDWord();
	size_t version_len = file.ReadDWord();
	if (version_len) {
		version_.resize(version_len);
		file.Read(&version_[0], version_len);
	}
	flags_ = file.ReadWord();
	size_t streams = file.ReadWord();
	for (i = 0; i < streams; i++) {
		uint64_t stream_address = file.ReadDWord() + address_;
		uint32_t stream_size = file.ReadDWord();
		std::string stream_name = file.ReadString();
		for (size_t str_size = stream_name.size() + 1, pad_size = AlignValue(str_size, sizeof(uint32_t)); str_size < pad_size; str_size++) {
			file.ReadByte();
		}
		Add(stream_address, stream_size, stream_name);
	}
	if (!heap_)
		throw std::runtime_error("Invalid .NET format");

	for (i = 0; i < count(); i++) {
		ILStream *stream = item(i);
		if (stream == heap_)
			continue;
		stream->ReadFromFile(file);
	}
	heap_->ReadFromFile(file);

	ILTable *table = this->table(ttNestedClass);
	for (i = 0; i < table->count(); i++) {
		ILNestedClass *nested = reinterpret_cast<ILNestedClass *>(table->item(i));
		ILTypeDef *nested_type = nested->nested_type();
		ILTypeDef *declaring_type = nested->declaring_type();
		if (!nested_type || !declaring_type)
			throw std::runtime_error("Invalid nested class");
		nested_type->set_declaring_type(declaring_type);
	}

	table = this->table(ttTypeDef);
	for (i = 0; i < table->count(); i++) {
		ILTypeDef *type_def = reinterpret_cast<ILTypeDef *>(table->item(i));
		ILTypeDef *next = type_def->next();
		ILMethodDef *method_end = next ? next->method_list() : NULL;
		if (type_def->method_list() == method_end)
			type_def->set_method_list(NULL);
		else for (ILMethodDef *method = type_def->method_list(); method && method != method_end; method = method->next())
			method->set_declaring_type(type_def);

		ILField *field_end = next ? next->field_list() : NULL;
		if (type_def->field_list() == field_end)
			type_def->set_field_list(NULL);
		else for (ILField *field = type_def->field_list(); field && field != field_end; field = field->next())
			field->set_declaring_type(type_def);
	}

	table = this->table(ttMethodDef);
	for (i = 0; i < table->count(); i++) {
		ILMethodDef *method = reinterpret_cast<ILMethodDef *>(table->item(i));
		ILMethodDef *next = method->next();
		ILParam *param_end = next ? next->param_list() : NULL;
		if (method->param_list() == param_end)
			method->set_param_list(NULL);
		else for (ILParam *param = method->param_list(); param && param != param_end; param = param->next())
			param->set_parent(method);
	}

	table = this->table(ttPropertyMap);
	for (i = 0; i < table->count(); i++) {
		ILPropertyMap *property_map = reinterpret_cast<ILPropertyMap *>(table->item(i));
		ILPropertyMap *next = property_map->next();
		ILProperty *property_end = next ? next->property_list() : NULL;
		if (property_map->property_list() == property_end)
			property_map->set_property_list(NULL);
		else for (ILProperty *property = property_map->property_list(); property && property != property_end; property = property->next())
			property->set_declaring_type(property_map->parent());
	}

	table = this->table(ttEventMap);
	for (i = 0; i < table->count(); i++) {
		ILEventMap *event_map = reinterpret_cast<ILEventMap *>(table->item(i));
		ILEventMap *next = event_map->next();
		ILEvent *event_end = next ? next->event_list() : NULL;
		if (event_map->event_list() == event_end)
			event_map->set_event_list(NULL);
		else for (ILEvent *event = event_map->event_list(); event && event != event_end; event = event->next())
			event->set_declaring_type(event_map->parent());
	}

	table = this->table(ttCustomAttribute);
	for (i = 0; i < table->count(); i++) {
		ILCustomAttribute *attribute = reinterpret_cast<ILCustomAttribute *>(table->item(i));
		if (attribute->type()->type() == ttMemberRef) {
			ILMemberRef *member_ref = reinterpret_cast<ILMemberRef *>(attribute->type());
			if (member_ref->name() == ".ctor") {
				if (ILToken *declaring_type = member_ref->declaring_type()) {
					std::string full_name;
					switch (declaring_type->type()) {
					case ttTypeRef:
						full_name = reinterpret_cast<ILTypeRef *>(declaring_type)->full_name();
						break;
					}
					if (full_name == "System.Runtime.Versioning.TargetFrameworkAttribute") {
						CustomAttributeValue *value = attribute->ParseValue();
						if (value->fixed_list()->count() == 1) {
							std::string str = value->fixed_list()->item(0)->ToString();
							str.erase(std::remove_if(str.begin(), str.end(), [](char c) { return c == ' '; }), str.end());
							i = str.find(",");
							if (i != std::string::npos) {
								std::string name = str.substr(0, i);
								if (name == ".NETFramework")
									framework_.type = fwFramework;
								else if (name == ".NETCoreApp")
									framework_.type = fwCore;
								else if (name == ".NETStandard")
									framework_.type = fwStandard;
							}
							if (framework_.type != fwUnknown) {
								i = str.find("Version=v");
								if (i != std::string::npos)
									framework_.version.Parse(str.substr(i + 9));
							}
							break;
						}
					}
				}
			}
		}
	}

	if (framework_.type == fwUnknown) {
		if (ILAssemblyRef *core_lib = GetCoreLib()) {
			if (core_lib->name() == "mscorlib") {
				framework_.type = fwFramework;
				framework_.version.major = core_lib->major_version();
			}
			else if (core_lib->name() == "System.Runtime")
				framework_.type = fwCore;
			else if (core_lib->name() == "netstandard")
				framework_.type = fwStandard;
		}
	}
}

void ILMetaData::FreeByManager(MemoryManager &manager)
{
	for (size_t i = 0; i < count(); i++) {
		item(i)->FreeByManager(manager);
	}
}

void ILMetaData::Prepare()
{
	for (size_t i = 0; i < count(); i++) {
		item(i)->Prepare();
	}
}

void ILMetaData::WriteToFile(NETArchitecture &file)
{
	if (heap_)
		heap_->Pack();

	address_ = file.AddressTell();
	uint64_t pos = file.Tell();

	size_t i;
	file.WriteDWord(signature_);
	file.WriteWord(major_version_);
	file.WriteWord(minor_version_);
	file.WriteDWord(reserved_);
	file.WriteDWord(static_cast<uint32_t>(version_.size()));
	if (!version_.empty())
		file.Write(version_.data(), version_.size());
	file.WriteWord(flags_);
	file.WriteWord(static_cast<uint16_t>(count()));

	std::vector<uint64_t> pos_list;
	for (i = 0; i < count(); i++) {
		ILStream *stream = item(i);
		pos_list.push_back(file.Tell());
		file.WriteDWord(0);
		file.WriteDWord(0);
		std::string stream_name = stream->name();
		file.Write(stream_name.c_str(), stream_name.size() + 1);
		for (size_t str_size = stream_name.size() + 1, pad_size = AlignValue(str_size, sizeof(uint32_t)); str_size < pad_size; str_size++) {
			file.WriteByte(0);
		}
	}

	if (heap_)
		heap_->WriteToFile(file);
	for (i = 0; i < count(); i++) {
		ILStream *stream = item(i);
		if (stream == heap_)
			continue;
		stream->WriteToFile(file);
	}

	size_ = static_cast<uint32_t>(file.Tell() - pos);

	for (i = 0; i < count(); i++) {
		ILStream *stream = item(i);
		file.Seek(pos_list[i]);
		file.WriteDWord(static_cast<uint32_t>(stream->address() - address_));
		file.WriteDWord(stream->size());
	}
}

ILStream *ILMetaData::item(size_t index) const 
{ 
	return reinterpret_cast<ILStream *>(BaseCommandList::item(index));
}

ILStream *ILMetaData::GetStreamByName(const std::string &name) const
{
	for (size_t i = 0; i < count(); i++) {
		ILStream *stream = item(i);
		if (stream->name() == name)
			return stream;
	}

	return NULL;
}

ILTable *ILMetaData::table(ILTokenType type) const
{
	if (type == ttUserString)
		return us_table_;

	size_t i = type >> 24;
	if (i >= heap_->count())
		return NULL;

	return heap_->table(i);
}

uint32_t ILMetaData::token_count(ILTokenType type) const
{
	ILTable *table = this->table(type);
	if (!table)
		return 0;

	return static_cast<uint32_t>(table->count());
}

ILToken *ILMetaData::token(uint32_t id) const
{
	ILTokenType type = static_cast<ILTokenType>(TOKEN_TYPE(id));
	uint32_t value = TOKEN_VALUE(id);
	if (type == ttUserString)
		return us_table_->GetTokenByPos(value);

	ILTable *table = this->table(type);
	if (!table || value < 1 || value > table->count())
		return NULL;

	return table->item(value - 1);
}

size_t ILMetaData::field_size(ILTokenType type) const
{ 
	return (token_count(type) < 0x10000) ? sizeof(uint16_t) : sizeof(uint32_t);
}

size_t ILMetaData::field_size(const EncodingDesc &desc) const
{
	uint32_t count = 0;
	for (size_t i = 0; i < desc.size; i++) {
		count = std::max(count, token_count(desc.types[i]));
	}
	return (count < uint32_t(1 << (16 - desc.bits))) ? sizeof(uint16_t) : sizeof(uint32_t);
}

std::string ILMetaData::GetUserString(uint32_t pos) const
{
	if (!user_strings_)
		throw std::runtime_error("Invalid .NET format");
	return user_strings_->GetString(pos);
}

ILData ILMetaData::GetUserData(uint32_t pos, uint64_t *address) const
{
	if (!user_strings_)
		throw std::runtime_error("Invalid .NET format");
	return user_strings_->GetData(pos, address);
}

std::string ILMetaData::GetString(uint32_t pos) const
{
	if (!strings_)
		throw std::runtime_error("Invalid .NET format");
	return strings_->GetString(pos);
}

ILData ILMetaData::GetGuid(uint32_t pos) const
{
	if (!pos)
		return ILData();

	if (!guid_)
		throw std::runtime_error("Invalid .NET format");
	return guid_->GetData(pos - 1);
}

ILData ILMetaData::GetBlob(uint32_t pos) const
{
	if (!pos)
		return ILData();

	if (!blob_)
		throw std::runtime_error("Invalid .NET format");
	return blob_->GetData(pos);
}

uint32_t ILMetaData::AddUserString(const std::string &str) const
{
	if (!user_strings_)
		throw std::runtime_error("Invalid .NET format");
	return user_strings_->AddString(str);
}

uint32_t ILMetaData::AddString(const std::string &str) const
{
	if (!strings_)
		throw std::runtime_error("Invalid .NET format");
	return strings_->AddString(str);
}

uint32_t ILMetaData::AddGuid(const ILData &data) const
{
	if (data.empty())
		return 0;

	if (!guid_)
		throw std::runtime_error("Invalid .NET format");
	return guid_->AddData(data) + 1;
}

uint32_t ILMetaData::AddBlob(const ILData &data) const
{
	if (data.empty())
		return 0;

	if (!blob_)
		throw std::runtime_error("Invalid .NET format");
	return blob_->AddData(data);
}

void ILMetaData::UpdateTokens()
{
	uint64_t pos = owner()->Tell();
	if (heap_)
		heap_->UpdateTokens();
	if (us_table_)
		us_table_->UpdateTokens();
	owner()->Seek(pos);
}

void ILMetaData::Rebase(uint64_t delta_base)
{
	BaseCommandList::Rebase(delta_base);
	us_table_->Rebase(delta_base);
}

const char *ElementTypeToName[ELEMENT_TYPE_MAX] =
{
	"", "Void", "Boolean", "Char",
	"SByte", "Byte", "Int16", "UInt16",
	"Int32", "UInt32", "Int64", "UInt64",
	"Single", "Double", "String", "", "", "", "", "", "", "", "", "", "IntPtr", "UIntPtr", "", "", "Object", "Array", "", "", "", ""
};

ILToken *ILMetaData::GetType(const ILElement &element) const
{
	std::string type_name;
	ILTable *table;
	size_t i;
	ILToken *assembly_ref;

	switch (element.type()) {
	case ELEMENT_TYPE_VOID:
	case ELEMENT_TYPE_BOOLEAN:
	case ELEMENT_TYPE_CHAR:
	case ELEMENT_TYPE_I1:
	case ELEMENT_TYPE_U1:
	case ELEMENT_TYPE_I2:
	case ELEMENT_TYPE_U2:
	case ELEMENT_TYPE_I4:
	case ELEMENT_TYPE_U4:
	case ELEMENT_TYPE_I8:
	case ELEMENT_TYPE_U8:
	case ELEMENT_TYPE_R4:
	case ELEMENT_TYPE_R8:
	case ELEMENT_TYPE_STRING:
	case ELEMENT_TYPE_I:
	case ELEMENT_TYPE_U:
	case ELEMENT_TYPE_OBJECT:
	case ELEMENT_TYPE_SZARRAY:
		assembly_ref = GetCoreLib();
		if (!assembly_ref)
			throw std::runtime_error("Unknown framework");

		return GetTypeRef(assembly_ref, "System", ElementTypeToName[element.type()]);
		break;
	case ELEMENT_TYPE_GENERICINST:
	case ELEMENT_TYPE_PTR:
	case ELEMENT_TYPE_ARRAY:
		type_name = element.name();
		table = this->table(ttTypeSpec);
		for (i = 0; i < table->count(); i++) {
			ILTypeSpec *ref = reinterpret_cast<ILTypeSpec *>(table->item(i));
			if (ref->name() == type_name)
				return ref;
		}
		break;
	case ELEMENT_TYPE_CLASS:
	case ELEMENT_TYPE_VALUETYPE:
		return element.token();
	default:
		throw std::runtime_error("Invalid element type");
	}

	return NULL;
}

ILTypeRef *ILMetaData::ImportTypeRef(ILToken *resolution_scope, const std::string &name_space, const std::string &name)
{
	ILTypeRef *res = GetTypeRef(resolution_scope, name_space, name);
	if (!res)
		res = AddTypeRef(resolution_scope, name_space, name);
	return res;
}

ILTypeRef *ILMetaData::GetTypeRef(ILToken *resolution_scope, const std::string &name_space, const std::string &name) const
{
	ILTable *table = this->table(ttTypeRef);
	for (size_t i = 0; i < table->count(); i++) {
		ILTypeRef *ref = reinterpret_cast<ILTypeRef *>(table->item(i));
		if (ref->resolution_scope() == resolution_scope && ref->name_space() == name_space && ref->name() == name)
			return ref;
	}
	return NULL;
}

ILTypeRef *ILMetaData::AddTypeRef(ILToken *resolution_scope, const std::string &name_space, const std::string &name)
{
	ILTable *table = this->table(ttTypeRef);
	ILTypeRef *res = new ILTypeRef(this, table, resolution_scope, name_space, name);
	table->AddObject(res);
	return res;
}

ILToken *ILMetaData::AddType(const ILElement &element)
{
	ILData data;
	ILTable *table;
	ILToken *assembly_ref;
	ILToken *res;

	switch (element.type()) {
	case ELEMENT_TYPE_VOID:
	case ELEMENT_TYPE_BOOLEAN:
	case ELEMENT_TYPE_CHAR:
	case ELEMENT_TYPE_I1:
	case ELEMENT_TYPE_U1:
	case ELEMENT_TYPE_I2:
	case ELEMENT_TYPE_U2:
	case ELEMENT_TYPE_I4:
	case ELEMENT_TYPE_U4:
	case ELEMENT_TYPE_I8:
	case ELEMENT_TYPE_U8:
	case ELEMENT_TYPE_R4:
	case ELEMENT_TYPE_R8:
	case ELEMENT_TYPE_STRING:
	case ELEMENT_TYPE_I:
	case ELEMENT_TYPE_U:
	case ELEMENT_TYPE_OBJECT:
	case ELEMENT_TYPE_SZARRAY:
		assembly_ref = GetCoreLib();
		if (!assembly_ref)
			throw std::runtime_error("Unknown framework");

		return AddTypeRef(assembly_ref, "System", ElementTypeToName[element.type()]);
	case ELEMENT_TYPE_GENERICINST:
	case ELEMENT_TYPE_PTR:
	case ELEMENT_TYPE_ARRAY:
		element.WriteToData(data);
		table = this->table(ttTypeSpec);
		res = new ILTypeSpec(this, table, data);
		table->AddObject(res);
		return res;
	default:
		throw std::runtime_error("Invalid element type");
	}

	return NULL;
}

ILToken *ILMetaData::ImportType(CorElementType type)
{
	ILElement element(NULL, NULL, type);
	return ImportType(element);
}

ILToken *ILMetaData::ImportType(const ILElement &element)
{
	ILToken *res = GetType(element);
	if (!res)
		res = AddType(element);
	return res;
}

ILMethodDef *ILMetaData::GetMethod(uint64_t address) const
{
	ILTable *table = this->table(ttMethodDef);
	for (size_t i = 0; i < table->count(); i++) {
		ILMethodDef *method = reinterpret_cast<ILMethodDef*>(table->item(i));
		if (method->address() == address)
			return method;
	}
	return NULL;
}

ILTypeDef *ILMetaData::GetTypeDef(const std::string &name) const
{
	ILTable *table = this->table(ttTypeDef);
	for (size_t i = 0; i < table->count(); i++) {
		ILTypeDef *type_def = reinterpret_cast<ILTypeDef*>(table->item(i));
		if (type_def->full_name() == name)
			return type_def;
	}
	return NULL;
}

ILExportedType *ILMetaData::GetExportedType(const std::string &name) const
{
	ILTable *table = this->table(ttExportedType);
	for (size_t i = 0; i < table->count(); i++) {
		ILExportedType *exported_type = reinterpret_cast<ILExportedType*>(table->item(i));
		if (exported_type->full_name() == name)
			return exported_type;
	}
	return NULL;
}

ILAssemblyRef *ILMetaData::GetAssemblyRef(const std::string &name) const
{
	ILTable *table = this->table(ttAssemblyRef);
	bool is_full_name = (name.find(',') != std::string::npos);
	for (size_t i = 0; i < table->count(); i++) {
		ILAssemblyRef *ref = reinterpret_cast<ILAssemblyRef*>(table->item(i));
		if (is_full_name) {
			if (ref->full_name() == name)
				return ref;
		}
		else {
			if (ref->name() == name)
				return ref;
		}
	}
	return NULL;
}

ILStandAloneSig *ILMetaData::AddStandAloneSig(const ILData &data)
{
	ILTable *table = this->table(ttStandAloneSig);
	ILStandAloneSig *signature = new ILStandAloneSig(this, table, data);
	table->AddObject(signature);
	signature->set_value(static_cast<uint32_t>(table->count()));
	return signature;
}

ILAssemblyRef *ILMetaData::GetCoreLib() const
{
	ILTable *table = this->table(ttAssemblyRef);
	for (size_t i = 0; i < table->count(); i++) {
		ILAssemblyRef *ref = reinterpret_cast<ILAssemblyRef *>(table->item(i));
		if (ref->name() == "mscorlib" || ref->name() == "System.Runtime" || ref->name() == "netstandard")
			return ref;
	}
	return NULL;
}

ILTypeDef *ILMetaData::AddTypeDef(ILToken *base_type, const std::string &name_space, const std::string &name, CorTypeAttr flags)
{
	ILTable *table = this->table(ttTypeDef);
	ILTypeDef *res = new ILTypeDef(this, table, base_type, name_space, name, flags);
	table->AddObject(res);
	return res;
}

ILMethodDef *ILMetaData::AddMethod(ILTypeDef *declaring_type, const std::string &name, const ILData &signature, CorMethodAttr flags, CorMethodImpl impl_flags)
{
	ILMethodDef *res = new ILMethodDef(this, table(ttMethodDef), name, signature, flags, impl_flags);
	res->set_declaring_type(declaring_type);
	declaring_type->AddMethod(res);
	return res;
}

ILMetaData *ILMetaData::ResolveAssembly(const std::string &name, bool show_error) const
{
	if (ILAssembly *assembly = reinterpret_cast<ILAssembly *>(token(ttAssembly | 1))) {
		std::string self_name = (name.find(',') == std::string::npos) ? assembly->name() : assembly->full_name();
		if (self_name == name)
			return const_cast<ILMetaData *>(this);
	}

	ILMetaData *res = resolver.Resolve(*this, name);
	if (!res && show_error)
		throw std::runtime_error(string_format("Can't resolve assembly: %s", name.c_str()));

	return res;
}

ILTypeDef *ILMetaData::ResolveType(const std::string &name, bool show_error)
{
	size_t pos = 0;
	size_t length = name.size();

	std::string type_name;
	while (pos < length) {
		char c = name[pos];
		if (c == ',' || c == '+')
			break;
		pos++;
	}
	type_name = name.substr(0, pos);

	std::vector<std::string> nested_names;
	while (pos < length && name[pos] == '+') {
		pos++;
		size_t start = pos;
		while (pos < length) {
			char c = name[pos];
			if (c == ',' || c == '+')
				break;
			pos++;
		}
		nested_names.push_back(name.substr(start, pos - start));
	}

	std::string assembly_name;
	if (pos < length && name[pos] == ',') {
		pos++;
		while (pos < length && name[pos] == ' ') {
			pos++;
		}

		size_t start = pos;
		while (pos < length) {
			char c = name[pos];
			if (c == '[' || c == ']')
				break;
			pos++;
		}
		assembly_name = name.substr(start, pos - start);
	}

	if (assembly_name.empty() && nested_names.empty() && name.substr(0, 7) == "System.") {
		std::string corlib_type = name.substr(7);
		const char *corlib_types[] = { "Void", "Boolean", "Char", "SByte", "Byte", "Int16", "UInt16", "Int32", "UInt32", "Int64", "UInt64", "Single", "Double", "String", "TypedReference", "IntPtr", "UIntPtr", "Object" };
		for (size_t i = 0; i < _countof(corlib_types); i++) {
			if (corlib_types[i] == corlib_type) {
				if (ILAssemblyRef *assembly_ref = GetCoreLib())
					assembly_name = assembly_ref->full_name();
				break;
			}
		}
	}
	
	ILMetaData *assembly = assembly_name.empty() ? this : ResolveAssembly(assembly_name, show_error);
	if (assembly) {
		ILTypeDef *type_def = assembly->GetTypeDef(type_name);
		if (!type_def) {
			if (ILExportedType *exported_type = assembly->GetExportedType(type_name))
				type_def = Resolve(exported_type, show_error);
		}
		if (type_def) {
			for (size_t i = 0; i < nested_names.size(); i++) {
				type_def = type_def->GetNested(nested_names[i]);
				if (!type_def)
					break;
			}
			return type_def;
		}
	}

	if (show_error)
		throw std::runtime_error(string_format("Can't resolve type: %s", name.c_str()));

	return NULL;
}

ILTypeDef *ILMetaData::Resolve(const ILExportedType *exported_type, bool show_error) const
{
	std::string type_name = exported_type->full_name();

	std::set<const ILExportedType *> recursion_stack;
	while (true) {
		if (recursion_stack.find(exported_type) != recursion_stack.end())
			break;
		recursion_stack.insert(exported_type);

		const ILExportedType *non_nested_type = exported_type;
		while (non_nested_type->declaring_type()) {
			non_nested_type = non_nested_type->declaring_type();
		}

		ILToken *scope = non_nested_type->implementation();
		if (scope && scope->type() == ttAssemblyRef) {
			if (ILMetaData *assembly = ResolveAssembly(reinterpret_cast<ILAssemblyRef *>(scope)->full_name(), show_error)) {
				if (ILTypeDef *type_def = assembly->GetTypeDef(type_name))
					return type_def;
				exported_type = assembly->GetExportedType(type_name);
				if (exported_type)
					continue;
			}
		}
		break;
	}

	return NULL;
}

ILTypeDef *ILMetaData::Resolve(const ILTypeRef *type_ref, bool show_error) const
{
	std::string type_name = type_ref->full_name();

	const ILTypeRef *non_nested_type = type_ref;
	while (non_nested_type->declaring_type()) {
		non_nested_type = non_nested_type->declaring_type();
	}

	ILToken *scope = non_nested_type->resolution_scope();
	if (scope && scope->type() == ttAssemblyRef) {
		if (ILMetaData *assembly = ResolveAssembly(reinterpret_cast<ILAssemblyRef *>(scope)->full_name(), show_error)) {
			ILTypeDef *type_def = assembly->GetTypeDef(type_name);
			if (!type_def) {
				if (ILExportedType *exported_type = assembly->GetExportedType(type_name))
					type_def = Resolve(exported_type, show_error);
			}
			if (type_def)
				return type_def;
		}
	}

	if (show_error)
		throw std::runtime_error(string_format("Can't resolve token: %.8x", type_ref->id()));

	return NULL;
}

/**
 * TokenReference
 */

TokenReference::TokenReference(TokenReferenceList *owner, uint64_t address, uint32_t command_type)
	: IObject(), owner_(owner), address_(address), is_deleted_(false), command_type_(command_type)
{

}

TokenReference::TokenReference(TokenReferenceList *owner, const TokenReference &src)
	: IObject(src), owner_(owner)
{
	address_ = src.address_;
	is_deleted_ = src.is_deleted_;
	command_type_ = src.command_type_;
}

TokenReference::~TokenReference()
{
	if (owner_)
		owner_->RemoveObject(this);
}

void TokenReference::set_owner(TokenReferenceList *owner)
{
	if (owner == owner_)
		return;
	if (owner_)
		owner_->RemoveObject(this);
	owner_ = owner;
	if (owner_)
		owner_->AddObject(this);
}

TokenReference *TokenReference::Clone(TokenReferenceList *owner) const
{
	TokenReference *ref = new TokenReference(owner, *this);
	return ref;
}

void TokenReference::Rebase(uint64_t delta_base)
{
	address_ += delta_base;
}

/**
 * TokenReferenceList
 */

TokenReferenceList::TokenReferenceList(ILToken *owner)
	: ObjectList<TokenReference>(), owner_(owner)
{

}

TokenReferenceList::TokenReferenceList(ILToken *owner, const TokenReferenceList &src)
	: ObjectList<TokenReference>(src), owner_(owner)
{
	for (size_t i = 0; i < src.count(); i++) {
		AddObject(src.item(i)->Clone(this));
	}
}

TokenReferenceList *TokenReferenceList::Clone(ILToken *owner) const
{
	TokenReferenceList *list = new TokenReferenceList(owner, *this);
	return list;
}

TokenReference *TokenReferenceList::Add(uint64_t address, uint32_t command_type)
{
	TokenReference *ref = new TokenReference(this, address, command_type);
	AddObject(ref);
	return ref;
}

TokenReference *TokenReferenceList::GetReferenceByAddress(uint64_t address) const
{
	for (size_t i = 0; i < count(); i++) {
		TokenReference *ref = item(i);
		if (ref->address() == address)
			return ref;
	}
	return NULL;
}

void TokenReferenceList::Rebase(uint64_t delta_base)
{
	for (size_t i = 0; i < count(); i++) {
		item(i)->Rebase(delta_base);
	}
}

/**
 * EncodingDesc
 */

const ILTokenType resolution_scope_types[] = {ttModule, ttModuleRef, ttAssemblyRef, ttTypeRef};
const ILTokenType typedef_ref_types[] = {ttTypeDef, ttTypeRef, ttTypeSpec};
const ILTokenType type_or_methoddef_types[] = {ttTypeDef, ttMethodDef};
const ILTokenType has_semantics_types[] = {ttEvent, ttProperty};
const ILTokenType methoddef_ref_types[] = {ttMethodDef, ttMemberRef};
const ILTokenType member_forwarded_types[] = {ttField, ttMethodDef};
const ILTokenType has_field_marshal_types[] = {ttField, ttParam};
const ILTokenType implementation_types[] = {ttFile, ttAssemblyRef, ttExportedType};
const ILTokenType member_ref_parent_types[] = {ttTypeDef, ttTypeRef, ttModuleRef, ttMethodDef, ttTypeSpec};
const ILTokenType has_constant_types[] = {ttField, ttParam, ttProperty};
const ILTokenType custom_attribute_types[] = {ttInvalid, ttInvalid, ttMethodDef, ttMemberRef};
const ILTokenType has_custom_attribute_types[] = {ttMethodDef, ttField, ttTypeRef, ttTypeDef, ttParam, ttInterfaceImpl, ttMemberRef, ttModule, ttDeclSecurity,
	ttProperty, ttEvent, ttStandAloneSig, ttModuleRef, ttTypeSpec, ttAssembly, ttAssemblyRef, ttFile, ttExportedType,
	ttManifestResource, ttGenericParam, ttGenericParamConstraint, ttMethodSpec};
const ILTokenType has_decl_security_types[] = {ttTypeDef, ttMethodDef, ttAssembly};

const EncodingDesc ResolutionScope = EncodingDesc(resolution_scope_types, _countof(resolution_scope_types), 2);
const EncodingDesc TypeDefRef = EncodingDesc(typedef_ref_types, _countof(typedef_ref_types), 2);
const EncodingDesc TypeMethodDef = EncodingDesc(type_or_methoddef_types, _countof(type_or_methoddef_types), 1);
const EncodingDesc HasSemantics = EncodingDesc(has_semantics_types, _countof(has_semantics_types), 1);
const EncodingDesc MethodDefRef = EncodingDesc(methoddef_ref_types, _countof(methoddef_ref_types), 1);
const EncodingDesc MemberForwarded = EncodingDesc(member_forwarded_types, _countof(member_forwarded_types), 1);
const EncodingDesc HasFieldMarshal = EncodingDesc(has_field_marshal_types, _countof(has_field_marshal_types), 1);
const EncodingDesc Implementation = EncodingDesc(implementation_types, _countof(implementation_types), 2);
const EncodingDesc MemberRefParent = EncodingDesc(member_ref_parent_types, _countof(member_ref_parent_types), 3);
const EncodingDesc HasConstant = EncodingDesc(has_constant_types, _countof(has_constant_types), 2);
const EncodingDesc CustomAttribute = EncodingDesc(custom_attribute_types, _countof(custom_attribute_types), 3);
const EncodingDesc HasCustomAttribute = EncodingDesc(has_custom_attribute_types, _countof(has_custom_attribute_types), 5);
const EncodingDesc HasDeclSecurity = EncodingDesc(has_decl_security_types, _countof(has_decl_security_types), 2);

/**
 * ILToken
 */

ILToken::ILToken(ILMetaData *meta, ILTable *owner, uint32_t id)
	: IObject(), meta_(meta), owner_(owner), id_(id), is_deleted_(false), can_rename_(true)
{
	reference_list_ = new TokenReferenceList(this);
}

ILToken::ILToken(ILMetaData *meta, ILTable *owner, const ILToken &src)
	: IObject(), meta_(meta), owner_(owner)
{
	id_ = src.id_;
	is_deleted_ = src.is_deleted_;
	can_rename_ = src.can_rename_;
	reference_list_ = src.reference_list_->Clone(this);
}

ILToken::~ILToken()
{
	if (owner_)
		owner_->RemoveObject(this);
	delete reference_list_;
}

ILToken *ILToken::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILToken *token = new ILToken(meta, owner, *this);
	return token;
}

void ILToken::set_value(uint32_t value, IArchitecture *file)
{
	if (value == this->value())
		return;

	id_ = TOKEN_TYPE(id_) | TOKEN_VALUE(value);
	if (file) {
		for (size_t i = 0; i < reference_list_->count(); i++) {
			TokenReference *reference = reference_list_->item(i);
			if (reference->is_deleted() || !reference->address())
				continue;

			if (!file->AddressSeek(reference->address()))
				throw std::runtime_error("Invalid reference address");
			file->WriteDWord(id_);
		}
	}
}

void ILToken::set_owner(ILMetaData *meta, ILTable *owner)
{
	meta_ = meta;
	if (owner == owner_)
		return;
	if (owner_)
		owner_->RemoveObject(this);
	owner_ = owner;
	if (owner_)
		owner_->AddObject(this);
}

ILToken *ILToken::next() const 
{ 
	return meta_->token(id() + 1);
}

std::string ILToken::ReadStringFromFile(NETArchitecture &file) const
{
	uint32_t value = (meta_->string_field_size() == sizeof(uint16_t)) ? file.ReadWord() : file.ReadDWord();
	return meta_->GetString(value);
}

std::string ILToken::ReadUserString(uint32_t value) const
{
	return meta_->GetUserString(value);
}

ILData ILToken::ReadBlobFromFile(NETArchitecture &file) const
{
	uint32_t value = (meta_->blob_field_size() == sizeof(uint16_t)) ? file.ReadWord() : file.ReadDWord();
	return meta_->GetBlob(value);
}

ILData ILToken::ReadGUIDFromFile(NETArchitecture &file) const
{
	std::string res;
	uint32_t value = (meta_->guid_field_size() == sizeof(uint16_t)) ? file.ReadWord() : file.ReadDWord();
	return meta_->GetGuid(value);
}

ILToken *ILToken::ReadTokenFromFile(NETArchitecture &file, const EncodingDesc &desc) const
{
	uint32_t value = (meta_->field_size(desc) == sizeof(uint16_t)) ? file.ReadWord() : file.ReadDWord();
	size_t i = (value & ((1 << desc.bits) - 1));
	if (i >= desc.size || desc.types[i] == ttInvalid)
		throw std::runtime_error("Unknown ref type");
	return meta_->token(desc.types[i] | (value >> desc.bits));
}

ILToken *ILToken::ReadTokenFromFile(NETArchitecture &file, ILTokenType type) const
{
	uint32_t value = (meta_->field_size(type) == sizeof(uint16_t)) ? file.ReadWord() : file.ReadDWord();
	return meta_->token(type | value);
}

void ILToken::WriteStringToFile(NETArchitecture &file, uint32_t pos) const
{
	if (meta_->string_field_size() == sizeof(uint16_t)) 
		file.WriteWord(static_cast<uint16_t>(pos));
	else
		file.WriteDWord(pos);
}

void ILToken::WriteGuidToFile(NETArchitecture &file, uint32_t pos) const
{
	if (meta_->guid_field_size() == sizeof(uint16_t)) 
		file.WriteWord(static_cast<uint16_t>(pos));
	else
		file.WriteDWord(pos);
}

void ILToken::WriteBlobToFile(NETArchitecture &file, uint32_t pos) const
{
	if (meta_->blob_field_size() == sizeof(uint16_t)) 
		file.WriteWord(static_cast<uint16_t>(pos));
	else
		file.WriteDWord(pos);
}

void ILToken::WriteTokenToFile(NETArchitecture &file, ILTokenType type, ILToken *token) const
{
	uint32_t value = token ? token->value() : 0;
	if (meta_->field_size(type) == sizeof(uint16_t)) 
		file.WriteWord(static_cast<uint16_t>(value));
	else
		file.WriteDWord(value);
}

void ILToken::WriteTokenListToFile(NETArchitecture &file, ILTokenType type, ILToken *token) const
{
	uint32_t value = token ? token->value() : static_cast<uint32_t>(meta_->table(type)->count() + 1);
	if (meta_->field_size(type) == sizeof(uint16_t)) 
		file.WriteWord(static_cast<uint16_t>(value));
	else
		file.WriteDWord(value);
}

uint32_t ILToken::Encode(const EncodingDesc &desc) const
{
	uint32_t res = value() << desc.bits;
	for (size_t i = 0; i < desc.size; i++) {
		if (type() == desc.types[i]) {
			res |= i;
			break;
		}
	}
	return res;
}

void ILToken::WriteTokenToFile(NETArchitecture &file, const EncodingDesc &desc, ILToken *token) const
{
	uint32_t value = token ? token->Encode(desc) : 0;
	if (meta_->field_size(desc) == sizeof(uint16_t)) 
		file.WriteWord(static_cast<uint16_t>(value));
	else
		file.WriteDWord(value);
}

void ILToken::Rebase(uint64_t delta_base)
{
	reference_list_->Rebase(delta_base);
}

int ILToken::CompareWith(const ILToken &other) const
{
	throw std::runtime_error("Abstract error");
}

/**
 * ILAssembly
 */

ILAssembly::ILAssembly(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), hash_id_(0), major_version_(0), minor_version_(0), build_number_(0), revision_number_(0), flags_(0), 
	name_pos_(0), public_key_pos_(0), culture_pos_(0)
{

}

ILAssembly::ILAssembly(ILMetaData *meta, ILTable *owner, const std::string &name)
	: ILToken(meta, owner, ttAssembly), hash_id_(0), major_version_(0), minor_version_(0), build_number_(0), revision_number_(0), flags_(0),
	name_pos_(0), public_key_pos_(0), culture_pos_(0), name_(name)
{

}

ILAssembly::ILAssembly(ILMetaData *meta, ILTable *owner, const ILAssembly &src)
	: ILToken(meta, owner, src), name_pos_(0), public_key_pos_(0), culture_pos_(0)
{
	hash_id_ = src.hash_id_;
	major_version_ = src.major_version_;
	minor_version_ = src.minor_version_;
	build_number_ = src.build_number_;
	revision_number_ = src.revision_number_;
	flags_ = src.flags_;
	public_key_ = src.public_key_;
	name_ = src.name_;
	culture_ = src.culture_;
}

ILToken *ILAssembly::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILAssembly *token = new ILAssembly(meta, owner, *this);
	return token;
}

void ILAssembly::ReadFromFile(NETArchitecture &file)
{
	hash_id_ = file.ReadDWord();
	major_version_ = file.ReadWord();
	minor_version_ = file.ReadWord();
	build_number_ = file.ReadWord();
	revision_number_ = file.ReadWord();
	flags_ = file.ReadDWord();
	public_key_ = ReadBlobFromFile(file);
	name_ = ReadStringFromFile(file);
	culture_ = ReadStringFromFile(file);
}

void ILAssembly::WriteToStreams(ILMetaData &data)
{
	public_key_pos_ = data.AddBlob(public_key_);
	name_pos_ = data.AddString(name_);
	culture_pos_ = data.AddString(culture_);
}

void ILAssembly::WriteToFile(NETArchitecture &file)
{
	file.WriteDWord(hash_id_);
	file.WriteWord(major_version_);
	file.WriteWord(minor_version_);
	file.WriteWord(build_number_);
	file.WriteWord(revision_number_);
	file.WriteDWord(flags_);
	WriteBlobToFile(file,public_key_pos_);
	WriteStringToFile(file, name_pos_);
	WriteStringToFile(file, culture_pos_);
}

std::string ILAssembly::full_name() const
{
	std::string res = name_;
	res += ", Version=" + string_format("%d.%d.%d.%d", major_version_, minor_version_, build_number_, revision_number_);
	res += ", Culture=" + (!culture_.empty() ? culture_ : "neutral");
	res += ", PublicKeyToken=";
	if (public_key_.empty())
		res += "null";
	else {
		SHA1 sha;
		sha.Input(public_key_.data(), public_key_.size());
		const uint8_t *p = sha.Result();
		for (size_t i = 0; i < 8; i++) {
			res += string_format("%.2x", p[sha.ResultSize() - 1 - i]);
		}
	}
	return res;
}

/**
 * ILAssemblyOS
 */

ILAssemblyOS::ILAssemblyOS(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), os_platform_id_(0), os_major_version_(0), os_minor_version_(0)
{

}

void ILAssemblyOS::ReadFromFile(NETArchitecture &file)
{
	os_platform_id_ = file.ReadDWord();
	os_major_version_ = file.ReadDWord();
	os_minor_version_ = file.ReadDWord();
}

void ILAssemblyOS::WriteToFile(NETArchitecture &file)
{
	file.WriteDWord(os_platform_id_);
	file.WriteDWord(os_major_version_);
	file.WriteDWord(os_minor_version_);
}

/**
 * ILAssemblyProcessor
 */

ILAssemblyProcessor::ILAssemblyProcessor(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), processor_(0)
{

}

void ILAssemblyProcessor::ReadFromFile(NETArchitecture &file)
{
	processor_ = file.ReadDWord();
}

void ILAssemblyProcessor::WriteToFile(NETArchitecture &file)
{
	file.WriteDWord(processor_);
}

/**
 * ILAssemblyRef
 */

ILAssemblyRef::ILAssemblyRef(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), major_version_(0), minor_version_(0), build_number_(0), revision_number_(0), flags_(0), name_pos_(0),
	public_key_or_token_pos_(0), culture_pos_(0), hash_value_pos_(0)
{

}

ILAssemblyRef::ILAssemblyRef(ILMetaData *meta, ILTable *owner, const std::string &name)
	: ILToken(meta, owner, ttAssemblyRef), major_version_(0), minor_version_(0), build_number_(0), revision_number_(0), flags_(0), name_pos_(0),
	public_key_or_token_pos_(0), culture_pos_(0), hash_value_pos_(0), name_(name)
{

}

ILAssemblyRef::ILAssemblyRef(ILMetaData *meta, ILTable *owner, const ILAssemblyRef &src)
	: ILToken(meta, owner, src), name_pos_(0), public_key_or_token_pos_(0), culture_pos_(0), hash_value_pos_(0)
{
	major_version_ = src.major_version_;
	minor_version_ = src.minor_version_;
	build_number_ = src.build_number_;
	revision_number_ = src.revision_number_;
	flags_ = src.flags_;
	public_key_or_token_ = src.public_key_or_token_;
	name_ = src.name_;
	culture_ = src.culture_;
	hash_value_ = src.hash_value_;
}

ILToken *ILAssemblyRef::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILAssemblyRef *token = new ILAssemblyRef(meta, owner, *this);
	return token;
}

void ILAssemblyRef::ReadFromFile(NETArchitecture &file)
{
	major_version_ = file.ReadWord();
	minor_version_ = file.ReadWord();
	build_number_ = file.ReadWord();
	revision_number_ = file.ReadWord();
	flags_ = file.ReadDWord();
	public_key_or_token_ = ReadBlobFromFile(file);
	name_ = ReadStringFromFile(file);
	culture_ = ReadStringFromFile(file);
	hash_value_ = ReadBlobFromFile(file);
}

void ILAssemblyRef::WriteToStreams(ILMetaData &data)
{
	public_key_or_token_pos_ = data.AddBlob(public_key_or_token_);
	name_pos_ = data.AddString(name_);
	culture_pos_ = data.AddString(culture_);
	hash_value_pos_ = data.AddBlob(hash_value_);
}

void ILAssemblyRef::WriteToFile(NETArchitecture &file)
{
	file.WriteWord(major_version_);
	file.WriteWord(minor_version_);
	file.WriteWord(build_number_);
	file.WriteWord(revision_number_);
	file.WriteDWord(flags_);
	WriteBlobToFile(file, public_key_or_token_pos_);
	WriteStringToFile(file, name_pos_);
	WriteStringToFile(file, culture_pos_);
	WriteBlobToFile(file, hash_value_pos_);
}

std::string ILAssemblyRef::full_name() const
{
	std::string res = name_;
	res += ", Version=" + string_format("%d.%d.%d.%d", major_version_, minor_version_, build_number_, revision_number_);
	res += ", Culture=" + (!culture_.empty() ? culture_ : "neutral");
	res += ", PublicKeyToken=";
	if (public_key_or_token_.empty())
		res += "null";
	else {
		if (flags_ & afPublicKey) {
			SHA1 sha;
			sha.Input(public_key_or_token_.data(), public_key_or_token_.size());
			const uint8_t *p = sha.Result();
			for (size_t i = 0; i < 8; i++) {
				res += string_format("%.2x", p[sha.ResultSize() - 1 - i]);
			}
		}
		else {
			for (size_t i = 0; i < public_key_or_token_.size(); i++) {
				res += string_format("%.2x", public_key_or_token_[i]);
			}
		}
	}
	return res;
}

/**
 * ILAssemblyRefOS
 */

ILAssemblyRefOS::ILAssemblyRefOS(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), os_platform_id_(0), os_major_version_(0), os_minor_version_(0), assembly_ref_(0)
{

}

void ILAssemblyRefOS::ReadFromFile(NETArchitecture &file)
{
	os_platform_id_ = file.ReadDWord();
	os_major_version_ = file.ReadDWord();
	os_minor_version_ = file.ReadDWord();
	assembly_ref_ = reinterpret_cast<ILAssemblyRef *>(ReadTokenFromFile(file, ttAssemblyRef));
}

void ILAssemblyRefOS::WriteToFile(NETArchitecture &file)
{
	file.WriteDWord(os_platform_id_);
	file.WriteDWord(os_major_version_);
	file.WriteDWord(os_minor_version_);
	WriteTokenToFile(file, ttAssemblyRef, assembly_ref_);
}

void ILAssemblyRefOS::UpdateTokens()
{
	if (assembly_ref_)
		assembly_ref_ = reinterpret_cast<ILAssemblyRef *>(meta()->token(assembly_ref_->id()));
}

/**
 * ILAssemblyRefProcessor
 */

ILAssemblyRefProcessor::ILAssemblyRefProcessor(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), processor_(0), assembly_ref_(0)
{

}

void ILAssemblyRefProcessor::ReadFromFile(NETArchitecture &file)
{
	processor_ = file.ReadDWord();
	assembly_ref_ = reinterpret_cast<ILAssemblyRef *>(ReadTokenFromFile(file, ttAssemblyRef));
}

void ILAssemblyRefProcessor::WriteToFile(NETArchitecture &file)
{
	file.WriteDWord(processor_);
	WriteTokenToFile(file, ttAssemblyRef, assembly_ref_);
}

void ILAssemblyRefProcessor::UpdateTokens()
{
	if (assembly_ref_)
		assembly_ref_ = reinterpret_cast<ILAssemblyRef *>(meta()->token(assembly_ref_->id()));
}

/**
 * ILClassLayout
 */

ILClassLayout::ILClassLayout(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), packing_size_(0), class_size_(0), parent_(0)
{

}

ILClassLayout::ILClassLayout(ILMetaData *meta, ILTable *owner, const ILClassLayout &src)
	: ILToken(meta, owner, src)
{
	packing_size_ = src.packing_size_;
	class_size_ = src.class_size_;
	parent_ = src.parent_;
}

ILToken *ILClassLayout::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILClassLayout *token = new ILClassLayout(meta, owner, *this);
	return token;
}

void ILClassLayout::ReadFromFile(NETArchitecture &file)
{
	packing_size_ = file.ReadWord();
	class_size_ = file.ReadDWord();
	parent_ = reinterpret_cast<ILTypeDef *>(ReadTokenFromFile(file, ttTypeDef));
}

void ILClassLayout::WriteToFile(NETArchitecture &file)
{
	file.WriteWord(packing_size_);
	file.WriteDWord(class_size_);
	WriteTokenToFile(file, ttTypeDef, parent_);
}

void ILClassLayout::UpdateTokens()
{
	if (parent_)
		parent_ = reinterpret_cast<ILTypeDef *>(meta()->token(parent_->id()));
}

void ILClassLayout::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(parent_);
	if (it != token_map.end()) {
		parent_ = reinterpret_cast<ILTypeDef *>(it->second);
		if (!parent_)
			set_deleted(true);
	}
}

/**
 * ILConstant
 */

ILConstant::ILConstant(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), type_(0), padding_zero_(0), parent_(NULL), value_pos_(0)
{

}

ILConstant::ILConstant(ILMetaData *meta, ILTable *owner, const ILConstant &src)
	: ILToken(meta, owner, src), value_pos_(0)
{
	type_ = src.type_;
	padding_zero_ = src.padding_zero_;
	parent_ = src.parent_;
	value_ = src.value_;
}

ILToken *ILConstant::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILConstant *token = new ILConstant(meta, owner, *this);
	return token;
}

void ILConstant::ReadFromFile(NETArchitecture &file)
{
	type_ = file.ReadByte();
	padding_zero_ = file.ReadByte();
	parent_ = ReadTokenFromFile(file, HasConstant);
	value_ = ReadBlobFromFile(file);
}

void ILConstant::WriteToStreams(ILMetaData &data)
{
	value_pos_ = data.AddBlob(value_);
}

void ILConstant::WriteToFile(NETArchitecture &file)
{
	file.WriteByte(type_);
	file.WriteByte(padding_zero_);
	WriteTokenToFile(file, HasConstant, parent_);
	WriteBlobToFile(file, value_pos_);
}

void ILConstant::UpdateTokens()
{
	if (parent_)
		parent_ = meta()->token(parent_->id());
}

void ILConstant::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(parent_);
	if (it != token_map.end()) {
		parent_ = it->second;
		if (!parent_)
			set_deleted(true);
	}
}

int ILConstant::CompareWith(const ILToken &other) const
{
	if (other.type() == ttConstant) {
		const ILConstant &obj = reinterpret_cast<const ILConstant &>(other);
		uint32_t self_value = parent_ ? parent_->Encode(HasConstant) : 0;
		uint32_t other_value = obj.parent_ ? obj.parent_->Encode(HasConstant) : 0;
		if (self_value < other_value)
			return -1;
		if (self_value > other_value)
			return 1;
		return 0;
	}
	return ILToken::CompareWith(other);
}

/**
 * ILCustomAttribute
 */

ILCustomAttribute::ILCustomAttribute(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), parent_(NULL), type_(NULL), value_pos_(0)
{
	parser_ = new CustomAttributeValue(meta);
}

ILCustomAttribute::ILCustomAttribute(ILMetaData *meta, ILTable *owner, const ILCustomAttribute &src)
	: ILToken(meta, owner, src), value_pos_(0)
{
	parser_ = new CustomAttributeValue(meta);

	parent_ = src.parent_;
	type_ = src.type_;
	value_ = src.value_;
}

ILCustomAttribute::~ILCustomAttribute()
{
	delete parser_;
}

ILToken *ILCustomAttribute::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILCustomAttribute *token = new ILCustomAttribute(meta, owner, *this);
	return token;
}

void ILCustomAttribute::ReadFromFile(NETArchitecture &file)
{
	parent_ = ReadTokenFromFile(file, HasCustomAttribute);
	type_ = ReadTokenFromFile(file, CustomAttribute);
	value_ = ReadBlobFromFile(file);
}

void ILCustomAttribute::WriteToStreams(ILMetaData &data)
{
	value_pos_ = data.AddBlob(value_);
}

void ILCustomAttribute::WriteToFile(NETArchitecture &file)
{
	WriteTokenToFile(file, HasCustomAttribute, parent_);
	WriteTokenToFile(file, CustomAttribute, type_);
	WriteBlobToFile(file, value_pos_);
}

void ILCustomAttribute::UpdateTokens()
{
	if (parent_)
		parent_ = meta()->token(parent_->id());
	if (type_)
		type_ = meta()->token(type_->id());
}

void ILCustomAttribute::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(parent_);
	if (it != token_map.end()) {
		parent_ = it->second;
		if (!parent_)
			set_deleted(true);
	}
	it = token_map.find(type_);
	if (it != token_map.end()) {
		type_ = it->second;
		if (!type_)
			set_deleted(true);
	}
}

int ILCustomAttribute::CompareWith(const ILToken &other) const
{
	if (other.type() == ttCustomAttribute) {
		const ILCustomAttribute &obj = reinterpret_cast<const ILCustomAttribute &>(other);
		uint32_t self_value = parent_ ? parent_->Encode(HasCustomAttribute) : 0;
		uint32_t other_value = obj.parent_ ? obj.parent_->Encode(HasCustomAttribute) : 0;
		if (self_value < other_value)
			return -1;
		if (self_value > other_value)
			return 1;
		return 0;
	}
	return ILToken::CompareWith(other);
}

CustomAttributeValue *ILCustomAttribute::ParseValue() const
{
	parser_->Parse(type_, value_);
	return parser_;
}

void ILCustomAttribute::UpdateValue()
{
	value_.clear();
	parser_->Write(value_);
}

/**
 * ILDeclSecurity
 */

ILDeclSecurity::ILDeclSecurity(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), action_(0), parent_(NULL), permission_set_pos_(0)
{

}

ILDeclSecurity::ILDeclSecurity(ILMetaData *meta, ILTable *owner, const ILDeclSecurity &src)
	: ILToken(meta, owner, src), permission_set_pos_(0)
{
	action_ = src.action_;
	parent_ = src.parent_;
	permission_set_ = src.permission_set_;
}

ILToken *ILDeclSecurity::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILDeclSecurity *token = new ILDeclSecurity(meta, owner, *this);
	return token;
}

void ILDeclSecurity::ReadFromFile(NETArchitecture &file)
{
	action_ = file.ReadWord();
	parent_ = ReadTokenFromFile(file, HasDeclSecurity);
	permission_set_ = ReadBlobFromFile(file);
}

void ILDeclSecurity::WriteToStreams(ILMetaData &data)
{
	permission_set_pos_ = data.AddBlob(permission_set_);
}

void ILDeclSecurity::WriteToFile(NETArchitecture &file)
{
	file.WriteWord(action_);
	WriteTokenToFile(file, HasDeclSecurity, parent_);
	WriteBlobToFile(file, permission_set_pos_);
}

void ILDeclSecurity::UpdateTokens()
{
	if (parent_)
		parent_ = meta()->token(parent_->id());
}

/**
 * ILEvent
 */

ILEvent::ILEvent(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), flags_(0), parent_(NULL), name_pos_(0), declaring_type_(NULL)
{

}

ILEvent::ILEvent(ILMetaData *meta, ILTable *owner, const ILEvent &src)
	: ILToken(meta, owner, src), name_pos_(0)
{
	flags_ = src.flags_;
	name_ = src.name_;
	parent_ = src.parent_;
	declaring_type_ = src.declaring_type_;
}

ILToken *ILEvent::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILEvent *token = new ILEvent(meta, owner, *this);
	return token;
}

void ILEvent::ReadFromFile(NETArchitecture &file)
{
	flags_ = file.ReadWord();
	name_ = ReadStringFromFile(file);
	parent_ = ReadTokenFromFile(file, TypeDefRef);
}

void ILEvent::WriteToStreams(ILMetaData &data)
{
	name_pos_ = data.AddString(name_);
}

void ILEvent::WriteToFile(NETArchitecture &file)
{
	file.WriteWord(flags_);
	WriteStringToFile(file, name_pos_);
	WriteTokenToFile(file, TypeDefRef, parent_);
}

void ILEvent::UpdateTokens()
{
	if (declaring_type_)
		declaring_type_ = reinterpret_cast<ILTypeDef *>(meta()->token(declaring_type_->id()));
	if (parent_)
		parent_ = meta()->token(parent_->id());
}

void ILEvent::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(declaring_type_);
	if (it != token_map.end()) {
		declaring_type_ = reinterpret_cast<ILTypeDef *>(it->second);
		if (!declaring_type_)
			set_deleted(true);
	}

	it = token_map.find(parent_);
	if (it != token_map.end()) {
		parent_ = reinterpret_cast<ILTypeDef *>(it->second);
		if (!parent_)
			set_deleted(true);
	}
}

bool ILEvent::is_exported() const
{
	return parent_->is_exported();
}

/**
 * ILEventMap
 */

ILEventMap::ILEventMap(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), parent_(0), event_list_(0)
{

}

ILEventMap::ILEventMap(ILMetaData *meta, ILTable *owner, const ILEventMap &src)
	: ILToken(meta, owner, src)
{
	parent_ = src.parent_;
	event_list_ = src.event_list_;
}

ILToken *ILEventMap::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILEventMap *token = new ILEventMap(meta, owner, *this);
	return token;
}

void ILEventMap::ReadFromFile(NETArchitecture &file)
{
	parent_ = reinterpret_cast<ILTypeDef *>(ReadTokenFromFile(file, ttTypeDef));
	event_list_ = reinterpret_cast<ILEvent *>(ReadTokenFromFile(file, ttEvent));
}

void ILEventMap::WriteToFile(NETArchitecture &file)
{
	WriteTokenToFile(file, ttTypeDef, parent_);

	ILEvent *event_list = NULL;
	for (ILEventMap *src = this; src != NULL && event_list == NULL; src = src->next())
		event_list = src->event_list_;
	WriteTokenListToFile(file, ttEvent, event_list);
}

void ILEventMap::UpdateTokens()
{
	if (parent_)
		parent_ = reinterpret_cast<ILTypeDef *>(meta()->token(parent_->id()));
	if (event_list_)
		event_list_ = reinterpret_cast<ILEvent *>(meta()->token(event_list_->id()));
}

/**
 * ILField
 */

ILField::ILField(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), flags_(0), declaring_type_(NULL), signature_pos_(0), name_pos_(0)
{
	signature_ = new ILSignature(meta);
}

ILField::ILField(ILMetaData *meta, ILTable *owner, const ILField &src)
	: ILToken(meta, owner, src), signature_pos_(0), name_pos_(0)
{
	flags_ = src.flags_;
	name_ = src.name_;
	declaring_type_ = src.declaring_type_;
	signature_ = src.signature_->Clone(meta);
}

ILField::~ILField()
{
	delete signature_;
}

ILToken *ILField::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILField *token = new ILField(meta, owner, *this);
	return token;
}

void ILField::ReadFromFile(NETArchitecture &file)
{
	flags_ = file.ReadWord();
	name_ = ReadStringFromFile(file);
	signature_->Parse(ReadBlobFromFile(file));
}

void ILField::UpdateTokens()
{
	if (declaring_type_)
		declaring_type_ = reinterpret_cast<ILTypeDef *>(meta()->token(declaring_type_->id()));

	signature_->UpdateTokens();
}

void ILField::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(declaring_type_);
	if (it != token_map.end()) {
		declaring_type_ = reinterpret_cast<ILTypeDef *>(it->second);
		if (!declaring_type_)
			set_deleted(true);
	}
	signature_->RemapTokens(token_map);
}

void ILField::WriteToStreams(ILMetaData &data)
{
	name_pos_ = data.AddString(name_);
	signature_pos_ = data.AddBlob(signature_->data());
}

void ILField::WriteToFile(NETArchitecture &file)
{
	file.WriteWord(flags_);
	WriteStringToFile(file, name_pos_);
	WriteBlobToFile(file, signature_pos_);
}

bool ILField::is_exported() const
{
	if (declaring_type_->is_exported()) {
		switch (flags_ & fdFieldAccessMask) {
		case fdFamily:
		case fdFamORAssem:
		case fdPublic:
			return true;
		}
	}

	return false;
}

std::string ILField::full_name(bool mode) const
{
	return ILName(signature_->ret_name(mode), declaring_type_ ? declaring_type_->full_name() : "<NULL>", name_, "");
}

/**
 * ILFieldLayout
 */

ILFieldLayout::ILFieldLayout(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), offset_(0), field_(NULL)
{

}

ILFieldLayout::ILFieldLayout(ILMetaData *meta, ILTable *owner, const ILFieldLayout &src)
	: ILToken(meta, owner, src)
{
	offset_ = src.offset_;
	field_ = src.field_;
}

ILToken *ILFieldLayout::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILFieldLayout *token = new ILFieldLayout(meta, owner, *this);
	return token;
}

void ILFieldLayout::ReadFromFile(NETArchitecture &file)
{
	offset_ = file.ReadDWord();
	field_ = reinterpret_cast<ILField *>(ReadTokenFromFile(file, ttField));
}

void ILFieldLayout::WriteToFile(NETArchitecture &file)
{
	file.WriteDWord(offset_);
	WriteTokenToFile(file, ttField, field_);
}

void ILFieldLayout::UpdateTokens()
{
	if (field_)
		field_ = reinterpret_cast<ILField *>(meta()->token(field_->id()));
}

void ILFieldLayout::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(field_);
	if (it != token_map.end()) {
		field_ = reinterpret_cast<ILField *>(it->second);
		if (!field_)
			set_deleted(true);
	}
}

/**
 * ILFieldMarshal
 */

ILFieldMarshal::ILFieldMarshal(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), parent_(NULL), native_type_pos_(0)
{

}

ILFieldMarshal::ILFieldMarshal(ILMetaData *meta, ILTable *owner, const ILFieldMarshal &src)
	: ILToken(meta, owner, src), native_type_pos_(0)
{
	parent_ = src.parent_;
	native_type_ = src.native_type_;
}

ILToken *ILFieldMarshal::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILFieldMarshal *token = new ILFieldMarshal(meta, owner, *this);
	return token;
}

void ILFieldMarshal::ReadFromFile(NETArchitecture &file)
{
	parent_ = ReadTokenFromFile(file, HasFieldMarshal);
	native_type_ = ReadBlobFromFile(file);
}

void ILFieldMarshal::WriteToStreams(ILMetaData &data)
{
	native_type_pos_ = data.AddBlob(native_type_);
}

void ILFieldMarshal::WriteToFile(NETArchitecture &file)
{
	WriteTokenToFile(file, HasFieldMarshal, parent_);
	WriteBlobToFile(file, native_type_pos_);
}

void ILFieldMarshal::UpdateTokens()
{
	if (parent_)
		parent_ = meta()->token(parent_->id());
}

/**
 * ILFieldRVA
 */

ILFieldRVA::ILFieldRVA(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), address_(0), field_(NULL)
{

}

ILFieldRVA::ILFieldRVA(ILMetaData *meta, ILTable *owner, const ILFieldRVA &src)
	: ILToken(meta, owner, src)
{
	address_ = src.address_;
	field_ = src.field_;
}

ILToken *ILFieldRVA::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILFieldRVA *token = new ILFieldRVA(meta, owner, *this);
	return token;
}

void ILFieldRVA::ReadFromFile(NETArchitecture &file)
{
	address_ = file.ReadDWord() + file.image_base();
	field_ = reinterpret_cast<ILField *>(ReadTokenFromFile(file, ttField));
}

void ILFieldRVA::WriteToFile(NETArchitecture &file)
{
	file.WriteDWord(static_cast<uint32_t>(address_ - file.image_base()));
	WriteTokenToFile(file, ttField, field_);
}

void ILFieldRVA::UpdateTokens()
{
	if (field_)
		field_ = reinterpret_cast<ILField *>(meta()->token(field_->id()));
}

void ILFieldRVA::Rebase(uint64_t delta_base)
{
	ILToken::Rebase(delta_base);

	address_ += delta_base;
}

void ILFieldRVA::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(field_);
	if (it != token_map.end()) {
		field_ = reinterpret_cast<ILField *>(it->second);
		if (!field_)
			set_deleted(true);
	}
}

/**
 * ILFile
 */

ILFile::ILFile(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), flags_(0), name_pos_(0), value_pos_(0)
{

}

void ILFile::ReadFromFile(NETArchitecture &file)
{
	flags_ = file.ReadDWord();
	name_ = ReadStringFromFile(file);
	value_ = ReadBlobFromFile(file);
}

void ILFile::WriteToStreams(ILMetaData &data)
{
	name_pos_ = data.AddString(name_);
	value_pos_ = data.AddBlob(value_);
}

void ILFile::WriteToFile(NETArchitecture &file)
{
	file.WriteDWord(flags_);
	WriteStringToFile(file, name_pos_);
	WriteBlobToFile(file, value_pos_);
}

/**
 * ILGenericParam
 */

ILGenericParam::ILGenericParam(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), number_(0), flags_(0), parent_(NULL), name_pos_(0)
{

}

ILGenericParam::ILGenericParam(ILMetaData *meta, ILTable *owner, const ILGenericParam &src)
	: ILToken(meta, owner, src), name_pos_(0)
{
	number_ = src.number_;
	flags_ = src.flags_;
	parent_ = src.parent_;
	name_ = src.name_;
}

ILToken *ILGenericParam::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILGenericParam *token = new ILGenericParam(meta, owner, *this);
	return token;
}

void ILGenericParam::ReadFromFile(NETArchitecture &file)
{
	number_ = file.ReadWord();
	flags_ = file.ReadWord();
	parent_ = ReadTokenFromFile(file, TypeMethodDef);
	name_ = ReadStringFromFile(file);
}

void ILGenericParam::WriteToStreams(ILMetaData &data)
{
	name_pos_ = data.AddString(name_);
}

void ILGenericParam::WriteToFile(NETArchitecture &file)
{
	file.WriteWord(number_);
	file.WriteWord(flags_);
	WriteTokenToFile(file, TypeMethodDef, parent_);
	WriteStringToFile(file, name_pos_);
}

void ILGenericParam::UpdateTokens()
{
	if (parent_)
		parent_ = meta()->token(parent_->id());
}

void ILGenericParam::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(parent_);
	if (it != token_map.end()) {
		parent_ = it->second;
		if (!parent_)
			set_deleted(true);
	}
}

int ILGenericParam::CompareWith(const ILToken &other) const
{
	if (other.type() == ttGenericParam) {
		const ILGenericParam &obj = reinterpret_cast<const ILGenericParam &>(other);
		uint32_t self_value = parent_ ? parent_->Encode(TypeMethodDef) : 0;
		uint32_t other_value = obj.parent_ ? obj.parent_->Encode(TypeMethodDef) : 0;
		if (self_value < other_value)
			return -1;
		if (self_value > other_value)
			return 1;

		if (number_ < obj.number_)
			return -1;
		if (number_ > obj.number_)
			return 1;
		return 0;
	}
	return ILToken::CompareWith(other);
}

/**
 * ILGenericParamConstraint
 */

ILGenericParamConstraint::ILGenericParamConstraint(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), parent_(0), constraint_(0)
{

}

ILGenericParamConstraint::ILGenericParamConstraint(ILMetaData *meta, ILTable *owner, const ILGenericParamConstraint &src)
	: ILToken(meta, owner, src)
{
	parent_ = src.parent_;
	constraint_ = src.constraint_;
}

ILToken *ILGenericParamConstraint::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILGenericParamConstraint *token = new ILGenericParamConstraint(meta, owner, *this);
	return token;
}

void ILGenericParamConstraint::ReadFromFile(NETArchitecture &file)
{
	parent_ = reinterpret_cast<ILGenericParam *>(ReadTokenFromFile(file, ttGenericParam));
	constraint_ = ReadTokenFromFile(file, TypeDefRef);
}

void ILGenericParamConstraint::WriteToFile(NETArchitecture &file)
{
	WriteTokenToFile(file, ttGenericParam, parent_);
	WriteTokenToFile(file, TypeDefRef, constraint_);
}

void ILGenericParamConstraint::UpdateTokens()
{
	if (parent_)
		parent_ = reinterpret_cast<ILGenericParam *>(meta()->token(parent_->id()));
	if (constraint_)
		constraint_ = meta()->token(constraint_->id());
}


void ILGenericParamConstraint::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(parent_);
	if (it != token_map.end()) {
		parent_ = reinterpret_cast<ILGenericParam *>(it->second);
		if (!parent_)
			set_deleted(true);
	}
	it = token_map.find(constraint_);
	if (it != token_map.end()) {
		constraint_ = it->second;
		if (!constraint_)
			set_deleted(true);
	}
}

int ILGenericParamConstraint::CompareWith(const ILToken &other) const
{
	if (other.type() == ttGenericParamConstraint) {
		const ILGenericParamConstraint &obj = reinterpret_cast<const ILGenericParamConstraint &>(other);
		uint32_t self_value = parent_->value();
		uint32_t other_value = obj.parent_->value();
		if (self_value < other_value)
			return -1;
		if (self_value > other_value)
			return 1;
		return 0;
	}
	return ILToken::CompareWith(other);
}

/**
 * ILImplMap
 */

ILImplMap::ILImplMap(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), mapping_flags_(0), member_forwarded_(0), import_scope_(0), import_name_pos_(0)
{

}

ILImplMap::ILImplMap(ILMetaData *meta, ILTable *owner, const ILImplMap &src)
	: ILToken(meta, owner, src), import_name_pos_(0)
{
	mapping_flags_ = src.mapping_flags_;
	member_forwarded_ = src.member_forwarded_;
	import_name_ = src.import_name_;
	import_scope_ = src.import_scope_;
}

ILToken *ILImplMap::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILImplMap *token = new ILImplMap(meta, owner, *this);
	return token;
}

void ILImplMap::ReadFromFile(NETArchitecture &file)
{
	mapping_flags_ = file.ReadWord();
	member_forwarded_ = ReadTokenFromFile(file, MemberForwarded);
	import_name_ = ReadStringFromFile(file);
	import_scope_ = reinterpret_cast<ILModuleRef *>(ReadTokenFromFile(file, ttModuleRef));
}

void ILImplMap::WriteToStreams(ILMetaData &data)
{
	import_name_pos_ = data.AddString(import_name_);
}

void ILImplMap::WriteToFile(NETArchitecture &file)
{
	file.WriteWord(mapping_flags_);
	WriteTokenToFile(file, MemberForwarded, member_forwarded_);
	WriteStringToFile(file, import_name_pos_);
	WriteTokenToFile(file, ttModuleRef, import_scope_);
}

void ILImplMap::UpdateTokens()
{
	if (member_forwarded_)
		member_forwarded_ = meta()->token(member_forwarded_->id());
	if (import_scope_)
		import_scope_ = reinterpret_cast<ILModuleRef *>(meta()->token(import_scope_->id()));
}

void ILImplMap::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(member_forwarded_);
	if (it != token_map.end()) {
		member_forwarded_ = it->second;
		if (!member_forwarded_)
			set_deleted(true);
	}
	it = token_map.find(import_scope_);
	if (it != token_map.end()) {
		import_scope_ = reinterpret_cast<ILModuleRef *>(it->second);
		if (!import_scope_)
			set_deleted(true);
	}
}

int ILImplMap::CompareWith(const ILToken &other) const
{
	if (other.type() == ttImplMap) {
		const ILImplMap &obj = reinterpret_cast<const ILImplMap &>(other);
		uint32_t self_value = member_forwarded_ ? member_forwarded_->Encode(MemberForwarded) : 0;
		uint32_t other_value = obj.member_forwarded_ ? obj.member_forwarded_->Encode(MemberForwarded) : 0;
		if (self_value < other_value)
			return -1;
		if (self_value > other_value)
			return 1;
		return 0;
	}
	return ILToken::CompareWith(other);
}

/**
 * ILInterfaceImpl
 */

ILInterfaceImpl::ILInterfaceImpl(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), class_(0), interface_(0)
{

}

ILInterfaceImpl::ILInterfaceImpl(ILMetaData *meta, ILTable *owner, const ILInterfaceImpl &src)
	: ILToken(meta, owner, src)
{
	class_ = src.class_;
	interface_ = src.interface_;
}

ILToken *ILInterfaceImpl::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILInterfaceImpl *token = new ILInterfaceImpl(meta, owner, *this);
	return token;
}

void ILInterfaceImpl::ReadFromFile(NETArchitecture &file)
{
	class_ = reinterpret_cast<ILTypeDef *>(ReadTokenFromFile(file, ttTypeDef));
	interface_ = ReadTokenFromFile(file, TypeDefRef);
}

void ILInterfaceImpl::WriteToFile(NETArchitecture &file)
{
	WriteTokenToFile(file, ttTypeDef, class_);
	WriteTokenToFile(file, TypeDefRef, interface_);
}

void ILInterfaceImpl::UpdateTokens()
{
	if (class_)
		class_ = reinterpret_cast<ILTypeDef *>(meta()->token(class_->id()));
	if (interface_)
		interface_ = meta()->token(interface_->id());
}

void ILInterfaceImpl::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(class_);
	if (it != token_map.end()) {
		class_ = reinterpret_cast<ILTypeDef *>(it->second);
		if (!class_)
			set_deleted(true);
	}
	it = token_map.find(interface_);
	if (it != token_map.end()) {
		interface_ = it->second;
		if (!interface_)
			set_deleted(true);
	}
}

int ILInterfaceImpl::CompareWith(const ILToken &other) const
{
	if (other.type() == ttInterfaceImpl) {
		const ILInterfaceImpl &obj = reinterpret_cast<const ILInterfaceImpl &>(other);
		uint32_t self_value = class_ ? class_->value() : 0;
		uint32_t other_value = obj.class_ ? obj.class_->value() : 0;
		if (self_value < other_value)
			return -1;
		if (self_value > other_value)
			return 1;

		self_value = interface_ ? interface_->Encode(TypeDefRef) : 0;
		other_value = obj.interface_ ? obj.interface_->Encode(TypeDefRef) : 0;
		if (self_value < other_value)
			return -1;
		if (self_value > other_value)
			return 1;
		return 0;
	}
	return ILToken::CompareWith(other);
}

/**
 * ILManifestResource
 */

ILManifestResource::ILManifestResource(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), offset_(0), flags_(0), implementation_(NULL), name_pos_(0)
{
	value_ = new ManifestResourceValue();
}

ILManifestResource::ILManifestResource(ILMetaData *meta, ILTable *owner, const ILManifestResource &src)
	: ILToken(meta, owner, src), name_pos_(0)
{
	offset_ = src.offset_;
	flags_ = src.flags_;
	name_ = src.name_;
	implementation_ = src.implementation_;
	value_ = src.value_->Clone();
}

ILManifestResource::~ILManifestResource()
{
	delete value_;
}

ILToken *ILManifestResource::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILManifestResource *token = new ILManifestResource(meta, owner, *this);
	return token;
}

void ILManifestResource::ReadFromFile(NETArchitecture &file)
{
	offset_ = file.ReadDWord();
	flags_ = file.ReadDWord();
	name_ = ReadStringFromFile(file);
	implementation_ = ReadTokenFromFile(file, Implementation);

	if (!implementation_) {
		if (uint64_t resource_address = file.header().Resources.VirtualAddress) {
			uint64_t pos = file.Tell();
			value_->ReadFromFile(file, resource_address + file.image_base() + offset_);
			file.Seek(pos);
		}
	}
}

void ILManifestResource::WriteToStreams(ILMetaData &data)
{
	name_pos_ = data.AddString(name_);
}

void ILManifestResource::WriteToFile(NETArchitecture &file)
{
	file.WriteDWord(offset_);
	file.WriteDWord(flags_);
	WriteStringToFile(file, name_pos_);
	WriteTokenToFile(file, Implementation, implementation_);
}

void ILManifestResource::UpdateTokens()
{
	if (implementation_)
		implementation_ = meta()->token(implementation_->id());
}

void ILManifestResource::UpdateValue()
{
	NETStream stream;

	value_->WriteToStream(stream);
	data_ = stream.data();
}

/**
* ManifestResourceItem
*/

ManifestResourceItem::ManifestResourceItem(ManifestResourceValue *owner, const std::string &name, uint32_t type, uint64_t address, uint32_t size, const std::vector<uint8_t> &data)
	: IObject(), owner_(owner), name_(name), type_(type), address_(address), size_(size), data_(data), baml_(NULL)
{

}

ManifestResourceItem::ManifestResourceItem(ManifestResourceValue *owner, const ManifestResourceItem &src)
	: IObject(), owner_(owner), baml_(NULL)
{
	name_ = src.name_;
	type_ = src.type_;
	address_ = src.address_;
	size_ = src.size_;
	data_ = src.data_;
}

ManifestResourceItem::~ManifestResourceItem()
{
	if (owner_)
		owner_->RemoveObject(this);
	delete baml_;
}

ManifestResourceItem *ManifestResourceItem::Clone(ManifestResourceValue *owner) const
{
	ManifestResourceItem *item = new ManifestResourceItem(owner, *this);
	return item;
}

BamlDocument *ManifestResourceItem::ParseBaml()
{
	if (baml_)
		delete baml_;

	NETStream stream;
	stream.Write(data_.data(), data_.size());
	stream.Seek(0, soBeginning);

	baml_ = new BamlDocument();
	if (baml_->ReadFromStream(stream))
		return baml_;
	return NULL;
}

int32_t ManifestResourceItem::name_hash() const
{
	os::unicode_string name = os::FromUTF8(name_);

	uint32_t hash = 5381;
	for (size_t j = 0; j < name.size(); j++) {
		hash = ((hash << 5) + hash) ^ name[j];
	}
	return hash;
}

std::vector<uint8_t> ManifestResourceItem::data() const
{
	if (baml_) {
		NETStream stream;
		baml_->WriteToStream(stream);
		return stream.data();
	}

	return data_;
}

/**
* ManifestResourceValue
*/

ManifestResourceValue::ManifestResourceValue()
	: ObjectList<ManifestResourceItem>()
{

}

ManifestResourceValue::ManifestResourceValue(const ManifestResourceValue &src)
{
	address_ = src.address_;
	size_ = src.size_;

	magic_ = src.magic_;
	header_version_ = src.header_version_;
	reader_type_name_ = src.reader_type_name_;
	set_type_name_ = src.set_type_name_;
	reader_version_ = src.reader_version_;

	for (size_t i = 0; i < src.count(); i++) {
		AddObject(src.item(i)->Clone(this));
	}
}

ManifestResourceValue *ManifestResourceValue::Clone() const
{
	ManifestResourceValue *value = new ManifestResourceValue(*this);
	return value;
}

enum ResourceTypeCode {
	// Primitives
	Null = 0,
	String = 1,
	Boolean = 2,
	Char = 3,
	Byte = 4,
	SByte = 5,
	Int16 = 6,
	UInt16 = 7,
	Int32 = 8,
	UInt32 = 9,
	Int64 = 0xa,
	UInt64 = 0xb,
	Single = 0xc,
	Double = 0xd,
	Decimal = 0xe,
	DateTime = 0xf,
	TimeSpan = 0x10,

	// Types with a special representation, like byte[] and Stream
	ByteArray = 0x20,
	Stream = 0x21,

	// User types - serialized using the binary formatter.
	StartOfUserTypes = 0x40
};

void ManifestResourceValue::ReadFromFile(NETArchitecture &file, uint64_t address)
{
	if (!file.AddressSeek(address))
		return;

	size_ = file.ReadDWord();
	address_ = address + sizeof(uint32_t);

	if (!size_)
		return;

	NETStream stream(*file.owner()->stream(), size_);

	magic_ = stream.ReadDWord();
	if (magic_ != 0xBEEFCACE)
		return;

	size_t i;
	header_version_ = stream.ReadDWord();
	uint32_t skip_bytes = stream.ReadDWord();
	if (header_version_ > 1) {
		stream.Seek(skip_bytes, soCurrent);
	} else {
		reader_type_name_ = stream.ReadString();
		set_type_name_ = stream.ReadString();
	}

	reader_version_ = stream.ReadDWord();
	if (reader_version_ != 1 && reader_version_ != 2)
		return;

	uint32_t num_resources = stream.ReadDWord();
	uint32_t num_types = stream.ReadDWord();
	for (i = 0; i < num_types; i++) {
		type_names_.push_back(stream.ReadString());
	}
	while (stream.Tell() & 7)
		stream.ReadByte();

	std::vector<uint32_t> name_hashes;
	for (i = 0; i < num_resources; i++) {
		name_hashes.push_back(stream.ReadDWord());
	}

	std::vector<uint32_t> name_offsets;
	for (i = 0; i < num_resources; i++) {
		name_offsets.push_back(stream.ReadDWord());
	}
	uint32_t data_section_offset = stream.ReadDWord();
	uint32_t name_section_offset = static_cast<uint32_t>(stream.Tell());

	struct ResourceInfo {
		std::string name;
		uint32_t offset;
		ResourceInfo(std::string _name, uint32_t _offset) : name(_name), offset(_offset) {}
	};

	std::sort(name_offsets.begin(), name_offsets.end());
	std::vector<ResourceInfo> info_list;
	for (i = 0; i < num_resources; i++) {
		stream.Seek(name_section_offset + name_offsets[i], soBeginning);
		std::string name = stream.ReadUnicodeString();
		uint32_t offset = data_section_offset + stream.ReadDWord();
		info_list.push_back(ResourceInfo(name, offset));
	}

	for (i = 0; i < num_resources; i++) {
		ResourceInfo info = info_list[i];
		stream.Seek(info.offset, soBeginning);
		uint32_t type = stream.ReadEncoded();
		uint32_t size;
		if (reader_version_ == 1) {
			throw std::runtime_error("Unsupported reader version");
		}
		else {
			switch ((ResourceTypeCode)type) {
			case Null:
				size = 0;
				break;
			case String:
				size = stream.ReadEncoded7Bit();
				break;
			case Boolean:
			case Byte:
			case SByte:
				size = sizeof(uint8_t);
				break;
			case Char:
			case Int16:
			case UInt16:
				size = sizeof(uint16_t);
				break;
			case Int32:
			case UInt32:
				size = sizeof(uint32_t);
				break;
			case Int64:
			case UInt64:
				size = sizeof(uint64_t);
				break;
			case Single:
				size = 4;
				break;
			case Double:
				size = 8;
				break;
			case Decimal:
				size = 16;
				break;
			case DateTime:
			case TimeSpan:
				size = sizeof(uint64_t);
				break;
			case ByteArray:
			case Stream:
				size = stream.ReadDWord();
				break;
			default:
				if (type >= StartOfUserTypes) {
					// search next data offset
					uint32_t next_offset = static_cast<uint32_t>(size_);
					for (size_t j = 0; j < info_list.size(); j++) {
						uint32_t cur_offset = info_list[j].offset;
						if (cur_offset > stream.Tell() && next_offset > cur_offset)
							next_offset = cur_offset;
					}
					size = next_offset - static_cast<uint32_t>(stream.Tell());
				}
				else
					throw std::runtime_error("Unknown type of resource");
				break;
			}
		}
		std::vector<uint8_t> data;
		if (size) {
			data.resize(size);
			stream.Read(data.data(), data.size());
		}
		Add(info.name, type, address_ + stream.Tell(), size, data);
	}
}

ManifestResourceItem *ManifestResourceValue::Add(const std::string &name, uint32_t id, uint64_t address, uint32_t size, const std::vector<uint8_t> &data)
{
	ManifestResourceItem *item = new ManifestResourceItem(this, name, id, address, size, data);
	AddObject(item);
	return item;
}

void ManifestResourceValue::WriteToStream(NETStream &stream)
{
	size_t i;
	uint64_t pos;

	stream.WriteDWord(magic_);
	stream.WriteDWord(header_version_);

	if (header_version_ > 1) {
		stream.WriteDWord(0);
	}
	else {
		stream.WriteDWord(0);
		pos = stream.Size();
		stream.WriteString(reader_type_name_);
		stream.WriteString(set_type_name_);
		uint32_t skip_bytes = static_cast<uint32_t>(stream.Size() - pos);

		stream.Seek(pos - sizeof(uint32_t) , soBeginning);
		stream.WriteDWord(skip_bytes);
		stream.Seek(0, soEnd);
	}
	stream.WriteDWord(reader_version_);

	stream.WriteDWord(static_cast<uint32_t>(count()));
	stream.WriteDWord(static_cast<uint32_t>(type_names_.size()));
	for (i = 0; i < type_names_.size(); i++) {
		stream.WriteString(type_names_[i]);
	}
	const char *pad_str = "PAD";
	for (i = 0; static_cast<uint32_t>(stream.Size()) & 7; i++) {
		stream.WriteByte(pad_str[i % 3]);
	}

	std::vector<int32_t> name_hashes;
	for (i = 0; i < count(); i++) {
		name_hashes.push_back(item(i)->name_hash());
	}
	std::sort(name_hashes.begin(), name_hashes.end());
	for (i = 0; i < name_hashes.size(); i++) {
		stream.WriteDWord(name_hashes[i]);
	}

	uint64_t name_offsets_pos = stream.Size();
	for (i = 0; i < count(); i++) {
		stream.WriteDWord(0);
	}

	uint64_t data_section_offset_pos = stream.Size();
	stream.WriteDWord(0);

	uint64_t name_section_offset = stream.Size();

	std::vector<uint64_t> data_offset_pos;
	for (i = 0; i < count(); i++) {
		ManifestResourceItem *resource = item(i);

		pos = stream.Size();

		std::vector<int32_t>::const_iterator it = std::find(name_hashes.begin(), name_hashes.end(), resource->name_hash());
		size_t hash_index = it - name_hashes.begin();
		stream.Seek(name_offsets_pos + hash_index * sizeof(uint32_t), soBeginning);
		stream.WriteDWord(static_cast<uint32_t>(pos - name_section_offset));
		stream.Seek(0, soEnd);

		stream.WriteUnicodeString(os::FromUTF8(resource->name()));
		data_offset_pos.push_back(stream.Size());
		stream.WriteDWord(0);
	}

	uint32_t data_section_offset = static_cast<uint32_t>(stream.Size());
	stream.Seek(data_section_offset_pos, soBeginning);
	stream.WriteDWord(data_section_offset);
	stream.Seek(0, soEnd);

	for (i = 0; i < count(); i++) {
		ManifestResourceItem *resource = item(i);

		pos = stream.Size();

		stream.Seek(data_offset_pos[i], soBeginning);
		stream.WriteDWord(static_cast<uint32_t>(pos - data_section_offset));
		stream.Seek(0, soEnd);

		stream.WriteEncoded(resource->type());

		std::vector<uint8_t> data = resource->data();
		if (reader_version_ == 1) {
			// FIXME
		} else {
			switch ((ResourceTypeCode)resource->type()) {
			case String:
				stream.WriteEncoded7Bit(static_cast<uint32_t>(data.size()));
				break;
			case ByteArray:
			case Stream:
				stream.WriteDWord(static_cast<uint32_t>(data.size()));
				break;
			}
		}

		if (!data.empty())
			stream.Write(data.data(), data.size());
	}
}

/**
 * ILMemberRef
 */

ILMemberRef::ILMemberRef(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), declaring_type_(NULL), signature_pos_(0), name_pos_(0)
{
	signature_ = new ILSignature(meta);
}

ILMemberRef::ILMemberRef(ILMetaData *meta, ILTable *owner, const ILMemberRef &src)
	: ILToken(meta, owner, src), signature_pos_(0), name_pos_(0)
{
	declaring_type_ = src.declaring_type_;
	name_ = src.name_;
	signature_ = src.signature_->Clone(meta);
}

ILMemberRef::~ILMemberRef()
{
	delete signature_;
}

ILToken *ILMemberRef::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILMemberRef *token = new ILMemberRef(meta, owner, *this);
	return token;
}

std::string ILMemberRef::full_name(bool mode, ILSignature *method_gen_signature) const
{
	std::string type_name;
	if (declaring_type_) {
		switch (declaring_type_->type()) {
		case ttTypeDef:
			type_name = reinterpret_cast<ILTypeDef *>(declaring_type_)->name();
			break;
		case ttTypeRef:
			type_name = reinterpret_cast<ILTypeRef *>(declaring_type_)->full_name(mode);
			break;
		case ttTypeSpec:
			type_name = reinterpret_cast<ILTypeSpec *>(declaring_type_)->name(mode);
			break;
		}
	}
	else
		type_name = "<NULL>";

	return ILName(signature_->ret_name(mode), type_name, name(), signature_->is_method() ? signature_->name(mode, method_gen_signature) : "");
}

void ILMemberRef::ReadFromFile(NETArchitecture &file)
{
	declaring_type_ = ReadTokenFromFile(file, MemberRefParent);
	name_ = ReadStringFromFile(file);
	signature_->Parse(ReadBlobFromFile(file));
}

void ILMemberRef::WriteToStreams(ILMetaData &data)
{
	name_pos_ = data.AddString(name_);
	signature_pos_ = data.AddBlob(signature_->data());
}

void ILMemberRef::WriteToFile(NETArchitecture &file)
{
	WriteTokenToFile(file, MemberRefParent, declaring_type_);
	WriteStringToFile(file, name_pos_);
	WriteBlobToFile(file, signature_pos_);
}

void ILMemberRef::UpdateTokens()
{
	if (declaring_type_)
		declaring_type_ = meta()->token(declaring_type_->id());
	signature_->UpdateTokens();
}

void ILMemberRef::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(declaring_type_);
	if (it != token_map.end()) {
		declaring_type_ = it->second;
		if (!declaring_type_)
			set_deleted(true);
	}
	signature_->RemapTokens(token_map);
}

/**
 * ILCustomMod
 */

ILCustomMod::ILCustomMod(ILMetaData *meta)
	: IObject(), meta_(meta), type_(ELEMENT_TYPE_END), token_(NULL)
{

}

ILCustomMod::ILCustomMod(ILMetaData *meta, const ILCustomMod &src)
	: IObject(), meta_(meta)
{
	type_ = src.type_;
	token_ = src.token_;
}

ILCustomMod *ILCustomMod::Clone(ILMetaData *meta)
{
	ILCustomMod *mod = new ILCustomMod(meta, *this);
	return mod;
}

void ILCustomMod::Parse(const ILData &data, uint32_t &id)
{
	type_ = static_cast<CorElementType>(data.ReadByte(id));
	switch (type_) {
	case ELEMENT_TYPE_CMOD_REQD:
	case ELEMENT_TYPE_CMOD_OPT:
		// do nothing
		break;
	default:
		throw std::runtime_error("Invalid mod type");
	}

	uint32_t value = data.ReadEncoded(id);
	ILTokenType ref_type;
	switch (value & 3) {
	case 0:
		ref_type = ttTypeDef;
		break;
	case 1:
		ref_type = ttTypeRef;
		break;
	case 2:
		ref_type = ttTypeSpec;
		break;
	default:
		throw std::runtime_error("Invalid token");
	}

	token_ = meta_->token(ref_type | (value >> 2));
	if (!token_)
		throw std::runtime_error("Invalid token");
}

void ILCustomMod::WriteToData(ILData &data)
{
	data.push_back(type_);
	uint32_t value = token_->value() << 2;
	switch (token_->type()) {
	case ttTypeDef:
		value |= 0;
		break;
	case ttTypeRef:
		value |= 1;
		break;
	case ttTypeSpec:
		value |= 2;
		break;
	}
	data.WriteEncoded(value);
}

std::string ILCustomMod::name(bool mode) const
{
	std::string res = (type_ == ELEMENT_TYPE_CMOD_REQD) ? "modreq" : "modopt";

	res += '(';
	switch (token_->type()) {
	case ttTypeRef:
		res += reinterpret_cast<ILTypeRef*>(token_)->full_name(mode);
		break;
	case ttTypeDef:
		res += reinterpret_cast<ILTypeDef*>(token_)->full_name();
		break;
	}
	res += ')';

	return res;
}

void ILCustomMod::UpdateTokens()
{
	if (token_)
		token_ = meta_->token(token_->id());
}

void ILCustomMod::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	if (token_) {
		std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(token_);
		if (it != token_map.end())
			token_ = it->second;
	}
}

/**
 * ILElement
 */

ILElement::ILElement(ILMetaData *meta, ILSignature *owner, CorElementType type, ILToken *token, ILElement *next)
	: IObject(), meta_(meta), owner_(owner), type_(type), next_(next), byref_(false),
	token_(token), method_(NULL), generic_param_(0), array_shape_(NULL), pinned_(false), is_predicate_(false)
{

}

ILElement::ILElement(ILMetaData *meta, ILSignature *owner, const ILElement &src)
	: IObject(), meta_(meta), owner_(owner), next_(NULL), method_(NULL), array_shape_(NULL)
{
	type_ = src.type_;
	byref_ = src.byref_;
	pinned_ = src.pinned_;
	generic_param_ = src.generic_param_;
	is_predicate_ = src.is_predicate_;
	if (src.next_)
		next_ = src.next_->Clone(meta, NULL);
	token_ = src.token_;
	if (src.method_)
		method_ = src.method_->Clone(meta);
	if (src.array_shape_)
		array_shape_ = src.array_shape_->Clone();
	for (size_t i = 0; i < src.mod_list_.size(); i++) {
		mod_list_.push_back(src.mod_list_[i]->Clone(meta));
	}
	for (size_t i = 0; i < src.child_list_.size(); i++) {
		child_list_.push_back(src.child_list_[i]->Clone(meta, NULL));
	}
}

ILElement::~ILElement()
{
	if (owner_)
		owner_->RemoveObject(this);

	for (size_t i = 0; i < mod_list_.size(); i++) {
		delete mod_list_[i];
	}
	for (size_t i = 0; i < child_list_.size(); i++) {
		delete child_list_[i];
	}

	delete next_;
	delete method_;
	delete array_shape_;
}

ILElement *ILElement::Clone(ILMetaData *meta, ILSignature *owner)
{
	ILElement *element = new ILElement(meta, owner, *this);
	return element;
}

ILCustomMod *ILElement::AddMod()
{
	ILCustomMod *mod = new ILCustomMod(meta_);
	mod_list_.push_back(mod);
	return mod;
}

ILElement *ILElement::AddElement()
{
	ILElement *element = new ILElement(meta_, NULL);
	child_list_.push_back(element);
	return element;
}

void ILElement::Parse(const ILData &data)
{
	uint32_t id = 0;
	Parse(data, id);
}

void ILElement::Parse(const ILData &data, uint32_t &id)
{
	for (bool mod_found = true; mod_found;) {
		switch (data.ReadByte(id)) {
		case ELEMENT_TYPE_BYREF:
			byref_ = true;
			break;
		case ELEMENT_TYPE_PINNED:
			pinned_ = true;
			break;
		case ELEMENT_TYPE_CMOD_REQD:
		case ELEMENT_TYPE_CMOD_OPT:
			{
				id--;
				ILCustomMod *mod = AddMod();
				mod->Parse(data, id);
			}
			break;
		default:
			mod_found = false;
			id--;
			break;
		}
	}

	type_ = static_cast<CorElementType>(data.ReadEncoded(id));

	switch (type_){
	case ELEMENT_TYPE_VOID:
	case ELEMENT_TYPE_BOOLEAN:
	case ELEMENT_TYPE_CHAR:
	case ELEMENT_TYPE_I1:
	case ELEMENT_TYPE_U1:
	case ELEMENT_TYPE_I2:
	case ELEMENT_TYPE_U2:
	case ELEMENT_TYPE_I4:
	case ELEMENT_TYPE_U4:
	case ELEMENT_TYPE_I8:
	case ELEMENT_TYPE_U8:
	case ELEMENT_TYPE_R4:
	case ELEMENT_TYPE_R8:
	case ELEMENT_TYPE_I:
	case ELEMENT_TYPE_U:
	case ELEMENT_TYPE_STRING:
	case ELEMENT_TYPE_OBJECT:
	case ELEMENT_TYPE_TYPEDBYREF:
	case ELEMENT_TYPE_SENTINEL:
	case ELEMENT_TYPE_PINNED:
		break;
	case ELEMENT_TYPE_VALUETYPE:
	case ELEMENT_TYPE_CLASS: 
		{
			uint32_t value = data.ReadEncoded(id);
			ILTokenType ref_type;
			switch (value & 3) {
			case 0:
				ref_type = ttTypeDef;
				break;
			case 1:
				ref_type = ttTypeRef;
				break;
			case 2:
				ref_type = ttTypeSpec;
				break;
			default:
				throw std::runtime_error("Invalid token");
			}

			token_ = meta_->token(ref_type | (value >> 2));
			if (!token_)
				throw std::runtime_error("Invalid token");
		}
		break;
	case ELEMENT_TYPE_SZARRAY:
		next_ = new ILElement(meta_, NULL);
		next_->Parse(data, id);
		break;
	case ELEMENT_TYPE_PTR:
		next_ = new ILElement(meta_, NULL);
		next_->Parse(data, id);
		break;
	case ELEMENT_TYPE_FNPTR:
		method_ = new ILSignature(meta_);
		method_->Parse(data, id);
		if (!method_->is_method())
			throw std::runtime_error("Invalid signature type");
		break;
	case ELEMENT_TYPE_ARRAY:
		next_ = new ILElement(meta_, NULL);
		next_->Parse(data, id);
		array_shape_ = new ILArrayShape();
		array_shape_->Parse(data, id);
		break;
	case ELEMENT_TYPE_MVAR:
	case ELEMENT_TYPE_VAR:
		generic_param_ = data.ReadEncoded(id);
		break;
	case ELEMENT_TYPE_GENERICINST:
		next_ = new ILElement(meta_, NULL);
		next_->Parse(data, id);
		{
			uint32_t count = data.ReadEncoded(id);
			for (size_t i = 0; i < count; i++) {
				ILElement *element = AddElement();
				element->Parse(data, id);
			}
		}
		break;
	default:
		throw std::runtime_error("Invalid element type");
	}
}

std::string ILElement::name(bool mode) const
{
	std::string res;

	switch (type_) {
	case ELEMENT_TYPE_VOID:
		res += "void";
		break;
	case ELEMENT_TYPE_BOOLEAN:
		res += "bool";
		break;
	case ELEMENT_TYPE_CHAR:
		res += "char";
		break;
	case ELEMENT_TYPE_I1:
		res += "int8";
		break;
	case ELEMENT_TYPE_U1:
		res += "unsigned int8";
		break;
	case ELEMENT_TYPE_I2:
		res += "int16";
		break;
	case ELEMENT_TYPE_U2:
		res += "unsigned int16";
		break;
	case ELEMENT_TYPE_I4:
		res += "int32";
		break;
	case ELEMENT_TYPE_U4:
		res += "unsigned int32";
		break;
	case ELEMENT_TYPE_I8:
		res += "int64";
		break;
	case ELEMENT_TYPE_U8:
		res += "unsigned int64";
		break;
	case ELEMENT_TYPE_R4:
		res += "float32";
		break;
	case ELEMENT_TYPE_R8:
		res += "float64";
		break;
	case ELEMENT_TYPE_I:
		res += "native int";
		break;
	case ELEMENT_TYPE_U:
		res += "native unsigned int";
		break;
	case ELEMENT_TYPE_OBJECT:
		res += "object";
		break;
	case ELEMENT_TYPE_STRING:
		res += "string";
		break;
	case ELEMENT_TYPE_SZARRAY:
		res += next_->name(mode);
		res += "[]";
		break;
	case ELEMENT_TYPE_PTR:
		res += next_->name(mode);
		res += '*';
		break;
	case ELEMENT_TYPE_TYPEDBYREF:
		res += "typedref";
		break;
	case ELEMENT_TYPE_FNPTR:
		{
			std::string call_type = method_->type_name();
			res = string_format("method %s%s%s *%s", call_type.c_str(), call_type.empty() ? "" :  " ", method_->ret_name(mode).c_str(), method_->name(mode).c_str());
		}
		break;
	case ELEMENT_TYPE_ARRAY:
		res += next_->name(mode);
		res += ' ';
		res += array_shape_->name();
		break;
	case ELEMENT_TYPE_VALUETYPE:
	case ELEMENT_TYPE_CLASS:
		res += (type_ == ELEMENT_TYPE_VALUETYPE) ? "valuetype " : "class ";

		switch (token_->type()) {
		case ttTypeRef:
			res += reinterpret_cast<ILTypeRef*>(token_)->full_name(mode);
			break;
		case ttTypeDef:
			res += reinterpret_cast<ILTypeDef*>(token_)->full_name();
			break;
		}
		break;
	case ELEMENT_TYPE_GENERICINST:
		res += next_->name(mode);
		res += '<';
		for (size_t i = 0; i < child_list_.size(); i++) {
			if (i > 0)
				res += ", ";
			res += child_list_[i]->name(mode);
		}
		res += '>';
		break;
	case ELEMENT_TYPE_MVAR:
	case ELEMENT_TYPE_VAR:
		res += string_format("%s%d", (type_ == ELEMENT_TYPE_VAR) ? "!" : "!!", generic_param_);
		break;
	default:
		// FIXME
		res += "???";
	}

	for (size_t i = 0; i < mod_list_.size(); i++) {
		res += ' ';
		res += mod_list_[i]->name(mode);
	}

	if (byref_)
		res += '&';

	if (pinned_)
		res += " pinned";

	return res;
}

void ILElement::UpdateTokens()
{
	if (token_)
		token_ = meta_->token(token_->id());
	if (method_)
		method_->UpdateTokens();
	if (next_)
		next_->UpdateTokens();
	for (size_t i = 0; i < mod_list_.size(); i++) {
		mod_list_[i]->UpdateTokens();
	}
	for (size_t i = 0; i < child_list_.size(); i++) {
		child_list_[i]->UpdateTokens();
	}
}

void ILElement::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	if (token_) {
		std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(token_);
		if (it != token_map.end())
			token_ = it->second;
	}
	if (method_)
		method_->RemapTokens(token_map);
	if (next_)
		next_->RemapTokens(token_map);
	for (size_t i = 0; i < mod_list_.size(); i++) {
		mod_list_[i]->RemapTokens(token_map);
	}
	for (size_t i = 0; i < child_list_.size(); i++) {
		child_list_[i]->RemapTokens(token_map);
	}
}

ILData ILElement::data() const
{
	ILData data;
	WriteToData(data);
	return data;
}

void ILElement::WriteToData(ILData &data) const
{
	if (pinned_)
		data.push_back(ELEMENT_TYPE_PINNED);
	if (byref_)
		data.push_back(ELEMENT_TYPE_BYREF);

	for (size_t i = 0; i < mod_list_.size(); i++) {
		ILCustomMod *mod = mod_list_[i];
		mod->WriteToData(data);
	}
	
	data.WriteEncoded(type_);
	switch (type_) {
	case ELEMENT_TYPE_VALUETYPE:
	case ELEMENT_TYPE_CLASS: 
		{
			uint32_t value = token_->value() << 2;
			switch (token_->type()) {
			case ttTypeDef:
				value |= 0;
				break;
			case ttTypeRef:
				value |= 1;
				break;
			case ttTypeSpec:
				value |= 2;
				break;
			}
			data.WriteEncoded(value);
		}
		break;
	case ELEMENT_TYPE_SZARRAY:
	case ELEMENT_TYPE_PTR:
		next_->WriteToData(data);
		break;
	case ELEMENT_TYPE_FNPTR:
		method_->WriteToData(data);
		break;
	case ELEMENT_TYPE_ARRAY:
		next_->WriteToData(data);
		array_shape_->WriteToData(data);
		break;
	case ELEMENT_TYPE_MVAR:
	case ELEMENT_TYPE_VAR:
		data.WriteEncoded(generic_param_);
		break;
	case ELEMENT_TYPE_GENERICINST:
		next_->WriteToData(data);
		{
			data.WriteEncoded(static_cast<uint32_t>(child_list_.size()));
			for (size_t i = 0; i < child_list_.size(); i++) {
				ILElement *element = child_list_[i];
				element->WriteToData(data);
			}
		}
		break;
	}
}

/**
 * ILArrayShape
 */

ILArrayShape::ILArrayShape()
	: IObject(), rank_(0)
{

}

ILArrayShape::ILArrayShape(const ILArrayShape &src)
	: IObject()
{
	rank_ = src.rank_;
	sizes_ = src.sizes_;
	lo_bounds_ = src.lo_bounds_;
}

ILArrayShape *ILArrayShape::Clone()
{
	ILArrayShape *shape = new ILArrayShape(*this);
	return shape;
}

std::string ILArrayShape::name() const
{
	std::string res;

	res += '[';
	for (size_t i = 0; i < rank_; i++) {
		if (i > 0)
			res += ',';
		if (i < lo_bounds_.size()) {
			uint32_t lo_bound = lo_bounds_[i];
			res += string_format("%d..", lo_bound);
			if (i < sizes_.size())
				res += string_format("%d", lo_bound + sizes_[rank_] - 1);
			else
				res += '.';
		}
	}
	res += ']';
	return res;
}

void ILArrayShape::Parse(const ILData &data, uint32_t &id)
{
	rank_ = data.ReadEncoded(id);
	uint32_t count = data.ReadEncoded(id);
	for (uint32_t i = 0; i < count; i++) {
		sizes_.push_back(data.ReadEncoded(id));
	}
	count = data.ReadEncoded(id);
	for (uint32_t i = 0; i < count; i++) {
		lo_bounds_.push_back(data.ReadEncoded(id));
	}
}

void ILArrayShape::WriteToData(ILData &data) const
{
	data.WriteEncoded(rank_);
	data.WriteEncoded(static_cast<uint32_t>(sizes_.size()));
	for (uint32_t i = 0; i < sizes_.size(); i++) {
		data.WriteEncoded(sizes_[i]);
	}
	data.WriteEncoded(static_cast<uint32_t>(lo_bounds_.size()));
	for (uint32_t i = 0; i < lo_bounds_.size(); i++) {
		data.WriteEncoded(lo_bounds_[i]);
	}
}

/**
 * ILSignature
 */

ILSignature::ILSignature(ILMetaData *meta)
	: ObjectList<ILElement>(), meta_(meta), type_(stDefault), gen_param_count_(0)
{
	ret_ = new ILElement(meta, NULL);
}

ILSignature::ILSignature(ILMetaData *meta, const ILSignature &src)
	: ObjectList<ILElement>(), meta_(meta)
{
	type_ = src.type_;
	gen_param_count_ = src.gen_param_count_;
	ret_ = src.ret_->Clone(meta, this);

	for (size_t i = 0; i < src.count(); i++) {
		AddObject(src.item(i)->Clone(meta, this));
	}
}

ILSignature::~ILSignature()
{
	delete ret_;
}

ILSignature *ILSignature::Clone(ILMetaData *meta)
{
	ILSignature *sign = new ILSignature(meta, *this);
	return sign;
}

ILElement *ILSignature::Add()
{
	ILElement *element = new ILElement(meta_, this);
	AddObject(element);
	return element;
}

void ILSignature::Parse(const ILData &data)
{
	uint32_t id = 0;
	Parse(data, id);
}

bool ILSignature::Parse(const ILData &data, uint32_t &id)
{
	type_ = static_cast<ILSignatureType>(data.ReadByte(id));
	if (type_ & stGeneric)
		gen_param_count_ = data.ReadEncoded(id);

	switch (type_ & 0x0f) {
	case stDefault:
	case stC:
	case stStdCall:
	case stThisCall:
	case stFastCall:
	case stVarArg:
	case stUnmanaged:
	case stNativeVarArg:
	case stProperty:
		{
			uint32_t param_count = data.ReadEncoded(id);
			ret_->Parse(data, id);
			for (uint32_t i = 0; i < param_count; i++) {
				ILElement *element = Add();
				element->Parse(data, id);
			}
		}
		break;
	case stField:
		ret_->Parse(data, id);
		break;
	case stLocal:
	case stGenericinst:
		{
			uint32_t param_count = data.ReadEncoded(id);
			for (uint32_t i = 0; i < param_count; i++) {
				ILElement *element = Add();
				element->Parse(data, id);
			}
		}
		break;
	default:
		throw std::runtime_error("Unknown signature type");
	}

	return true;
}

std::string ILSignature::name(bool mode, ILSignature *gen_signature) const
{
	std::string res;

	bool is_generic_inst = false;
	switch (type_ & 0x0f) {
	case stGenericinst:
		is_generic_inst = true;
		// fall through
	case stDefault:
	case stC:
	case stStdCall:
	case stThisCall:
	case stFastCall:
	case stVarArg:
	case stLocal:
	case stUnmanaged:
	case stNativeVarArg:
		if (type_ & stGeneric) {
			if (gen_signature)
				res += gen_signature->name(mode);
			else {
				res += '<';
				for (size_t i = 0; i < gen_param_count_; i++) {
					if (i > 0)
						res += ", ";
					res += string_format("%d", i);
				}
				res += '>';
			}
		}

		res += is_generic_inst ? '<' : '(';
		for (size_t i = 0; i < count(); i++) {
			if (i > 0)
				res += ", ";
			res += item(i)->name(mode);
		}
		res += is_generic_inst ? '>' : ')';
		break;
	}

	return res;
}

std::string ILSignature::type_name() const
{
	std::string res;

	switch (type_ & 0x0f) {
	case stDefault:
		break;
	case stC:
		break;
	case stStdCall:
		res = "stdcall";
		break;
	case stThisCall:
		res = "thiscall";
		break;
	case stFastCall:
		res = "fastcall";
		break;
	}

	return res;
}

std::string ILSignature::ret_name(bool mode) const
{
	std::string res;

	if (has_this())
		res = "instance ";

	res += ret_->name(mode);
	return res;
}

void ILSignature::WriteToData(ILData &data) const
{
	data.push_back(type_);

	if (type_ & stGeneric)
		data.WriteEncoded(gen_param_count_);

	switch (type_ & 0x0f) {
	case stDefault:
	case stC:
	case stStdCall:
	case stThisCall:
	case stFastCall:
	case stVarArg:
	case stProperty:
	case stUnmanaged:
	case stNativeVarArg:
		{
			data.WriteEncoded(static_cast<uint32_t>(count()));
			ret_->WriteToData(data);
			for (size_t i = 0; i < count(); i++) {
				item(i)->WriteToData(data);
			}
		}
		break;
	case stField:
		ret_->WriteToData(data);
		break;
	case stLocal:
	case stGenericinst:
		{
			data.WriteEncoded(static_cast<uint32_t>(count()));
			for (size_t i = 0; i < count(); i++) {
				item(i)->WriteToData(data);
			}
		}
		break;
	}
}

void ILSignature::UpdateTokens()
{
	if (ret_)
		ret_->UpdateTokens();
	for (size_t i = 0; i < count(); i++) {
		item(i)->UpdateTokens();
	}
}

void ILSignature::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	if (ret_)
		ret_->RemapTokens(token_map);
	for (size_t i = 0; i < count(); i++) {
		item(i)->RemapTokens(token_map);
	}
}

ILData ILSignature::data() const
{
	ILData data;
	WriteToData(data);
	return data;
}

bool ILSignature::is_method() const
{
	switch (type_ & 0x0f) {
	case stDefault:
	case stC:
	case stStdCall:
	case stThisCall:
	case stFastCall:
	case stVarArg:
	case stUnmanaged:
	case stNativeVarArg:
		return true;
	default:
		return false;
	}
}

bool ILSignature::is_field() const
{
	return ((type_ & 0x0f) == stField);
}
	
/**
 * ILMethod
 */

ILMethodDef::ILMethodDef(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), address_(0), impl_flags_(miIL), flags_(mdPrivateScope), param_list_(NULL),
	declaring_type_(NULL), locals_(NULL), fat_size_(0), code_size_(0), signature_pos_(0), name_pos_(0)
{
	signature_ = new ILSignature(meta);
}

ILMethodDef::ILMethodDef(ILMetaData *meta, ILTable *owner, const ILMethodDef &src)
	: ILToken(meta, owner, src), signature_pos_(0), name_pos_(0)
{
	address_ = src.address_;
	impl_flags_ = src.impl_flags_;
	flags_ = src.flags_;
	name_ = src.name_;
	signature_ = src.signature_->Clone(meta);
	param_list_ = src.param_list_;
	declaring_type_ = src.declaring_type_;
	fat_size_ = src.fat_size_;
	code_size_ = src.code_size_;
	locals_ = src.locals_;
}

ILMethodDef::ILMethodDef(ILMetaData *meta, ILTable *owner, const std::string &name, const ILData &signature, CorMethodAttr flags, CorMethodImpl impl_flags)
	: ILToken(meta, owner, ttMethodDef), name_(name), flags_(flags), param_list_(NULL), locals_(NULL), fat_size_(0), code_size_(0),
	impl_flags_(impl_flags), declaring_type_(NULL), signature_pos_(0), name_pos_(0), address_(0)
{
	signature_ = new ILSignature(meta);
	signature_->Parse(signature);
}

ILMethodDef::~ILMethodDef()
{
	delete signature_;
}

ILToken *ILMethodDef::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILMethodDef *method = new ILMethodDef(meta, owner, *this);
	return method;
}

void ILMethodDef::ReadFromFile(NETArchitecture &file)
{
	address_ = file.ReadDWord();
	if (address_)
		address_ += file.image_base();
	impl_flags_ = static_cast<CorMethodImpl>(file.ReadWord());
	flags_ = static_cast<CorMethodAttr>(file.ReadWord());
	name_ = ReadStringFromFile(file);
	signature_->Parse(ReadBlobFromFile(file));
	param_list_ = reinterpret_cast<ILParam *>(ReadTokenFromFile(file, ttParam));

	if (address_ && (impl_flags_ & miCodeTypeMask) == miIL) {
		uint64_t pos = file.Tell();
		if (file.AddressSeek(address_)) {
			IMAGE_COR_ILMETHOD_FAT fat = IMAGE_COR_ILMETHOD_FAT();
			file.Read(&fat, sizeof(uint8_t));

			switch (fat.Flags & CorILMethod_FormatMask) {
			case CorILMethod_TinyFormat:
				fat_size_ = 1;
				code_size_ = (fat.Flags >> CorILMethod_FormatShift);
				break;
			case CorILMethod_FatFormat:
				file.Read(reinterpret_cast<uint8_t *>(&fat) + 1, sizeof(fat) - 1);
				fat_size_ = fat.Size * sizeof(uint32_t);
				code_size_ = fat.CodeSize;
				if (fat.LocalVarSigTok) {
					ILToken *token = meta()->token(fat.LocalVarSigTok);
					if (!token || token->type() != ttStandAloneSig)
						throw std::runtime_error("Invalid method signature");
					locals_ = reinterpret_cast<ILStandAloneSig *>(token);
				}
				break;
			}
		}
		file.Seek(pos);
	}
}

void ILMethodDef::WriteToStreams(ILMetaData &data)
{
	name_pos_ = data.AddString(name_);
	signature_pos_ = data.AddBlob(signature_->data());
}

void ILMethodDef::WriteToFile(NETArchitecture &file)
{
	file.WriteDWord(address_ ? static_cast<uint32_t>(address_ - file.image_base()) : 0);
	file.WriteWord(impl_flags_);
	file.WriteWord(flags_);
	WriteStringToFile(file, name_pos_);
	WriteBlobToFile(file, signature_pos_);

	ILParam *param_list = NULL;
	for (ILMethodDef *src = this; src != NULL && param_list == NULL; src = src->next())
		param_list = src->param_list_;
	WriteTokenListToFile(file, ttParam, param_list);
}

void ILMethodDef::UpdateTokens()
{
	if (declaring_type_)
		declaring_type_ = reinterpret_cast<ILTypeDef *>(meta()->token(declaring_type_->id()));
	if (param_list_)
		param_list_ = reinterpret_cast<ILParam *>(meta()->token(param_list_->id()));
	if (locals_)
		locals_ = reinterpret_cast<ILStandAloneSig *>(meta()->token(locals_->id()));
	signature_->UpdateTokens();
}

void ILMethodDef::Rebase(uint64_t delta_base)
{
	ILToken::Rebase(delta_base);

	if (address_)
		address_ += delta_base;
}

void ILMethodDef::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(declaring_type_);
	if (it != token_map.end()) {
		declaring_type_ = reinterpret_cast<ILTypeDef*>(it->second);
		if (!declaring_type_)
			set_deleted(true);
	}
	signature_->RemapTokens(token_map);
}

bool ILMethodDef::is_exported() const
{
	if (declaring_type_->is_exported()) {
		switch (flags_ & mdMemberAccessMask) {
		case mdFamily:
		case mdFamORAssem:
		case mdPublic:
			return true;
		}
	}

	return false;
}

std::string ILMethodDef::full_name(bool mode, ILSignature *method_gen_signature) const
{
	return ILName(signature_->ret_name(mode), declaring_type_ ? declaring_type_->full_name() : "<NULL>", name_, signature_->name(mode, method_gen_signature));
}

/**
 * ILMethodImpl
 */

ILMethodImpl::ILMethodImpl(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), class_(0), method_body_(0), method_declaration_(0)
{

}

ILMethodImpl::ILMethodImpl(ILMetaData *meta, ILTable *owner, const ILMethodImpl &src)
	: ILToken(meta, owner, src)
{
	class_ = src.class_;
	method_body_ = src.method_body_;
	method_declaration_ = src.method_declaration_;
}
	
ILToken *ILMethodImpl::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILMethodImpl *token = new ILMethodImpl(meta, owner, *this);
	return token;
}

void ILMethodImpl::ReadFromFile(NETArchitecture &file)
{
	class_ = reinterpret_cast<ILTypeDef *>(ReadTokenFromFile(file, ttTypeDef));
	method_body_ = ReadTokenFromFile(file, MethodDefRef);
	method_declaration_ = ReadTokenFromFile(file, MethodDefRef);
}

void ILMethodImpl::WriteToFile(NETArchitecture &file)
{
	WriteTokenToFile(file, ttTypeDef, class_);
	WriteTokenToFile(file, MethodDefRef, method_body_);
	WriteTokenToFile(file, MethodDefRef, method_declaration_);
}

void ILMethodImpl::UpdateTokens()
{
	if (class_)
		class_ = reinterpret_cast<ILTypeDef *>(meta()->token(class_->id()));
	if (method_body_)
		method_body_ = meta()->token(method_body_->id());
	if (method_declaration_)
		method_declaration_ = meta()->token(method_declaration_->id());
}

int ILMethodImpl::CompareWith(const ILToken &other) const
{
	if (other.type() == ttMethodImpl) {
		const ILMethodImpl &obj = reinterpret_cast<const ILMethodImpl &>(other);
		uint32_t self_value = class_ ? class_->value() : 0;
		uint32_t other_value = obj.class_ ? obj.class_->value() : 0;
		if (self_value < other_value)
			return -1;
		if (self_value > other_value)
			return 1;
		return 0;
	}
	return ILToken::CompareWith(other);
}

/**
 * ILMethodImpl
 */

ILMethodSemantics::ILMethodSemantics(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), flags_(CorMethodSemanticsAttr(0)), method_(0), association_(0)
{

}

ILMethodSemantics::ILMethodSemantics(ILMetaData *meta, ILTable *owner, const ILMethodSemantics &src)
	: ILToken(meta, owner, src)
{
	flags_ = src.flags_;
	method_ = src.method_;
	association_ = src.association_;
}

ILToken *ILMethodSemantics::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILMethodSemantics *token = new ILMethodSemantics(meta, owner, *this);
	return token;
}

void ILMethodSemantics::ReadFromFile(NETArchitecture &file)
{
	flags_ = (CorMethodSemanticsAttr)file.ReadWord();
	method_ = reinterpret_cast<ILMethodDef *>(ReadTokenFromFile(file, ttMethodDef));
	association_ = ReadTokenFromFile(file, HasSemantics);
}

void ILMethodSemantics::WriteToFile(NETArchitecture &file)
{
	file.WriteWord(flags_);
	WriteTokenToFile(file, ttMethodDef, method_);
	WriteTokenToFile(file, HasSemantics, association_);
}

void ILMethodSemantics::UpdateTokens()
{
	if (method_)
		method_ = reinterpret_cast<ILMethodDef *>(meta()->token(method_->id()));
	if (association_)
		association_ = meta()->token(association_->id());
}

void ILMethodSemantics::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(method_);
	if (it != token_map.end()) {
		method_ = reinterpret_cast<ILMethodDef*>(it->second);
		if (!method_)
			set_deleted(true);
	}
	it = token_map.find(association_);
	if (it != token_map.end())
		association_ = it->second;
}

int ILMethodSemantics::CompareWith(const ILToken &other) const
{
	if (other.type() == ttMethodSemantics) {
		const ILMethodSemantics &obj = reinterpret_cast<const ILMethodSemantics &>(other);
		uint32_t self_value = association_ ? association_->Encode(HasSemantics) : 0;
		uint32_t other_value = obj.association_ ? obj.association_->Encode(HasSemantics) : 0;
		if (self_value < other_value)
			return -1;
		if (self_value > other_value)
			return 1;
		return 0;
	}
	return ILToken::CompareWith(other);
}

/**
 * ILMethodSpec
 */

ILMethodSpec::ILMethodSpec(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), parent_(NULL), instantiation_pos_(0)
{
	signature_ = new ILSignature(meta);
}

ILMethodSpec::ILMethodSpec(ILMetaData *meta, ILTable *owner, const ILMethodSpec &src)
	: ILToken(meta, owner, src), instantiation_pos_(0)
{
	parent_ = src.parent_;
	signature_ = src.signature_->Clone(meta);
}

ILMethodSpec::~ILMethodSpec()
{
	delete signature_;
}

ILToken *ILMethodSpec::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILMethodSpec *token = new ILMethodSpec(meta, owner, *this);
	return token;
}

void ILMethodSpec::ReadFromFile(NETArchitecture &file)
{
	parent_ = ReadTokenFromFile(file, MethodDefRef);
	signature_->Parse(ReadBlobFromFile(file));
}

void ILMethodSpec::WriteToStreams(ILMetaData &data)
{
	instantiation_pos_ = data.AddBlob(signature_->data());
}

void ILMethodSpec::WriteToFile(NETArchitecture &file)
{
	WriteTokenToFile(file, MethodDefRef, parent_);
	WriteBlobToFile(file, instantiation_pos_);
}

void ILMethodSpec::UpdateTokens()
{
	if (parent_)
		parent_ = meta()->token(parent_->id());
	signature_->UpdateTokens();
}

void ILMethodSpec::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(parent_);
	if (it != token_map.end()) {
		parent_ = it->second;
		if (!parent_)
			set_deleted(true);
	}
	signature_->RemapTokens(token_map);
}

std::string ILMethodSpec::full_name(bool mode) const
{
	if (parent_) {
		switch (parent_->type()) {
		case ttMethodDef:
			return reinterpret_cast<ILMethodDef*>(parent_)->full_name(mode, signature_);
		case ttMemberRef:
			return reinterpret_cast<ILMemberRef*>(parent_)->full_name(mode, signature_);
		}
	}

	return "<NULL>";
}

/**
 * ILModule
 */

ILModule::ILModule(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), generation_(0), name_pos_(0), mv_id_pos_(0), enc_id_pos_(0), enc_base_id_pos_(0)
{

}

ILModule::ILModule(ILMetaData *meta, ILTable *owner, const std::string &name)
	: ILToken(meta, owner, ttModule), generation_(0), name_pos_(0), mv_id_pos_(0), enc_id_pos_(0), enc_base_id_pos_(0), name_(name)
{
	for (size_t i = 0; i < 16; i++) {
		mv_id_.push_back(rand());
	}
}

ILModule::ILModule(ILMetaData *meta, ILTable *owner, const ILModule &src)
	: ILToken(meta, owner, src)
{
	generation_ = src.generation_;
	name_ = src.name_;
	mv_id_ = src.mv_id_;
	enc_id_ = src.enc_id_;
	enc_base_id_ = src.enc_base_id_;
}

ILToken *ILModule::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILModule *token = new ILModule(meta, owner, *this);
	return token;
}

void ILModule::ReadFromFile(NETArchitecture &file)
{
	generation_ = file.ReadWord();
	name_ = ReadStringFromFile(file);
	mv_id_ = ReadGUIDFromFile(file);
	enc_id_ = ReadGUIDFromFile(file);
	enc_base_id_ = ReadGUIDFromFile(file);
}

void ILModule::WriteToStreams(ILMetaData &data)
{
	name_pos_ = data.AddString(name_);
	mv_id_pos_ = data.AddGuid(mv_id_);
	enc_id_pos_ = data.AddGuid(enc_id_);
	enc_base_id_pos_ = data.AddGuid(enc_base_id_);
}

void ILModule::WriteToFile(NETArchitecture &file)
{
	file.WriteWord(generation_);
	WriteStringToFile(file, name_pos_);
	WriteGuidToFile(file, mv_id_pos_);
	WriteGuidToFile(file, enc_id_pos_);
	WriteGuidToFile(file, enc_base_id_pos_);
}

/**
 * ILModuleRef
 */

ILModuleRef::ILModuleRef(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), name_pos_(0)
{

}

ILModuleRef::ILModuleRef(ILMetaData *meta, ILTable *owner, const ILModuleRef &src)
	: ILToken(meta, owner, src), name_pos_(0)
{
	name_ = src.name_;
}

ILToken *ILModuleRef::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILModuleRef *token = new ILModuleRef(meta, owner, *this);
	return token;
}

void ILModuleRef::ReadFromFile(NETArchitecture &file)
{
	name_ = ReadStringFromFile(file);
}

void ILModuleRef::WriteToStreams(ILMetaData &data)
{
	name_pos_ = data.AddString(name_);
}

void ILModuleRef::WriteToFile(NETArchitecture &file)
{
	WriteStringToFile(file, name_pos_);
}

/**
 * ILNestedClass
 */

ILNestedClass::ILNestedClass(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), nested_type_(NULL), declaring_type_(NULL)
{

}

ILNestedClass::ILNestedClass(ILMetaData *meta, ILTable *owner, const ILNestedClass &src)
	: ILToken(meta, owner, src)
{
	nested_type_ = src.nested_type_;
	declaring_type_ = src.declaring_type_;
}

ILToken *ILNestedClass::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILNestedClass *token = new ILNestedClass(meta, owner, *this);
	return token;
}

void ILNestedClass::ReadFromFile(NETArchitecture &file)
{
	nested_type_ = reinterpret_cast<ILTypeDef*>(ReadTokenFromFile(file, ttTypeDef));
	declaring_type_ = reinterpret_cast<ILTypeDef*>(ReadTokenFromFile(file, ttTypeDef));
}

void ILNestedClass::WriteToFile(NETArchitecture &file)
{
	WriteTokenToFile(file, ttTypeDef, nested_type_);
	WriteTokenToFile(file, ttTypeDef, declaring_type_);
}

void ILNestedClass::UpdateTokens()
{
	if (nested_type_)
		nested_type_ = reinterpret_cast<ILTypeDef*>(meta()->token(nested_type_->id()));
	if (declaring_type_)
		declaring_type_ = reinterpret_cast<ILTypeDef*>(meta()->token(declaring_type_->id()));
}

void ILNestedClass::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(nested_type_);
	if (it != token_map.end()) {
		nested_type_ = reinterpret_cast<ILTypeDef*>(it->second);
		if (!nested_type_)
			set_deleted(true);
	}

	it = token_map.find(declaring_type_);
	if (it != token_map.end())
		declaring_type_ = reinterpret_cast<ILTypeDef *>(it->second);
}

/**
 * ILParam
 */

ILParam::ILParam(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), flags_(0), sequence_(0), parent_(NULL), name_pos_(0)
{

}

ILParam::ILParam(ILMetaData *meta, ILTable *owner, const ILParam &src)
	: ILToken(meta, owner, src), name_pos_(0)
{
	flags_ = src.flags_;
	sequence_ = src.sequence_;
	name_ = src.name_;
	parent_ = src.parent_;
}

ILToken *ILParam::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILParam *param = new ILParam(meta, owner, *this);
	return param;
}

void ILParam::ReadFromFile(NETArchitecture &file)
{
	flags_ = file.ReadWord();
	sequence_ = file.ReadWord();
	name_ = ReadStringFromFile(file);
}

void ILParam::WriteToStreams(ILMetaData &data)
{
	name_pos_ = data.AddString(name_);
}

void ILParam::WriteToFile(NETArchitecture &file)
{
	file.WriteWord(flags_);
	file.WriteWord(sequence_);
	WriteStringToFile(file, name_pos_);
}

void ILParam::UpdateTokens()
{
	if (parent_)
		parent_ = reinterpret_cast<ILMethodDef *>(meta()->token(parent_->id()));
}

void ILParam::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(parent_);
	if (it != token_map.end()) {
		parent_ = reinterpret_cast<ILMethodDef *>(it->second);
		if (!parent_)
			set_deleted(true);
	}
}

/**
 * ILProperty
 */

ILProperty::ILProperty(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), flags_(0), name_pos_(0), type_pos_(0), declaring_type_(NULL)
{
	type_ = new ILSignature(meta);
}

ILProperty::ILProperty(ILMetaData *meta, ILTable *owner, const ILProperty &src)
	: ILToken(meta, owner, src), name_pos_(0), type_pos_(0)
{
	flags_ = src.flags_;
	name_ = src.name_;
	type_ = src.type_->Clone(meta);
	declaring_type_ = src.declaring_type_;
	name_pos_ = src.name_pos_;
	type_pos_ = src.type_pos_;
}

ILProperty::~ILProperty()
{
	delete type_;
}

ILToken *ILProperty::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILProperty *token = new ILProperty(meta, owner, *this);
	return token;
}

void ILProperty::ReadFromFile(NETArchitecture &file)
{
	flags_ = file.ReadWord();
	name_ = ReadStringFromFile(file);
	type_->Parse(ReadBlobFromFile(file));
}

void ILProperty::WriteToStreams(ILMetaData &data)
{
	name_pos_ = data.AddString(name_);
	type_pos_ = data.AddBlob(type_->data());
}

void ILProperty::WriteToFile(NETArchitecture &file)
{
	file.WriteWord(flags_);
	WriteStringToFile(file, name_pos_);
	WriteBlobToFile(file, type_pos_);
}

void ILProperty::UpdateTokens()
{
	if (declaring_type_)
		declaring_type_ = reinterpret_cast<ILTypeDef *>(meta()->token(declaring_type_->id()));

	type_->UpdateTokens();
}

void ILProperty::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(declaring_type_);
	if (it != token_map.end()) {
		declaring_type_ = reinterpret_cast<ILTypeDef *>(it->second);
		if (!declaring_type_)
			set_deleted(true);
	}
	type_->RemapTokens(token_map);
}

bool ILProperty::is_exported() const
{
	return declaring_type_->is_exported();
}

/**
 * ILPropertyMap
 */

ILPropertyMap::ILPropertyMap(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), parent_(0), property_list_(0)
{

}

ILPropertyMap::ILPropertyMap(ILMetaData *meta, ILTable *owner, const ILPropertyMap &src)
	: ILToken(meta, owner, src)
{
	parent_ = src.parent_;
	property_list_ = src.property_list_;
}
	
ILToken *ILPropertyMap::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILPropertyMap *token = new ILPropertyMap(meta, owner, *this);
	return token;
}

void ILPropertyMap::ReadFromFile(NETArchitecture &file)
{
	parent_ = reinterpret_cast<ILTypeDef *>(ReadTokenFromFile(file, ttTypeDef));
	property_list_ = reinterpret_cast<ILProperty *>(ReadTokenFromFile(file, ttProperty));
}

void ILPropertyMap::WriteToFile(NETArchitecture &file)
{
	WriteTokenToFile(file, ttTypeDef, parent_);

	ILProperty *property_list = NULL;
	for (ILPropertyMap *src = this; src != NULL && property_list == NULL; src = src->next())
		property_list = src->property_list_;
	WriteTokenListToFile(file, ttProperty, property_list);
}

void ILPropertyMap::UpdateTokens()
{
	if (parent_)
		parent_ = reinterpret_cast<ILTypeDef *>(meta()->token(parent_->id()));
}

void ILPropertyMap::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(parent_);
	if (it != token_map.end()) {
		parent_ = reinterpret_cast<ILTypeDef *>(it->second);
		if (!parent_)
			set_deleted(true);
	}
	it = token_map.find(property_list_);
	if (it != token_map.end())
		property_list_ = reinterpret_cast<ILProperty *>(it->second);
}

bool ILPropertyMap::is_exported() const
{
	return parent_->is_exported();
}

/**
 * ILStandAloneSig
 */

ILStandAloneSig::ILStandAloneSig(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), signature_(0), signature_pos_(0)
{
	signature_ = new ILSignature(meta);
}

ILStandAloneSig::ILStandAloneSig(ILMetaData *meta, ILTable *owner, const ILStandAloneSig &src)
	: ILToken(meta, owner, src), signature_pos_(0)
{
	signature_ = src.signature_->Clone(meta);
}

ILStandAloneSig::ILStandAloneSig(ILMetaData *meta, ILTable *owner, const ILData &data)
	: ILToken(meta, owner, ttStandAloneSig)
{
	signature_ = new ILSignature(meta);
	signature_->Parse(data);
}

ILStandAloneSig *ILStandAloneSig::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILStandAloneSig *token = new ILStandAloneSig(meta, owner, *this);
	return token;
}

ILStandAloneSig::~ILStandAloneSig()
{
	delete signature_;
}

void ILStandAloneSig::ReadFromFile(NETArchitecture &file)
{
	signature_->Parse(ReadBlobFromFile(file));
}

void ILStandAloneSig::UpdateTokens()
{
	signature_->UpdateTokens();
}

void ILStandAloneSig::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	signature_->RemapTokens(token_map);
}

void ILStandAloneSig::WriteToStreams(ILMetaData &data)
{
	signature_pos_ = data.AddBlob(signature_->data());
}

void ILStandAloneSig::WriteToFile(NETArchitecture &file)
{
	WriteBlobToFile(file, signature_pos_);
}

std::string ILStandAloneSig::name(bool mode) const
{
	std::string res;
	if (signature_->is_method())
		res += signature_->ret_name(mode);

	if (!res.empty())
		res += ' ';

	return res + signature_->name(mode);
}

/**
 * ILTypeDef
 */

ILTypeDef::ILTypeDef(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), flags_(tdNotPublic), base_type_(NULL), field_list_(NULL), method_list_(NULL), declaring_type_(NULL),
	class_size_(0), name_pos_(0), namespace_pos_(0)
{

}

ILTypeDef::ILTypeDef(ILMetaData *meta, ILTable *owner, ILToken *base_type, const std::string &name_space, const std::string &name, CorTypeAttr flags)
	: ILToken(meta, owner, ttTypeDef), flags_(flags), base_type_(base_type), field_list_(NULL), method_list_(NULL), declaring_type_(NULL),
	class_size_(0), name_pos_(0), namespace_pos_(0), namespace_(name_space), name_(name)
{

}

ILTypeDef::ILTypeDef(ILMetaData *meta, ILTable *owner, const ILTypeDef &src)
	: ILToken(meta, owner, src), name_pos_(0), namespace_pos_(0)
{
	flags_ = src.flags_;
	name_ = src.name_;
	namespace_ = src.namespace_;
	base_type_ = src.base_type_;
	field_list_ = src.field_list_;
	method_list_ = src.method_list_;
	class_size_ = src.class_size_;
	declaring_type_ = src.declaring_type_;
}

ILToken *ILTypeDef::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILTypeDef *token = new ILTypeDef(meta, owner, *this);
	return token;
}

void ILTypeDef::ReadFromFile(NETArchitecture &file)
{
	flags_ = static_cast<CorTypeAttr>(file.ReadDWord());
	name_ = ReadStringFromFile(file);
	namespace_ = ReadStringFromFile(file);
	base_type_ = ReadTokenFromFile(file, TypeDefRef);
	field_list_ = reinterpret_cast<ILField *>(ReadTokenFromFile(file, ttField));
	method_list_ = reinterpret_cast<ILMethodDef *>(ReadTokenFromFile(file, ttMethodDef));
}

void ILTypeDef::UpdateTokens()
{
	if (declaring_type_)
		declaring_type_ = reinterpret_cast<ILTypeDef *>(meta()->token(declaring_type_->id()));
	if (base_type_)
		base_type_ = meta()->token(base_type_->id());
	if (field_list_)
		field_list_ = reinterpret_cast<ILField *>(meta()->token(field_list_->id()));
	if (method_list_)
		method_list_ = reinterpret_cast<ILMethodDef *>(meta()->token(method_list_->id()));
}

void ILTypeDef::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(base_type_);
	if (it != token_map.end())
		base_type_ = it->second;
	it = token_map.find(field_list_);
	if (it != token_map.end())
		field_list_ = reinterpret_cast<ILField *>(it->second);
	it = token_map.find(method_list_);
	if (it != token_map.end())
		method_list_ = reinterpret_cast<ILMethodDef *>(it->second);
}

void ILTypeDef::WriteToStreams(ILMetaData &data)
{
	name_pos_ = data.AddString(name_);
	namespace_pos_ = data.AddString(namespace_);
}

void ILTypeDef::WriteToFile(NETArchitecture &file)
{
	file.WriteDWord(flags_);
	WriteStringToFile(file, name_pos_);
	WriteStringToFile(file, namespace_pos_);
	WriteTokenToFile(file, TypeDefRef, base_type_);

	ILField *field_list = NULL;
	for (ILTypeDef *src = this; src != NULL && field_list == NULL; src = src->next())
		field_list = src->field_list_;
	WriteTokenListToFile(file, ttField, field_list);

	ILMethodDef *method_list = NULL;
	for (ILTypeDef *src = this; src != NULL && method_list == NULL; src = src->next())
		method_list = src->method_list_;
	WriteTokenListToFile(file, ttMethodDef, method_list);
}

std::string ILTypeDef::full_name() const
{
	std::string res;
	if (declaring_type_)
		res = declaring_type_->full_name() + '/';
	else {
		res = namespace_;
		if (!res.empty())
			res += '.';
	}
	res += name_;

	return res;
}

std::string ILTypeDef::reflection_name() const
{
	std::string res;
	if (declaring_type_)
		res = declaring_type_->full_name() + '+';
	else {
		res = namespace_;
		if (!res.empty())
			res += '.';
	}
	res += name_;

	return res;
}

bool ILTypeDef::is_exported() const
{
	const ILTypeDef *type_def = this;
	while (type_def->declaring_type()) {
		if ((type_def->flags() & (tdNestedPublic | tdNestedFamily | tdNestedFamORAssem)) == 0)
			return false;
		type_def = type_def->declaring_type();
	}
	return (type_def->flags() & tdPublic) != 0;
}

void ILTypeDef::AddMethod(ILMethodDef *method)
{
	size_t pos = NOT_ID;
	ILTable *type_table = meta()->table(ttTypeDef);
	ILTable *method_table = meta()->table(ttMethodDef);
	for (size_t i = type_table->IndexOf(this) + 1; i < type_table->count(); i++) {
		ILTypeDef *next = reinterpret_cast<ILTypeDef *>(type_table->item(i));
		if (next->method_list()) {
			pos = method_table->IndexOf(next->method_list());
			break;
		}
	}
	if (pos == NOT_ID)
		method_table->AddObject(method);
	else 
		method_table->InsertObject(pos, method);

	if (!method_list_)
		method_list_ = method;
}

ILField *ILTypeDef::GetField(const std::string &name) const
{
	if (field_list_) {
		ILTable *table = meta()->table(ttField);
		for (size_t i = table->IndexOf(field_list_); i < table->count(); i++) {
			ILField *field = reinterpret_cast<ILField *>(table->item(i));
			if (field->declaring_type() != this)
				break;

			if (field->name() == name)
				return field;
		}
	}

	return NULL;
}

ILMethodDef *ILTypeDef::GetMethod(const std::string &name, ILSignature *signature) const
{
	if (method_list_) {
		std::string full_name;
		if (signature)
			full_name = ILName(signature->ret_name(), this->full_name(), name, signature->name());
		ILTable *table = meta()->table(ttMethodDef);
		for (size_t i = table->IndexOf(method_list_); i < table->count(); i++) {
			ILMethodDef *method = reinterpret_cast<ILMethodDef *>(table->item(i));
			if (method->declaring_type() != this)
				break;

			if (signature) {
				if (method->full_name() == full_name)
					return method;
			}
			else {
				if (method->name() == name)
					return method;
			}
		}
	}

	return NULL;
}

ILProperty *ILTypeDef::GetProperty(const std::string &name) const
{
	ILTable *table = meta()->table(ttProperty);
	for (size_t i = 0; i < table->count(); i++) {
		ILProperty *prop = reinterpret_cast<ILProperty *>(table->item(i));
		if (prop->declaring_type() == this && prop->name() == name)
			return prop;
	}

	return NULL;
}

ILEvent *ILTypeDef::GetEvent(const std::string &name) const
{
	ILTable *table = meta()->table(ttEvent);
	for (size_t i = 0; i < table->count(); i++) {
		ILEvent *event = reinterpret_cast<ILEvent *>(table->item(i));
		if (event->declaring_type() == this && event->name() == name)
			return event;
	}

	return NULL;
}

ILTypeDef *ILTypeDef::GetNested(const std::string &name) const
{
	ILTable *table = meta()->table(ttTypeDef);
	for (size_t i = 0; i < table->count(); i++) {
		ILTypeDef *type_def = reinterpret_cast<ILTypeDef*>(table->item(i));
		if (type_def->declaring_type() == this && type_def->name() == name)
			return type_def;
	}
	return NULL;
}

ILElement *ILTypeDef::GetEnumUnderlyingType() const
{
	ILTable *table = meta()->table(ttField);
	for (size_t i = 0; i < table->count(); i++) {
		ILField *field = reinterpret_cast<ILField*>(table->item(i));
		if (field->declaring_type() == this && (field->flags() & fdStatic) == 0)
			return field->signature()->ret();
	}
	return NULL;
}

bool ILTypeDef::FindBaseType(const std::string &name) const
{
	ILToken *base_type = base_type_;
	while (base_type) {
		ILTypeDef *type_def;
		switch (base_type->type()) {
		case ttTypeRef:
			type_def = reinterpret_cast<ILTypeRef *>(base_type)->Resolve(true);
			break;
		case ttTypeDef:
			type_def = reinterpret_cast<ILTypeDef *>(base_type);
			break;
		default:
			type_def = NULL;
			break;
		}

		if (!type_def)
			break;

		if (type_def->full_name() == name)
			return true;

		base_type = type_def->base_type();
	}
	return false;
}

bool ILTypeDef::FindImplement(const std::string &name) const
{
	const ILTypeDef *type_def = this;
	while (type_def) {
		ILTable *table = type_def->meta()->table(ttInterfaceImpl);
		for (size_t i = 0; i < table->count(); i++) {
			ILInterfaceImpl *impl = reinterpret_cast<ILInterfaceImpl *>(table->item(i));
			if (impl->parent() == type_def) {
				ILToken *token = impl->_interface();
				switch (token->type()) {
				case ttTypeRef:
					if (reinterpret_cast<ILTypeRef *>(token)->full_name() == name)
						return true;
					break;
				case ttTypeDef:
					if (reinterpret_cast<ILTypeDef *>(token)->full_name() == name)
						return true;
					break;
				}
			}
		}

		if (!type_def->base_type())
			break;
		
		ILToken *base_type = type_def->base_type();
		switch (base_type->type()) {
		case ttTypeRef:
			type_def = reinterpret_cast<ILTypeRef *>(base_type)->Resolve(true);
			break;
		case ttTypeDef:
			type_def = reinterpret_cast<ILTypeDef *>(base_type);
			break;
		default:
			type_def = NULL;
			break;
		}
	}
	return false;
}

/**
 * ILTypeRef
 */

ILTypeRef::ILTypeRef(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), resolution_scope_(NULL), name_pos_(0), namespace_pos_(0)
{

}

ILTypeRef::ILTypeRef(ILMetaData *meta, ILTable *owner, ILToken *resolution_scope, const std::string &name_space, const std::string &name)
	: ILToken(meta, owner, ttTypeRef), resolution_scope_(resolution_scope), namespace_(name_space), name_(name), name_pos_(0), namespace_pos_(0)
{

}

ILTypeRef::ILTypeRef(ILMetaData *meta, ILTable *owner, const ILTypeRef &src)
	: ILToken(meta, owner, src), name_pos_(0), namespace_pos_(0)
{
	resolution_scope_ = src.resolution_scope_;
	name_ = src.name_;
	namespace_ = src.namespace_;
}

ILToken *ILTypeRef::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILTypeRef *token = new ILTypeRef(meta, owner, *this);
	return token;
}

std::string ILTypeRef::module_name() const
{
	ILTypeRef *declaring_type = this->declaring_type();
	if (declaring_type)
		return declaring_type->module_name();

	ILToken *scope = this->resolution_scope();
	if (scope) {
		switch (scope->type()) {
		case ttAssemblyRef:
			return reinterpret_cast<ILAssemblyRef*>(scope)->name();
		case ttModuleRef:
			return reinterpret_cast<ILModuleRef*>(scope)->name();
		}
	}

	return std::string();
}

ILTypeRef *ILTypeRef::declaring_type() const
{
	ILToken *scope = this->resolution_scope();
	if (scope && scope->type() == ttTypeRef)
		return reinterpret_cast<ILTypeRef*>(scope);
	return NULL;
}

std::string ILTypeRef::full_name(bool mode) const
{
	std::string res;

	res = namespace_;
	if (!res.empty())
		res += '.';
	res += name_;

	ILTypeRef *declaring_type = this->declaring_type();
	while (declaring_type) {
		res = declaring_type->full_name() + '/' + res;
		declaring_type = declaring_type->declaring_type();
	}

	if (mode)
		res = '[' + module_name() + ']' + res;

	return res;
}

void ILTypeRef::ReadFromFile(NETArchitecture &file)
{
	resolution_scope_ = ReadTokenFromFile(file, ResolutionScope);
	name_ = ReadStringFromFile(file);
	namespace_ = ReadStringFromFile(file);
}

void ILTypeRef::WriteToStreams(ILMetaData &data)
{
	name_pos_ = data.AddString(name_);
	namespace_pos_ = data.AddString(namespace_);
}

void ILTypeRef::WriteToFile(NETArchitecture &file)
{
	WriteTokenToFile(file, ResolutionScope, resolution_scope_);
	WriteStringToFile(file, name_pos_);
	WriteStringToFile(file, namespace_pos_);
}

void ILTypeRef::UpdateTokens()
{
	if (resolution_scope_)
		resolution_scope_ = meta()->token(resolution_scope_->id());
}

void ILTypeRef::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	std::map<ILToken*, ILToken*>::const_iterator it = token_map.find(resolution_scope_);
	if (it != token_map.end())
		resolution_scope_ = it->second;
}

ILTypeDef *ILTypeRef::Resolve(bool show_error) const
{
	return meta()->Resolve(this, show_error);
}

/**
 * ILTypeSpec
 */

ILTypeSpec::ILTypeSpec(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), signature_pos_(0)
{
	signature_ = new ILElement(meta, NULL);
}

ILTypeSpec::ILTypeSpec(ILMetaData *meta, ILTable *owner, const ILTypeSpec &src)
	: ILToken(meta, owner, src), signature_pos_(0)
{
	signature_ = src.signature_->Clone(meta, NULL);
}

ILTypeSpec::ILTypeSpec(ILMetaData *meta, ILTable *owner, ILData &data)
	: ILToken(meta, owner, ttTypeSpec)
{
	signature_ = new ILElement(meta, NULL);
	signature_->Parse(data);
}

ILTypeSpec::~ILTypeSpec()
{
	delete signature_;
}

ILToken *ILTypeSpec::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILTypeSpec *token = new ILTypeSpec(meta, owner, *this);
	return token;
}

void ILTypeSpec::ReadFromFile(NETArchitecture &file)
{
	signature_->Parse(ReadBlobFromFile(file));
}

void ILTypeSpec::WriteToStreams(ILMetaData &data)
{
	signature_pos_ = data.AddBlob(signature_->data());
}

void ILTypeSpec::WriteToFile(NETArchitecture &file)
{
	WriteBlobToFile(file, signature_pos_);
}

void ILTypeSpec::UpdateTokens()
{
	signature_->UpdateTokens();
}

void ILTypeSpec::RemapTokens(const std::map<ILToken*, ILToken*> &token_map)
{
	signature_->RemapTokens(token_map);
}

/**
 * ILUserString
 */

ILUserString::ILUserString(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id)
{
	name_ = ReadUserString(value());
}
	
ILUserString::ILUserString(ILMetaData *meta, ILTable *owner, const ILUserString &src)
	: ILToken(meta, owner, src)
{
	name_ = src.name_;
}

ILToken *ILUserString::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILToken *token = new ILUserString(meta, owner, *this);
	return token;
}

/**
* ILExportedType
*/

ILExportedType::ILExportedType(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), flags_(0), type_def_id_(0), implementation_(NULL)
{

}

ILExportedType::ILExportedType(ILMetaData *meta, ILTable *owner, const ILExportedType &src)
	: ILToken(meta, owner, src)
{
	flags_ = src.flags_;
	type_def_id_ = src.type_def_id_;
	name_ = src.name_;
	namespace_ = src.namespace_;
	implementation_ = src.implementation_;
}

ILToken *ILExportedType::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILToken *token = new ILExportedType(meta, owner, *this);
	return token;
}

void ILExportedType::ReadFromFile(NETArchitecture &file)
{
	flags_ = file.ReadDWord();
	type_def_id_ = file.ReadDWord();
	name_ = ReadStringFromFile(file);
	namespace_ = ReadStringFromFile(file);
	implementation_ = ReadTokenFromFile(file, Implementation);
}

void ILExportedType::WriteToStreams(ILMetaData &data)
{
	name_pos_ = data.AddString(name_);
	namespace_pos_ = data.AddString(namespace_);
}

void ILExportedType::WriteToFile(NETArchitecture &file)
{
	file.WriteDWord(flags_);
	file.WriteDWord(type_def_id_);
	WriteStringToFile(file, name_pos_);
	WriteStringToFile(file, namespace_pos_);
	WriteTokenToFile(file, Implementation, implementation_);
}

void ILExportedType::UpdateTokens()
{
	if (implementation_)
		implementation_ = meta()->token(implementation_->id());
}

ILExportedType *ILExportedType::declaring_type() const
{
	ILToken *scope = implementation();
	if (scope && scope->type() == ttExportedType)
		return reinterpret_cast<ILExportedType*>(scope);
	return NULL;
}

std::string ILExportedType::full_name() const
{
	std::string res;

	res = namespace_;
	if (!res.empty())
		res += '.';
	res += name_;

	ILExportedType *declaring_type = this->declaring_type();
	while (declaring_type) {
		res = declaring_type->full_name() + '/' + res;
		declaring_type = declaring_type->declaring_type();
	}

	return res;
}

/**
* ILENCLog
*/

ILEncLog::ILEncLog(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), token_(0), func_code_(0)
{

}

ILEncLog::ILEncLog(ILMetaData *meta, ILTable *owner, const ILEncLog &src)
	: ILToken(meta, owner, src)
{
	token_ = src.token_;
	func_code_ = src.func_code_;
}

ILToken *ILEncLog::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILToken *token = new ILEncLog(meta, owner, *this);
	return token;
}

void ILEncLog::ReadFromFile(NETArchitecture &file)
{
	token_ = file.ReadDWord();
	func_code_ = file.ReadDWord();
}

void ILEncLog::WriteToFile(NETArchitecture &file)
{
	file.WriteDWord(token_);
	file.WriteDWord(func_code_);
}

/**
* ILENCMap
*/

ILEncMap::ILEncMap(ILMetaData *meta, ILTable *owner, uint32_t id)
	: ILToken(meta, owner, id), token_(0)
{

}

ILEncMap::ILEncMap(ILMetaData *meta, ILTable *owner, const ILEncMap &src)
	: ILToken(meta, owner, src)
{
	token_ = src.token_;
}

ILToken *ILEncMap::Clone(ILMetaData *meta, ILTable *owner) const
{
	ILToken *token = new ILEncMap(meta, owner, *this);
	return token;
}

void ILEncMap::ReadFromFile(NETArchitecture &file)
{
	token_ = file.ReadDWord();
}

void ILEncMap::WriteToFile(NETArchitecture &file)
{
	file.WriteDWord(token_);
}

/**
 * ILTable
 */

ILTable::ILTable(ILMetaData *meta, ILTokenType type, uint32_t token_count)
	: ObjectList<ILToken>(), meta_(meta), type_(type)
{
	for (uint32_t i = 1; i <= token_count; i++) {
		Add(type_ | i);
	}
}

ILTable::ILTable(ILMetaData *meta, const ILTable &src)
	: ObjectList<ILToken>(), meta_(meta)
{
	type_ = src.type_;

	for (size_t i = 0; i < src.count(); i++) {
		AddObject(src.item(i)->Clone(meta, this));
	}
}

ILTable *ILTable::Clone(ILMetaData *meta) const
{
	ILTable *table = new ILTable(meta, *this);
	return table;
}

ILToken *ILTable::Add(uint32_t id)
{
	ILToken *token = NULL;
	switch (type_) {
	case ttAssembly:
		token = new ILAssembly(meta_, this, id);
		break;
	case ttAssemblyOS:
		token = new ILAssemblyOS(meta_, this, id);
		break;
	case ttAssemblyProcessor:
		token = new ILAssemblyProcessor(meta_, this, id);
		break;
	case ttAssemblyRef:
		token = new ILAssemblyRef(meta_, this, id);
		break;
	case ttAssemblyRefOS:
		token = new ILAssemblyRefOS(meta_, this, id);
		break;
	case ttAssemblyRefProcessor:
		token = new ILAssemblyRefProcessor(meta_, this, id);
		break;
	case ttClassLayout:
		token = new ILClassLayout(meta_, this, id);
		break;
	case ttConstant:
		token = new ILConstant(meta_, this, id);
		break;
	case ttCustomAttribute:
		token = new ILCustomAttribute(meta_, this, id);
		break;
	case ttDeclSecurity:
		token = new ILDeclSecurity(meta_, this, id);
		break;
	case ttEvent:
		token = new ILEvent(meta_, this, id);
		break;
	case ttEventMap:
		token = new ILEventMap(meta_, this, id);
		break;
	case ttField:
		token = new ILField(meta_, this, id);
		break;
	case ttFieldLayout:
		token = new ILFieldLayout(meta_, this, id);
		break;
	case ttFieldMarshal:
		token = new ILFieldMarshal(meta_, this, id);
		break;
	case ttFieldRVA:
		token = new ILFieldRVA(meta_, this, id);
		break;
	case ttFile:
		token = new ILFile(meta_, this, id);
		break;
	case ttGenericParam:
		token = new ILGenericParam(meta_, this, id);
		break;
	case ttGenericParamConstraint:
		token = new ILGenericParamConstraint(meta_, this, id);
		break;
	case ttImplMap:
		token = new ILImplMap(meta_, this, id);
		break;
	case ttInterfaceImpl:
		token = new ILInterfaceImpl(meta_, this, id);
		break;
	case ttManifestResource:
		token = new ILManifestResource(meta_, this, id);
		break;
	case ttMemberRef:
		token = new ILMemberRef(meta_, this, id);
		break;
	case ttMethodDef:
		token = new ILMethodDef(meta_, this, id);
		break;
	case ttMethodImpl:
		token = new ILMethodImpl(meta_, this, id);
		break;
	case ttMethodSemantics:
		token = new ILMethodSemantics(meta_, this, id);
		break;
	case ttMethodSpec:
		token = new ILMethodSpec(meta_, this, id);
		break;
	case ttModule:
		token = new ILModule(meta_, this, id);
		break;
	case ttModuleRef:
		token = new ILModuleRef(meta_, this, id);
		break;
	case ttNestedClass:
		token = new ILNestedClass(meta_, this, id);
		break;
	case ttParam:
		token = new ILParam(meta_, this, id);
		break;
	case ttProperty:
		token = new ILProperty(meta_, this, id);
		break;
	case ttPropertyMap:
		token = new ILPropertyMap(meta_, this, id);
		break;
	case ttStandAloneSig:
		token = new ILStandAloneSig(meta_, this, id);
		break;
	case ttTypeDef:
		token = new ILTypeDef(meta_, this, id);
		break;
	case ttTypeRef:
		token = new ILTypeRef(meta_, this, id);
		break;
	case ttTypeSpec:
		token = new ILTypeSpec(meta_, this, id);
		break;
	case ttUserString:
		token = new ILUserString(meta_, this, id);
		break;
	case ttExportedType:
		token = new ILExportedType(meta_, this, id);
		break;
	case ttEncLog:
		token = new ILEncLog(meta_, this, id);
		break;
	case ttEncMap:
		token = new ILEncMap(meta_, this, id);
		break;
	default:
		throw std::runtime_error("Unknown token type");
	}

	AddObject(token);
	return token;
}

void ILTable::ReadFromFile(NETArchitecture &file)
{
	for (size_t i = 0; i < count(); i++) {
		item(i)->ReadFromFile(file);
	}
}

void ILTable::WriteToStreams(ILMetaData &data)
{
	for (size_t i = 0; i < count(); i++) {
		item(i)->WriteToStreams(data);
	}
}

void ILTable::WriteToFile(NETArchitecture &file)
{
	for (size_t i = 0; i < count(); i++) {
		item(i)->WriteToFile(file);
	}
}

void ILTable::Rebase(uint64_t delta_base)
{
	for (size_t i = 0; i < count(); i++) {
		item(i)->Rebase(delta_base);
	}
}

void ILTable::Pack()
{
	size_t i;
	ILToken *token;

	for (i = count(); i > 0; i--) {
		token = item(i - 1);
		if (token->is_deleted())
			delete token;
	}
}

void ILTable::UpdateTokens()
{
	size_t i, j;
	ILToken *token;

	IArchitecture *file = meta_->owner();
	if (type_ == ttUserString) {
		for (i = 0; i < count(); i++) {
			ILUserString *user_string = reinterpret_cast<ILUserString*>(item(i));
			bool has_references = false;
			for (j = 0; j < user_string->reference_list()->count(); j++) {
				if (!user_string->reference_list()->item(j)->is_deleted()) {
					has_references = true;
					break;
				}
			}
			if (has_references)
				user_string->set_value(meta_->AddUserString(user_string->name()), file);
		}
	} else {
		uint32_t id = 1;
		for (i = 0; i < count(); i++) {
			token = item(i);
			if (token->is_deleted())
				continue;

			token->set_value(id++, file);
		}
	}
}

/**
 * NETImportFunction
 */

NETImportFunction::NETImportFunction(NETImport *owner, uint32_t token, const std::string &name, size_t name_pos)
	: BaseImportFunction(owner), token_(token), name_(name), name_pos_(name_pos)
{

}

NETImportFunction::NETImportFunction(NETImport *owner, const NETImportFunction &src)
	: BaseImportFunction(owner, src)
{
	token_ = src.token_;
	name_ = src.name_;
	name_pos_ = src.name_pos_;
}

NETImportFunction *NETImportFunction::Clone(IImport *owner) const
{
	NETImportFunction *func = new NETImportFunction(reinterpret_cast<NETImport *>(owner), *this);
	return func;
}

/**
 * NETImport
 */

NETImport::NETImport(NETImportList *owner, uint32_t token, const std::string &name)
	: BaseImport(owner), token_(token), name_(name), is_sdk_(false)
{

}

NETImport::NETImport(NETImportList *owner, const NETImport &src)
	: BaseImport(owner, src)
{
	token_ = src.token_;
	name_ = src.name_;
	is_sdk_ = src.is_sdk_;
}

NETImportFunction *NETImport::item(size_t index) const
{
	return reinterpret_cast<NETImportFunction *>(BaseImport::item(index));
}

NETImport *NETImport::Clone(IImportList *owner) const
{
	NETImport *import = new NETImport(reinterpret_cast<NETImportList *>(owner), *this);
	return import;
}

NETImportFunction *NETImport::Add(uint32_t token, const std::string &name, size_t name_pos)
{
	NETImportFunction *func = new NETImportFunction(this, token, name, name_pos);
	AddObject(func);
	return func;
}

NETImportFunction *NETImport::GetFunctionByToken(uint32_t token) const
{
	for (size_t i = 0; i < count(); i++) {
		NETImportFunction *func = item(i);
		if (func->token() == token)
			return func;
	}

	return NULL;
}

/**
 * NETImportList
 */

NETImportList::NETImportList(NETArchitecture *owner)
	: BaseImportList(owner)
{

}

NETImportList::NETImportList(NETArchitecture *owner, const NETImportList &src)
	: BaseImportList(owner, src)
{

}

NETImportList *NETImportList::Clone(NETArchitecture *owner) const
{
	NETImportList *list = new NETImportList(owner, *this);
	return list;
}

NETImport *NETImportList::GetImportByName(const std::string &name) const
{
	return reinterpret_cast<NETImport *>(BaseImportList::GetImportByName(name));
}

NETImport *NETImportList::item(size_t index) const
{
	return reinterpret_cast<NETImport *>(BaseImportList::item(index));
}

NETImportFunction *NETImportList::GetFunctionByToken(uint32_t token) const
{
	for (size_t i = 0; i < count(); i++) {
		NETImportFunction *func = item(i)->GetFunctionByToken(token);
		if (func)
			return func;
	}

	return NULL;
}

NETImport *NETImportList::Add(uint32_t token, const std::string &name)
{
	NETImport *import = new NETImport(this, token, name);
	AddObject(import);
	return import;
}

void NETImportList::ReadFromFile(NETArchitecture &file)
{
	static const ImportInfo sdk_info[] = {
		{atBegin, "void VMProtect.Begin::.ctor()", ioNone, ctNone},
		{atBegin, "void VMProtect.BeginVirtualization::.ctor()", ioHasCompilationType, ctVirtualization},
		{atBegin, "void VMProtect.BeginMutation::.ctor()", ioHasCompilationType, ctMutation},
		{atBegin, "void VMProtect.BeginUltra::.ctor()", ioHasCompilationType, ctUltra},
		{atBegin, "void VMProtect.BeginVirtualizationLockByKey::.ctor()", ioHasCompilationType | ioLockToKey, ctVirtualization},
		{atBegin, "void VMProtect.BeginUltraLockByKey::.ctor()", ioHasCompilationType | ioLockToKey, ctUltra},
		{atIsProtected, "bool VMProtect.SDK::IsProtected()", ioNone, ctNone},
		{atIsVirtualMachinePresent, "bool VMProtect.SDK::IsVirtualMachinePresent()", ioNone, ctNone},
		{atIsDebuggerPresent, "bool VMProtect.SDK::IsDebuggerPresent(bool)", ioNone, ctNone},
		{atIsValidImageCRC, "bool VMProtect.SDK::IsValidImageCRC()", ioNone, ctNone},
		{atDecryptStringA, "string VMProtect.SDK::DecryptString(string)", ioNone, ctNone},
		{atFreeString, "bool VMProtect.SDK::FreeString(string&)", ioNone, ctNone },
		{atSetSerialNumber, "valuetype VMProtect.SerialState VMProtect.SDK::SetSerialNumber(string)", ioNone, ctNone},
		{atGetSerialNumberState, "valuetype VMProtect.SerialState VMProtect.SDK::GetSerialNumberState()", ioNone, ctNone},
		{atGetSerialNumberData, "bool VMProtect.SDK::GetSerialNumberData(class VMProtect.SerialNumberData&)", ioNone, ctNone},
		{atGetCurrentHWID, "string VMProtect.SDK::GetCurrentHWID()", ioNone, ctNone},
		{atActivateLicense, "valuetype VMProtect.ActivationStatus VMProtect.SDK::ActivateLicense(string, string&)", ioNone, ctNone},
		{atDeactivateLicense, "valuetype VMProtect.ActivationStatus VMProtect.SDK::DeactivateLicense(string)", ioNone, ctNone},
		{atGetOfflineActivationString, "valuetype VMProtect.ActivationStatus VMProtect.SDK::GetOfflineActivationString(string, string&)", ioNone, ctNone},
		{atGetOfflineDeactivationString, "valuetype VMProtect.ActivationStatus VMProtect.SDK::GetOfflineDeactivationString(string, string&)", ioNone, ctNone}
	};

	size_t i;
	std::map<ILToken *, NETImport *> import_map;
	std::map<ILToken *, NETImport *> type_map;
	NETImport *import;

	ILTable *table = file.command_list()->table(ttAssemblyRef);
	for (i = 0; i < table->count(); i++) {
		ILAssemblyRef *assembly_ref = reinterpret_cast<ILAssemblyRef *>(table->item(i));
		std::string module_name = assembly_ref->name();

		import = GetImportByName(module_name);
		if (!import) {
			import = Add(assembly_ref->id(), module_name);
			std::transform(module_name.begin(), module_name.end(), module_name.begin(), tolower);
			if (module_name == "vmprotect.sdk")
				import->set_is_sdk(true);
		}
		import_map[assembly_ref] = import;
	}

	table = file.command_list()->table(ttTypeRef);
	for (i = 0; i < table->count(); i++) {
		ILTypeRef *type_ref = reinterpret_cast<ILTypeRef *>(table->item(i));
		std::map<ILToken *, NETImport *>::const_iterator it = import_map.find(type_ref->resolution_scope());
		if (it == import_map.end())
			continue;

		import = it->second;
		type_map[type_ref] = import;
		import->Add(type_ref->id(), type_ref->full_name(), 0);
	}


	table = file.command_list()->table(ttTypeSpec);
	for (i = 0; i < table->count(); i++) {
		ILTypeSpec *type_spec = reinterpret_cast<ILTypeSpec *>(table->item(i));
		ILToken *token = NULL;
		
		switch (type_spec->info()->type()) {
		case ELEMENT_TYPE_GENERICINST:
			token = type_spec->info()->next()->token();
			break;
		case ELEMENT_TYPE_VALUETYPE:
		case ELEMENT_TYPE_CLASS:
			token = type_spec->info()->token();
			break;
		}

		if (!token || (token->type() != ttTypeRef))
			continue;

		std::map<ILToken *, NETImport *>::const_iterator it = import_map.find(reinterpret_cast<ILTypeRef *>(token)->resolution_scope());
		if (it == import_map.end())
			continue;

		import = it->second;
		type_map[type_spec] = import;
		import->Add(type_spec->id(), type_spec->name(), 0);
	}

	table = file.command_list()->table(ttMemberRef);
	for (i = 0; i < table->count(); i++) {
		ILMemberRef *member_ref = reinterpret_cast<ILMemberRef*>(table->item(i));
		std::map<ILToken *, NETImport *>::const_iterator it = type_map.find(member_ref->declaring_type());
		if (it == type_map.end())
			continue;

		import = it->second;
		std::string ret_name = member_ref->signature()->ret_name();
		NETImportFunction *func = import->Add(member_ref->id(), member_ref->full_name(), ret_name.empty() ? 0 : ret_name.size() + 1);
		if (import->is_sdk()) {
			for (size_t i = 0; i < _countof(sdk_info); i++) {
				const ImportInfo *import_info = &sdk_info[i];
				if (func->name().compare(import_info->name) == 0) {
					func->set_type(import_info->type);
					if (import_info->options & ioHasCompilationType) {
						func->include_option(ioHasCompilationType);
						func->set_compilation_type(import_info->compilation_type);
						if (import_info->options & ioLockToKey)
							func->include_option(ioLockToKey);
					}
				}
			}
		}
	}

	table = file.command_list()->table(ttModuleRef);
	for (i = 0; i < table->count(); i++) {
		ILModuleRef *module_ref = reinterpret_cast<ILModuleRef *>(table->item(i));

		import = GetImportByName(module_ref->name());
		if (!import)
			import = Add(module_ref->id(), module_ref->name());
		import_map[module_ref] = import;
	}

	table = file.command_list()->table(ttImplMap);
	for (i = 0; i < table->count(); i++) {
		ILImplMap *impl_map = reinterpret_cast<ILImplMap*>(table->item(i));
		std::map<ILToken *, NETImport *>::const_iterator it = import_map.find(impl_map->import_scope());
		if (it == import_map.end())
			continue;

		import = it->second;
		NETImportFunction *func = import->Add(impl_map->id(), impl_map->import_name(), 0);
	}
}

void NETImportList::Pack()
{
	size_t i, j, k;
	std::map<ILToken *, ILToken *> type_map;
	ILMetaData *meta = reinterpret_cast<NETArchitecture*>(owner())->command_list();

	ILTable *type_def_table = meta->table(ttTypeDef);
	ILTable *field_table = meta->table(ttField);
	ILTable *method_table = meta->table(ttMethodDef);
	ILTable *custom_attribute_table = meta->table(ttCustomAttribute);
	for (i = 0; i < count(); i++) {
		NETImport *import = item(i);
		if (!import->is_sdk())
			continue;

		ILToken *token = meta->token(import->token());
		token->set_deleted(true);

		for (j = 0; j < import->count(); j++) {
			NETImportFunction *func = import->item(j);

			token = meta->token(func->token());
			switch (token->type()) {
			case ttTypeRef:
				{
					ILTypeRef *type_ref = reinterpret_cast<ILTypeRef *>(token);
					for (k = 0; k < type_def_table->count(); k++) {
						ILTypeDef *type_def = reinterpret_cast<ILTypeDef *>(type_def_table->item(k));
						if (type_def->full_name() == type_ref->full_name()) {
							type_map[type_ref] = type_def;
							break;
						}
					}
				}
				break;
			case ttMemberRef:
				{
					ILMemberRef *member_ref = reinterpret_cast<ILMemberRef*>(meta->token(func->token()));
					ILToken *declaring_type = member_ref->declaring_type();
					if (declaring_type && declaring_type->type() == ttTypeRef) {
						ILTypeRef *type_ref = reinterpret_cast<ILTypeRef *>(declaring_type);
						if (func->type() == atNone) {
							std::string name = member_ref->full_name();
							if (member_ref->signature()->is_field()) {
								// field
								for (k = 0; k < field_table->count(); k++) {
									ILField *field = reinterpret_cast<ILField *>(field_table->item(k));
									if (field->full_name() == name) {
										type_map[member_ref] = field;
										break;
									}
								}
							} else {
								// method
								for (k = 0; k < method_table->count(); k++) {
									ILMethodDef *method = reinterpret_cast<ILMethodDef *>(method_table->item(k));
									if (method->full_name() == name) {
										type_map[member_ref] = method;
										break;
									}
								}
							}
						} else {
							type_ref->set_deleted(true);
						}
					}
				}
				break;
			}
		}
	}

	if (!type_map.empty()) {
		for (std::map<ILToken *, ILToken *>::const_iterator it = type_map.begin(); it != type_map.end(); it++) {
			ILToken *src_token = it->first;
			ILToken *dst_token = it->second;
			src_token->set_deleted(true);

			while (src_token->reference_list()->count()) {
				TokenReference *reference = src_token->reference_list()->item(0);
				reference->set_owner(dst_token->reference_list());
			}
			if (dst_token->value() != src_token->value())
				dst_token->set_value(0);
		}

		for (i = 0; i < 64; i++) {
			ILTable *table = meta->table(static_cast<ILTokenType>(i << 24));
			for (size_t j = 0; j < table->count(); j++) {
				table->item(j)->RemapTokens(type_map);
			}
		}
	}
}

/**
 * NETExport
 */

NETExport::NETExport(NETExportList *owner, uint64_t address, const std::string &name, size_t name_pos)
	: BaseExport(owner), address_(address), name_(name), name_pos_(name_pos)
{

}

NETExport::NETExport(NETExportList *owner, const NETExport &src)
	: BaseExport(owner, src)
{
	address_ = src.address_;
	name_ = src.name_;
	name_pos_ = src.name_pos_;
}

NETExport *NETExport::Clone(IExportList *owner) const
{
	NETExport *exp = new NETExport(reinterpret_cast<NETExportList *>(owner), *this);
	return exp;
}

void NETExport::Rebase(uint64_t delta_base)
{
	address_ += delta_base;
}

/**
 * NETExportList
 */

NETExportList::NETExportList(NETArchitecture *owner)
	: BaseExportList(owner)
{

}

NETExportList::NETExportList(NETArchitecture *owner, const NETExportList &src)
	: BaseExportList(owner, src)
{

}
	
NETExportList *NETExportList::Clone(NETArchitecture *owner) const
{
	NETExportList *list = new NETExportList(owner, *this);
	return list;
}

IExport *NETExportList::Add(uint64_t address)
{
	return Add(address, "", 0);
}

NETExport *NETExportList::Add(uint64_t address, const std::string &name, size_t name_pos)
{
	NETExport *exp = new NETExport(this, address, name, name_pos);
	AddObject(exp);
	return exp;
}

void NETExportList::ReadFromFile(NETArchitecture &file)
{
	ILTable *table = file.command_list()->table(ttMethodDef);
	for (size_t i = 0; i < table->count(); i++) {
		ILMethodDef *method = reinterpret_cast<ILMethodDef *>(table->item(i));
		if (!method->declaring_type() || (method->flags() & mdMemberAccessMask) != mdPublic)
			continue;

		std::string ret_name = method->signature()->ret_name();
		Add(method->address(), method->full_name(), ret_name.empty() ? 0 : ret_name.size() + 1);
	}
}

void NETExportList::ReadFromBuffer(Buffer &buffer, IArchitecture &file)
{
	static const APIType export_function_types[] = {
		atSetupImage,
		atDecryptStringA,
		atDecryptStringW,
		atFreeString,
		atSetSerialNumber,
		atGetSerialNumberState,
		atGetSerialNumberData,
		atGetCurrentHWID,
		atActivateLicense,
		atDeactivateLicense,
		atGetOfflineActivationString,
		atGetOfflineDeactivationString,
		atIsValidImageCRC,
		atIsDebuggerPresent,
		atIsVirtualMachinePresent,
		atDecryptBuffer,
		atIsProtected,
		atLoaderData,
		atRandom,
		atCalcCRC,
		atBoxPointer,
		atUnboxPointer
	};

	clear();
	BaseExportList::ReadFromBuffer(buffer, file);

	assert(count() == _countof(export_function_types));
	for (size_t i = 0; i < count(); i++) {
		item(i)->set_type(export_function_types[i]);
	}
}

/**
 * NETRuntimeFunction
 */

NETRuntimeFunction::NETRuntimeFunction(NETRuntimeFunctionList *owner, uint64_t begin, uint64_t end, uint64_t start, ILMethodDef *method)
	: BaseRuntimeFunction(owner), begin_(begin), end_(end), start_(start)
{
	if (method)
		method_list_.push_back(method);
}

NETRuntimeFunction::NETRuntimeFunction(NETRuntimeFunctionList *owner, const NETRuntimeFunction &src)
	: BaseRuntimeFunction(owner)
{
	begin_ = src.begin_;
	end_ = src.end_;
	start_ = src.start_;
	method_list_ = src.method_list_;
}

NETRuntimeFunction *NETRuntimeFunction::Clone(IRuntimeFunctionList *owner) const
{
	NETRuntimeFunction *func = new NETRuntimeFunction(reinterpret_cast<NETRuntimeFunctionList *>(owner), *this);
	return func;
}

void NETRuntimeFunction::Rebase(uint64_t delta_base)
{
	begin_ += delta_base;
	end_ += delta_base;
	start_ += delta_base;
}

void NETRuntimeFunction::set_begin(uint64_t begin)
{
	begin_ = begin;
	for (size_t i = 0; i < method_list_.size(); i++) {
		method_list_[i]->set_address(begin_);
	}
}

/**
 * NETRuntimeFunctionList
 */

NETRuntimeFunctionList::NETRuntimeFunctionList()
	: BaseRuntimeFunctionList()
{

}

NETRuntimeFunctionList::NETRuntimeFunctionList(const NETRuntimeFunctionList &src)
	: BaseRuntimeFunctionList(src)
{

}

NETRuntimeFunctionList *NETRuntimeFunctionList::Clone() const
{
	NETRuntimeFunctionList *list = new NETRuntimeFunctionList(*this);
	return list;
}

NETRuntimeFunction *NETRuntimeFunctionList::item(size_t index) const
{
	return reinterpret_cast<NETRuntimeFunction *>(IRuntimeFunctionList::item(index));
}

NETRuntimeFunction *NETRuntimeFunctionList::GetFunctionByAddress(uint64_t address) const
{
	return reinterpret_cast<NETRuntimeFunction *>(BaseRuntimeFunctionList::GetFunctionByAddress(address));
}

NETRuntimeFunction * NETRuntimeFunctionList::Add(uint64_t begin, uint64_t end, uint64_t start, ILMethodDef *method)
{
	NETRuntimeFunction *func = new NETRuntimeFunction(this, begin, end, start, method);
	AddObject(func);
	return func;
}

void NETRuntimeFunctionList::ReadFromFile(NETArchitecture &file)
{
	ILTable *table = file.command_list()->table(ttMethodDef);
	for (size_t i = 0; i < table->count(); i++) {
		ILMethodDef *method = reinterpret_cast<ILMethodDef *>(table->item(i));
		if (!method->address() || (method->impl_flags() & miCodeTypeMask) != miIL)
			continue;

		uint64_t address = method->address();
		uint64_t start_address = address + method->fat_size();
		uint64_t end_address = start_address + method->code_size();
		NETRuntimeFunction *func = GetFunctionByAddress(address);
		if (func)
			func->AddMethod(method);
		else
			Add(address, end_address, start_address, method);
	}
}

IRuntimeFunction *NETRuntimeFunctionList::Add(uint64_t address, uint64_t begin, uint64_t end, uint64_t unwind_address, IRuntimeFunction *source, const std::vector<uint8_t> &call_frame_instructions)
{
	if (source) {
		NETRuntimeFunction *runtime_func = reinterpret_cast<NETRuntimeFunction *>(source);
		runtime_func->set_begin(begin);
		runtime_func->set_end(end);
	}

	return NULL;
}

/**
 * NETResource
 */

NETResource::NETResource(IResource *owner, const std::string &name, uint32_t id, uint64_t address, uint32_t size)
	: BaseResource(owner), name_(name), id_(id), address_(address), size_(size)
{

}

NETResource::NETResource(IResource *owner, const NETResource &src)
	: BaseResource(owner, src)
{
	name_ = src.name_;
	id_ = src.id_;
	address_ = src.address_;
	size_ = src.size_;
}

IResource *NETResource::Clone(IResource *owner) const
{
	NETResource *resource = new NETResource(owner, *this);
	return resource;
}

NETResource *NETResource::item(size_t index) const
{
	return reinterpret_cast<NETResource *>(BaseResource::item(index));
}

NETResource *NETResource::Add(const std::string &name, uint32_t id, uint64_t address, uint32_t size)
{
	NETResource *resource = new NETResource(this, name, id, address, size);
	AddObject(resource);
	return resource;
}

/**
 * NETResourceList
 */

NETResourceList::NETResourceList(NETArchitecture *owner)
	: BaseResourceList(owner)
{

}

NETResourceList::NETResourceList(NETArchitecture *owner, const NETResourceList &src)
	: BaseResourceList(owner, src)
{

}

NETResourceList *NETResourceList::Clone(NETArchitecture *owner) const
{
	NETResourceList *list = new NETResourceList(owner, *this);
	return list;
}

NETResource *NETResourceList::item(size_t index) const
{
	return reinterpret_cast<NETResource *>(BaseResourceList::item(index));
}

NETResource *NETResourceList::Add(const std::string &name, uint32_t id, uint64_t address, uint32_t size)
{
	NETResource *resource = new NETResource(this, name, id, address, size);
	AddObject(resource);
	return resource;
}

void NETResourceList::ReadFromFile(NETArchitecture &file)
{
	ILTable *table = file.command_list()->table(ttManifestResource);
	for (size_t i = 0; i < table->count(); i++) {
		ILManifestResource *resource = reinterpret_cast<ILManifestResource*>(table->item(i));
		ILToken *implementation = resource->implementation();
		if (implementation) {
			NETResource *folder = reinterpret_cast<NETResource*>(GetResourceById(string_format("%.4X", implementation->id())));
			if (!folder) {
				std::string name;
				switch (implementation->type()) {
				case ttFile:
					folder = Add(reinterpret_cast<ILFile*>(implementation)->name(), implementation->id(), 0, 0);
					break;
				case ttAssemblyRef:
					folder = Add(reinterpret_cast<ILAssemblyRef*>(implementation)->name(), implementation->id(), 0, 0);
					break;
				}
				if (!folder)
					continue;
			}
			folder->Add(resource->name(), resource->id(), resource->offset(), 0);
		} else {
			NETResource *folder = Add(resource->name(), resource->id(), resource->value()->address(), resource->value()->size());
			for (size_t j = 0; j < resource->value()->count(); j++) {
				ManifestResourceItem *item = resource->value()->item(j);
				folder->Add(item->name(), static_cast<uint32_t>(j), item->address(), item->size());
			}
		}
	}
}

/**
 * NETArchitecture
 */

NETArchitecture::NETArchitecture(PEFile *owner)
	: BaseArchitecture(owner, owner->arch_pe()->offset(), owner->arch_pe()->size()), function_list_(NULL),
	entry_point_(0), pe_(owner->arch_pe()), virtual_machine_list_(NULL), optimized_section_count_(0), resize_header_(0)
{
	meta_data_ = new ILMetaData(this);
	import_list_ = new NETImportList(this);
	export_list_ = new NETExportList(this);
	resource_list_ = new NETResourceList(this);
	runtime_function_list_ = new NETRuntimeFunctionList();
}

NETArchitecture::NETArchitecture(PEFile *owner, const NETArchitecture &src)
	: BaseArchitecture(owner, src), pe_(owner->arch_pe()), function_list_(NULL), entry_point_(NULL),
	virtual_machine_list_(NULL), optimized_section_count_(0), resize_header_(0)
{
	size_t i, j;

	header_ = src.header_;
	meta_data_ = src.meta_data_->Clone(this);
	import_list_ = src.import_list_->Clone(this);
	export_list_ = src.export_list_->Clone(this);
	resource_list_ = src.resource_list_->Clone(this);
	runtime_function_list_ = src.runtime_function_list_->Clone();

	if (src.entry_point_)
		entry_point_ = reinterpret_cast<ILMethodDef *>(meta_data_->token(src.entry_point_->id()));

	if (src.function_list_)
		function_list_ = src.function_list_->Clone(this);
	if (src.virtual_machine_list_)
		virtual_machine_list_ = src.virtual_machine_list_->Clone();

	for (i = 0; i < runtime_function_list_->count(); i++) {
		NETRuntimeFunction *func = runtime_function_list_->item(i);
		std::vector<ILMethodDef *> method_list = func->method_list();
		for (j = 0; j < method_list.size(); j++) {
			method_list[j] = reinterpret_cast<ILMethodDef *>(meta_data_->token(method_list[j]->id()));
		}
		func->set_method_list(method_list);
	}

	if (function_list_) {
		for (i = 0; i < function_list_->count(); i++) {
			ILFunction *func = reinterpret_cast<ILFunction *>(function_list_->item(i));
			for (j = 0; j < func->count(); j++) {
				ILCommand *command = func->item(j);
				if (command->token_reference())
					command->set_token_reference(meta_data_->token(command->token_reference()->owner()->owner()->id())->reference_list()->GetReferenceByAddress(command->token_reference()->address()));
			}
			for (j = 0; j < func->function_info_list()->count(); j++) {
				FunctionInfo *info = func->function_info_list()->item(j);
				if (info->source())
					info->set_source(runtime_function_list_->GetFunctionByAddress(info->source()->begin()));
			}
		}
	}
}

NETArchitecture::~NETArchitecture()
{
	delete import_list_;
	delete export_list_;
	delete resource_list_;
	delete runtime_function_list_;
	delete meta_data_;
	delete function_list_;
}

NETArchitecture *NETArchitecture::Clone(IFile *file) const
{
	NETArchitecture *arch = new NETArchitecture(dynamic_cast<PEFile *>(file), *this);
	return arch;
}

OpenStatus NETArchitecture::ReadFromFile(uint32_t mode)
{
	PEDirectory *dir = pe_->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR);
	if (!dir || !dir->address() || !AddressSeek(dir->address()))
		return osUnknownFormat;

	Read(&header_, sizeof(header_));
	if (!header_.MetaData.VirtualAddress)
		return osInvalidFormat;

	entry_point_ = NULL;
	meta_data_->ReadFromFile(*this, header_.MetaData.VirtualAddress + image_base());
	if (header_.u.EntryPointToken && (header_.Flags & COMIMAGE_FLAGS_NATIVE_ENTRYPOINT) == 0) {
		ILToken *token = meta_data_->token(header_.u.EntryPointToken);
		if (!token || token->type() != ttMethodDef)
			return osInvalidFormat;
		entry_point_ = reinterpret_cast<ILMethodDef*>(token);
	}

	size_t i, j;

	if (header_.VTableFixups.VirtualAddress) {
		if (!AddressSeek(image_base() + header_.VTableFixups.VirtualAddress))
			return osInvalidFormat;

		for (i = 0; i < header_.VTableFixups.Size / sizeof(IMAGE_COR_VTABLEFIXUP); i++) {
			IMAGE_COR_VTABLEFIXUP fixup;
			Read(&fixup, sizeof(fixup));
			uint64_t pos = Tell();
			uint64_t address = image_base() + fixup.RVA;
			if (!AddressSeek(address))
				return osInvalidFormat;

			for (j = 0; j < fixup.Count; j++) {
				ILToken *token = meta_data_->token(ReadDWord());
				if (!token)
					return osInvalidFormat;

				token->reference_list()->Add(address);

				address += 4;
				if (fixup.Type & COR_VTABLE_64BIT) {
					ReadDWord();
					address += 4;
				}
			}
			Seek(pos);
		}
	}

	import_list_->ReadFromFile(*this);
	resource_list_->ReadFromFile(*this);
	runtime_function_list_->ReadFromFile(*this);

	if ((mode & foHeaderOnly) == 0) {
		ILAssemblyRef *corelib = meta_data_->GetCoreLib();
		bool is_supported_framework = false;
		if (corelib) {
			if (corelib->name() == "mscorlib") {
				// .NET Framework
				if (corelib->major_version() >= 2)
					is_supported_framework = true;
			}
			else if (corelib->name() == "System.Runtime") {
				// .NET Core
				if (corelib->major_version() == 4) {
					if (corelib->minor_version() == 2 && corelib->build_number() >= 1)
						is_supported_framework = true;
					if (corelib->minor_version() > 2)
						is_supported_framework = true;
				}
				else if (corelib->major_version() > 4)
					is_supported_framework = true;
			}
			else if (corelib->name() == "netstandard") {
				// .NET Standard
				if (corelib->major_version() == 2 && corelib->minor_version() >= 1)
					is_supported_framework = true;
				else if (corelib->major_version() > 2)
					is_supported_framework = true;
			}
		}
		if (!is_supported_framework)
			return osUnsupportedSubsystem;

		enum ObfuscationType {
			ftUnknown,
			ftRenaming,
			ftCompilationType,
			ftStrings
		};

		struct ObfuscationInfo {
			bool exclude;
			bool apply_to_members;
			size_t value;
			ObfuscationInfo() : exclude(false), apply_to_members(false), value(0) {}
		};

		std::map<ILToken *, NETImportFunction *> import_map;
		std::map<ILToken *, std::map<ObfuscationType, ObfuscationInfo> > attribute_map;
		ILTable *table = meta_data_->table(ttCustomAttribute);
		for (i = 0; i < table->count(); i++) {
			ILCustomAttribute *attribute = reinterpret_cast<ILCustomAttribute *>(table->item(i));
			if (!attribute->parent() || !attribute->type())
				continue;

			if (attribute->type()->type() == ttMemberRef) {
				ILMemberRef *member_ref = reinterpret_cast<ILMemberRef *>(attribute->type());
				if (member_ref->name() == ".ctor") {
					if (ILToken *declaring_type = member_ref->declaring_type()) {
						std::string full_name;
						switch (declaring_type->type()) {
						case ttTypeRef:
							full_name = reinterpret_cast<ILTypeRef *>(declaring_type)->full_name();
							break;
						}
						if (full_name == "System.Reflection.ObfuscationAttribute") {
							std::map<ObfuscationType, ObfuscationInfo> feature_map;
							std::map<ILToken *, std::map<ObfuscationType, ObfuscationInfo> >::iterator attribute_it = attribute_map.find(attribute->parent());
							if (attribute_it != attribute_map.end())
								feature_map = attribute_it->second;

							ObfuscationType feature = ftUnknown;
							ObfuscationInfo info;
							info.exclude = true; // default value of ObfuscationAttribute.Exclude
							bool need_delete = true;
							CustomAttributeValue *value = attribute->ParseValue();
							for (j = 0; j < value->named_list()->count(); j++) {
								CustomAttributeNamedArgument *arg = value->named_list()->item(j);
								if (arg->is_field())
									continue;

								if (arg->name() == "Exclude")
									info.exclude = arg->ToBoolean();
								else if (arg->name() == "ApplyToMembers")
									info.apply_to_members = arg->ToBoolean();
								else if (arg->name() == "StripAfterObfuscation")
									need_delete = arg->ToBoolean();
								else if (arg->name() == "Feature") {
									std::string str = arg->ToString();
									if (str == "renaming")
										feature = ftRenaming;
									else if (str == "virtualization") {
										feature = ftCompilationType;
										info.value = ctVirtualization;
									}
									else if (str == "mutation") {
										feature = ftCompilationType;
										info.value = ctMutation;
									}
									else if (str == "ultra") {
										feature = ftCompilationType;
										info.value = ctUltra;
									}
									else if (str == "virtualizationlockbykey") {
										feature = ftCompilationType;
										info.value = ctVirtualization | 0x80;
									}
									else if (str == "ultralockbykey") {
										feature = ftCompilationType;
										info.value = ctUltra | 0x80;
									}
									else if (str == "strings")
										feature = ftStrings;
								}
							}

							if (need_delete)
								attribute->set_deleted(true);

							std::map<ObfuscationType, ObfuscationInfo>::const_iterator feature_it = feature_map.find(feature);
							if (feature_it != feature_map.end()) {
								if (feature_it->second.exclude != info.exclude)
									feature_map.erase(feature_it);
							} else
								feature_map[feature] = info;

							attribute_map[attribute->parent()] = feature_map;
							continue;
						}
					}
				}
			}

			NETImportFunction *import_function = import_list_->GetFunctionByToken(attribute->type()->id());
			if (import_function && import_function->owner()->is_sdk())
				import_map[attribute->parent()] = import_function;
		}

		if (!attribute_map.empty()) {
			std::map<ObfuscationType, ObfuscationInfo> assembly_map;
			if (ILToken *assembly = meta_data_->token(ttAssembly | 1)) {
				std::map<ILToken *, std::map<ObfuscationType, ObfuscationInfo> >::const_iterator attribute_it = attribute_map.find(assembly);
				if (attribute_it != attribute_map.end())
					assembly_map = attribute_it->second;
			}

			const ILTokenType table_types[] = {ttTypeDef, ttMethodDef, ttField, ttProperty};
			for (i = 0; i < _countof(table_types); i++) {
				table = meta_data_->table(table_types[i]);
				for (j = 0; j < table->count(); j++) {
					std::map<ObfuscationType, ObfuscationInfo> feature_map;
					ILToken *token = table->item(j);

					std::map<ILToken *, std::map<ObfuscationType, ObfuscationInfo> >::const_iterator attribute_it = attribute_map.find(token);
					if (attribute_it != attribute_map.end())
						feature_map = attribute_it->second;

					ILTypeDef *declaring_type = NULL;
					switch (token->type()) {
					case ttTypeDef:
						declaring_type = reinterpret_cast<ILTypeDef *>(token)->declaring_type();
						break;
					case ttMethodDef:
						declaring_type = reinterpret_cast<ILMethodDef *>(token)->declaring_type();
						break;
					case ttField:
						declaring_type = reinterpret_cast<ILField *>(token)->declaring_type();
						break;
					case ttProperty:
						declaring_type = reinterpret_cast<ILProperty *>(token)->declaring_type();
						break;
					}

					while (declaring_type) {
						attribute_it = attribute_map.find(declaring_type);
						if (attribute_it != attribute_map.end()) {
							std::map<ObfuscationType, ObfuscationInfo> parent_map = attribute_it->second;
							for (std::map<ObfuscationType, ObfuscationInfo>::const_iterator parent_feature_it = parent_map.begin(); parent_feature_it != parent_map.end(); parent_feature_it++) {
								ObfuscationType feature = parent_feature_it->first;
								ObfuscationInfo info = parent_feature_it->second;
								if (info.apply_to_members && feature_map.find(feature) == feature_map.end())
									feature_map[feature] = info;
							}
						}
						declaring_type = declaring_type->declaring_type();
					}

					for (std::map<ObfuscationType, ObfuscationInfo>::const_iterator parent_feature_it = assembly_map.begin(); parent_feature_it != assembly_map.end(); parent_feature_it++) {
						ObfuscationType feature = parent_feature_it->first;
						ObfuscationInfo info = parent_feature_it->second;
						if (feature_map.find(feature) == feature_map.end())
							feature_map[feature] = info;
					}

					std::map<ObfuscationType, ObfuscationInfo>::const_iterator feature_it = feature_map.find(ftRenaming);
					if (feature_it != feature_map.end() && feature_it->second.exclude)
						token->set_can_rename(false);

					if (token->type() == ttMethodDef)
						attribute_map[token] = feature_map;
				}
			}
		}

		table = meta_data_->table(ttMethodDef);
		for (i = 0; i < table->count(); i++) {
			ILMethodDef *method = reinterpret_cast<ILMethodDef *>(table->item(i));
			if (!method->declaring_type())
				continue;

			MapFunctionList *map_function_list = (method->impl_flags() & miCodeTypeMask) == miNative ? pe_->map_function_list() : this->map_function_list();

			std::string ret_name = method->signature()->ret_name();
			MapFunction *map_function = map_function_list->Add(method->address(), 0, ((method->flags() & mdMemberAccessMask) == mdPublic) ? otExport : otCode, 
				FunctionName(method->full_name(), ret_name.empty() ? 0 : ret_name.size() + 1));

			std::map<ILToken *, std::map<ObfuscationType, ObfuscationInfo> >::const_iterator attribute_it = attribute_map.find(method);
			if (attribute_it != attribute_map.end()) {
				std::map<ObfuscationType, ObfuscationInfo> feature_map = attribute_it->second;
				std::map<ObfuscationType, ObfuscationInfo>::const_iterator feature_it = feature_map.find(ftStrings);
				if (feature_it != feature_map.end()) {
					ObfuscationInfo info = feature_it->second;
					if (!info.exclude)
						map_function->set_strings_protection(true);
				}
			}

			std::map<ILToken *, NETImportFunction *>::const_iterator it = import_map.find(method);
			if (it != import_map.end()) {
				map_function->set_type(otMarker);
				NETImportFunction *import_function = it->second;
				if (import_function->compilation_type() != ctNone) {
					map_function->set_compilation_type(import_function->compilation_type());
					map_function->set_lock_to_key((import_function->options() & ioLockToKey) != 0);
				}
			}
			else if (attribute_it != attribute_map.end()) {
				std::map<ObfuscationType, ObfuscationInfo> feature_map = attribute_it->second;
				std::map<ObfuscationType, ObfuscationInfo>::const_iterator feature_it = feature_map.find(ftCompilationType);
				if (feature_it != feature_map.end()) {
					ObfuscationInfo info = feature_it->second;
					if (!info.exclude) {
						map_function->set_type(otMarker);
						if (info.value != ctNone) {
							map_function->set_compilation_type((CompilationType)(info.value & 0x7f));
							map_function->set_lock_to_key((info.value & 0x80) != 0);
						}
					}
				}
			}
		}
		map_function_list()->ReadFromFile(*this);
		export_list_->ReadFromFile(*this);
	}

	function_list_ = new ILFunctionList(this);
	virtual_machine_list_ = new ILVirtualMachineList();
	if ((mode & foHeaderOnly) == 0) {
		ILFileHelper helper;
		helper.Parse(*this);
	}

	return osSuccess;
}

bool NETArchitecture::Prepare(CompileContext &ctx)
{
	ctx.vm_runtime = ctx.runtime;
	if (!BaseArchitecture::Prepare(ctx))
		return false;

	size_t i;
	PESegment *section;
	std::vector<PESegment *> optimized_section_list;

	// optimize sections
	if (pe_->resource_section())
		optimized_section_list.push_back(pe_->resource_section());
	if (pe_->fixup_section())
		optimized_section_list.push_back(pe_->fixup_section());

	optimized_section_count_ = segment_list()->count();
	for (i = segment_list()->count(); i > 0; i--) {
		section = segment_list()->item(i - 1);

		std::vector<PESegment *>::iterator it = std::find(optimized_section_list.begin(), optimized_section_list.end(), section);
		if (it != optimized_section_list.end()) {
			optimized_section_list.erase(it);
			optimized_section_count_--;
		} else {
			break;
		}
	}

	// calc new header size
	uint32_t new_section_count = static_cast<uint32_t>(segment_list()->count() + 1);
	if (ctx.runtime)
		new_section_count++;

	// calc header resizes
	uint32_t new_header_size = header_offset() + offsetof(IMAGE_NT_HEADERS32, OptionalHeader) + header_size() + new_section_count * sizeof(IMAGE_SECTION_HEADER);
	uint32_t aligned_header_size = AlignValue(new_header_size, file_alignment());
	resize_header_ = 0;
	for (size_t i = 0; i < segment_list()->count(); i++) {
		section = segment_list()->item(i);
		if (section->physical_size() == 0 || section->physical_offset() == 0 || aligned_header_size <= section->physical_offset())
			continue;

		uint32_t rva = static_cast<uint32_t>(section->address() - image_base());
		if (aligned_header_size > rva) {
			Notify(mtError, NULL, language[lsCreateSegmentError]);
			return false;
		}
		if (aligned_header_size > section->physical_offset())
			resize_header_ = std::max(resize_header_, aligned_header_size - section->physical_offset());
	}

	if (optimized_section_count_ > 0) {
		section = segment_list()->item(optimized_section_count_ - 1);
		if (ctx.runtime) {
			NETArchitecture *runtime = reinterpret_cast<NETArchitecture *>(ctx.runtime);
			if (runtime->segment_list()->count()) {
				MemoryManager runtime_manager(runtime);
				if (runtime->segment_list()->last() == runtime->pe_->fixup_section())
					delete runtime->pe_->fixup_section();
				if (runtime->segment_list()->last() == runtime->pe_->resource_section())
					delete runtime->pe_->resource_section();
				runtime->Rebase(AlignValue(section->address() + section->size(), segment_alignment()) - runtime->segment_list()->item(0)->address());
				runtime->meta_data_->FreeByManager(runtime_manager);
				runtime_manager.Pack();
				for (i = 0; i < runtime_manager.count(); i++) {
					MemoryRegion *region = runtime_manager.item(i);
					ctx.manager->Add(region->address(), region->size(), region->type());
				}
				section = runtime->segment_list()->last();
			} else {
				runtime->Rebase(UINT32_MAX);
			}
		}
		else if (ctx.vm_runtime) {
			NETArchitecture *runtime = reinterpret_cast<NETArchitecture *>(ctx.vm_runtime);
			runtime->segment_list()->clear();
			runtime->Rebase(UINT32_MAX);
		}

		// add new section
		assert(section);
		ctx.manager->Add(AlignValue(section->address() + section->size(), segment_alignment()), static_cast<uint32_t>(-1),  mtReadable | mtExecutable | mtWritable | mtNotPaged | (runtime_function_list()->count() ? mtSolid : mtNone));
	}

	if (ctx.options.flags & (cpPack | cpStripDebugInfo)) {
		PEDirectory *dir = pe_->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_DEBUG);
		if (dir && dir->address() && dir->size()) {
			ctx.manager->Add(dir->address(), dir->size());
			if (AddressSeek(dir->address())) {
				IMAGE_DEBUG_DIRECTORY debug_directory_data;
				size_t c = dir->size() / sizeof(debug_directory_data);
				for (i = 0; i < c; i++) {
					Read(&debug_directory_data, sizeof(debug_directory_data));
					if (debug_directory_data.AddressOfRawData)
						ctx.manager->Add(debug_directory_data.AddressOfRawData + image_base(), debug_directory_data.SizeOfData);
				}
			}
		}
	}
	rename_map_.clear();
	if (ctx.options.flags & cpStripDebugInfo)
		RenameSymbols();

	meta_data_->FreeByManager(*ctx.manager);
	meta_data_->Prepare();

	resolver.Prepare();

	return true;
}

void NETArchitecture::RenameToken(ILToken *token)
{
	bool need_first_char = false;
	if (token->type() == ttTypeDef) {
		ILTypeDef *type_def = reinterpret_cast<ILTypeDef *>(token);
		if (type_def->flags() & tdSerializable)
			need_first_char = true;
	}
		
	std::string new_name;
	do {
		uint32_t id = rand32();
		if (need_first_char)
			id |= 0xA0000000;
		new_name = string_format("%.8X", id);
	} while (rename_map_.find(new_name) != rename_map_.end());
	rename_map_.insert(new_name);

	switch (token->type()) {
	case ttParam:
		{
			ILParam *param = reinterpret_cast<ILParam *>(token);
			param->set_name(new_name);
		}
		break;
	case ttTypeDef:
		{
			ILTypeDef *type_def = reinterpret_cast<ILTypeDef *>(token);
			type_def->set_name(new_name);
			type_def->set_namespace("");
		}
		break;
	case ttMethodDef:
		{
			ILMethodDef *mehod = reinterpret_cast<ILMethodDef *>(token);
			mehod->set_name(new_name);
		}
		break;
	case ttField:
		{
			ILField *field = reinterpret_cast<ILField *>(token);
			field->set_name(new_name);
		}
		break;
	case ttProperty:
		{
			ILProperty *prop = reinterpret_cast<ILProperty *>(token);
			prop->set_name(new_name);
		}
		break;
	case ttEvent:
		{
			ILEvent *event = reinterpret_cast<ILEvent *>(token);
			event->set_name(new_name);
		}
		break;
	case ttGenericParam:
		{
			ILGenericParam *generic_param = reinterpret_cast<ILGenericParam *>(token);
			generic_param->set_name(new_name);
		}
		break;
	}
}

void NETArchitecture::RenameSymbols()
{
	size_t i, j, k;
	ILTable *table;
	ILToken *token;
	std::vector<ILToken *> token_list;
	NameReferenceList reference_list;
	bool is_dll = (pe_->image_type() == itLibrary);
	if (ILToken *assembly = meta_data_->token(ttAssembly | 1)) {
		table = meta_data_->table(ttCustomAttribute);
		for (i = 0; i < table->count(); i++) {
			ILCustomAttribute *attribute = reinterpret_cast<ILCustomAttribute *>(table->item(i));
			if (attribute->parent() != assembly || !attribute->type())
				continue;

			if (attribute->type()->type() == ttMemberRef) {
				ILMemberRef *member_ref = reinterpret_cast<ILMemberRef *>(attribute->type());
				if (member_ref->name() == ".ctor") {
					if (ILToken *declaring_type = member_ref->declaring_type()) {
						std::string full_name;
						switch (declaring_type->type()) {
						case ttTypeRef:
							full_name = reinterpret_cast<ILTypeRef *>(declaring_type)->full_name();
							break;
						}
						if (full_name == "System.Reflection.ObfuscateAssemblyAttribute") {
							bool need_delete = true;
							CustomAttributeValue *value = attribute->ParseValue();
							if (value->fixed_list()->count() == 1)
								is_dll = !value->fixed_list()->item(0)->ToBoolean();
							for (j = 0; j < value->named_list()->count(); j++) {
								CustomAttributeNamedArgument *arg = value->named_list()->item(j);
								if (arg->is_field())
									continue;

								if (arg->name() == "StripAfterObfuscation")
									need_delete = arg->ToBoolean();
							}

							if (need_delete)
								attribute->set_deleted(true);

							break;
						}
					}
				}
			}
		}
	}

	ILTokenType source_types[] = { ttTypeDef, ttMethodDef, ttField, ttProperty, ttEvent, ttParam, ttGenericParam };
	for (i = 0; i < _countof(source_types); i++) {
		table = meta_data_->table(source_types[i]);
		for (j = 0; j < table->count(); j++) {
			token = table->item(j);
			if (!token->can_rename())
				continue;

			if (is_dll && token->is_exported()) {
				token->set_can_rename(false);
				continue;
			}

			switch (token->type()) {
			case ttTypeDef:
				{
					ILTypeDef *type_def = reinterpret_cast<ILTypeDef *>(token);
					if (type_def->value() == 1 || (type_def->flags() & tdRTSpecialName)) {
						token->set_can_rename(false);
						continue;
					}

					if (type_def->FindBaseType("System.Configuration.SettingsBase")) {
						token->set_can_rename(false);
						continue;
					}
				}
				break;
			case ttMethodDef:
				{
					ILMethodDef *method = reinterpret_cast<ILMethodDef *>(token);
					if (method->flags() & mdRTSpecialName) {
						token->set_can_rename(false);
						continue;
					}

					if (method->flags() & mdVirtual) {
						token->set_can_rename(false);
						continue;
					}

					if ((method->declaring_type()->flags() & tdClassSemanticsMask) == tdClass) {
						// check delegate
						ILToken *base_type = method->declaring_type()->base_type();
						if (base_type && base_type->type() == ttTypeRef) {
							ILTypeRef *type_ref = reinterpret_cast<ILTypeRef *>(base_type);
							if (type_ref->resolution_scope() == meta_data_->GetCoreLib() && type_ref->name_space() == "System" && type_ref->name() == "MulticastDelegate") {
								token->set_can_rename(false);
								continue;
							}
						}
					}
				}
				break;
			case ttField:
				{
					ILField *field = reinterpret_cast<ILField *>(token);
					if (field->flags() & fdRTSpecialName) {
						token->set_can_rename(false);
						continue;
					}
					if ((field->declaring_type()->flags() & tdSerializable) && (field->flags() & fdNotSerialized) == 0) {
						token->set_can_rename(false);
						continue;
					}
					if (field->flags() & fdLiteral) {
						// check enum
						if ((field->declaring_type()->flags() & tdClassSemanticsMask) == tdClass) {
							ILToken *base_type = field->declaring_type()->base_type();
							if (base_type && base_type->type() == ttTypeRef) {
								ILTypeRef *type_ref = reinterpret_cast<ILTypeRef *>(base_type);
								if (type_ref->resolution_scope() == meta_data_->GetCoreLib() && type_ref->name_space() == "System" && type_ref->name() == "Enum") {
									token->set_can_rename(false);
									continue;
								}
							}
						}
					}
				}
				break;
			case ttProperty:
				{
					ILProperty *prop = reinterpret_cast<ILProperty *>(token);
					if (prop->flags() & prRTSpecialName) {
						token->set_can_rename(false);
						continue;
					}

					if (prop->declaring_type()->FindImplement("System.ComponentModel.INotifyPropertyChanged")) {
						token->set_can_rename(false);
						continue;
					}
				}
				break;
			case ttEvent:
				{
					ILEvent *event = reinterpret_cast<ILEvent *>(token);
					if (event->flags() & evRTSpecialName) {
						token->set_can_rename(false);
						continue;
					}
				}
				break;
			}

			token_list.push_back(token);
		}
	}

	table = meta_data_->table(ttUserString);
	for (i = 0; i < table->count(); i++) {
		ILUserString *str = reinterpret_cast<ILUserString *>(table->item(i));
		ILTypeDef *type_def = meta_data_->GetTypeDef(str->name());
		if (type_def && type_def->can_rename()) {
			reference_list.AddStringReference(str, type_def);

			uint64_t address;
			if (!meta_data_->GetUserData(str->value(), &address).empty()) {
				if (ILCommand *command = reinterpret_cast<ILCommand *>(function_list_->GetCommandByAddress(address, true)))
					reference_list.AddCommandReference(command, type_def);
			}
		}
	}

	table = meta_data_->table(ttMethodSpec);
	for (i = 0; i < table->count(); i++) {
		ILMethodSpec *method_spec = reinterpret_cast<ILMethodSpec *>(table->item(i));
		if (method_spec->parent() && method_spec->parent()->type() == ttMemberRef) {
			std::string name = reinterpret_cast<ILMemberRef*>(method_spec->parent())->full_name();
			if (name.size() > 54 && name.substr(0, 54) == "!!0 Newtonsoft.Json.JsonConvert::DeserializeObject<0>(") {
				token = method_spec->signature()->item(0)->token();
				if (token && token->type() == ttTypeDef) {
					ILTypeDef *type_def = reinterpret_cast<ILTypeDef *>(token);
					ILTable *ref_table = meta_data_->table(ttProperty);
					for (size_t r = 0; r < ref_table->count(); r++) {
						ILProperty *property = reinterpret_cast<ILProperty*>(ref_table->item(r));
						if (property->declaring_type() == type_def)
							property->set_can_rename(false);
					}
				}
			}
		}
	}

	table = meta_data_->table(ttMemberRef);
	for (i = 0; i < table->count(); i++) {
		ILMemberRef *member_ref = reinterpret_cast<ILMemberRef *>(table->item(i));
		ILToken *declaring_type = member_ref->declaring_type();
		if (declaring_type->type() == ttTypeSpec) {
			ILTypeSpec *type_spec = reinterpret_cast<ILTypeSpec *>(declaring_type);
			if (type_spec->info()->type() == ELEMENT_TYPE_GENERICINST) {
				if (type_spec->info()->next()->token()->type() == ttTypeDef) {
					ILTypeDef *type_def = reinterpret_cast<ILTypeDef *>(type_spec->info()->next()->token());
					if (member_ref->signature()->is_method()) {
						ILMethodDef *method = type_def->GetMethod(member_ref->name(), member_ref->signature());
						if (method && method->can_rename())
							reference_list.AddMemberReference(member_ref, method);
					}
					else if (member_ref->signature()->is_field()) {
						ILField *field = type_def->GetField(member_ref->name());
						if (field && field->can_rename())
							reference_list.AddMemberReference(member_ref, field);
					}
				}
			}
		}
	}

	table = meta_data_->table(ttCustomAttribute);
	for (i = 0; i < table->count(); i++) {
		ILCustomAttribute *attribute = reinterpret_cast<ILCustomAttribute *>(table->item(i));
		CustomAttributeValue *value = attribute->ParseValue();

		std::vector<CustomAttributeArgument *> arg_list;
		for (j = 0; j < value->fixed_list()->count(); j++) {
			arg_list.push_back(value->fixed_list()->item(j));
		}
		for (j = 0; j < value->named_list()->count(); j++) {
			arg_list.push_back(value->named_list()->item(j));
		}

		for (j = 0; j < arg_list.size(); j++) {
			CustomAttributeArgument *arg = arg_list[j];
			if (arg->reference() && arg->reference()->meta() == meta_data_) {
				if (arg->reference()->can_rename())
					reference_list.AddCustomAttribute(attribute);
			}

			if (arg->children()) {
				for (size_t k = 0; k < arg->children()->count(); k++) {
					arg_list.push_back(arg->children()->item(k));
				}
			}
		}

		ILToken *type;
		switch (attribute->type()->type()) {
		case ttMethodDef:
			type = reinterpret_cast<ILMethodDef *>(attribute->type())->declaring_type();
			break;
		case ttMemberRef:
			type = reinterpret_cast<ILMemberRef *>(attribute->type())->declaring_type();
			break;
		default:
			type = NULL;
			break;
		}

		for (size_t j = 0; j < value->named_list()->count(); j++) {
			CustomAttributeNamedArgument *arg = value->named_list()->item(j);
			while (type && type->type() == ttTypeDef) {
				ILTypeDef *declaring_type = reinterpret_cast<ILTypeDef *>(type);
				if (arg->is_field()) {
					if (ILField *field = declaring_type->GetField(arg->name())) {
						if (field->can_rename())
							reference_list.AddCustomAttributeNameReference(attribute, arg, field);
						break;
					}
				}
				else {
					if (ILProperty *prop = declaring_type->GetProperty(arg->name())) {
						if (prop->can_rename())
							reference_list.AddCustomAttributeNameReference(attribute, arg, prop);
						break;
					}
				}
				type = declaring_type->base_type();
			}
		}
	}

	std::map<std::string, std::set<ILProperty *> > property_map;
	table = meta_data_->table(ttProperty);
	ILTable *method_semantics_table = meta_data_->table(ttMethodSemantics);
	for (i = 0; i < table->count(); i++) {
		ILProperty *prop = reinterpret_cast<ILProperty *>(table->item(i));

		CorMethodAttr method_flags = (CorMethodAttr)0;
		for (j = 0; j < method_semantics_table->count(); j++) {
			ILMethodSemantics *semantics = reinterpret_cast<ILMethodSemantics *>(method_semantics_table->item(j));
			if (semantics->association() == prop) {
				method_flags = semantics->method()->flags();
				break;
			}
		}

		if ((method_flags & mdMemberAccessMask) == mdPublic && (method_flags & mdStatic) == 0) {
			std::map<std::string, std::set<ILProperty *> >::iterator it = property_map.find(prop->name());
			if (it == property_map.end())
				property_map[prop->name()].insert(prop);
			else
				it->second.insert(prop);
		}
	}

	table = meta_data_->table(ttManifestResource);
	for (i = 0; i < table->count(); i++) {
		ILManifestResource *resource = reinterpret_cast<ILManifestResource *>(table->item(i));
		if (resource->implementation())
			continue;

		std::string name = resource->name();
		if (name.size() >= 10 && name.substr(name.size() - 10) != ".resources")
			continue;

		if (name.size() >= 2 && name.substr(name.size() - 2) == ".g")
			continue;

		name = name.substr(0, name.size() - 10);
		ILTypeDef *type_def = meta_data_->GetTypeDef(name);
		if (type_def && type_def->can_rename())
			reference_list.AddResourceReference(resource, type_def, ".resources");

		ManifestResourceValue *resource_value = resource->value();
		for (j = 0; j < resource_value->count(); j++) {
			ManifestResourceItem *resource_item = resource_value->item(j);
			std::string name = resource_item->name();
			if (name.size() >= 5 && name.substr(name.size() - 5) == ".baml") {
				BamlDocument *baml = resource_item->ParseBaml();
				if (!baml)
					continue;

				for (k = baml->count(); k > 0; k--) {
					BamlRecord *record = baml->item(k - 1);
					if (record->type() == LineNumberAndPosition || record->type() == LinePosition) {
						delete record;
						reference_list.AddManifestResource(resource);
					}
				}

				BamlElement root(NULL);
				if (root.Parse(baml)) {
					std::map<uint16_t, ILMetaData *> assembly_info_map;
					std::map<uint16_t, ILTypeDef *> type_info_map;
					std::map<uint16_t, AttributeInfoRecord *> attribute_info_map;

					for (k = 0; k < baml->count(); k++) {
						BamlRecord *record = baml->item(k);
						switch (record->type()) {
						case AssemblyInfo:
							{
								AssemblyInfoRecord *assembly_info = reinterpret_cast<AssemblyInfoRecord *>(record);
								if (ILMetaData *assembly = meta_data_->ResolveAssembly(assembly_info->assembly_name(), false))
									assembly_info_map[assembly_info->assembly_id()] = assembly;
							}
							break;
						case AttributeInfo:
							{
								AttributeInfoRecord *attribute_info = reinterpret_cast<AttributeInfoRecord *>(record);
								attribute_info_map[attribute_info->attribute_id()] = attribute_info;
							}
							break;
						case TypeInfo:
						case TypeSerializerInfo:
							{
								TypeInfoRecord *type_info = reinterpret_cast<TypeInfoRecord *>(record);
								std::map<uint16_t, ILMetaData *>::const_iterator it = assembly_info_map.find(type_info->assembly_id());
								if (it != assembly_info_map.end()) {
									if (ILTypeDef *type_def = it->second->GetTypeDef(type_info->type_name()))
										type_info_map[type_info->type_id()] = type_def;
								}
							}
							break;
						}
					}

					std::vector<BamlElement *> stack;
					stack.push_back(&root);
					BamlElement *type_root = root.children().empty() ? NULL : root.children().at(0);
					while (!stack.empty()) {
						BamlElement *elem = stack.back();
						stack.pop_back();

						// process header
						switch (elem->header()->type()) {
						case ConstructorParametersStart:
							elem->set_type(elem->parent()->type());
							break;
						case ElementStart:
						case NamedElementStart:
							{
								ElementStartRecord *element_record = reinterpret_cast<ElementStartRecord *>(elem->header());
								std::map<uint16_t, ILTypeDef *>::const_iterator it = type_info_map.find(element_record->type_id());
								if (it != type_info_map.end())
									elem->set_type(it->second);
							}
							break;
						}

						// process body
						std::vector<BamlRecord *> body = elem->body();
						for (k = 0; k < body.size(); k++) {
							BamlRecord *record = body[k];
							switch (record->type()) {
							case Property:
							case PropertyWithConverter:
								{
									if (!type_root || !type_root->type())
										break;

									PropertyRecord *property = reinterpret_cast<PropertyRecord *>(record);
									std::map<uint16_t, AttributeInfoRecord *>::const_iterator attribute_it = attribute_info_map.find(property->attribute_id());
									if (attribute_it != attribute_info_map.end()) {
										AttributeInfoRecord *attribute_info = attribute_it->second;
										std::map<uint16_t, ILTypeDef *>::const_iterator it = type_info_map.find(attribute_info->owner_type_id());
										if (it != type_info_map.end()) {
											ILTypeDef *type_def = it->second;
											while (type_def) {
												if (ILEvent *event = type_def->GetEvent(attribute_info->name())) {
													if (ILMethodDef *method = type_root->type()->GetMethod(property->value(), NULL)) {
														if (method->meta() == meta_data_ && method->can_rename())
															reference_list.AddPropertyRecordReference(resource, property, method);
														break;
													}
												}

												ILToken *base_type = type_def->base_type();
												if (!base_type)
													break;

												switch (base_type->type()) {
												case ttTypeDef:
													type_def = reinterpret_cast<ILTypeDef *>(base_type);
													break;
												case ttTypeRef:
													type_def = reinterpret_cast<ILTypeRef *>(base_type)->Resolve(true);
													break;
												default:
													type_def = NULL;
													break;
												}
											}
										}
									}
								}
								break;
							case Text:
								{
									TextRecord *text = reinterpret_cast<TextRecord *>(record);
									std::map<std::string, std::set<ILProperty *> >::const_iterator it = property_map.find(text->value());
									if (it != property_map.end()) {
										for (std::set<ILProperty *>::const_iterator prop_it = it->second.begin(); prop_it != it->second.end(); prop_it++) {
											(*prop_it)->set_can_rename(false);
										}
									}
								}
								break;
							case TypeInfo:
							case TypeSerializerInfo:
								{
									TypeInfoRecord *type_info = reinterpret_cast<TypeInfoRecord *>(record);
									std::map<uint16_t, ILTypeDef *>::const_iterator it = type_info_map.find(type_info->type_id());
									if (it != type_info_map.end()) {
										ILTypeDef *type_def = it->second;
										if (type_def->meta() == meta_data_ && type_def->can_rename())
											reference_list.AddTypeInfoRecordReference(resource, type_info, type_def);
									}
								}
								break;
							case AttributeInfo:
								{
									AttributeInfoRecord *attribute_info = reinterpret_cast<AttributeInfoRecord *>(record);
									std::map<uint16_t, ILTypeDef *>::const_iterator it = type_info_map.find(attribute_info->owner_type_id());
									if (it != type_info_map.end()) {
										ILTypeDef *type_def = it->second;
										while (type_def) {
											if (ILProperty *prop = type_def->GetProperty(attribute_info->name())) {
												if (prop->meta() == meta_data_ && prop->can_rename())
													reference_list.AddAttributeInfoRecordReference(resource, attribute_info, prop);
												break;
											}

											if (ILEvent *event = type_def->GetEvent(attribute_info->name())) {
												if (event->meta() == meta_data_ && event->can_rename())
													reference_list.AddAttributeInfoRecordReference(resource, attribute_info, event);
												break;
											}

											ILToken *base_type = type_def->base_type();
											if (!base_type)
												break;

											switch (base_type->type()) {
											case ttTypeDef:
												type_def = reinterpret_cast<ILTypeDef *>(base_type);
												break;
											case ttTypeRef:
												type_def = reinterpret_cast<ILTypeRef *>(base_type)->Resolve(true);
												break;
											default:
												type_def = NULL;
												break;
											}
										}
									}
								}
								break;
							}
						}

						// process children
						std::vector<BamlElement *> children = elem->children();
						for (k = 0; k < children.size(); k++) {
							stack.push_back(children[k]);
						}
					}
				}
			}
		}
	}

	for (i = 0; i < token_list.size(); i++) {
		token = token_list[i];
		if (token->can_rename())
			RenameToken(token);
	}

	reference_list.UpdateNames();
}

void NETArchitecture::Save(CompileContext &ctx)
{
	PESegment *vmp_segment, *last_segment, *segment;
	uint64_t address, file_crc_address, loader_crc_address, loader_crc_size_address, loader_crc_hash_address, file_crc_size_address;
	uint32_t size;
	PEDirectory *dir;
	size_t i, c, j, vmp_index;
	uint64_t pos;
	uint32_t fixup_section_flags, resource_section_flags, file_crc_size, loader_crc_size;
	std::string fixup_section_name, resource_section_name;
	MemoryRegion *region;
	std::set<ILTypeDef *> runtime_type_list;

	MemoryManager *manager = memory_manager();
	NETArchitecture *source = (NETArchitecture *)this->source();

	// erase sections area
	{
		IMAGE_SECTION_HEADER section_header = IMAGE_SECTION_HEADER();
		Seek(header_offset() + offsetof(IMAGE_NT_HEADERS32, OptionalHeader) + header_size());
		for (i = 0; i < segment_list()->count(); i++) {
			Write(&section_header, sizeof(section_header));
		}
	}

	// resize header
	if (resize_header_) {
		size_t total_header_size = offsetof(IMAGE_NT_HEADERS32, OptionalHeader) + header_size() + segment_list()->count() * sizeof(IMAGE_SECTION_HEADER);
		if (resize_header_) {
			source->Seek(header_offset() + total_header_size);
			Seek(header_offset() + total_header_size);
			for (i = 0; i < resize_header_; i++) {
				WriteByte(0);
			}
			CopyFrom(*source, this->size() - source->Tell());
			for (i = 0; i < segment_list()->count(); i++) {
				segment = segment_list()->item(i);
				if (segment->physical_offset())
					segment->set_physical_offset(segment->physical_offset() + resize_header_);
			}
		}
	}

	// calc progress maximum
	c = 0;
	if (ctx.runtime)
		c += ctx.runtime->segment_list()->count();
	for (i = 0; i < function_list_->count(); i++) {
		IFunction *func = function_list_->item(i);
		if (!func->need_compile())
			continue;

		for (j = 0; j < func->block_list()->count(); j++) {
			CommandBlock *block = func->block_list()->item(j);
			c += block->end_index() - block->start_index() + 1;
		}
	}
	StartProgress(string_format("%s...", language[lsSaving].c_str()), c);

	resource_section_flags = IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA;
	resource_section_name = ".rsrc";

	fixup_section_flags = IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_CNT_INITIALIZED_DATA;
	fixup_section_name = ".reloc";

	// need erase optimized sections
	for (i = segment_list()->count(); i > optimized_section_count_; i--) {
		PESegment *section = segment_list()->item(i - 1);
		if (pe_->resource_section() == section) {
			resource_section_flags = section->flags();
			resource_section_name = section->name();
		} else if (pe_->fixup_section() == section) {
			fixup_section_flags = section->flags();
			fixup_section_name = section->name();
		}
		delete section;
	}

	vmp_index = 0;
	last_segment = segment_list()->last();
	address = AlignValue(last_segment->address() + last_segment->size(), segment_alignment());
	pos = Resize(AlignValue(this->size(), file_alignment()));
	vmp_segment = segment_list()->Add(address, -1, static_cast<uint32_t>(pos), -1, IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE, "");

	std::vector<IFunction *> ref_function_list = this->function_list()->processor_list();
	NETArchitecture *runtime = reinterpret_cast<NETArchitecture *>(ctx.vm_runtime);
	if (ctx.runtime) {
		// create EntryPoint method
		ILTypeDef *module = reinterpret_cast<ILTypeDef *>(meta_data_->token(ttTypeDef | 1));
		if (!module)
			throw std::runtime_error("Runtime error at Save");

		ILData signature;
		signature.push_back(0x00);
		signature.push_back(0x00);
		signature.push_back(0x01);
		ILMethodDef *module_cctor = meta_data_->AddMethod(module, ".cctor", signature, (CorMethodAttr)(mdPrivate | mdHideBySig | mdStatic | mdSpecialName | mdRTSpecialName), miIL);
		runtime->set_entry_point_method(module_cctor);

		// merge runtime objects
		if (runtime->segment_list()->count()) {
			// merge segments
			for (i = 0; i < runtime->segment_list()->count(); i++) {
				segment = runtime->segment_list()->item(i);
				if (segment->physical_offset() && segment->physical_size()) {
					runtime->Seek(segment->physical_offset());
					size = static_cast<uint32_t>(segment->physical_size());
					uint8_t *buffer = new uint8_t[size];
					runtime->Read(buffer, size);
					Write(buffer, size);
					delete[] buffer;
				}
				size = static_cast<uint32_t>(AlignValue(segment->size(), runtime->segment_alignment()) - segment->physical_size());
				for (j = 0; j < size; j++) {
					WriteByte(0);
				}
				vmp_segment->include_write_type(segment->memory_type());

				StepProgress();
			}
			ref_function_list.clear();
		}
		else {
			for (i = 0; i < runtime->function_list()->count(); i++) {
				IFunction *func = runtime->function_list()->item(i);
				if (func->tag() == ftLoader)
					ref_function_list.push_back(func);
			}
		}
	}
	else {
		if (ref_function_list.empty())
			runtime = NULL;
	}

	if (runtime) {
		if (ref_function_list.empty()) {
			ILToken *token = runtime->meta_data_->token(ttTypeDef | 1);
			if (token)
				token->set_deleted(true);
		} else {
			std::set<ILToken *> filter_token_list;
			for (i = 0; i < ref_function_list.size(); i++) {
				ILFunction *func = reinterpret_cast<ILFunction *>(ref_function_list[i]);
				for (j = 0; j < func->count(); j++) {
					ILCommand *command = func->item(j);
					if (command->token_reference()) {
						ILToken *token = command->token_reference()->owner()->owner();
						ILSignature *signature = NULL;
						switch (token->type()) {
						case ttMethodDef:
							filter_token_list.insert(token);
							filter_token_list.insert(reinterpret_cast<ILMethodDef *>(token)->declaring_type());
							signature = reinterpret_cast<ILMethodDef *>(token)->signature();
							break;
						case ttMethodSpec:
							filter_token_list.insert(token);
							filter_token_list.insert(reinterpret_cast<ILMethodSpec *>(token)->parent());
							signature = reinterpret_cast<ILMethodSpec *>(token)->signature();
							break;
						case ttMemberRef:
							filter_token_list.insert(token);
							filter_token_list.insert(reinterpret_cast<ILMemberRef *>(token)->declaring_type());
							signature = reinterpret_cast<ILMemberRef *>(token)->signature();
							break;
						case ttField:
							filter_token_list.insert(reinterpret_cast<ILField *>(token)->declaring_type());
							signature = reinterpret_cast<ILField *>(token)->signature();
							break;
						case ttStandAloneSig:
							filter_token_list.insert(token);
							signature = reinterpret_cast<ILStandAloneSig *>(token)->signature();
							break;
						default:
							filter_token_list.insert(token);
							break;
						}

						if (signature) {
							std::vector<ILElement *> element_list;
							for (c = 0; c < signature->count(); c++) {
								element_list.push_back(signature->item(c));
							}
							if (signature->ret())
								element_list.push_back(signature->ret());
							for (c = 0; c < element_list.size(); c++) {
								ILElement *element = element_list[c];
								do {
									if (element->token())
										filter_token_list.insert(element->token());
									element = element->next();
								} while (element);
							}
						}
					}
				}
			}

			ILTokenType link_types[] = { ttTypeDef, ttMethodDef, ttUserString, ttStandAloneSig, ttImplMap, ttModuleRef, ttMemberRef, ttTypeSpec, ttTypeRef };
			for (i = 0; i < _countof(link_types); i++) {
				ILTokenType type = link_types[i];
				ILTable *table = runtime->meta_data_->table(type);
				for (j = 0; j < table->count(); j++) {
					ILToken *token = table->item(j);
					if (token->type() == ttImplMap) {
						ILImplMap *impl_map = reinterpret_cast<ILImplMap *>(token);
						if (filter_token_list.find(impl_map->member_forwarded()) != filter_token_list.end())
							filter_token_list.insert(impl_map->import_scope());
					}
					else if (filter_token_list.find(token) != filter_token_list.end()) {
						if (token->type() == ttTypeDef) {
							ILTypeDef *type_def = reinterpret_cast<ILTypeDef *>(token);
							if (type_def->base_type())
								filter_token_list.insert(type_def->base_type());
						}
					} else {
						// token not found
						if (token->type() == ttTypeDef) {
							bool has_nested = false;
							for (std::set<ILToken *>::const_iterator it = filter_token_list.begin(); it != filter_token_list.end(); it++) {
								ILToken *tmp = *it;
								if (tmp->type() == ttTypeDef) {
									ILTypeDef *type_def = reinterpret_cast<ILTypeDef *>(tmp);
									while (type_def) {
										ILTypeDef *declaring_type = type_def->declaring_type();
										if (declaring_type == token) {
											has_nested = true;
											break;
										}
										type_def = declaring_type;
									}
								}
								if (has_nested)
									break;
							}
							if (has_nested)
								continue;
						} else if (token->type() == ttMethodDef) {
							ILMethodDef *method = reinterpret_cast<ILMethodDef *>(token);
							if (filter_token_list.find(method->declaring_type()) != filter_token_list.end()) {
								if (method->flags() & (mdRTSpecialName | mdVirtual)) {
									if (!method->declaring_type()->is_deleted()) {
										ILSignature *signature = method->signature();
										std::vector<ILElement *> element_list;
										for (c = 0; c < signature->count(); c++) {
											element_list.push_back(signature->item(c));
										}
										if (signature->ret())
											element_list.push_back(signature->ret());
										for (c = 0; c < element_list.size(); c++) {
											ILElement *element = element_list[c];
											do {
												if (element->token())
													filter_token_list.insert(element->token());
												element = element->next();
											} while (element);
										}
									}
									continue;
								}

								if (method->declaring_type()->method_list() == method) {
									ILMethodDef *next_method = method->next();
									method->declaring_type()->set_method_list(next_method->declaring_type() == method->declaring_type() ? next_method : NULL);
								}
							}
						}

						if (token->type() == ttUserString)
							token->reference_list()->clear();
						else 
							token->set_deleted(true);
					}
				}
			}
		}

		// merge meta data
		ILTable *src_table = runtime->meta_data_->us_table();
		ILTable *dst_table = meta_data_->us_table();
		for (i = 0; i < src_table->count(); i++) {
			ILToken *src_token = src_table->item(i);
			ILToken *dst_token = src_token->Clone(meta_data_, dst_table);
			dst_token->reference_list()->clear();
			while (src_token->reference_list()->count()) {
				TokenReference *reference = src_token->reference_list()->item(0);
				reference->set_owner(dst_token->reference_list());
				if (runtime->segment_list()->count() == 0)
					reference->set_address(0);
			}
			dst_table->AddObject(dst_token);
		}

		src_table = runtime->meta_data_->table(ttTypeDef);
		for (i = 0; i < src_table->count(); i++) {
			ILTypeDef *type_def = reinterpret_cast<ILTypeDef *>(src_table->item(i));
			if (type_def->full_name() == "VMProtect.DeleteOnCompilation") {
				type_def->set_deleted(true);
				src_table = runtime->meta_data_->table(ttCustomAttribute);
				for (j = 0; j < src_table->count(); j++) {
					ILCustomAttribute *attribute = reinterpret_cast<ILCustomAttribute *>(src_table->item(j));
					if (attribute->type() == type_def->method_list())
						attribute->parent()->set_deleted(true);
				}
				break;
			}
		}

		src_table = runtime->meta_data_->table(ttCustomAttribute);
		for (i = 0; i < src_table->count(); i++) {
			ILCustomAttribute *attribute = reinterpret_cast<ILCustomAttribute *>(src_table->item(i));
			if (attribute->parent()->is_deleted())
				continue;

			switch (attribute->parent()->type()) {
			case ttModule:
			case ttAssembly:
				attribute->set_deleted(true);
				{
					ILToken *token = attribute->type();
					if (token->type() == ttMemberRef) {
						ILMemberRef *member_ref = reinterpret_cast<ILMemberRef *>(token);
						if (member_ref->declaring_type()->type() == ttTypeRef && reinterpret_cast<ILTypeRef *>(member_ref->declaring_type())->full_name() == "System.Runtime.CompilerServices.SuppressIldasmAttribute") {
							member_ref->set_deleted(false);
							member_ref->declaring_type()->set_deleted(false);
							attribute->set_deleted(false);
						}
					}
				}
				break;
			}
		}

		ILTokenType types[] = { ttModule, ttAssembly, ttAssemblyRef, ttModuleRef, ttTypeRef, ttTypeDef, ttTypeSpec, ttNestedClass, ttClassLayout, ttMemberRef, ttField,
			ttFieldLayout, ttFieldRVA, ttMethodDef, ttMethodSpec, ttImplMap, ttParam, ttGenericParam, ttConstant, ttCustomAttribute, ttPropertyMap, ttProperty,
			ttMethodSemantics, ttStandAloneSig, ttInterfaceImpl};
		std::map<ILToken *, ILToken *> token_map;
		for (i = 0; i < _countof(types); i++) {
			ILTokenType type = types[i];
			src_table = runtime->meta_data_->table(type);
			dst_table = meta_data_->table(type);
			c = dst_table->count();
			for (size_t k = 0; k < src_table->count();) {
				ILToken *src_token = src_table->item(k);

				if (runtime->segment_list()->count() == 0) {
					for (j = 0; j < src_token->reference_list()->count(); j++) {
						src_token->reference_list()->item(j)->set_address(0);
					}
				}

				src_token->RemapTokens(token_map);
				bool is_equal = false;
				if (!src_token->is_deleted()) {
					if (type == ttModule || type == ttAssembly || type == ttAssemblyRef || type == ttModuleRef || type == ttTypeRef || type == ttMemberRef || type == ttCustomAttribute) {
						for (j = 0; j < c; j++) {
							ILToken *dst_token = dst_table->item(j);
							switch (type) {
							case ttModule:
							case ttAssembly:
								is_equal = src_token->id() == dst_token->id();
								break;
							case ttAssemblyRef:
								{
									ILAssemblyRef *src = reinterpret_cast<ILAssemblyRef *>(src_token);
									ILAssemblyRef *dst = reinterpret_cast<ILAssemblyRef *>(dst_token);
									is_equal = (src->name() == dst->name());
								}
								break;
							case ttModuleRef:
								{
									ILModuleRef *src = reinterpret_cast<ILModuleRef *>(src_token);
									ILModuleRef *dst = reinterpret_cast<ILModuleRef *>(dst_token);
									is_equal = (src->name() == dst->name());
								}
								break;
							case ttTypeRef:
								{
									ILTypeRef *src = reinterpret_cast<ILTypeRef *>(src_token);
									ILTypeRef *dst = reinterpret_cast<ILTypeRef *>(dst_token);
									is_equal = (src->resolution_scope() == dst->resolution_scope() && src->name_space() == dst->name_space() && src->name() == dst->name());
								}
								break;
							case ttMemberRef:
								{
									ILMemberRef *src = reinterpret_cast<ILMemberRef *>(src_token);
									ILMemberRef *dst = reinterpret_cast<ILMemberRef *>(dst_token);
									is_equal = (src->declaring_type() == dst->declaring_type() && src->name() == dst->name() && src->signature()->ret_name(true) == dst->signature()->ret_name(true) && src->signature()->name(true) == dst->signature()->name(true));
								}
								break;
							case ttCustomAttribute:
								{
									ILCustomAttribute *src = reinterpret_cast<ILCustomAttribute *>(src_token);
									ILCustomAttribute *dst = reinterpret_cast<ILCustomAttribute *>(dst_token);
									is_equal = (src->parent() == dst->parent() && src->type() == dst->type());
								}
								break;
							}
							if (is_equal) {
								token_map[src_token] = dst_token;
								while (src_token->reference_list()->count()) {
									TokenReference *reference = src_token->reference_list()->item(0);
									reference->set_owner(dst_token->reference_list());
								}
								if (dst_token->value() != src_token->value())
									dst_token->set_value(0);
								k++;
								break;
							}
						}
					}
				}
				if (!is_equal) {
					src_token->set_owner(meta_data_, dst_table);
					if (src_token->type() == ttTypeDef)
						runtime_type_list.insert(reinterpret_cast<ILTypeDef*>(src_token));
				}
			}
		}
	}
	import_list_->Pack();
	meta_data_->UpdateTokens();

	// update tokens
	for (i = 0; i < function_list_->count(); i++) {
		ILFunction *func = reinterpret_cast<ILFunction *>(function_list_->item(i));
		for (j = 0; j < func->count(); j++) {
			ILCommand *command = func->item(j);
			if (!command->block())
				continue;

			if (command->block()->type() & mtExecutable) {
				TokenReference *reference = command->token_reference();
				if (reference) {
					uint32_t id = reference->owner()->owner()->id();
					if (command->operand_value() != id) {
						if (command->type() == icComment) {
							Data data;
							data.PushDWord(id);
							command->set_dump(data.data(), data.size());
						}
						else {
							command->set_operand_value(0, id);
							command->CompileToNative();
						}
					}
				}
			}
			else {
				for (c = 0; c < command->count(); c++) {
					ILVMCommand *vm_command = command->item(c);
					TokenReference *reference = vm_command->token_reference();
					if (reference) {
						uint32_t id = reference->owner()->owner()->id();
						if (vm_command->value() != id) {
							vm_command->set_value(id);
							vm_command->Compile();
						}
					}
				}
			}
		}
	}

	// write functions
	for (i = 0; i < function_list_->count(); i++) {
		function_list_->item(i)->WriteToFile(*this);
	}

	// erase not used memory regions
	if (manager->count() > 1) {
		// need skip last big region
		for (i = 0; i < manager->count() - 1; i++) {
			region = manager->item(i);
			if (!AddressSeek(region->address()))
				continue;

			for (j = 0; j < region->size(); j++) {
				WriteByte((region->type() & mtReadable) ? rand() : 0);
			}
		}
	}

	if (vmp_segment->write_type() == mtNone)
		delete vmp_segment;
	else {
		vmp_segment->set_name(string_format("%s%d", ctx.options.section_name.c_str(), vmp_index++));
	
		size = static_cast<uint32_t>(this->size() - vmp_segment->physical_offset());
		vmp_segment->set_size(size);
		vmp_segment->set_physical_size(AlignValue(size, file_alignment()));
		vmp_segment->update_type(vmp_segment->write_type());

		Resize(vmp_segment->physical_offset() + vmp_segment->physical_size());
	}

	//if (false)
	if (!runtime_type_list.empty()) {
		// rename runtime symbols
		NameReferenceList reference_list;
		std::vector<ILToken *> rename_token_list;
		for (std::set<ILTypeDef *>::const_iterator it = runtime_type_list.begin(); it != runtime_type_list.end(); it++) {
			rename_token_list.push_back(*it);
		}

		ILTable *table = meta_data_->table(ttMethodDef);
		for (j = 0; j < table->count(); j++) {
			ILMethodDef *method = reinterpret_cast<ILMethodDef*>(table->item(j));
			if (runtime_type_list.find(method->declaring_type()) != runtime_type_list.end()) {
				if (method->flags() & mdRTSpecialName)
					continue;

				if (method->flags() & mdVirtual) {
					if (method->name() == "Invoke" || method->name() == "BeginInvoke" || method->name() == "EndInvoke" || method->name() == "ToString")
						continue;

					ILToken *base_type = method->declaring_type()->base_type();
					ILMethodDef *base_method = NULL;
					while (base_type && base_type->type() == ttTypeDef) {
						ILTypeDef *type_def = reinterpret_cast<ILTypeDef *>(base_type);
						if (ILMethodDef *tmp_method = type_def->GetMethod(method->name(), method->signature()))
							base_method = tmp_method;
						base_type = type_def->base_type();
					}

					if (base_method) {
						reference_list.AddMethodReference(method, base_method);
						continue;
					}
				}

				rename_token_list.push_back(method);
			}
		}

		table = meta_data_->table(ttParam);
		for (j = 0; j < table->count(); j++) {
			ILParam *param = reinterpret_cast<ILParam*>(table->item(j));
			if (param->parent() && runtime_type_list.find(param->parent()->declaring_type()) != runtime_type_list.end())
				rename_token_list.push_back(param);
		}

		table = meta_data_->table(ttField);
		for (j = 0; j < table->count(); j++) {
			ILField *field = reinterpret_cast<ILField*>(table->item(j));
			if (field->flags() & fdRTSpecialName)
				continue;

			if (runtime_type_list.find(field->declaring_type()) != runtime_type_list.end()) {
				if (field->flags() & fdLiteral) {
					std::string type_name = field->declaring_type()->full_name();
					if (type_name == "VMProtect.SerialState" || type_name == "VMProtect.ActivationStatus")
						continue;
				}

				rename_token_list.push_back(field);
			}
		}

		table = meta_data_->table(ttProperty);
		for (j = 0; j < table->count(); j++) {
			ILProperty *prop = reinterpret_cast<ILProperty*>(table->item(j));
			if (prop->flags() & prRTSpecialName)
				continue;

			if (runtime_type_list.find(prop->declaring_type()) != runtime_type_list.end())
				rename_token_list.push_back(prop);
		}

		for (i = 0; i < rename_token_list.size(); i++) {
			RenameToken(rename_token_list[i]);
		}
		reference_list.UpdateNames();
	}

	// write memory CRC table
	if (function_list_->crc_table()) {
		ILCRCTable *il_crc = reinterpret_cast<ILCRCTable *>(function_list_->crc_table());
		CRCTable crc_table(function_list_->crc_cryptor(), il_crc->table_size());

		// add non writable sections
		for (i = 0; i < segment_list()->count(); i++) {
			segment = segment_list()->item(i);
			if ((segment->memory_type() & (mtReadable | mtWritable)) != mtReadable || segment->excluded_from_memory_protection())
				continue;

			size = std::min(static_cast<uint32_t>(segment->size()), segment->physical_size());
			if (size)
				crc_table.Add(segment->address(), size);
		}

		// skip writable runtime's sections
		if (runtime) {
			for (i = 0; i < runtime->segment_list()->count(); i++) {
				segment = runtime->segment_list()->item(i);
				if (segment->memory_type() & mtWritable)
					crc_table.Remove(segment->address(), static_cast<uint32_t>(segment->size()));
			}
		}

		// skip IAT
		size = OperandSizeToValue(pe_->cpu_address_size());
		size_t k = (runtime && runtime->segment_list()->count() > 0) ? 2 : 1;
		for (size_t n = 0; n < k; n++) {
			PEImportList *import_list = (n == 0) ? pe_->import_list() : runtime->pe_->import_list();
			for (i = 0; i < import_list->count(); i++) {
				PEImport *import = import_list->item(i);
				if (import->count() > 0)
					crc_table.Remove(import->item(0)->address(), size * import->count());
			}
		}

		// skip fixups
		if ((ctx.options.flags & cpStripFixups) == 0) {
			for (i = 0; i < pe_->fixup_list()->count(); i++) {
				PEFixup *fixup = pe_->fixup_list()->item(i);
				if (!fixup->is_deleted())
					crc_table.Remove(fixup->address(), OperandSizeToValue(fixup->size()));
			}
		}

		// skip memory CRC table
		crc_table.Remove(il_crc->table_entry()->address(), il_crc->table_size());
		crc_table.Remove(il_crc->size_entry()->address(), sizeof(uint32_t));
		crc_table.Remove(il_crc->hash_entry()->address(), sizeof(uint32_t));

		// write to file
		AddressSeek(il_crc->table_entry()->address());
		uint32_t hash;
		size = static_cast<uint32_t>(crc_table.WriteToFile(*this, false, &hash));
		AddressSeek(il_crc->size_entry()->address());
		WriteDWord(size);
		AddressSeek(il_crc->hash_entry()->address());
		WriteDWord(hash);

		il_crc->size_entry()->set_operand_value(0, size);
		il_crc->hash_entry()->set_operand_value(0, hash);
	}
	EndProgress();

	file_crc_address = 0;
	file_crc_size = 0;
	file_crc_size_address = 0;
	loader_crc_address = 0;
	loader_crc_size = 0;
	loader_crc_size_address = 0;
	loader_crc_hash_address = 0;
	if (ctx.runtime) {
		std::vector<IFunction *> processor_list = function_list_->processor_list();

		NETLoader *loader = new NETLoader(NULL, cpu_address_size());

		last_segment = segment_list()->last();
		address = AlignValue(last_segment->address() + last_segment->size(), segment_alignment());

		manager->clear();
		manager->Add(address, -1, mtReadable | mtExecutable | mtWritable | mtNotPaged | (runtime_function_list()->count() ? mtSolid : mtNone));

		if (!loader->Prepare(ctx)) {
			delete loader;
			throw std::runtime_error("Runtime error at Save");
		}
		size_t processor_count = 0;
		for (i = 0; i < processor_list.size(); i++) {
			processor_count += processor_list[i]->count();
		}
		ctx.file->StartProgress(string_format("%s...", language[lsSavingStartupCode].c_str()), loader->count() + processor_count);
		loader->Compile(ctx);

		pos = Resize(AlignValue(this->size(), file_alignment()));
		segment = segment_list()->Add(address, -1, static_cast<uint32_t>(pos), -1, IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE, string_format("%s%d", ctx.options.section_name.c_str(), vmp_index++));
		loader->WriteToFile(*this);
		segment->update_type(segment->write_type());
		for (i = 0; i < processor_list.size(); i++) {
			processor_list[i]->WriteToFile(*this);
		}

		// copy directories
		if (ctx.options.flags & cpPack) {
			IArchitecture *source = const_cast<IArchitecture *>(this->source());
			last_segment = segment_list()->last();

			dir = pe_->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG);
			if (dir && dir->address() && dir->physical_size() && source->AddressSeek(dir->address())) {
				size = dir->physical_size();
				pos = Resize(AlignValue(this->size(), 0x10));
				CopyFrom(*source, size);
				address = last_segment->address() + pos - last_segment->physical_offset();
				for (i = 0; i < size; i++) {
					PEFixup *fixup = reinterpret_cast<PEFixup *>(source->fixup_list()->GetFixupByAddress(dir->address() + i));
					if (fixup) {
						fixup = fixup->Clone(fixup_list());
						fixup->set_address(address + i);
						fixup_list()->AddObject(fixup);
					}
				}
				dir->set_address(address);
			}

			if ((ctx.options.flags & cpStripDebugInfo) == 0) {
				dir = pe_->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_DEBUG);
				if (dir && dir->address() && dir->physical_size() && source->AddressSeek(dir->address())) {
					IMAGE_DEBUG_DIRECTORY debug_directory_data;
					std::vector<IMAGE_DEBUG_DIRECTORY> debug_directory_data_list;
					c = dir->size() / sizeof(debug_directory_data);
					for (i = 0; i < c; i++) {
						source->Read(&debug_directory_data, sizeof(debug_directory_data));
						debug_directory_data_list.push_back(debug_directory_data);
					}
					for (i = 0; i < debug_directory_data_list.size(); i++) {
						debug_directory_data = debug_directory_data_list[i];
						if (source->Seek(debug_directory_data.PointerToRawData)) {
							size = debug_directory_data.SizeOfData;
							pos = Resize(AlignValue(this->size(), 0x10));
							CopyFrom(*source, size);
							address = last_segment->address() + pos - last_segment->physical_offset();

							debug_directory_data.PointerToRawData = static_cast<uint32_t>(pos);
							debug_directory_data.AddressOfRawData = static_cast<uint32_t>(address - image_base());
							debug_directory_data_list[i] = debug_directory_data;
						}
					}
					pos = Resize(AlignValue(this->size(), 0x10));
					address = last_segment->address() + pos - last_segment->physical_offset();
					for (i = 0; i < debug_directory_data_list.size(); i++) {
						debug_directory_data = debug_directory_data_list[i];
						Write(&debug_directory_data, sizeof(debug_directory_data));
					}
					dir->set_address(address);
				}
			}
		}

		if (loader->import_entry()) {
			dir = pe_->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_IMPORT);
			if (dir) {
				dir->set_address(loader->import_entry()->address());
				dir->set_size(loader->import_size());
			}

			dir = pe_->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_IAT);
			if (dir) {
				dir->set_address(loader->iat_entry()->address());
				dir->set_size(loader->iat_size());
			}
		}

		if (loader->tls_entry()) {
			dir = pe_->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_TLS);
			if (dir) {
				if (loader->tls_size()) {
					dir->set_address(loader->tls_entry()->address());
					dir->set_size(loader->tls_size());
				}
				else {
					dir->clear();
				}
			}
		}

		if (loader->pe_entry())
			pe_->set_entry_point(loader->pe_entry()->address());

		if (loader->strong_name_signature_entry())
			header_.StrongNameSignature.VirtualAddress = static_cast<uint32_t>(loader->strong_name_signature_entry()->address() - image_base());

		if (loader->vtable_fixups_entry())
			header_.VTableFixups.VirtualAddress = static_cast<uint32_t>(loader->vtable_fixups_entry()->address() - image_base());

		if (loader->file_crc_entry()) {
			file_crc_address = loader->file_crc_entry()->address();
			file_crc_size = loader->file_crc_size();
			file_crc_size_address = loader->file_crc_size_entry()->address();
		}

		if (loader->loader_crc_entry()) {
			loader_crc_address = loader->loader_crc_entry()->address();
			loader_crc_size = loader->loader_crc_size();
			loader_crc_size_address = loader->loader_crc_size_entry()->address();
			loader_crc_hash_address = loader->loader_crc_hash_entry()->address();
		}

		delete loader;

		ctx.file->EndProgress();
	}

	// write NET header
	vmp_segment = segment_list()->last();
	pos = Resize(AlignValue(this->size(), 0x10));
	address = vmp_segment->address() + pos - vmp_segment->physical_offset();
	vmp_segment->set_physical_size(-1);
	dir = pe_->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR);
	dir->set_address(address);
	Write(&header_, sizeof(header_));

	// write NET resources
	if (header_.Resources.VirtualAddress) {
		if (ctx.options.flags & cpResourceProtection) {
			header_.Resources.VirtualAddress = 0;
			header_.Resources.Size = 0;
		}
		else {
			Resize(AlignValue(this->size(), sizeof(uint32_t)));
			address = AddressTell();
			ILTable *table = meta_data_->table(ttManifestResource);
			for (i = 0; i < table->count(); i++) {
				ILManifestResource *manifest_resource = reinterpret_cast<ILManifestResource *>(table->item(i));;
				if (manifest_resource->implementation())
					continue;

				std::vector<uint8_t> data = manifest_resource->data();
				if (data.empty()) {
					source->AddressSeek(header_.Resources.VirtualAddress + image_base() + manifest_resource->offset());
					size = source->ReadDWord();
					manifest_resource->set_offset(static_cast<uint32_t>(AddressTell() - address));
					WriteDWord(size);
					CopyFrom(*source, size);
				}
				else {
					manifest_resource->set_offset(static_cast<uint32_t>(AddressTell() - address));
					WriteDWord(static_cast<uint32_t>(data.size()));
					Write(data.data(), data.size());
				}
			}
			header_.Resources.VirtualAddress = static_cast<uint32_t>(address - image_base());
		}
	}

	// write metadata
	Resize(AlignValue(this->size(), sizeof(uint32_t)));
	meta_data_->WriteToFile(*this);
	
	size = static_cast<uint32_t>(this->size() - vmp_segment->physical_offset());
	vmp_segment->set_size(size);
	vmp_segment->set_physical_size(AlignValue(size, pe_->file_alignment()));
	Resize(vmp_segment->physical_offset() + vmp_segment->physical_size());

	// write PE resources
	dir = pe_->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_RESOURCE);
	if (dir && dir->address() && dir->physical_size() && source->AddressSeek(dir->address())) {
		last_segment = segment_list()->last();
		address = AlignValue(last_segment->address() + last_segment->size(), pe_->segment_alignment());
		pos = Resize(AlignValue(this->size(), pe_->file_alignment()));
		segment = segment_list()->Add(address, dir->size(), static_cast<uint32_t>(pos), AlignValue(dir->size(), pe_->file_alignment()), resource_section_flags, resource_section_name);

		uint32_t delta_rva = static_cast<uint32_t>(address - dir->address());
		CopyFrom(*source, dir->size());

		std::vector<uint64_t> directory_list;
		directory_list.push_back(pos);

		for (i = 0; i < directory_list.size(); i++) {
			Seek(directory_list[i]);
			IMAGE_RESOURCE_DIRECTORY directory;
			Read(&directory, sizeof(directory));
			for (size_t j = 0; j < static_cast<size_t>(directory.NumberOfNamedEntries) + static_cast<size_t>(directory.NumberOfIdEntries); j++) {
				IMAGE_RESOURCE_DIRECTORY_ENTRY entry;
				Read(&entry, sizeof(entry));
				if (entry.u2.OffsetToData & IMAGE_RESOURCE_DATA_IS_DIRECTORY)
					directory_list.push_back(directory_list[0] + (entry.u2.OffsetToData & ~IMAGE_RESOURCE_DATA_IS_DIRECTORY));
				else {
					pos = Tell();
					Seek(directory_list[0] + entry.u2.OffsetToData);
					IMAGE_RESOURCE_DATA_ENTRY item;
					Read(&item, sizeof(item));

					Seek(directory_list[0] + entry.u2.OffsetToData);
					item.OffsetToData += delta_rva;
					Write(&item, sizeof(item));
					Seek(pos);
				}
			}
		}

		Resize(segment->physical_offset() + segment->physical_size());

		dir->set_address(address);
	}

	// write relocations
	dir = pe_->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_BASERELOC);
	if (dir) {
		if (pe_->fixup_list()->Pack() == 0 || (ctx.options.flags & cpStripFixups) != 0) {
			dir->clear();
		} else {
			last_segment = segment_list()->last();
			address = AlignValue(last_segment->address() + last_segment->size(), pe_->segment_alignment());
			pos = Resize(AlignValue(this->size(), pe_->file_alignment()));

			size = static_cast<uint32_t>(pe_->fixup_list()->WriteToFile(*pe_));
		
			segment = segment_list()->Add(address, size, static_cast<uint32_t>(pos), AlignValue(size, file_alignment()), fixup_section_flags, fixup_section_name);
			Resize(segment->physical_offset() + segment->physical_size());

			dir->set_address(address);
			dir->set_size(size);
		}
	}

	// clear directories
	if (ctx.options.flags & cpStripDebugInfo) {
		dir = pe_->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_DEBUG);
		if (dir)
			dir->clear();
	}

	if (ctx.options.script)
		ctx.options.script->DoAfterSaveFile();

	// write header
	WriteToFile();

	// write loader CRC table
	if (loader_crc_address) {
		CRCTable crc_table(function_list_->crc_cryptor(), loader_crc_size);

		// add loader sections
		j = segment_list()->IndexOf(segment_list()->GetSectionByAddress(loader_crc_address));
		if (j != NOT_ID) {
			c = (ctx.options.flags & cpLoaderCRC) ? j + 1 : segment_list()->count();
			for (i = j; i < c; i++) {
				segment = segment_list()->item(i);
				if (segment->memory_type() & mtWritable)
					continue;

				size = std::min(static_cast<uint32_t>(segment->size()), segment->physical_size());
				if (size)
					crc_table.Add(segment->address(), size);
			}
		}

		// skip IAT directory
		dir = pe_->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_IAT);
		if (dir)
			crc_table.Remove(dir->address(), dir->size());

		// skip fixups
		if ((ctx.options.flags & cpStripFixups) == 0) {
			for (i = 0; i < pe_->fixup_list()->count(); i++) {
				PEFixup *fixup = pe_->fixup_list()->item(i);
				if (!fixup->is_deleted())
					crc_table.Remove(fixup->address(), OperandSizeToValue(fixup->size()));
			}
		}
		// skip loader CRC table
		crc_table.Remove(loader_crc_address, loader_crc_size);
		crc_table.Remove(loader_crc_size_address, sizeof(uint32_t));
		crc_table.Remove(loader_crc_hash_address, sizeof(uint32_t));
		// skip file CRC table
		if (file_crc_address)
			crc_table.Remove(file_crc_address, file_crc_size);
		if (file_crc_size_address)
			crc_table.Remove(file_crc_size_address, sizeof(uint32_t));

		// write to file
		AddressSeek(loader_crc_address);
		uint32_t hash;
		size = static_cast<uint32_t>(crc_table.WriteToFile(*this, false, &hash));
		AddressSeek(loader_crc_size_address);
		WriteDWord(size);
		AddressSeek(loader_crc_hash_address);
		WriteDWord(hash);
	}

	// write file CRC table
	if (file_crc_address) {
		CRCTable crc_table(function_list_->crc_cryptor(), file_crc_size - sizeof(uint32_t));

		// add file range
		crc_table.Add(1, static_cast<size_t>(this->size()) - 1);
		// skip IMAGE_OPTIONAL_HEADER.CheckSum
		crc_table.Remove(header_offset() + sizeof(uint32_t) + sizeof(IMAGE_FILE_HEADER) +
			((cpu_address_size() == osDWord) ? offsetof(IMAGE_OPTIONAL_HEADER32, CheckSum) : offsetof(IMAGE_OPTIONAL_HEADER64, CheckSum)),
			sizeof(uint32_t));
		// skip position of security directory
		crc_table.Remove(header_offset() + sizeof(uint32_t) + sizeof(IMAGE_FILE_HEADER) + 
			((cpu_address_size() == osDWord) ? offsetof(IMAGE_OPTIONAL_HEADER32, DataDirectory) : offsetof(IMAGE_OPTIONAL_HEADER64, DataDirectory)) + 
			IMAGE_DIRECTORY_ENTRY_SECURITY * sizeof(IMAGE_DATA_DIRECTORY), 
			sizeof(IMAGE_DATA_DIRECTORY));
		// skip file CRC table
		if (AddressSeek(file_crc_address))
			crc_table.Remove(Tell(), file_crc_size);
		if (AddressSeek(file_crc_size_address))
			crc_table.Remove(Tell(), sizeof(uint32_t));

		// write to file
		AddressSeek(file_crc_address);
		size = static_cast<uint32_t>(this->size());
		WriteDWord(size);
		size = static_cast<uint32_t>(crc_table.WriteToFile(*this, true));
		AddressSeek(file_crc_size_address);
		WriteDWord(size);
	}

	pe_->WriteCheckSum();
	
	EndProgress();
}

bool NETArchitecture::WriteToFile()
{
	PEDirectory *dir = pe_->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR);
	if (!dir || !AddressSeek(dir->address()))
		return false;

	if ((header_.Flags & COMIMAGE_FLAGS_NATIVE_ENTRYPOINT) == 0)
		header_.u.EntryPointToken = entry_point_ ? entry_point_->id() : 0;
	header_.MetaData.VirtualAddress = static_cast<uint32_t>(meta_data_->address() - image_base());
	header_.MetaData.Size = meta_data_->size();
	Write(&header_, sizeof(header_));
	return pe_->WriteToFile();
}

bool NETArchitecture::WriteResources(const std::string module_name, Data &dest_data)
{
	dest_data.clear();

	if (!header_.Resources.VirtualAddress)
		return false;

	size_t i;
	std::vector<ILManifestResource *> resource_list;

	ILTable *src_table = command_list()->table(ttManifestResource);
	for (i = 0; i < src_table->count(); i++) {
		ILManifestResource *resource = reinterpret_cast<ILManifestResource *>(src_table->item(i));
		if (resource->is_deleted() || resource->implementation())
			continue;

		resource_list.push_back(resource);
	}
	if (resource_list.empty())
		return false;

	Data data;

	// DOS header
	data.PushByte(0x4d); data.PushByte(0x5a); data.PushByte(0x90); data.PushByte(0x00); data.PushByte(0x03); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00);
	data.PushByte(0x04); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0xff); data.PushByte(0xff); data.PushByte(0x00); data.PushByte(0x00);
	data.PushByte(0xb8); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00);
	data.PushByte(0x40); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00);
	data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00);
	data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00);
	data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00);
	data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x80); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00);
	data.PushByte(0x0e); data.PushByte(0x1f); data.PushByte(0xba); data.PushByte(0x0e); data.PushByte(0x00); data.PushByte(0xb4); data.PushByte(0x09); data.PushByte(0xcd);
	data.PushByte(0x21); data.PushByte(0xb8); data.PushByte(0x01); data.PushByte(0x4c); data.PushByte(0xcd); data.PushByte(0x21); data.PushByte(0x54); data.PushByte(0x68);
	data.PushByte(0x69); data.PushByte(0x73); data.PushByte(0x20); data.PushByte(0x70); data.PushByte(0x72); data.PushByte(0x6f); data.PushByte(0x67); data.PushByte(0x72);
	data.PushByte(0x61); data.PushByte(0x6d); data.PushByte(0x20); data.PushByte(0x63); data.PushByte(0x61); data.PushByte(0x6e); data.PushByte(0x6e); data.PushByte(0x6f);
	data.PushByte(0x74); data.PushByte(0x20); data.PushByte(0x62); data.PushByte(0x65); data.PushByte(0x20); data.PushByte(0x72); data.PushByte(0x75); data.PushByte(0x6e);
	data.PushByte(0x20); data.PushByte(0x69); data.PushByte(0x6e); data.PushByte(0x20); data.PushByte(0x44); data.PushByte(0x4f); data.PushByte(0x53); data.PushByte(0x20);
	data.PushByte(0x6d); data.PushByte(0x6f); data.PushByte(0x64); data.PushByte(0x65); data.PushByte(0x2e); data.PushByte(0x0d); data.PushByte(0x0d); data.PushByte(0x0a);
	data.PushByte(0x24); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00); data.PushByte(0x00);

	// PE header
	data.PushDWord(IMAGE_NT_SIGNATURE); // Magic
	data.PushWord(IMAGE_FILE_MACHINE_I386); // Machine
	data.PushWord(1); // NumberOfSections
	data.PushDWord(static_cast<uint32_t>(pe()->time_stamp())); // TimeDateStamp
	data.PushDWord(0); // PointerToSymbolTable
	data.PushDWord(0); // NumberOfSymbols
	data.PushWord(sizeof(IMAGE_OPTIONAL_HEADER32)); // SizeOfOptionalHeader
	data.PushWord(IMAGE_FILE_EXECUTABLE_IMAGE | IMAGE_FILE_DLL | IMAGE_FILE_32BIT_MACHINE); // Characteristics

	// optional header
	data.PushWord(IMAGE_NT_OPTIONAL_HDR32_MAGIC); // Magic
	data.PushByte(0x30); // MajorLinkerVersion
	data.PushByte(0); // MinorLinkerVersion
	data.PushDWord(0); // SizeOfCode
	data.PushDWord(0); // SizeOfInitializedData
	data.PushDWord(0); // SizeOfUninitializedData
	data.PushDWord(0); // AddressOfEntryPoint
	data.PushDWord(0); // BaseOfCode
	data.PushDWord(0); // BaseOfData
	data.PushDWord(0x10000000); // ImageBase
	data.PushDWord(0x2000); // SectionAlignment
	data.PushDWord(0x200); // FileAlignment
	data.PushWord(4); // MajorOperatingSystemVersion
	data.PushWord(0); // MinorOperatingSystemVersion
	data.PushWord(0); // MajorImageVersion
	data.PushWord(0); // MinorImageVersion
	data.PushWord(4); // MajorSubsystemVersion
	data.PushWord(0); // MinorSubsystemVersion
	data.PushDWord(0); // Win32VersionValue
	data.PushDWord(0); // SizeOfImage
	data.PushDWord(0); // SizeOfHeaders
	data.PushDWord(0); // CheckSum
	data.PushWord(IMAGE_SUBSYSTEM_WINDOWS_GUI); // Subsystem
	data.PushWord(IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE | IMAGE_DLLCHARACTERISTICS_NO_SEH | IMAGE_DLLCHARACTERISTICS_NX_COMPAT | IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE); // DllCharacteristics
	data.PushDWord(0x100000); // SizeOfStackReserve
	data.PushDWord(0x1000); // SizeOfStackCommit
	data.PushDWord(0x100000); // SizeOfHeapReserve
	data.PushDWord(0x1000); // SizeOfHeapCommit
	data.PushDWord(0); // LoaderFlags
	data.PushDWord(0x10); // NumberOfRvaAndSizes

	// directories
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0);
	data.PushDWord(0x2000);
	data.PushDWord(0x48);
	data.PushDWord(0);
	data.PushDWord(0);

	// sections
	std::string str = ".text";
	str.resize(8);
	data.PushBuff(str.c_str(), str.size());
	data.PushDWord(0x1000); // VirtualSize
	data.PushDWord(0x2000); // VirtualAddress
	data.PushDWord(0x1000); // SizeOfRawData
	data.PushDWord(0x200); // PointerToRawData
	data.PushDWord(0); // PointerToRelocations
	data.PushDWord(0); // PointerToLineNumbers
	data.PushWord(0); // NumberOfRelocations
	data.PushWord(0); // NumberOfLineNumbers
	data.PushDWord(IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_CNT_CODE); // Characteristics

	// ".text"
	data.resize(AlignValue(data.size(), 0x200));
	data.PushDWord(0x48);
	data.PushWord(header_.MajorRuntimeVersion);
	data.PushWord(header_.MinorRuntimeVersion);
	data.PushDWord(0x2048);
	data.PushDWord(0x1000);
	data.PushDWord(1);
	data.PushDWord(0); // EntryPoint
	data.PushDWord(0); data.PushDWord(0); // Resources
	data.PushDWord(0); data.PushDWord(0); // StrongNameSignature
	data.PushDWord(0); data.PushDWord(0); // CodeManagerTable
	data.PushDWord(0); data.PushDWord(0); // VTableFixups
	data.PushDWord(0); data.PushDWord(0); // ExportAddressTableJumps
	data.PushDWord(0); data.PushDWord(0); // ManagedNativeHeader

	size_t start_offset = data.size();
	data.PushDWord(0x424a5342);	// Signature
	data.PushWord(1); // MajorVersion
	data.PushWord(1); // MinorVersion
	data.PushDWord(0); // Reserved
	str = meta_data_->version();
	data.PushDWord(static_cast<uint32_t>(str.size()));
	data.PushBuff(str.c_str(), str.size());
	data.PushWord(0); // Flags
	data.PushWord(5); // StreamCount

	size_t heap_offset = data.size();
	data.PushDWord(0);
	data.PushDWord(0);
	str = "#~";
	str.resize(AlignValue(str.size() + 1, sizeof(uint32_t)));
	data.PushBuff(str.c_str(), str.size());

	data.PushDWord(0);
	data.PushDWord(0);
	str = "#Strings";
	str.resize(AlignValue(str.size() + 1, sizeof(uint32_t)));
	data.PushBuff(str.c_str(), str.size());

	data.PushDWord(0);
	data.PushDWord(0);
	str = "#US";
	str.resize(AlignValue(str.size() + 1, sizeof(uint32_t)));
	data.PushBuff(str.c_str(), str.size());

	data.PushDWord(0);
	data.PushDWord(0);
	str = "#GUID";
	str.resize(AlignValue(str.size() + 1, sizeof(uint32_t)));
	data.PushBuff(str.c_str(), str.size());

	data.PushDWord(0);
	data.PushDWord(0);
	str = "#Blob";
	str.resize(AlignValue(str.size() + 1, sizeof(uint32_t)));
	data.PushBuff(str.c_str(), str.size());

	data.WriteDWord(heap_offset, static_cast<uint32_t>(data.size() - start_offset));
	data.PushDWord(0);
	data.PushByte(2);
	data.PushByte(0);
	data.PushByte(0);
	data.PushByte(1);
	data.PushQWord(0);
	data.PushQWord(0x000016003301FA00);

	PEFile pe_file;
	pe_file.OpenResource(data.data(), data.size(), false);
	NETArchitecture *dst = reinterpret_cast<NETArchitecture *>(pe_file.item(1));
	dst->set_append_mode(true);

	ILTable *dst_table = dst->command_list()->table(ttModule);
	ILModule *module_def = new ILModule(dst->command_list(), dst_table, module_name + ".dll");
	dst_table->AddObject(module_def);

	dst_table = dst->command_list()->table(ttAssembly);
	ILAssembly *assembly_def = new ILAssembly(dst->command_list(), dst_table, module_name);
	dst_table->AddObject(assembly_def);

	dst_table = dst->command_list()->table(ttTypeDef);
	ILTypeDef *type_def = new ILTypeDef(dst->command_list(), dst_table, NULL, "", "<Module>");
	dst_table->AddObject(type_def);

	dst_table = command_list()->table(ttAssemblyRef);
	ILAssemblyRef *assembly_ref = new ILAssemblyRef(command_list(), dst_table, module_name);
	dst_table->AddObject(assembly_ref);

	// ".text"
	PESegment *segment = dst->segment_list()->item(0);
	segment->set_size(UINT32_MAX);
	segment->set_physical_size(UINT32_MAX);
	dst->Resize(segment->physical_offset());

	uint64_t address = dst->AddressTell();
	PEDirectory *iat = dst->pe()->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_IAT);
	iat->set_address(address);
	iat->set_size(8);
	dst->WriteDWord(0);
	dst->WriteDWord(0);

	address = dst->AddressTell();
	PEDirectory *dir = dst->pe()->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR);
	dir->set_address(address);

	IMAGE_COR20_HEADER header = {};
	dst->Write(&header, sizeof(header));

	uint32_t size;
	uint64_t pos = dst->Resize(AlignValue(dst->size(), sizeof(uint32_t)));
	address = dst->AddressTell();
	dst_table = dst->command_list()->table(ttManifestResource);
	for (i = 0; i < resource_list.size(); i++) {
		uint32_t offset = static_cast<uint32_t>(dst->Resize(AlignValue(dst->size(), sizeof(uint32_t))) - pos);
		ILManifestResource *resource = resource_list[i];
		size_t resource_offset = resource->offset();
		ILManifestResource *dest_resource = reinterpret_cast<ILManifestResource *>(resource->Clone(dst->command_list(), dst_table));
		resource->set_offset(0);
		resource->set_implementation(assembly_ref);

		dest_resource->set_flags(mrPublic);
		dest_resource->set_offset(offset);
		dst_table->AddObject(dest_resource);

		std::vector<uint8_t> data = resource->data();
		if (data.empty()) {
			AddressSeek(image_base() + header_.Resources.VirtualAddress + resource_offset);
			size = ReadDWord();
			dst->WriteDWord(size);
			dst->CopyFrom(*this, size);
		}
		else {
			dst->WriteDWord(static_cast<uint32_t>(data.size()));
			dst->Write(data.data(), data.size());
		}
	}
	dst->header_.Resources.VirtualAddress = static_cast<uint32_t>(address - dst->image_base());
	dst->header_.Resources.Size = static_cast<uint32_t>(dst->size() - pos);

	dst->meta_data_->Prepare();
	dst->meta_data_->UpdateTokens();
	dst->Resize(AlignValue(dst->size(), sizeof(uint32_t)));
	dst->meta_data_->WriteToFile(*dst);

	dst->Resize(AlignValue(dst->size(), sizeof(uint32_t)));
	address = dst->AddressTell();
	dir = dst->pe()->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_IMPORT);
	dir->set_address(address);
	dir->set_size(0x4f);
	dst->WriteDWord(static_cast<uint32_t>(address - dst->image_base() + 40));
	dst->WriteDWord(0);
	dst->WriteDWord(0);
	dst->WriteDWord(static_cast<uint32_t>(address - dst->image_base() + 66));
	dst->WriteDWord(static_cast<uint32_t>(iat->address() - dst->image_base()));

	dst->WriteDWord(0);
	dst->WriteDWord(0);
	dst->WriteDWord(0);
	dst->WriteDWord(0);
	dst->WriteDWord(0);

	dst->WriteDWord(static_cast<uint32_t>(address - dst->image_base() + 52));
	dst->WriteDWord(0);
	dst->WriteDWord(0);
	address = dst->AddressTell();
	dst->WriteWord(0);
	str = "_CorDllMain";
	dst->Write(str.c_str(), str.size() + 1);
	str = "mscoree.dll";
	dst->Write(str.c_str(), str.size() + 1);
	dst->WriteByte(0);
	dst->AddressSeek(iat->address());
	dst->WriteDWord(static_cast<uint32_t>(address - dst->image_base()));
	dst->Seek(dst->size());

	address = dst->AddressTell();
	dst->pe()->set_entry_point(address);
	dst->WriteByte(0xff);
	dst->WriteByte(0x25);
	dst->WriteDWord(static_cast<uint32_t>(iat->address()));

	size = static_cast<uint32_t>(dst->size() - segment->physical_offset());
	segment->set_size(size);
	segment->set_physical_size(AlignValue(size, dst->file_alignment()));
	dst->Resize(segment->physical_offset() + segment->physical_size());

	// ".reloc"
	address = AlignValue(segment->address() + segment->size(), dst->segment_alignment());
	segment = dst->segment_list()->Add(address, UINT32_MAX, segment->physical_offset() + segment->physical_size(), UINT32_MAX, IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE | IMAGE_SCN_CNT_INITIALIZED_DATA, ".reloc");
	uint32_t reloc_rva = static_cast<uint32_t>(dst->pe()->entry_point() - dst->image_base()) + 2;
	uint32_t page_rva = reloc_rva & ~0xfff;
	dst->WriteDWord(page_rva);
	dst->WriteDWord(0x0c);
	dst->WriteDWord((IMAGE_REL_BASED_HIGHLOW << 12) + reloc_rva - page_rva);
	size = static_cast<uint32_t>(dst->size() - segment->physical_offset());
	segment->set_size(size);
	segment->set_physical_size(AlignValue(size, dst->file_alignment()));
	dir = dst->pe()->command_list()->GetCommandByType(IMAGE_DIRECTORY_ENTRY_BASERELOC);
	dir->set_address(segment->address());
	dir->set_size(size);
	dst->Resize(segment->physical_offset() + segment->physical_size());

	dst->Seek(dst->pe()->header_offset() + offsetof(IMAGE_NT_HEADERS32, OptionalHeader) + offsetof(IMAGE_OPTIONAL_HEADER32, SizeOfCode));
	dst->WriteDWord(static_cast<uint32_t>(dst->segment_list()->item(0)->physical_size()));
	dst->WriteDWord(static_cast<uint32_t>(dst->segment_list()->item(1)->physical_size()));
	dst->Seek(dst->pe()->header_offset() + offsetof(IMAGE_NT_HEADERS32, OptionalHeader) + offsetof(IMAGE_OPTIONAL_HEADER32, BaseOfCode));
	dst->WriteDWord(static_cast<uint32_t>(dst->segment_list()->item(0)->address() - dst->image_base()));
	dst->WriteDWord(static_cast<uint32_t>(dst->segment_list()->item(1)->address() - dst->image_base()));

	dst->WriteToFile();

	dst->set_append_mode(false);

	dst->Seek(0);
	dest_data.resize(static_cast<size_t>(pe_file.stream()->Size()));
	dst->Read(&dest_data[0], dest_data.size());

	return true;
}

void NETArchitecture::Rebase(uint64_t delta_base)
{
	BaseArchitecture::Rebase(delta_base);

	meta_data_->Rebase(delta_base);
	segment_list()->Rebase(delta_base);
	runtime_function_list_->Rebase(delta_base);
	export_list_->Rebase(delta_base);
	function_list_->Rebase(delta_base);

	if (entry_point_)
		entry_point_ += delta_base;
	//image_base_ += delta_base;
}

bool NETArchitecture::is_executable() const
{
	return pe_->is_executable();
}

std::string NETArchitecture::full_name() const
{
	if (ILAssembly *assembly = reinterpret_cast<ILAssembly *>(meta_data_->token(ttAssembly | 1)))
		return assembly->full_name();
	return std::string();
}

/**
 * ILUserStringsTable
 */

ILUserStringsTable::ILUserStringsTable(ILMetaData *meta) 
	: ILTable(meta, ttUserString, 0)
{

}

ILUserStringsTable::ILUserStringsTable(ILMetaData *meta, const ILUserStringsTable &src) 
	: ILTable(meta, src)
{
	for (size_t i = 0; i < count(); i++) {
		ILToken *token = item(i);
		map_[token->value()] = token;
	}
}

ILUserStringsTable *ILUserStringsTable::Clone(ILMetaData *meta) const
{
	ILUserStringsTable *table = new ILUserStringsTable(meta, *this);
	return table;
}

ILToken *ILUserStringsTable::GetTokenByPos(uint32_t pos) const
{
	auto it = map_.find(pos);
	if (it != map_.end())
		return it->second;

	return NULL;
}

void ILUserStringsTable::AddObject(ILToken *token)
{
	ILTable::AddObject(token);
	map_[token->value()] = token;
}

/**
* BaseNameReference
*/

BaseNameReference::BaseNameReference(NameReferenceList *owner)
	: INameReference(), owner_(owner)
{

}

BaseNameReference::~BaseNameReference()
{
	if (owner_)
		owner_->RemoveObject(this);
}

/**
* ResourceNameReference
*/

ResourceNameReference::ResourceNameReference(NameReferenceList *owner, ILManifestResource *resource, ILTypeDef *type, const std::string &add)
	: BaseNameReference(owner), resource_(resource), type_(type), add_(add)
{

}

void ResourceNameReference::UpdateName()
{
	resource_->set_name(type_->full_name() + add_);
}

/**
* StringNameReference
*/

StringNameReference::StringNameReference(NameReferenceList *owner, ILUserString *string, ILTypeDef *type)
	: BaseNameReference(owner), string_(string), type_(type)
{

}

void StringNameReference::UpdateName()
{
	string_->set_name(type_->full_name());
}

/**
* CommandNameReference
*/

CommandNameReference::CommandNameReference(NameReferenceList *owner, ILCommand *command, ILTypeDef *type)
	: BaseNameReference(owner), command_(command), type_(type)
{

}

void CommandNameReference::UpdateName()
{
	os::unicode_string unicode_name = os::FromUTF8(type_->full_name());
	command_->set_dump(unicode_name.data(), unicode_name.size() * sizeof(os::unicode_char));
}

/**
* CustomAttributeNameReference
*/

CustomAttributeNameReference::CustomAttributeNameReference(NameReferenceList *owner, CustomAttributeNamedArgument *arg, ILToken *token)
	: BaseNameReference(owner), arg_(arg), token_(token)
{

}

void CustomAttributeNameReference::UpdateName()
{
	std::string name;
	switch (token_->type()) {
	case ttField:
		name = reinterpret_cast<ILField *>(token_)->name();
		break;
	case ttProperty:
		name = reinterpret_cast<ILProperty *>(token_)->name();
		break;
	default:
		throw std::runtime_error("Invalid token type");
	}
	arg_->set_name(name);
}

/**
* MemberReference
*/

MemberReference::MemberReference(NameReferenceList *owner, ILMemberRef *member, ILToken *token)
	: BaseNameReference(owner), member_(member), token_(token)
{

}

void MemberReference::UpdateName()
{
	std::string name;
	switch (token_->type()) {
	case ttField:
		name = reinterpret_cast<ILField *>(token_)->name();
		break;
	case ttMethodDef:
		name = reinterpret_cast<ILMethodDef *>(token_)->name();
		break;
	default:
		throw std::runtime_error("Invalid token type");
	}

	member_->set_name(name);
}

/**
* MethodReference
*/

MethodReference::MethodReference(NameReferenceList *owner, ILMethodDef *method, ILMethodDef *source)
	: BaseNameReference(owner), method_(method), source_(source)
{

}

void MethodReference::UpdateName()
{
	method_->set_name(source_->name());
}

/**
* BamlTypeInfoRecordReference
*/

BamlTypeInfoRecordReference::BamlTypeInfoRecordReference(NameReferenceList *owner, TypeInfoRecord *record, ILToken *token)
	: BaseNameReference(owner), record_(record), token_(token)
{

}

void BamlTypeInfoRecordReference::UpdateName()
{
	std::string name;
	switch (token_->type()) {
	case ttTypeDef:
		name = reinterpret_cast<ILTypeDef *>(token_)->name();
		break;
	case ttTypeRef:
		name = reinterpret_cast<ILTypeRef *>(token_)->name();
		break;
	default:
		throw std::runtime_error("Invalid token type");
	}

	record_->set_type_name(name);
}

/**
* BamlAttributeInfoRecordReference
*/

BamlAttributeInfoRecordReference::BamlAttributeInfoRecordReference(NameReferenceList *owner, AttributeInfoRecord *record, ILToken *token)
	: BaseNameReference(owner), record_(record), token_(token)
{

}

void BamlAttributeInfoRecordReference::UpdateName()
{
	std::string name;
	switch (token_->type()) {
	case ttProperty:
		name = reinterpret_cast<ILProperty *>(token_)->name();
		break;
	case ttEvent:
		name = reinterpret_cast<ILEvent *>(token_)->name();
		break;
	default:
		throw std::runtime_error("Invalid token type");
	}

	record_->set_name(name);
}

/**
* BamlPropertyRecordReference
*/

BamlPropertyRecordReference::BamlPropertyRecordReference(NameReferenceList *owner, PropertyRecord *record, ILToken *token)
	: BaseNameReference(owner), record_(record), token_(token)
{

}

void BamlPropertyRecordReference::UpdateName()
{
	std::string name;
	switch (token_->type()) {
	case ttMethodDef:
		name = reinterpret_cast<ILMethodDef *>(token_)->name();
		break;
	default:
		throw std::runtime_error("Invalid token type");
	}

	record_->set_value(name);
}

/**
* NameReferenceList
*/

NameReferenceList::NameReferenceList()
	: ObjectList<INameReference>()
{

}

void NameReferenceList::AddResourceReference(ILManifestResource *resource, ILTypeDef *type, const std::string &add)
{
	AddObject(new ResourceNameReference(this, resource, type, add));
}

void NameReferenceList::AddStringReference(ILUserString *string, ILTypeDef *type)
{
	AddObject(new StringNameReference(this, string, type));
}

void NameReferenceList::AddCommandReference(ILCommand *command, ILTypeDef *type)
{
	AddObject(new CommandNameReference(this, command, type));
}

void NameReferenceList::AddCustomAttributeNameReference(ILCustomAttribute *attribute, CustomAttributeNamedArgument *arg, ILToken *token)
{
	AddObject(new CustomAttributeNameReference(this, arg, token));
	if (attribute)
		custom_attribute_list_.insert(attribute);
}

void NameReferenceList::AddCustomAttribute(ILCustomAttribute *attribute)
{
	if (attribute)
		custom_attribute_list_.insert(attribute);
}

void NameReferenceList::AddMemberReference(ILMemberRef *member, ILToken *token)
{
	AddObject(new MemberReference(this, member, token));
}

void NameReferenceList::UpdateNames()
{
	for (size_t i = 0; i < count(); i++) {
		item(i)->UpdateName();
	}

	for (std::set<ILCustomAttribute *>::const_iterator it = custom_attribute_list_.begin(); it != custom_attribute_list_.end(); it++) {
		(*it)->UpdateValue();
	}

	for (std::set<ILManifestResource *>::const_iterator it = manifest_resource_list_.begin(); it != manifest_resource_list_.end(); it++) {
		(*it)->UpdateValue();
	}
}

void NameReferenceList::AddTypeInfoRecordReference(ILManifestResource *resource, TypeInfoRecord *record, ILToken *token)
{
	AddObject(new BamlTypeInfoRecordReference(this, record, token));
	if (resource)
		manifest_resource_list_.insert(resource);
}

void NameReferenceList::AddAttributeInfoRecordReference(ILManifestResource *resource, AttributeInfoRecord *record, ILToken *token)
{
	AddObject(new BamlAttributeInfoRecordReference(this, record, token));
	if (resource)
		manifest_resource_list_.insert(resource);
}

void NameReferenceList::AddPropertyRecordReference(ILManifestResource *resource, PropertyRecord *record, ILToken *token)
{
	AddObject(new BamlPropertyRecordReference(this, record, token));
	if (resource)
		manifest_resource_list_.insert(resource);
}

void NameReferenceList::AddMethodReference(ILMethodDef *method, ILMethodDef *source)
{
	AddObject(new MethodReference(this, method, source));
}

void NameReferenceList::AddManifestResource(ILManifestResource *resource)
{
	if (resource)
		manifest_resource_list_.insert(resource);
}

/**
* BamlRecord
*/

BamlRecord::BamlRecord(BamlDocument *owner)
	: IObject(), owner_(owner), position_(0)
{
	
}

BamlRecord::~BamlRecord()
{
	if (owner_)
		owner_->RemoveObject(this);
}

uint64_t BamlRecord::GetPosition(size_t index)
{
	while (index < owner()->count()) {
		bool keys = true;
		switch (owner()->item(index)->type()) {
		case DefAttributeKeyString:
		case DefAttributeKeyType:
		case OptimizedStaticResource:
			break;
		case StaticResourceStart:
			index = owner()->GetClosedIndex(StaticResourceStart, StaticResourceEnd, index + 1);
			if (index == NOT_ID)
				throw std::runtime_error("Invalid record index");
			break;
		case KeyElementStart:
			index = owner()->GetClosedIndex(KeyElementStart, KeyElementEnd, index + 1);
			if (index == NOT_ID)
				throw std::runtime_error("Invalid record index");
			break;
		default:
			keys = false;
			break;
		}
		if (!keys)
			break;

		index++;
	}
	return owner()->item(index)->position();
}

/**
* SizedBamlRecord
*/

SizedBamlRecord::SizedBamlRecord(BamlDocument *owner)
	: BamlRecord(owner), data_size_(0)
{

}

void SizedBamlRecord::Read(NETStream &stream)
{
	uint64_t pos = stream.Tell();
	uint32_t size = stream.ReadEncoded7Bit();
	data_size_ = size - static_cast<uint32_t>(stream.Tell() - pos);
	ReadData(stream);
}

uint32_t SizeOfEncodedInt(uint32_t value)
{
	if ((value & ~0x7F) == 0)
		return 1;
	if ((value & ~0x3FFF) == 0)
 		return 2;
	if ((value & ~0x1FFFFF) == 0)
		return 3;
	if ((value & ~0xFFFFFFF) == 0)
		return 4;
	return 5;
}

void SizedBamlRecord::Write(NETStream &stream)
{
	uint64_t pos = stream.Tell();
	WriteData(stream);
	uint32_t size = static_cast<uint32_t>(stream.Tell() - pos);
	size = SizeOfEncodedInt(SizeOfEncodedInt(size) + size) + size;
	stream.Seek(pos, soBeginning);
	stream.WriteEncoded7Bit(size);
	WriteData(stream);
}

/**
* DocumentStartRecord
*/

DocumentStartRecord::DocumentStartRecord(BamlDocument *owner)
	: BamlRecord(owner)
{

}

void DocumentStartRecord::Read(NETStream &stream)
{
	load_async_ = stream.ReadBoolean();
	max_async_records_ = stream.ReadDWord();
	debug_baml_ = stream.ReadBoolean();
}

void DocumentStartRecord::Write(NETStream &stream)
{
	stream.WriteBoolean(load_async_);
	stream.WriteDWord(max_async_records_);
	stream.WriteBoolean(debug_baml_);
}

/**
* DocumentEndRecord
*/

DocumentEndRecord::DocumentEndRecord(BamlDocument *owner)
	: BamlRecord(owner)
{

}

/**
* ElementStartRecord
*/

ElementStartRecord::ElementStartRecord(BamlDocument *owner)
	: BamlRecord(owner), type_id_(0), flags_(0)
{

}

void ElementStartRecord::Read(NETStream &stream)
{
	type_id_ = stream.ReadWord();
	flags_ = stream.ReadByte();
}

void ElementStartRecord::Write(NETStream &stream)
{
	stream.WriteWord(type_id_);
	stream.WriteByte(flags_);
}

/**
* ElementEndRecord
*/

ElementEndRecord::ElementEndRecord(BamlDocument *owner)
	: BamlRecord(owner)
{

}

/**
* AssemblyInfoRecord
*/

AssemblyInfoRecord::AssemblyInfoRecord(BamlDocument *owner)
	: SizedBamlRecord(owner), assembly_id_(0)
{

}

void AssemblyInfoRecord::ReadData(NETStream &stream)
{
	assembly_id_ = stream.ReadWord();
	assembly_name_ = stream.ReadString();
}

void AssemblyInfoRecord::WriteData(NETStream &stream)
{
	stream.WriteWord(assembly_id_);
	stream.WriteString(assembly_name_);
}

/**
* TypeInfoRecord
*/

TypeInfoRecord::TypeInfoRecord(BamlDocument *owner)
	: SizedBamlRecord(owner), type_id_(0), assembly_id_(0)
{

}

void TypeInfoRecord::ReadData(NETStream &stream)
{
	type_id_ = stream.ReadWord();
	assembly_id_ = stream.ReadWord();
	type_name_ = stream.ReadString();
}

void TypeInfoRecord::WriteData(NETStream &stream)
{
	stream.WriteWord(type_id_);
	stream.WriteWord(assembly_id_);
	stream.WriteString(type_name_);
}

/**
* XmlnsPropertyRecord
*/

XmlnsPropertyRecord::XmlnsPropertyRecord(BamlDocument *owner)
	: SizedBamlRecord(owner)
{

}

void XmlnsPropertyRecord::ReadData(NETStream &stream)
{
	prefix_ = stream.ReadString();
	xml_namespace_ = stream.ReadString();
	assembly_ids_.resize(stream.ReadWord());
	for (size_t i = 0; i < assembly_ids_.size(); i++) {
		assembly_ids_[i] = stream.ReadWord();
	}
}

void XmlnsPropertyRecord::WriteData(NETStream &stream)
{
	stream.WriteString(prefix_);
	stream.WriteString(xml_namespace_);
	stream.WriteWord(static_cast<uint16_t>(assembly_ids_.size()));
	for (size_t i = 0; i < assembly_ids_.size(); i++) {
		stream.WriteWord(assembly_ids_[i]);
	}
}

/**
* AttributeInfoRecord
*/

AttributeInfoRecord::AttributeInfoRecord(BamlDocument *owner)
	: SizedBamlRecord(owner), attribute_id_(0), owner_type_id_(0), attribute_usage_(0)
{

}

void AttributeInfoRecord::ReadData(NETStream &stream)
{
	attribute_id_ = stream.ReadWord();
	owner_type_id_ = stream.ReadWord();
	attribute_usage_ = stream.ReadByte();
	name_ = stream.ReadString();
}

void AttributeInfoRecord::WriteData(NETStream &stream)
{
	stream.WriteWord(attribute_id_);
	stream.WriteWord(owner_type_id_);
	stream.WriteByte(attribute_usage_);
	stream.WriteString(name_);
}

/**
* PropertyDictionaryStartRecord
*/

PropertyDictionaryStartRecord::PropertyDictionaryStartRecord(BamlDocument *owner)
	: BamlRecord(owner)
{

}

void PropertyDictionaryStartRecord::Read(NETStream &stream)
{
	attribute_id_ = stream.ReadWord();
}

void PropertyDictionaryStartRecord::Write(NETStream &stream)
{
	stream.WriteWord(attribute_id_);
}

/**
* PropertyDictionaryEndRecord
*/

PropertyDictionaryEndRecord::PropertyDictionaryEndRecord(BamlDocument *owner)
	: BamlRecord(owner)
{

}

/**
* StringInfoRecord
*/

StringInfoRecord::StringInfoRecord(BamlDocument *owner)
	: SizedBamlRecord(owner), string_id_(0)
{

}

void StringInfoRecord::ReadData(NETStream &stream)
{
	string_id_ = stream.ReadWord();
	value_ = stream.ReadString();
}

void StringInfoRecord::WriteData(NETStream &stream)
{
	stream.WriteWord(string_id_);
	stream.WriteString(value_);
}

/**
* DeferableContentStartRecord
*/

DeferableContentStartRecord::DeferableContentStartRecord(BamlDocument *owner)
	: BamlRecord(owner), offset_(0), offset_pos_(0), record_(NULL)
{

}

void DeferableContentStartRecord::Read(NETStream &stream)
{
	offset_pos_ = stream.Tell();
	offset_ = stream.ReadDWord();
}

void DeferableContentStartRecord::Write(NETStream &stream)
{
	offset_pos_ = stream.Tell();
	stream.WriteDWord(0);
}

void DeferableContentStartRecord::ReadDefer(size_t index)
{
	record_ = owner()->GetRecordByPosition(offset_pos_ + sizeof(offset_) + offset_);
}

void DeferableContentStartRecord::WriteDefer(size_t index, NETStream &stream)
{
	stream.Seek(offset_pos_, soBeginning);
	stream.WriteDWord(static_cast<uint32_t>(record_->position() - (offset_pos_ + sizeof(offset_))));
}

/**
* DefAttributeKeyStringRecord
*/

DefAttributeKeyStringRecord::DefAttributeKeyStringRecord(BamlDocument *owner)
	: SizedBamlRecord(owner), value_id_(0), offset_(0), shared_(false), shared_set_(false), record_(NULL), offset_pos_(0)
{

}

void DefAttributeKeyStringRecord::ReadData(NETStream &stream)
{
	value_id_ = stream.ReadWord();
	offset_ = stream.ReadDWord();
	shared_ = stream.ReadBoolean();
	shared_set_ = stream.ReadBoolean();
}

void DefAttributeKeyStringRecord::WriteData(NETStream &stream)
{
	stream.WriteWord(value_id_);
	offset_pos_ = static_cast<uint32_t>(stream.Tell());
	stream.WriteDWord(offset_);
	stream.WriteBoolean(shared_);
	stream.WriteBoolean(shared_set_);
}

void DefAttributeKeyStringRecord::ReadDefer(size_t index)
{
	record_ = owner()->GetRecordByPosition(GetPosition(index) + offset_);
}

void DefAttributeKeyStringRecord::WriteDefer(size_t index, NETStream &stream)
{
	stream.Seek(offset_pos_, soBeginning);
	stream.WriteDWord(static_cast<uint32_t>(record_->position() - GetPosition(index)));
}

/**
* DefAttributeKeyTypeRecord
*/

DefAttributeKeyTypeRecord::DefAttributeKeyTypeRecord(BamlDocument *owner)
	: ElementStartRecord(owner), offset_(0), record_(NULL), offset_pos_(0)
{

}

void DefAttributeKeyTypeRecord::Read(NETStream &stream)
{
	ElementStartRecord::Read(stream);
	offset_ = stream.ReadDWord();
	shared_ = stream.ReadBoolean();
	shared_set_ = stream.ReadBoolean();
}

void DefAttributeKeyTypeRecord::Write(NETStream &stream)
{
	ElementStartRecord::Write(stream);
	offset_pos_ = stream.Tell();
	stream.WriteDWord(0);
	stream.WriteBoolean(shared_);
	stream.WriteBoolean(shared_set_);
}

void DefAttributeKeyTypeRecord::ReadDefer(size_t index)
{
	record_ = owner()->GetRecordByPosition(GetPosition(index) + offset_);
}

void DefAttributeKeyTypeRecord::WriteDefer(size_t index, NETStream &stream)
{
	stream.Seek(offset_pos_, soBeginning);
	stream.WriteDWord(static_cast<uint32_t>(record_->position() - GetPosition(index)));
}

/**
* PropertyComplexStartRecord
*/

PropertyComplexStartRecord::PropertyComplexStartRecord(BamlDocument *owner)
	: BamlRecord(owner), attribute_id_(0)
{

}

void PropertyComplexStartRecord::Read(NETStream &stream)
{
	attribute_id_ = stream.ReadWord();
}

void PropertyComplexStartRecord::Write(NETStream &stream)
{
	stream.WriteWord(attribute_id_);
}

/**
* PropertyComplexEndRecord
*/

PropertyComplexEndRecord::PropertyComplexEndRecord(BamlDocument *owner)
	: BamlRecord(owner)
{

}

/**
* PropertyTypeReferenceRecord
*/

PropertyTypeReferenceRecord::PropertyTypeReferenceRecord(BamlDocument *owner)
	: PropertyComplexStartRecord(owner), type_id_(0)
{

}

void PropertyTypeReferenceRecord::Read(NETStream &stream)
{
	PropertyComplexStartRecord::Read(stream);
	type_id_ = stream.ReadWord();
}

void PropertyTypeReferenceRecord::Write(NETStream &stream)
{
	PropertyComplexStartRecord::Write(stream);
	stream.WriteWord(type_id_);
}

/**
* ContentPropertyRecord
*/

ContentPropertyRecord::ContentPropertyRecord(BamlDocument *owner)
	: BamlRecord(owner), attribute_id_(0)
{

}

void ContentPropertyRecord::Read(NETStream &stream)
{
	attribute_id_ = stream.ReadWord();
}

void ContentPropertyRecord::Write(NETStream &stream)
{
	stream.WriteWord(attribute_id_);
}

/**
* PropertyCustomRecord
*/

PropertyCustomRecord::PropertyCustomRecord(BamlDocument *owner)
	: SizedBamlRecord(owner), attribute_id_(0), serializer_type_id_(0)
{

}

void PropertyCustomRecord::ReadData(NETStream &stream)
{
	uint64_t pos = stream.Tell();
	attribute_id_ = stream.ReadWord();
	serializer_type_id_ = stream.ReadWord();
	data_.resize(data_size() - static_cast<uint32_t>(stream.Tell() - pos));
	stream.Read(data_.data(), data_.size());
}

void PropertyCustomRecord::WriteData(NETStream &stream)
{
	stream.WriteWord(attribute_id_);
	stream.WriteWord(serializer_type_id_);
	stream.Write(data_.data(), data_.size());
}

/**
* PropertyRecord
*/

PropertyRecord::PropertyRecord(BamlDocument *owner)
	: SizedBamlRecord(owner), attribute_id_(0)
{

}

void PropertyRecord::ReadData(NETStream &stream)
{
	attribute_id_ = stream.ReadWord();
	value_ = stream.ReadString();
}

void PropertyRecord::WriteData(NETStream &stream)
{
	stream.WriteWord(attribute_id_);
	stream.WriteString(value_);
}

/**
* PropertyWithConverterRecord
*/

PropertyWithConverterRecord::PropertyWithConverterRecord(BamlDocument *owner)
	: PropertyRecord(owner), converter_type_id_(0)
{

}

void PropertyWithConverterRecord::ReadData(NETStream &stream)
{
	PropertyRecord::ReadData(stream);
	converter_type_id_ = stream.ReadWord();
}

void PropertyWithConverterRecord::WriteData(NETStream &stream)
{
	PropertyRecord::WriteData(stream);
	stream.WriteWord(converter_type_id_);
}

/**
* PIMappingRecord
*/

PIMappingRecord::PIMappingRecord(BamlDocument *owner)
	: SizedBamlRecord(owner), assembly_id_(0)
{

}

void PIMappingRecord::ReadData(NETStream &stream)
{
	xml_namespace_ = stream.ReadString();
	clr_namespace_ = stream.ReadString();
	assembly_id_ = stream.ReadWord();
}

void PIMappingRecord::WriteData(NETStream &stream)
{
	stream.WriteString(xml_namespace_);
	stream.WriteString(clr_namespace_);
	stream.WriteWord(assembly_id_);
}

/**
* PropertyListStartRecord
*/

PropertyListStartRecord::PropertyListStartRecord(BamlDocument *owner)
	: PropertyComplexStartRecord(owner)
{

}

/**
* PropertyListEndRecord
*/

PropertyListEndRecord::PropertyListEndRecord(BamlDocument *owner)
	: BamlRecord(owner)
{

}

/**
* ConnectionIdRecord
*/

ConnectionIdRecord::ConnectionIdRecord(BamlDocument *owner)
	: BamlRecord(owner), connection_id_(0)
{

}

void ConnectionIdRecord::Read(NETStream &stream)
{
	connection_id_ = stream.ReadDWord();
}

void ConnectionIdRecord::Write(NETStream &stream)
{
	stream.WriteDWord(connection_id_);
}

/**
* OptimizedStaticResourceRecord
*/

OptimizedStaticResourceRecord::OptimizedStaticResourceRecord(BamlDocument *owner)
	: BamlRecord(owner), flags_(0), value_id_(0)
{

}

void OptimizedStaticResourceRecord::Read(NETStream &stream)
{
	flags_ = stream.ReadByte();
	value_id_ = stream.ReadWord();
}

void OptimizedStaticResourceRecord::Write(NETStream &stream)
{
	stream.WriteByte(flags_);
	stream.WriteWord(value_id_);
}

/**
* ConstructorParametersStartRecord
*/

ConstructorParametersStartRecord::ConstructorParametersStartRecord(BamlDocument *owner)
	: BamlRecord(owner)
{

}

/**
* ConstructorParametersEndRecord
*/

ConstructorParametersEndRecord::ConstructorParametersEndRecord(BamlDocument *owner)
	: BamlRecord(owner)
{

}

/**
* TextRecord
*/

TextRecord::TextRecord(BamlDocument *owner)
	: SizedBamlRecord(owner)
{

}

void TextRecord::ReadData(NETStream &stream)
{
	value_ = stream.ReadString();
}

void TextRecord::WriteData(NETStream &stream)
{
	stream.WriteString(value_);
}

/**
* StaticResourceIdRecord
*/

StaticResourceIdRecord::StaticResourceIdRecord(BamlDocument *owner)
	: BamlRecord(owner), static_resource_id_(0)
{

}

void StaticResourceIdRecord::Read(NETStream &stream)
{
	static_resource_id_ = stream.ReadWord();
}

void StaticResourceIdRecord::Write(NETStream &stream)
{
	stream.WriteWord(static_resource_id_);
}

/**
* StaticResourceEndRecord
*/

StaticResourceEndRecord::StaticResourceEndRecord(BamlDocument *owner)
	: BamlRecord(owner)
{

}

/**
* StaticResourceStartRecord
*/

StaticResourceStartRecord::StaticResourceStartRecord(BamlDocument *owner)
	: ElementStartRecord(owner)
{

}

/**
* PropertyWithStaticResourceIdRecord
*/

PropertyWithStaticResourceIdRecord::PropertyWithStaticResourceIdRecord(BamlDocument *owner)
	: StaticResourceIdRecord(owner), attribute_id_(0)
{

}

void PropertyWithStaticResourceIdRecord::Read(NETStream &stream)
{
	attribute_id_ = stream.ReadWord();
	StaticResourceIdRecord::Read(stream);
}

void PropertyWithStaticResourceIdRecord::Write(NETStream &stream)
{
	stream.WriteWord(attribute_id_);
	StaticResourceIdRecord::Write(stream);
}

/**
* PropertyWithExtensionRecord
*/

PropertyWithExtensionRecord::PropertyWithExtensionRecord(BamlDocument *owner)
	: BamlRecord(owner), attribute_id_(0), flags_(0), value_id_(0)
{

}

void PropertyWithExtensionRecord::Read(NETStream &stream)
{
	attribute_id_ = stream.ReadWord();
	flags_ = stream.ReadWord();
	value_id_ = stream.ReadWord();
}

void PropertyWithExtensionRecord::Write(NETStream &stream)
{
	stream.WriteWord(attribute_id_);
	stream.WriteWord(flags_);
	stream.WriteWord(value_id_);
}

/**
* DefAttributeRecord
*/

DefAttributeRecord::DefAttributeRecord(BamlDocument *owner)
	: SizedBamlRecord(owner), name_id_(0)
{

}

void DefAttributeRecord::ReadData(NETStream &stream)
{
	value_ = stream.ReadString();
	name_id_ = stream.ReadWord();
}

void DefAttributeRecord::WriteData(NETStream &stream)
{
	stream.WriteString(value_);
	stream.WriteWord(name_id_);
}

/**
* KeyElementStartRecord
*/

KeyElementStartRecord::KeyElementStartRecord(BamlDocument *owner)
	: DefAttributeKeyTypeRecord(owner)
{

}

/**
* KeyElementEndRecord
*/

KeyElementEndRecord::KeyElementEndRecord(BamlDocument *owner)
	: BamlRecord(owner)
{

}

/**
* ConstructorParameterTypeRecord
*/

ConstructorParameterTypeRecord::ConstructorParameterTypeRecord(BamlDocument *owner)
	: BamlRecord(owner), type_id_(0)
{

}

void ConstructorParameterTypeRecord::Read(NETStream &stream)
{
	type_id_ = stream.ReadWord();
}

void ConstructorParameterTypeRecord::Write(NETStream &stream)
{
	stream.WriteWord(type_id_);
}

/**
* TextWithConverterRecord
*/

TextWithConverterRecord::TextWithConverterRecord(BamlDocument *owner)
	: TextRecord(owner), converter_type_id_(0)
{

}

void TextWithConverterRecord::ReadData(NETStream &stream)
{
	TextRecord::ReadData(stream);
	converter_type_id_ = stream.ReadWord();
}

void TextWithConverterRecord::WriteData(NETStream &stream)
{
	TextRecord::WriteData(stream);
	stream.WriteWord(converter_type_id_);
}

/**
* TextWithIdRecord
*/

TextWithIdRecord::TextWithIdRecord(BamlDocument *owner)
	: TextRecord(owner), value_id_(0)
{

}

void TextWithIdRecord::ReadData(NETStream &stream)
{
	TextRecord::ReadData(stream);
	value_id_ = stream.ReadWord();
}

void TextWithIdRecord::WriteData(NETStream &stream)
{
	TextRecord::WriteData(stream);
	stream.WriteWord(value_id_);
}

/**
* LineNumberAndPositionRecord
*/

LineNumberAndPositionRecord::LineNumberAndPositionRecord(BamlDocument *owner)
	: BamlRecord(owner), line_number_(0), line_position_(0)
{

}

void LineNumberAndPositionRecord::Read(NETStream &stream)
{
	line_number_ = stream.ReadDWord();
	line_position_ = stream.ReadDWord();
}

void LineNumberAndPositionRecord::Write(NETStream &stream)
{
	stream.WriteDWord(line_number_);
	stream.WriteDWord(line_position_);
}

/**
* LinePositionRecord
*/

LinePositionRecord::LinePositionRecord(BamlDocument *owner)
	: BamlRecord(owner), line_position_(0)
{

}

void LinePositionRecord::Read(NETStream &stream)
{
	line_position_ = stream.ReadDWord();
}

void LinePositionRecord::Write(NETStream &stream)
{
	stream.WriteDWord(line_position_);
}

/**
* LiteralContentRecord
*/

LiteralContentRecord::LiteralContentRecord(BamlDocument *owner)
	: SizedBamlRecord(owner), reserved0_(0), reserved1_(0)
{

}

void LiteralContentRecord::ReadData(NETStream &stream)
{
	value_ = stream.ReadString();
	reserved0_ = stream.ReadDWord();
	reserved1_ = stream.ReadDWord();
}

void LiteralContentRecord::WriteData(NETStream &stream)
{
	stream.WriteString(value_);
	stream.WriteDWord(reserved0_);
	stream.WriteDWord(reserved1_);
}

/**
* PresentationOptionsAttributeRecord
*/

PresentationOptionsAttributeRecord::PresentationOptionsAttributeRecord(BamlDocument *owner)
	: SizedBamlRecord(owner), name_id_(0)
{

}

void PresentationOptionsAttributeRecord::ReadData(NETStream &stream)
{
	value_ = stream.ReadString();
	name_id_ = stream.ReadWord();
}

void PresentationOptionsAttributeRecord::WriteData(NETStream &stream)
{
	stream.WriteString(value_);
	stream.WriteWord(name_id_);
}

/**
* PropertyArrayStartRecord
*/

PropertyArrayStartRecord::PropertyArrayStartRecord(BamlDocument *owner)
	: PropertyComplexStartRecord(owner)
{

}

/**
* PropertyArrayStartRecord
*/

PropertyArrayEndRecord::PropertyArrayEndRecord(BamlDocument *owner)
	: BamlRecord(owner)
{

}

/**
* PropertyStringReferenceRecord
*/

PropertyStringReferenceRecord::PropertyStringReferenceRecord(BamlDocument *owner)
	: PropertyComplexStartRecord(owner), string_id_(0)
{

}

void PropertyStringReferenceRecord::Read(NETStream &stream)
{
	PropertyComplexStartRecord::Read(stream);
	string_id_ = stream.ReadWord();
}

void PropertyStringReferenceRecord::Write(NETStream &stream)
{
	PropertyComplexStartRecord::Write(stream);
	stream.WriteWord(string_id_);
}

/**
* RoutedEventRecord
*/

RoutedEventRecord::RoutedEventRecord(BamlDocument *owner)
	: SizedBamlRecord(owner), attribute_id_(0)
{

}

void RoutedEventRecord::ReadData(NETStream &stream)
{
	attribute_id_ = stream.ReadWord();
	value_ = stream.ReadString();
}

void RoutedEventRecord::WriteData(NETStream &stream)
{
	stream.WriteWord(attribute_id_);
	stream.WriteString(value_);
}

/**
* TypeSerializerInfoRecord
*/

TypeSerializerInfoRecord::TypeSerializerInfoRecord(BamlDocument *owner)
	: TypeInfoRecord(owner), type_id_(0)
{

}

void TypeSerializerInfoRecord::ReadData(NETStream &stream)
{
	TypeInfoRecord::ReadData(stream);
	type_id_ = stream.ReadWord();
}

void TypeSerializerInfoRecord::WriteData(NETStream &stream)
{
	TypeInfoRecord::WriteData(stream);
	stream.WriteWord(type_id_);
}

/**
* NETStream
*/

NETStream::NETStream() 
	: MemoryStream() 
{

}

NETStream::NETStream(AbstractStream &stream, size_t size)
{
	CopyFrom(stream, size);
	Seek(0, soBeginning);
}

size_t NETStream::Read(void *Buffer, size_t Count)
{
	size_t res = MemoryStream::Read(Buffer, Count);
	if (res != Count)
		throw std::runtime_error("Runtime error at Read");
	return res;
}

uint8_t NETStream::ReadByte()
{
	uint8_t b;
	Read(&b, sizeof(b));
	return b;
}

uint16_t NETStream::ReadWord()
{
	uint16_t w;
	Read(&w, sizeof(w));
	return w;
}

uint32_t NETStream::ReadDWord()
{
	uint32_t dw;
	Read(&dw, sizeof(dw));
	return dw;
}

bool NETStream::ReadBoolean()
{
	return (ReadByte() != 0);
}

uint32_t NETStream::ReadEncoded()
{
	uint32_t res;
	uint8_t b = ReadByte();
	if ((b & 0x80) == 0) {
		res = b & 0x7f;
	}
	else if ((b & 0x40) == 0) {
		res = ((b & 0x3f) << 8) + ReadByte();
	}
	else {
		res = ((b & 0x1f) << 24) + (ReadByte() << 16) + (ReadByte() << 8) + ReadByte();
	}
	return res;
}

uint32_t NETStream::ReadEncoded7Bit()
{
	uint32_t res = 0;
	size_t shift = 0;
	uint8_t b;
	do {
		b = ReadByte();
		res |= (b & 0x7F) << shift;
		shift += 7;
	} while ((b & 0x80) != 0);
	return res;
}

std::string NETStream::ReadString()
{
	std::string res;
	uint32_t size = ReadEncoded7Bit();
	for (size_t i = 0; i < size; i++) {
		res.push_back(ReadByte());
	}
	return res;
}

std::string NETStream::ReadUnicodeString()
{
	os::unicode_string res;
	uint32_t size = ReadEncoded7Bit() >> 1;
	for (size_t i = 0; i < size; i++) {
		res.push_back(ReadWord());
	}
	return os::ToUTF8(res);
}

void NETStream::WriteByte(uint8_t value)
{
	Write(&value, sizeof(value));
}

void NETStream::WriteWord(uint16_t value)
{
	Write(&value, sizeof(value));
}

void NETStream::WriteDWord(uint32_t value)
{
	Write(&value, sizeof(value));
}

void NETStream::WriteEncoded7Bit(uint32_t value)
{
	while (value >= 0x80) {
		WriteByte(static_cast<uint8_t>(value) | 0x80);
		value >>= 7;
	}
	WriteByte(static_cast<uint8_t>(value));
}

void NETStream::WriteString(const std::string &value)
{
	WriteEncoded7Bit(static_cast<uint32_t>(value.size()));
	Write(value.c_str(), value.size());
}

void NETStream::WriteBoolean(bool value)
{
	WriteByte(value ? 1 : 0);
}

void NETStream::WriteUnicodeString(const os::unicode_string &value)
{
	WriteEncoded7Bit(static_cast<uint32_t>(value.size()) << 1);
	for (size_t i = 0; i < value.size(); i++) {
		WriteWord(value[i]);
	}
}

void NETStream::WriteEncoded(uint32_t value)
{
	if (value < 0x80) {
		WriteByte(static_cast<uint8_t>(value));
	}
	else if (value < 0x4000) {
		WriteByte(static_cast<uint8_t>(value >> 8) | 0x80);
		WriteByte(static_cast<uint8_t>(value));
	}
	else if (value < 0x02000000) {
		WriteByte(static_cast<uint8_t>(value >> 24) | 0xc0);
		WriteByte(static_cast<uint8_t>(value >> 16));
		WriteByte(static_cast<uint8_t>(value >> 8));
		WriteByte(static_cast<uint8_t>(value));
	}
	else {
		throw std::runtime_error("Value can not be encoded");
	}
}

/**
* BamlDocument
*/

BamlDocument::BamlDocument()
	: ObjectList<BamlRecord>(), reader_version_major_(0), reader_version_minor_(0), updater_version_major_(0), updater_version_minor_(0),
	writer_version_major_(0), writer_version_minor_(0)
{

}

void BamlDocument::clear()
{
	ObjectList<BamlRecord>::clear();
	reader_version_major_ = 0;
	reader_version_minor_ = 0;
	updater_version_major_ = 0;
	updater_version_minor_ = 0;
	writer_version_major_ = 0;
	writer_version_minor_ = 0;
}

BamlRecord *BamlDocument::GetRecordByPosition(uint64_t pos) const
{
	for (size_t i = 0; i < count(); i++) {
		BamlRecord *record = item(i);
		if (record->position() == pos)
			return record;
	}
	return NULL;
}

size_t BamlDocument::GetClosedIndex(BamlRecordType start, BamlRecordType end, size_t index)
{
	while (index < count()) {
		BamlRecord *record = item(index);
		if (record->type() == start) {
			index = GetClosedIndex(start, end, index + 1);
			if (index == NOT_ID)
				break;
		} else if (record->type() == end)
			return index;
		index++;
	}
	return NOT_ID;
}

bool BamlDocument::ReadFromStream(NETStream &stream)
{
	clear();

	const os::unicode_char MSBAML[6] = { 'M', 'S', 'B', 'A', 'M', 'L' };

	uint32_t signature_size = stream.ReadDWord();
	signature_.resize(signature_size >> 1);
	stream.Read(&signature_[0], signature_.size() * sizeof(os::unicode_char));

	if (signature_.size() != _countof(MSBAML) || memcmp(signature_.data(), MSBAML, signature_.size() * sizeof(os::unicode_char)))
		return false;

	reader_version_major_ = stream.ReadWord();
	reader_version_minor_ = stream.ReadWord();
	updater_version_major_ = stream.ReadWord();
	updater_version_minor_ = stream.ReadWord();
	writer_version_major_ = stream.ReadWord();
	writer_version_minor_ = stream.ReadWord();

	if (reader_version_major_ != 0 || reader_version_minor_ != 0x60 ||
		updater_version_major_ != 0 || updater_version_minor_ != 0x60 ||
		writer_version_major_ != 0 || writer_version_minor_ != 0x60)
		return false;

	uint64_t size = stream.Size();
	while (stream.Tell() < size) {
		uint64_t pos = stream.Tell();
		uint8_t type = stream.ReadByte();
		BamlRecord *rec;
		switch (type) {
		case AssemblyInfo:
			rec = new AssemblyInfoRecord(this);
			break;
		case AttributeInfo:
			rec = new AttributeInfoRecord(this);
			break;
		case ConstructorParametersStart:
			rec = new ConstructorParametersStartRecord(this);
			break;
		case ConstructorParametersEnd:
			rec = new ConstructorParametersEndRecord(this);
			break;
		case ConstructorParameterType:
			rec = new ConstructorParameterTypeRecord(this);
			break;
		case ConnectionId:
			rec = new ConnectionIdRecord(this);
			break;
		case ContentProperty:
			rec = new ContentPropertyRecord(this);
			break;
		case DefAttribute:
			rec = new DefAttributeRecord(this);
			break;
		case DefAttributeKeyString:
			rec = new DefAttributeKeyStringRecord(this);
			break;
		case DefAttributeKeyType:
			rec = new DefAttributeKeyTypeRecord(this);
			break;
		case DeferableContentStart:
			rec = new DeferableContentStartRecord(this);
			break;
		case DocumentEnd:
			rec = new DocumentEndRecord(this);
			break;
		case DocumentStart:
			rec = new DocumentStartRecord(this);
			break;
		case ElementEnd:
			rec = new ElementEndRecord(this);
			break;
		case ElementStart:
			rec = new ElementStartRecord(this);
			break;
		case KeyElementEnd:
			rec = new KeyElementEndRecord(this);
			break;
		case KeyElementStart:
			rec = new KeyElementStartRecord(this);
			break;
		case LineNumberAndPosition:
			rec = new LineNumberAndPositionRecord(this);
			break;
		case LinePosition:
			rec = new LinePositionRecord(this);
			break;
		case LiteralContent:
			rec = new LiteralContentRecord(this);
			break;
		case OptimizedStaticResource:
			rec = new OptimizedStaticResourceRecord(this);
			break;
		case PIMapping:
			rec = new PIMappingRecord(this);
			break;
		case PresentationOptionsAttribute:
			rec = new PresentationOptionsAttributeRecord(this);
			break;
		case Property:
			rec = new PropertyRecord(this);
			break;
		case PropertyArrayEnd:
			rec = new PropertyArrayEndRecord(this);
			break;
		case PropertyArrayStart:
			rec = new PropertyArrayStartRecord(this);
			break;
		case PropertyComplexEnd:
			rec = new PropertyComplexEndRecord(this);
			break;
		case PropertyComplexStart:
			rec = new PropertyComplexStartRecord(this);
			break;
		case PropertyCustom:
			rec = new PropertyCustomRecord(this);
			break;
		case PropertyDictionaryEnd:
			rec = new PropertyDictionaryEndRecord(this);
			break;
		case PropertyDictionaryStart:
			rec = new PropertyDictionaryStartRecord(this);
			break;
		case PropertyListEnd:
			rec = new PropertyListEndRecord(this);
			break;
		case PropertyListStart:
			rec = new PropertyListStartRecord(this);
			break;
		case PropertyStringReference:
			rec = new PropertyStringReferenceRecord(this);
			break;
		case PropertyTypeReference:
			rec = new PropertyTypeReferenceRecord(this);
			break;
		case PropertyWithConverter:
			rec = new PropertyWithConverterRecord(this);
			break;
		case PropertyWithExtension:
			rec = new PropertyWithExtensionRecord(this);
			break;
		case PropertyWithStaticResourceId:
			rec = new PropertyWithStaticResourceIdRecord(this);
			break;
		case RoutedEvent:
			rec = new RoutedEventRecord(this);
			break;
		case StaticResourceEnd:
			rec = new StaticResourceEndRecord(this);
			break;
		case StaticResourceId:
			rec = new StaticResourceIdRecord(this);
			break;
		case StaticResourceStart:
			rec = new StaticResourceStartRecord(this);
			break;
		case StringInfo:
			rec = new StringInfoRecord(this);
			break;
		case Text:
			rec = new TextRecord(this);
			break;
		case TextWithConverter:
			rec = new TextWithConverterRecord(this);
			break;
		case TextWithId:
			rec = new TextWithIdRecord(this);
			break;
		case TypeInfo:
			rec = new TypeInfoRecord(this);
			break;
		case XmlnsProperty:
			rec = new XmlnsPropertyRecord(this);
			break;
		case TypeSerializerInfo:
			rec = new TypeSerializerInfoRecord(this);
			break;
		default:
			throw std::runtime_error(string_format("Unknown BAML record type: %x", type));
		}
		rec->set_position(pos);
		AddObject(rec);

		rec->Read(stream);
	}

	for (size_t i = 0; i < count(); i++) {
		item(i)->ReadDefer(i);
	}

	return true;
}

void BamlDocument::WriteToStream(NETStream &stream)
{
	stream.WriteDWord(static_cast<uint32_t>(signature_.size() * sizeof(os::unicode_char)));
	stream.Write(signature_.data(), signature_.size() * sizeof(os::unicode_char));
	stream.WriteWord(reader_version_major_);
	stream.WriteWord(reader_version_minor_);
	stream.WriteWord(updater_version_major_);
	stream.WriteWord(updater_version_minor_);
	stream.WriteWord(writer_version_major_);
	stream.WriteWord(writer_version_minor_);

	size_t i;
	for (i = 0; i < count(); i++) {
		BamlRecord *rec = item(i);
		rec->set_position(stream.Tell());
		stream.WriteByte(rec->type());
		rec->Write(stream);
	}
	for (i = 0; i < count(); i++) {
		item(i)->WriteDefer(i, stream);
	}
}

/**
* BamlElement
*/

BamlElement::BamlElement(BamlElement *parent)
	: IObject(), parent_(parent), header_(NULL), footer_(NULL), type_(NULL)
{

}

BamlElement::~BamlElement()
{
	for (size_t i = 0; i < children_.size(); i++) {
		delete children_[i];
	}
}

bool BamlElement::is_header(BamlRecordType type)
{
	switch (type) {
	case ConstructorParametersStart:
	case DocumentStart:
	case ElementStart:
	case KeyElementStart:
	case NamedElementStart:
	case PropertyArrayStart:
	case PropertyComplexStart:
	case PropertyDictionaryStart:
	case PropertyListStart:
	case StaticResourceStart:
		return true;
	}
	return false;
}

bool BamlElement::is_footer(BamlRecordType type)
{
	switch (type) {
	case ConstructorParametersEnd:
	case DocumentEnd:
	case ElementEnd:
	case KeyElementEnd:
	case PropertyArrayEnd:
	case PropertyComplexEnd:
	case PropertyDictionaryEnd:
	case PropertyListEnd:
	case StaticResourceEnd:
		return true;
	}
	return false;
}

bool BamlElement::is_match(BamlRecordType header, BamlRecordType footer)
{
	switch (header) {
	case ConstructorParametersStart:
		return footer == ConstructorParametersEnd;

	case DocumentStart:
		return footer == DocumentEnd;

	case KeyElementStart:
		return footer == KeyElementEnd;

	case PropertyArrayStart:
		return footer == PropertyArrayEnd;

	case PropertyComplexStart:
		return footer == PropertyComplexEnd;

	case PropertyDictionaryStart:
		return footer == PropertyDictionaryEnd;

	case PropertyListStart:
		return footer == PropertyListEnd;

	case StaticResourceStart:
		return footer == StaticResourceEnd;

	case ElementStart:
	case NamedElementStart:
		return footer == ElementEnd;
	}
	return false;
}

bool BamlElement::Parse(BamlDocument *document)
{
	std::vector<BamlElement *> stack;
	BamlElement *current = NULL;

	for (size_t i = 0; i < document->count(); i++) {
		BamlRecord *record = document->item(i);
		if (is_header(record->type())) {
			BamlElement *prev = current;

			current = prev ? new BamlElement(prev) : this;
			current->header_ = record;
			if (prev) {
				prev->children_.push_back(current);
				stack.push_back(prev);
			}
		}
		else if (is_footer(record->type())) {
			if (!current)
				return false;

			while (!is_match(current->header_->type(), record->type())) {
				if (stack.empty())
					return false;

				current = stack.back();
				stack.pop_back();
			}

			current->footer_ = record;
			if (!stack.empty()) {
				current = stack.back();
				stack.pop_back();
			}
		}
		else {
			if (!current)
				return false;

			current->body_.push_back(record);
		}
	}

	return (header_ && header_->type() == DocumentStart && footer_ && footer_->type() == DocumentEnd);
}

/**
* CustomAttributeValue
*/

CustomAttributeValue::CustomAttributeValue(ILMetaData *meta)
	: IObject(), meta_(meta)
{
	fixed_list_ = new CustomAttributeArgumentList();
	named_list_ = new CustomAttributeNamedArgumentList();
}

CustomAttributeValue::~CustomAttributeValue()
{
	delete fixed_list_;
	delete named_list_;
}

void CustomAttributeValue::clear()
{
	fixed_list_->clear();
	named_list_->clear();
}

void CustomAttributeValue::Parse(ILToken *type, const ILData &data)
{
	clear();

	uint32_t id = 0;
	if (data.ReadWord(id) != 1)
		throw std::runtime_error("Invalid format");

	ILSignature *signature;
	switch (type->type()) {
	case ttMethodDef:
		signature = reinterpret_cast<ILMethodDef *>(type)->signature();
		break;
	case ttMemberRef:
		signature = reinterpret_cast<ILMemberRef *>(type)->signature();
		break;
	default:
		throw std::runtime_error("Invalid format");
	}

	size_t i, c;

	for (i = 0; i < signature->count(); i++) {
		CustomAttributeFixedArgument *arg = new CustomAttributeFixedArgument(meta_, fixed_list_, signature->item(i));
		fixed_list_->AddObject(arg);
		arg->Read(data, id);
	}

	c = data.ReadWord(id);
	for (i = 0; i < c; i++) {
		CustomAttributeNamedArgument *arg = new CustomAttributeNamedArgument(meta_, named_list_);
		named_list_->AddObject(arg);
		arg->Read(data, id);
	}
}

void CustomAttributeValue::Write(ILData &data)
{
	size_t i;

	data.WriteWord(1);
	for (i = 0; i < fixed_list_->count(); i++) {
		fixed_list_->item(i)->Write(data);
	}

	data.WriteWord(static_cast<uint16_t>(named_list_->count()));
	for (i = 0; i < named_list_->count(); i++) {
		named_list_->item(i)->Write(data);
	}
}

/**
* BaseCustomAttributeArgument
*/

CustomAttributeArgument::CustomAttributeArgument(ILMetaData *meta, CustomAttributeArgumentList *owner)
	: IObject(), meta_(meta), owner_(owner), children_(NULL), reference_(NULL)
{

}

CustomAttributeArgument::~CustomAttributeArgument()
{
	if (owner_)
		owner_->RemoveObject(this);
	delete children_;
}

ILElement *CustomAttributeArgument::ReadFieldOrPropType(const ILData &data, uint32_t &id)
{
	CorElementType type = static_cast<CorElementType>(data.ReadByte(id));
	switch (type) {
	case ELEMENT_TYPE_BOOLEAN:
	case ELEMENT_TYPE_CHAR:
	case ELEMENT_TYPE_I1:
	case ELEMENT_TYPE_U1:
	case ELEMENT_TYPE_I2:
	case ELEMENT_TYPE_U2:
	case ELEMENT_TYPE_I4:
	case ELEMENT_TYPE_U4:
	case ELEMENT_TYPE_I8:
	case ELEMENT_TYPE_U8:
	case ELEMENT_TYPE_R4:
	case ELEMENT_TYPE_R8:
	case ELEMENT_TYPE_STRING:
	case ELEMENT_TYPE_TYPE:
	case ELEMENT_TYPE_TAGGED_OBJECT:
		return new ILElement(meta_, NULL, type);
	case ELEMENT_TYPE_SZARRAY:
		return new ILElement(meta_, NULL, ELEMENT_TYPE_SZARRAY, NULL, ReadFieldOrPropType(data, id));
	case ELEMENT_TYPE_ENUM:
		return new ILElement(meta_, NULL, ELEMENT_TYPE_ENUM, ReadType(data, id), NULL);
	default:
		throw std::runtime_error("Invalid serialization type");
	}
}

CustomAttributeFixedArgument *CustomAttributeArgument::AddChild(ILElement *type)
{
	if (!children_)
		children_ = new CustomAttributeArgumentList();
	CustomAttributeFixedArgument *res = new CustomAttributeFixedArgument(meta_, children_, type);
	children_->AddObject(res);
	return res;
}

void CustomAttributeArgument::Read(const ILData &data, uint32_t &id)
{
	ReadValue(data, id, type());
}

void CustomAttributeArgument::ReadEnum(const ILData &data, uint32_t &id, ILToken *type)
{
	ILTypeDef *type_def;
	switch (type->type()) {
	case ttTypeDef:
		type_def = reinterpret_cast<ILTypeDef *>(type);
		break;
	case ttTypeRef:
		type_def = reinterpret_cast<ILTypeRef *>(type)->Resolve(true);
		break;
	default:
		throw std::runtime_error("Invalid token type");
	}

	ILElement *underlying_type = type_def->GetEnumUnderlyingType();
	if (!underlying_type || underlying_type->type() < ELEMENT_TYPE_BOOLEAN || underlying_type->type() > ELEMENT_TYPE_U8)
		throw std::runtime_error("Invalid enum underlying type");

	ReadValue(data, id, underlying_type);
}

void CustomAttributeArgument::ReadObject(const ILData &data, uint32_t &id)
{
	AddChild(ReadFieldOrPropType(data, id))->Read(data, id);
}

void CustomAttributeArgument::ReadArray(const ILData &data, uint32_t &id, ILElement *type)
{
	size_t size = data.ReadDWord(id);
	if (size == UINT32_MAX)
		return;

	for (size_t i = 0; i < size; i++) {
		AddChild(type)->Read(data, id);
	}
}

std::string CustomAttributeArgument::ReadString(const ILData &data, uint32_t &id)
{
	std::string res;
	uint32_t old_pos = id;
	if (data.ReadByte(id) != 0xff) {
		--id;
		res = data.ReadString(id);
	}
	value_.Write(data.data() + old_pos, id - old_pos);
	return res;
}

ILTypeDef *CustomAttributeArgument::ReadType(const ILData &data, uint32_t &id)
{
	std::string type_name = data.ReadString(id);
	if (type_name.empty())
		throw std::runtime_error("Invalid format");

	return meta_->ResolveType(type_name, true);
}

void CustomAttributeArgument::ReadValue(const ILData &data, uint32_t &id, ILElement *type)
{
	switch (type->type()) {
	case ELEMENT_TYPE_BOOLEAN:
	case ELEMENT_TYPE_I1:
	case ELEMENT_TYPE_U1:
		value_.WriteByte(data.ReadByte(id));
		break;
	case ELEMENT_TYPE_CHAR:
	case ELEMENT_TYPE_I2:
	case ELEMENT_TYPE_U2:
		value_.WriteWord(data.ReadWord(id));
		break;
	case ELEMENT_TYPE_I4:
	case ELEMENT_TYPE_U4:
	case ELEMENT_TYPE_R4:
		value_.WriteDWord(data.ReadDWord(id));
		break;
	case ELEMENT_TYPE_I8:
	case ELEMENT_TYPE_U8:
	case ELEMENT_TYPE_R8:
		value_.WriteQWord(data.ReadQWord(id));
		break;
	case ELEMENT_TYPE_STRING:
		ReadString(data, id);
		break;
	case ELEMENT_TYPE_TYPE:
		reference_ = ReadType(data, id);
		break;
	case ELEMENT_TYPE_SZARRAY:
		ReadArray(data, id, type->next());
		break;
	case ELEMENT_TYPE_OBJECT:
	case ELEMENT_TYPE_TAGGED_OBJECT:
		ReadObject(data, id);
		break;
	case ELEMENT_TYPE_ENUM:
		reference_ = reinterpret_cast<ILTypeDef *>(type->token());
		ReadEnum(data, id, type->token());
		break;
	case ELEMENT_TYPE_VALUETYPE:
		ReadEnum(data, id, type->token());
		break;
	case ELEMENT_TYPE_CLASS:
		if (type->token()->type() == ttTypeRef) {
			ILTypeRef *type_ref = reinterpret_cast<ILTypeRef *>(type->token());
			if (type_ref->resolution_scope() == type_ref->meta()->GetCoreLib() && type_ref->name_space() == "System") {
				if (type_ref->name() == "Type") {
					reference_ = ReadType(data, id);
					break;
				} else if (type_ref->name() == "String") {
					ReadString(data, id);
					break;
				}
				else if (type_ref->name() == "Object") {
					ReadObject(data, id);
					break;
				}
			}
		}
		ReadEnum(data, id, type->token());
		break;
	default:
		throw std::runtime_error("Invalid element type");
	}
}

void CustomAttributeArgument::Write(ILData &data) const
{
	WriteValue(data, type());
}

void CustomAttributeArgument::WriteArray(ILData &data) const
{
	if (!children_) {
		data.WriteDWord(UINT32_MAX);
		return;
	}

	data.WriteDWord(static_cast<uint32_t>(children_->count()));
	for (size_t i = 0; i < children_->count(); i++) {
		children_->item(i)->Write(data);
	}
}

void CustomAttributeArgument::WriteObject(ILData &data) const
{
	CustomAttributeArgument *child = children_->item(0);
	WriteFieldOrPropType(data, child->type());
	child->Write(data);
}

void CustomAttributeArgument::WriteType(ILData &data, ILTypeDef *type_def) const
{
	std::string type_name = type_def->reflection_name();
	if (type_def->meta() != meta_) {
		ILAssembly *assembly = reinterpret_cast<ILAssembly *>(type_def->meta()->token(ttAssembly | 1));
		type_name += ", " + assembly->full_name();
	}
	data.WriteString(type_name);
}

void CustomAttributeArgument::WriteFieldOrPropType(ILData &data, ILElement *type) const
{
	data.WriteByte(type->type());
	switch (type->type()) {
	case ELEMENT_TYPE_BOOLEAN:
	case ELEMENT_TYPE_CHAR:
	case ELEMENT_TYPE_I1:
	case ELEMENT_TYPE_U1:
	case ELEMENT_TYPE_I2:
	case ELEMENT_TYPE_U2:
	case ELEMENT_TYPE_I4:
	case ELEMENT_TYPE_U4:
	case ELEMENT_TYPE_I8:
	case ELEMENT_TYPE_U8:
	case ELEMENT_TYPE_R4:
	case ELEMENT_TYPE_R8:
	case ELEMENT_TYPE_STRING:
	case ELEMENT_TYPE_TYPE:
	case ELEMENT_TYPE_TAGGED_OBJECT:
		break;
	case ELEMENT_TYPE_SZARRAY:
		WriteFieldOrPropType(data, type->next());
		break;
	case ELEMENT_TYPE_ENUM:
		WriteType(data, reinterpret_cast<ILTypeDef *>(type->token()));
		break;
	}
}

void CustomAttributeArgument::WriteValue(ILData &data, ILElement *type) const
{
	switch (type->type()) {
	case ELEMENT_TYPE_BOOLEAN:
	case ELEMENT_TYPE_I1:
	case ELEMENT_TYPE_U1:
	case ELEMENT_TYPE_CHAR:
	case ELEMENT_TYPE_I2:
	case ELEMENT_TYPE_U2:
	case ELEMENT_TYPE_I4:
	case ELEMENT_TYPE_U4:
	case ELEMENT_TYPE_R4:
	case ELEMENT_TYPE_I8:
	case ELEMENT_TYPE_U8:
	case ELEMENT_TYPE_R8:
	case ELEMENT_TYPE_STRING:
	case ELEMENT_TYPE_TYPE:
	case ELEMENT_TYPE_VALUETYPE:
	case ELEMENT_TYPE_ENUM:
		data.Write(value_.data(), value_.size());
		break;
	case ELEMENT_TYPE_SZARRAY:
		WriteArray(data);
		break;
	case ELEMENT_TYPE_OBJECT:
	case ELEMENT_TYPE_TAGGED_OBJECT:
		WriteObject(data);
		break;
	case ELEMENT_TYPE_CLASS:
		if (reference_) // System.Type
			WriteType(data, reference_);
		else if (children_) // System.Object
			WriteObject(data);
		else 
			data.Write(value_.data(), value_.size());
		break;
	default:
		throw std::runtime_error("Invalid element type");
	}
}

bool CustomAttributeArgument::ToBoolean() const
{
	if (type()->type() != ELEMENT_TYPE_BOOLEAN)
		throw std::runtime_error("Invalid element type");
	if (value_.size() != 1)
		throw std::runtime_error("Invalid value size");
	return (value_[0] != 0);
}

std::string CustomAttributeArgument::ToString() const
{
	if (type()->type() != ELEMENT_TYPE_STRING)
		throw std::runtime_error("Invalid element type");
	uint32_t pos = 0;
	return value_.ReadString(pos);
}

/**
* CustomAttributeArgument
*/

CustomAttributeFixedArgument::CustomAttributeFixedArgument(ILMetaData *meta, CustomAttributeArgumentList *owner, ILElement *type)
	: CustomAttributeArgument(meta, owner), type_(type)
{

}

/**
* CustomAttributeArgumentList
*/

CustomAttributeArgumentList::CustomAttributeArgumentList()
	: ObjectList<CustomAttributeArgument>()
{

}

/**
* CustomAttributeNamedArgument
*/

CustomAttributeNamedArgument::CustomAttributeNamedArgument(ILMetaData *meta, CustomAttributeArgumentList *owner)
	: CustomAttributeArgument(meta, owner), is_field_(false), type_(NULL)
{

}

CustomAttributeNamedArgument::~CustomAttributeNamedArgument()
{
	delete type_;
}

void CustomAttributeNamedArgument::Read(const ILData &data, uint32_t &id)
{
	switch (data.ReadByte(id)) {
	case 0x53:
		is_field_ = true;
		break;
	case 0x54:
		is_field_ = false;
		break;
	default:
		throw std::runtime_error("Invalid format");
	}
	type_ = ReadFieldOrPropType(data, id);
	name_ = data.ReadString(id);
	CustomAttributeArgument::Read(data, id);
}

void CustomAttributeNamedArgument::Write(ILData &data) const
{
	data.WriteByte(is_field_ ? 0x53 : 0x54);
	WriteFieldOrPropType(data, type());
	data.WriteString(name_);
	CustomAttributeArgument::Write(data);
}

/**
* CustomAttributeNamedArgumentList
*/

CustomAttributeNamedArgumentList::CustomAttributeNamedArgumentList()
	: CustomAttributeArgumentList()
{

}

CustomAttributeNamedArgument *CustomAttributeNamedArgumentList::item(size_t index) const
{
	return reinterpret_cast<CustomAttributeNamedArgument *>(CustomAttributeArgumentList::item(index));
}

/**
* FrameworkVersion
*/

bool try_stou(const std::string &str, uint32_t *value)
{
	if (str.empty())
		return false;

	if (str.find_first_not_of("0123456789") != std::string::npos)
		return false;

	*value = std::stoul(str);
	return true;
}

bool FrameworkVersion::Parse(const std::string &version)
{
	size_t pos;
	size_t start = 0;
	size_t value_index = 0;
	uint32_t values[3] = { 0 };
	uint32_t num;
	while (value_index < _countof(values)) {
		pos = version.find('.', start);
		if (pos != std::string::npos) {
			if (try_stou(version.substr(start, pos - start), &num)) {
				values[value_index] = num;
				value_index++;
				start = pos + 1;
				continue;
			}
		}
		pos = version.find_first_not_of("0123456789", start);
		if (try_stou(version.substr(start, (pos != std::string::npos) ? pos - start : std::string::npos), &num))
			values[value_index] = num;
		break;
	}

	if (value_index == 0)
		return false;

	major = values[0];
	minor = values[1];
	patch = values[2];
	return true;
}

/**
* AssemblyName
*/

AssemblyName::AssemblyName(const std::string &name)
{
	size_t start, end;
	for (start = 0; ; start = end + 1) {
		end = name.find(',', start);
		while (name[start] == ' ')
			start++;
		std::string str = (end == std::string::npos) ? name.substr(start) : name.substr(start, end - start);
		if (start == 0)
			this->name = str;
		else {
			size_t p = str.find('=');
			if (p == std::string::npos)
				throw std::runtime_error("Malformed assembly name: " + name);

			std::string key = str.substr(0, p);
			std::string value = str.substr(p + 1);
			if (key == "Version")
				version = value;
			else if (key == "Culture")
				culture = value;
			else if (key == "PublicKeyToken")
				public_key_token = value;
		}

		if (end == std::string::npos)
			break;
	}

	if (culture == "neutral")
		culture.clear();
}

std::string AssemblyName::value() const
{
	std::string res = name;
	res += ", Version=" + version;
	res += ", Culture=" + (culture.empty() ? "neutral" : culture);
	res += ", PublicKeyToken=" + (public_key_token.empty() ? "null" : public_key_token);
	return res;
}

/**
* AssemblyResolver
*/

AssemblyResolver::AssemblyResolver()
	: IObject()
{
#ifdef VMP_GNU
#else
	win_dir_ = os::GetEnvironmentVariable("WINDIR");

	std::string root = os::GetEnvironmentVariable("ProgramFiles");
	if (!root.empty()) {
		root = os::CombinePaths(root.c_str(), "dotnet");
		if (os::FileExists(root.c_str())) {
			root = os::CombinePaths(root.c_str(), "shared");
			if (os::FileExists(root.c_str())) {
				std::vector<std::string> root_list = os::FindFiles(root.c_str(), "*", true);
				for (size_t i = 0; i < root_list.size(); i++) {
					std::string path = os::CombinePaths(root.c_str(), root_list[i].c_str());
					std::vector<std::string> path_list = os::FindFiles(path.c_str(), "*", true);

					for (size_t j = 0; j < path_list.size(); j++) {
						FrameworkVersion version;
						if (!version.Parse(os::ExtractFileName(path_list[j].c_str())))
							continue;

						dotnet_dir_list_.push_back(FrameworkPathInfo(os::CombinePaths(os::CombinePaths(path.c_str(), path_list[j].c_str()).c_str(), ""), version));
					}
				}

				std::sort(dotnet_dir_list_.begin(), dotnet_dir_list_.end(), [](const FrameworkPathInfo &left, const FrameworkPathInfo &right)
				{
					return (left.version < right.version);
				});
			}
		}
	}

	redirect_v2_map_["Accessibility"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["cscompmgd"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "8.0.0.0");
	redirect_v2_map_["CustomMarshalers"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["IEExecRemote"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["IEHost"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["IIEHost"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["ISymWrapper"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["Microsoft.JScript"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "8.0.0.0");
	redirect_v2_map_["Microsoft.VisualBasic"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "8.0.0.0");
	redirect_v2_map_["Microsoft.VisualBasic.Compatibility"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "8.0.0.0");
	redirect_v2_map_["Microsoft.VisualBasic.Compatibility.Data"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "8.0.0.0");
	redirect_v2_map_["Microsoft.VisualBasic.Vsa"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "8.0.0.0");
	redirect_v2_map_["Microsoft.VisualC"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "8.0.0.0");
	redirect_v2_map_["Microsoft.Vsa"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "8.0.0.0");
	redirect_v2_map_["Microsoft.Vsa.Vb.CodeDOMProcessor"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "8.0.0.0");
	redirect_v2_map_["Microsoft_VsaVb"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "8.0.0.0");
	redirect_v2_map_["mscorcfg"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["mscorlib"] = FrameworkRedirectInfo("b77a5c561934e089", "2.0.0.0");
	redirect_v2_map_["System"] = FrameworkRedirectInfo("b77a5c561934e089", "2.0.0.0");
	redirect_v2_map_["System.Configuration"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.Configuration.Install"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.Data"] = FrameworkRedirectInfo("b77a5c561934e089", "2.0.0.0");
	redirect_v2_map_["System.Data.OracleClient"] = FrameworkRedirectInfo("b77a5c561934e089", "2.0.0.0");
	redirect_v2_map_["System.Data.SqlXml"] = FrameworkRedirectInfo("b77a5c561934e089", "2.0.0.0");
	redirect_v2_map_["System.Deployment"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.Design"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.DirectoryServices"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.DirectoryServices.Protocols"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.Drawing"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.Drawing.Design"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.EnterpriseServices"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.Management"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.Messaging"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.Runtime.Remoting"] = FrameworkRedirectInfo("b77a5c561934e089", "2.0.0.0");
	redirect_v2_map_["System.Runtime.Serialization.Formatters.Soap"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.Security"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.ServiceProcess"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.Transactions"] = FrameworkRedirectInfo("b77a5c561934e089", "2.0.0.0");
	redirect_v2_map_["System.Web"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.Web.Mobile"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.Web.RegularExpressions"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.Web.Services"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["System.Windows.Forms"] = FrameworkRedirectInfo("b77a5c561934e089", "2.0.0.0");
	redirect_v2_map_["System.Xml"] = FrameworkRedirectInfo("b77a5c561934e089", "2.0.0.0");
	redirect_v2_map_["vjscor"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["VJSharpCodeProvider"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["vjsJBC"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["vjslib"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["vjslibcw"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["Vjssupuilib"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["vjsvwaux"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["vjswfc"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["VJSWfcBrowserStubLib"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["vjswfccw"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v2_map_["vjswfchtml"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");

	redirect_v4_map_["Accessibility"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["CustomMarshalers"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["ISymWrapper"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["Microsoft.JScript"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "10.0.0.0");
	redirect_v4_map_["Microsoft.VisualBasic"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "10.0.0.0");
	redirect_v4_map_["Microsoft.VisualBasic.Compatibility"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "10.0.0.0");
	redirect_v4_map_["Microsoft.VisualBasic.Compatibility.Data"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "10.0.0.0");
	redirect_v4_map_["Microsoft.VisualC"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "10.0.0.0");
	redirect_v4_map_["mscorlib"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Configuration"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Configuration.Install"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Data"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Data.OracleClient"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Data.SqlXml"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Deployment"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Design"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.DirectoryServices"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.DirectoryServices.Protocols"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Drawing"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Drawing.Design"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.EnterpriseServices"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Management"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Messaging"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Runtime.Remoting"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Runtime.Serialization.Formatters.Soap"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Security"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.ServiceProcess"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Transactions"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Web"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Web.Mobile"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Web.RegularExpressions"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Web.Services"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Windows.Forms"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Xml"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["AspNetMMCExt"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["sysglobl"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["Microsoft.Build.Engine"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["Microsoft.Build.Framework"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["PresentationCFFRasterizer"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["PresentationCore"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["PresentationFramework"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["PresentationFramework.Aero"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["PresentationFramework.Classic"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["PresentationFramework.Luna"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["PresentationFramework.Royale"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["PresentationUI"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["ReachFramework"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Printing"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Speech"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["UIAutomationClient"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["UIAutomationClientsideProviders"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["UIAutomationProvider"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["UIAutomationTypes"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["WindowsBase"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["WindowsFormsIntegration"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["SMDiagnostics"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.IdentityModel"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.IdentityModel.Selectors"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.IO.Log"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Runtime.Serialization"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel.Install"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel.WasHosting"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Workflow.Activities"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Workflow.ComponentModel"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Workflow.Runtime"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["Microsoft.Transactions.Bridge"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["Microsoft.Transactions.Bridge.Dtc"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.AddIn"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.AddIn.Contract"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.ComponentModel.Composition"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Core"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Data.DataSetExtensions"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Data.Linq"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Xml.Linq"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.DirectoryServices.AccountManagement"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Management.Instrumentation"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Net"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel.Web"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Web.Extensions"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Web.Extensions.Design"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Windows.Presentation"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.WorkflowServices"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.ComponentModel.DataAnnotations"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Data.Entity"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Data.Entity.Design"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Data.Services"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Data.Services.Client"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Data.Services.Design"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Web.Abstractions"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Web.DynamicData"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Web.DynamicData.Design"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Web.Entity"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Web.Entity.Design"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Web.Routing"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["Microsoft.Build"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["Microsoft.CSharp"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Dynamic"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Numerics"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Xaml"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["Microsoft.Workflow.Compiler"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["Microsoft.Activities.Build"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["Microsoft.Build.Conversion.v4.0"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["Microsoft.Build.Tasks.v4.0"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["Microsoft.Build.Utilities.v4.0"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["Microsoft.Internal.Tasks.Dataflow"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["Microsoft.VisualBasic.Activities.Compiler"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "10.0.0.0");
	redirect_v4_map_["Microsoft.VisualC.STLCLR"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "2.0.0.0");
	redirect_v4_map_["Microsoft.Windows.ApplicationServer.Applications"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["PresentationBuildTasks"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["PresentationFramework.Aero2"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["PresentationFramework.AeroLite"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["PresentationFramework-SystemCore"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["PresentationFramework-SystemData"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["PresentationFramework-SystemDrawing"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["PresentationFramework-SystemXml"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["PresentationFramework-SystemXmlLinq"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Activities"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Activities.Core.Presentation"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Activities.DurableInstancing"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Activities.Presentation"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.ComponentModel.Composition.Registration"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Device"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.IdentityModel.Services"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.IO.Compression"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.IO.Compression.FileSystem"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Net.Http"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Net.Http.WebRequest"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Reflection.Context"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Runtime.Caching"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Runtime.DurableInstancing"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Runtime.WindowsRuntime"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Runtime.WindowsRuntime.UI.Xaml"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel.Activation"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel.Activities"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel.Channels"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel.Discovery"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel.Internals"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel.Routing"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel.ServiceMoniker40"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Web.ApplicationServices"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Web.DataVisualization"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Web.DataVisualization.Design"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Windows.Controls.Ribbon"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Windows.Forms.DataVisualization"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Windows.Forms.DataVisualization.Design"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Windows.Input.Manipulations"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
	redirect_v4_map_["System.Xaml.Hosting"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["XamlBuildTask"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["XsdBuildTask"] = FrameworkRedirectInfo("31bf3856ad364e35", "4.0.0.0");
	redirect_v4_map_["System.Collections"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Collections.Concurrent"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.ComponentModel"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.ComponentModel.Annotations"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.ComponentModel.EventBasedAsync"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Diagnostics.Contracts"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Diagnostics.Debug"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Diagnostics.Tools"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Diagnostics.Tracing"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Dynamic.Runtime"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Globalization"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.IO"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Linq"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Linq.Expressions"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Linq.Parallel"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Linq.Queryable"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Net.NetworkInformation"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Net.Primitives"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Net.Requests"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.ObjectModel"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Reflection"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Reflection.Emit"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Reflection.Emit.ILGeneration"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Reflection.Emit.Lightweight"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Reflection.Extensions"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Reflection.Primitives"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Resources.ResourceManager"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Runtime"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Runtime.Extensions"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Runtime.InteropServices"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Runtime.InteropServices.WindowsRuntime"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Runtime.Numerics"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Runtime.Serialization.Json"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Runtime.Serialization.Primitives"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Runtime.Serialization.Xml"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Security.Principal"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel.Duplex"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel.Http"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel.NetTcp"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel.Primitives"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.ServiceModel.Security"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Text.Encoding"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Text.Encoding.Extensions"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Text.RegularExpressions"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Threading"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Threading.Timer"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Threading.Tasks"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Threading.Tasks.Parallel"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Xml.ReaderWriter"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Xml.XDocument"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Xml.XmlSerializer"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Net.Http.Rtc"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Windows"] = FrameworkRedirectInfo("b03f5f7f11d50a3a", "4.0.0.0");
	redirect_v4_map_["System.Xml.Serialization"] = FrameworkRedirectInfo("b77a5c561934e089", "4.0.0.0");
#endif
}

AssemblyResolver::~AssemblyResolver()
{
	for (std::map<std::string, PEFile *>::const_iterator it = cache_.begin(); it != cache_.end(); it++) {
		delete it->second;
	}
}

void AssemblyResolver::Prepare()
{
	framework_path_map_.clear();
	for (std::map<std::string, PEFile *>::const_iterator it = cache_.begin(); it != cache_.end();) {
		if (!it->second)
			it = cache_.erase(it);
		else
			it++;
	}
}

ILMetaData *AssemblyResolver::Resolve(const ILMetaData &source, const std::string &orig_name)
{
	std::map<std::string, PEFile *>::const_iterator cache_it = cache_.find(orig_name);
	if (cache_it != cache_.end())
		return cache_it->second ? reinterpret_cast<NETArchitecture *>(cache_it->second->item(1))->command_list() : NULL;

	std::string name = orig_name;
	AssemblyName assembly(name);

	if (assembly.culture.empty()) {
		const std::map<std::string, FrameworkRedirectInfo, ci_less> *map;
		FrameworkInfo info = source.framework();
		if (info.type == fwFramework)
			map = (info.version.major >= 4) ? &redirect_v4_map_ : &redirect_v2_map_;
		else 
			map = NULL;

		if (map) {
			std::map<std::string, FrameworkRedirectInfo>::const_iterator redirect_it = map->find(assembly.name);
			if (redirect_it != map->end() && assembly.public_key_token == redirect_it->second.public_key_token) {
				assembly.version = redirect_it->second.version;
				name = assembly.value();

				// find redirected name
				cache_it = cache_.find(name);
				if (cache_it != cache_.end())
					return cache_it->second ? reinterpret_cast<NETArchitecture *>(cache_it->second->item(1))->command_list() : NULL;
			}
		}
	}

	std::vector<std::string> file_names = FindAssemblies(source, assembly);
	PEFile *file = new PEFile();
	for (size_t i = 0; i < file_names.size(); i++) {
		try {
			if (file->Open(file_names[i].c_str(), foRead | foHeaderOnly) == osSuccess) {
				if (file->count() > 1) {
					NETArchitecture *net = reinterpret_cast<NETArchitecture *>(file->item(1));
					std::string loaded_name = net->full_name();

					if (loaded_name != name) {
						AssemblyName loaded(loaded_name);
						if (_strcmpi(loaded.name.c_str(), assembly.name.c_str()) != 0)
							continue;

						if (loaded.version != assembly.version) {
							FrameworkVersion loaded_version;
							if (!loaded_version.Parse(loaded.version))
								continue;

							FrameworkVersion assembly_version;
							if (!assembly_version.Parse(assembly.version))
								continue;

							if (loaded_version.major != assembly_version.major)
								continue;

							if (loaded_version.minor < assembly_version.minor)
								continue;
						}

						if (loaded.culture != assembly.culture)
							continue;

						if (loaded.public_key_token != assembly.public_key_token)
							continue;
					}

					cache_[name] = file;
					return net->command_list();
				}
			}
		}
		catch (...)
		{

		}
		file->Close();
	}
	delete file;

	cache_[name] = NULL;
	return NULL;
}

std::vector<std::string> AssemblyResolver::FindAssemblies(const ILMetaData &source, const AssemblyName &assembly)
{
	std::vector<std::string> res;
	size_t i;

	std::string full_dll_name = assembly.name + ".dll";
	std::string source_path = os::ExtractFilePath(source.owner()->owner()->file_name().c_str());
	FrameworkInfo framework = source.framework();
	if (framework.type != fwUnknown) {
		if (source.owner()->owner()->is_executable())
			framework_path_map_[source_path] = framework;
	}
	if (framework.type == fwUnknown || framework.type == fwStandard) {
		std::map<std::string, FrameworkInfo>::const_iterator it = framework_path_map_.find(source_path);
		if (it != framework_path_map_.end())
			framework = it->second;
	}

	std::string file_name = os::CombinePaths(source_path.c_str(), full_dll_name.c_str());
	if (std::find(res.begin(), res.end(), file_name) == res.end()) {
		if (os::FileExists(file_name.c_str()))
			res.push_back(file_name);
	}
	
	switch (framework.type) {
	case fwFramework:
	case fwStandard:
		if (!win_dir_.empty()) {
			// search in GAC
			std::string prefix, path;
			std::vector<std::string> search_paths;

			if (framework.type == fwStandard || framework.version.major >= 4) {
				prefix = "v4.0_";
				path = os::CombinePaths(os::CombinePaths(win_dir_.c_str(), "Microsoft.NET").c_str(), "assembly");
				search_paths.push_back(os::CombinePaths(path.c_str(), "GAC_32"));
				search_paths.push_back(os::CombinePaths(path.c_str(), "GAC_64"));
				search_paths.push_back(os::CombinePaths(path.c_str(), "GAC_MSIL"));
			} else {
				prefix.clear();
				path = os::CombinePaths(win_dir_.c_str(), "assembly");
				search_paths.push_back(os::CombinePaths(path.c_str(), "GAC_32"));
				search_paths.push_back(os::CombinePaths(path.c_str(), "GAC_64"));
				search_paths.push_back(os::CombinePaths(path.c_str(), "GAC_MSIL"));
				search_paths.push_back(os::CombinePaths(path.c_str(), "GAC"));
			}

			for (i = 0; i < search_paths.size(); i++) {
				path = os::CombinePaths(os::CombinePaths(search_paths[i].c_str(), assembly.name.c_str()).c_str(), string_format("%s%s_%s_%s", prefix.c_str(), assembly.version.c_str(), assembly.culture.c_str(), assembly.public_key_token.c_str()).c_str());
				std::string file_name = os::CombinePaths(path.c_str(), full_dll_name.c_str());
				if (os::FileExists(file_name.c_str()))
					res.push_back(file_name);
			}
		}
		break;
	case fwCore:
		if (!dotnet_dir_list_.empty()) {
			std::vector<std::string> search_paths;
			std::map<uint32_t, std::vector<std::string> > minor_list;
			for (i = dotnet_dir_list_.size(); i > 0; i--) {
				FrameworkPathInfo info = dotnet_dir_list_[i - 1];
				if (framework.version.major) {
					if (info.version.major != framework.version.major)
						continue;

					// select best minor version
					uint32_t d;
					if (info.version.minor >= framework.version.minor)
						d = info.version.minor - framework.version.minor;
					else
						d = 0x80000000 + framework.version.minor - info.version.minor - 1;

					std::map<uint32_t, std::vector<std::string> >::iterator it = minor_list.find(d);
					if (it == minor_list.end()) {
						std::vector<std::string> list;
						list.push_back(info.path);
						minor_list[d] = list;
					}
					else
						it->second.push_back(info.path);
				} else 
					search_paths.push_back(info.path);
			}

			if (!minor_list.empty()) {
				std::map<uint32_t, std::vector<std::string> >::const_iterator it = minor_list.begin();
				for (i = 0; i < it->second.size(); i++) {
					search_paths.push_back(it->second[i]);
				}
			}

			for (i = 0; i < search_paths.size(); i++) {
				std::string path = search_paths[i];
				std::string file_name = os::CombinePaths(path.c_str(), full_dll_name.c_str());
				if (os::FileExists(file_name.c_str()))
					res.push_back(file_name);
			}
		}
		break;
	}

	return res;
}