#include "stdafx.h"

#include "../BasicCompiler_Common/common.h"

#ifndef RT_MANIFEST
#define RT_MANIFEST                        MAKEINTRESOURCE(24)
#endif

//リソースアドレススケジュール
DWORD *lpdwRSrcAddrSchedule;
int RSrcAddrScheduleNum;

void AddRSrcAddrSchedule(DWORD pos){
	extern HANDLE hHeap;

	//グローバル変数アドレススケジュールに追加する
	lpdwRSrcAddrSchedule=(DWORD *)HeapReAlloc(hHeap,0,lpdwRSrcAddrSchedule,(RSrcAddrScheduleNum+1)*sizeof(DWORD));
	lpdwRSrcAddrSchedule[RSrcAddrScheduleNum]=pos;
	RSrcAddrScheduleNum++;
}

char *PermutationString(char *buffer,char *lpszSearch,char *lpszRewrite){
	//バッファ長
	int length;
	length=lstrlen(buffer);

	//サーチ文字列の長さ
	int search_length;
	search_length=lstrlen(lpszSearch);

	//置換文字列の長さ
	int write_length;
	write_length=lstrlen(lpszRewrite);

	//置換時オフセット
	int offset;
	offset=lstrlen(lpszRewrite)-search_length;

	int i;
	for(i=0;i<length-search_length;i++){
		if(memcmp(buffer+i,lpszSearch,search_length)==0){
			if(offset>0){
				length+=offset;
				buffer=(char *)HeapReAlloc(hHeap,0,buffer,length+1);
			}

			SlideString(buffer+i+search_length,offset);
			memcpy(buffer+i,lpszRewrite,write_length);
			i+=write_length-1;
		}
	}

	return buffer;
}

char *GetRSrcSectionBuffer(int *pLen){
	extern HANDLE hHeap;
	char *buffer,*temporary;
	int i2,i3,i4,i5,i6,i7,sw,BufSize,TypeNum,NextBase;
	HANDLE hFile;

	//カーソルリソース
	extern RESOURCEDATAINFO *pCursorResourceInfo;
	extern int CursorResourceNum;
	int CursorNum;
	CURSORDIR *pCursorDir;
	CURSORDIRENTRY *pCursorDirEntry;
	CURSORDIRENTRY_RES CursorDirEntry_Res;
	CursorNum=0;

	//ビットマップリソース
	extern RESOURCEDATAINFO *pBitmapResourceInfo;
	extern int BitmapResourceNum;

	//アイコンリソース
	extern RESOURCEDATAINFO *pIconResourceInfo;
	extern int IconResourceNum;
	int IconNum;
	ICONDIR *pIconDir;
	ICONDIRENTRY *pIconDirEntry;
	ICONDIRENTRY_RES IconDirEntry_Res;
	IconNum=0;

	//XPManifestリソース
	extern char szManifestPath[MAX_PATH];
	extern int XPManiResourceNum;

	BufSize=8192*2;
	buffer=(char *)HeapAlloc(hHeap,0,BufSize);
	i2=0;
	NextBase=0;

	//リソースアドレススケジュール
	lpdwRSrcAddrSchedule=(DWORD *)HeapAlloc(hHeap,0,1);
	RSrcAddrScheduleNum=0;

	*pLen=0;

	if(CursorResourceNum==0&&
		BitmapResourceNum==0&&
		IconResourceNum==0&&
		XPManiResourceNum==0) return buffer;

	sw=0;

	//カーソルの枚数を計算（CursorNumに格納）
	for(i3=0;i3<CursorResourceNum;i3++){
		hFile=CreateFile(pCursorResourceInfo[i3].FileName,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
		if(hFile==INVALID_HANDLE_VALUE){
			compiler.errorMessenger.Output(23,pCursorResourceInfo[i3].FileName,-1);
			sw=1;
			continue;
		}
		i4=GetFileSize(hFile,NULL);
		temporary=(char *)HeapAlloc(hHeap,0,i4);
		ReadFile(hFile,temporary,i4,(DWORD *)&i5,NULL);
		CloseHandle(hFile);

		pCursorDir=(CURSORDIR *)temporary;
		CursorNum+=pCursorDir->idCount;

		HeapDefaultFree(temporary);
	}

	//ビットマップのファイルの有無を確認
	for(i3=0;i3<BitmapResourceNum;i3++){
		hFile=CreateFile(pBitmapResourceInfo[i3].FileName,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
		if(hFile==INVALID_HANDLE_VALUE){
			compiler.errorMessenger.Output(23,pBitmapResourceInfo[i3].FileName,-1);
			sw=1;
			continue;
		}
		CloseHandle(hFile);
	}

	//アイコンの枚数を計算（IconNumに格納）
	for(i3=0;i3<IconResourceNum;i3++){
		hFile=CreateFile(pIconResourceInfo[i3].FileName,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
		if(hFile==INVALID_HANDLE_VALUE){
			compiler.errorMessenger.Output(23,pIconResourceInfo[i3].FileName,-1);
			sw=1;
			continue;
		}
		i4=GetFileSize(hFile,NULL);
		temporary=(char *)HeapAlloc(hHeap,0,i4);
		ReadFile(hFile,temporary,i4,(DWORD *)&i5,NULL);
		CloseHandle(hFile);

		pIconDir=(ICONDIR *)temporary;
		IconNum+=pIconDir->idCount;

		HeapDefaultFree(temporary);
	}

	//ファイルの読み込みに失敗した場合
	if(sw) return buffer;


	/////////////////////////
	// ディレクトリ エントリ
	/////////////////////////
	TypeNum=0;
	if(CursorResourceNum) TypeNum+=2;
	if(BitmapResourceNum) TypeNum++;
	if(IconResourceNum) TypeNum+=2;
	if(XPManiResourceNum) TypeNum++;

	NextBase=sizeof(IMAGE_RESOURCE_DIRECTORY)+
		sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)*TypeNum;

	//1階層
	IMAGE_RESOURCE_DIRECTORY ImgResDir;
	ImgResDir.Characteristics=0;
	ImgResDir.TimeDateStamp=0;
	ImgResDir.MajorVersion=0;
	ImgResDir.MinorVersion=0;
	ImgResDir.NumberOfNamedEntries=0;
	ImgResDir.NumberOfIdEntries=TypeNum;
	memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);

	i6=0;
	IMAGE_RESOURCE_DIRECTORY_ENTRY ImgDirEntry;
	if(CursorNum){
		//RT_CURSOR
		ImgDirEntry.Name=(DWORD)(LONG_PTR)RT_CURSOR;
		ImgDirEntry.OffsetToData=(NextBase+i6)|0x80000000;
		memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
		i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);

		//2階層のサイズ
		i6+=	sizeof(IMAGE_RESOURCE_DIRECTORY)+
				sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)*CursorNum;
	}
	if(BitmapResourceNum){
		//RT_BITMAP
		ImgDirEntry.Name=(DWORD)(LONG_PTR)RT_BITMAP;
		ImgDirEntry.OffsetToData=(NextBase+i6)|0x80000000;
		memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
		i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);

		//2階層のサイズ
		i6+=	sizeof(IMAGE_RESOURCE_DIRECTORY)+
				sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)*BitmapResourceNum;
	}
	if(IconNum){
		//RT_ICON
		ImgDirEntry.Name=(DWORD)(LONG_PTR)RT_ICON;
		ImgDirEntry.OffsetToData=(NextBase+i6)|0x80000000;
		memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
		i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);

		//2階層のサイズ
		i6+=	sizeof(IMAGE_RESOURCE_DIRECTORY)+
				sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)*IconNum;
	}
	if(CursorResourceNum){
		//RT_GROUP_CURSOR
		ImgDirEntry.Name=(DWORD)(LONG_PTR)RT_GROUP_CURSOR;
		ImgDirEntry.OffsetToData=(NextBase+i6)|0x80000000;
		memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
		i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);

		//2階層のサイズ
		i6+=	sizeof(IMAGE_RESOURCE_DIRECTORY)+
				sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)*CursorNum;
	}
	if(IconResourceNum){
		//RT_GROUP_ICON
		ImgDirEntry.Name=(DWORD)(LONG_PTR)RT_GROUP_ICON;
		ImgDirEntry.OffsetToData=(NextBase+i6)|0x80000000;
		memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
		i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);

		//2階層のサイズ
		i6+=	sizeof(IMAGE_RESOURCE_DIRECTORY)+
				sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)*IconResourceNum;
	}
	if(XPManiResourceNum){
		//RT_MANIFEST
		ImgDirEntry.Name=(DWORD)(LONG_PTR)RT_MANIFEST;
		ImgDirEntry.OffsetToData=(NextBase+i6)|0x80000000;
		memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
		i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);

		//2階層のサイズ
		i6+=	sizeof(IMAGE_RESOURCE_DIRECTORY)+
				sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)*XPManiResourceNum;
	}

	NextBase+=i6;

	//2階層
	i6=0;
	i7=0;
	if(CursorNum){
		//RT_CURSOR
		ImgResDir.Characteristics=0;
		ImgResDir.TimeDateStamp=0;
		ImgResDir.MajorVersion=0;
		ImgResDir.MinorVersion=0;
		ImgResDir.NumberOfNamedEntries=0;
		ImgResDir.NumberOfIdEntries=CursorNum;
		memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
		i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);

		for(i3=0;i3<CursorNum;i3++,i7++){
			ImgDirEntry.Name=i7+1;
			ImgDirEntry.OffsetToData=(NextBase+i6+
				(sizeof(IMAGE_RESOURCE_DIRECTORY)+
				sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*i3)
				|0x80000000;
			memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
		}

		//3階層のサイズ
		i6+=(sizeof(IMAGE_RESOURCE_DIRECTORY)+
			sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*CursorNum;
	}
	if(BitmapResourceNum){
		//RT_BITMAP
		ImgResDir.Characteristics=0;
		ImgResDir.TimeDateStamp=0;
		ImgResDir.MajorVersion=0;
		ImgResDir.MinorVersion=0;
		ImgResDir.NumberOfNamedEntries=0;
		ImgResDir.NumberOfIdEntries=BitmapResourceNum;
		memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
		i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);

		for(i3=0;i3<BitmapResourceNum;i3++){
			ImgDirEntry.Name=pBitmapResourceInfo[i3].dwId;
			ImgDirEntry.OffsetToData=(NextBase+i6+
				(sizeof(IMAGE_RESOURCE_DIRECTORY)+
				sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*i3)
				|0x80000000;
			memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
		}

		i6+=(sizeof(IMAGE_RESOURCE_DIRECTORY)+
			sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*BitmapResourceNum;
	}
	if(IconNum){
		//RT_ICON
		ImgResDir.Characteristics=0;
		ImgResDir.TimeDateStamp=0;
		ImgResDir.MajorVersion=0;
		ImgResDir.MinorVersion=0;
		ImgResDir.NumberOfNamedEntries=0;
		ImgResDir.NumberOfIdEntries=IconNum;
		memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
		i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);

		for(i3=0;i3<IconNum;i3++,i7++){
			ImgDirEntry.Name=i7+1;
			ImgDirEntry.OffsetToData=(NextBase+i6+
				(sizeof(IMAGE_RESOURCE_DIRECTORY)+
				sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*i3)
				|0x80000000;
			memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
		}

		//3階層のサイズ
		i6+=(sizeof(IMAGE_RESOURCE_DIRECTORY)+
			sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*IconNum;
	}
	if(CursorResourceNum){
		//RT_GROUP_CURSOR
		ImgResDir.Characteristics=0;
		ImgResDir.TimeDateStamp=0;
		ImgResDir.MajorVersion=0;
		ImgResDir.MinorVersion=0;
		ImgResDir.NumberOfNamedEntries=0;
		ImgResDir.NumberOfIdEntries=CursorResourceNum;
		memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
		i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);

		for(i3=0;i3<CursorResourceNum;i3++){
			ImgDirEntry.Name=pCursorResourceInfo[i3].dwId;
			ImgDirEntry.OffsetToData=(NextBase+i6+
				(sizeof(IMAGE_RESOURCE_DIRECTORY)+
				sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*i3)
				|0x80000000;
			memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
		}

		//3階層のサイズ
		i6+=(sizeof(IMAGE_RESOURCE_DIRECTORY)+
			sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*CursorResourceNum;
	}
	if(IconResourceNum){
		//RT_GROUP_ICON
		ImgResDir.Characteristics=0;
		ImgResDir.TimeDateStamp=0;
		ImgResDir.MajorVersion=0;
		ImgResDir.MinorVersion=0;
		ImgResDir.NumberOfNamedEntries=0;
		ImgResDir.NumberOfIdEntries=IconResourceNum;
		memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
		i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);

		for(i3=0;i3<IconResourceNum;i3++){
			ImgDirEntry.Name=pIconResourceInfo[i3].dwId;
			ImgDirEntry.OffsetToData=(NextBase+i6+
				(sizeof(IMAGE_RESOURCE_DIRECTORY)+
				sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*i3)
				|0x80000000;
			memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
		}

		//3階層のサイズ
		i6+=(sizeof(IMAGE_RESOURCE_DIRECTORY)+
			sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*IconResourceNum;
	}
	if(XPManiResourceNum){
		//RT_MANIFEST
		ImgResDir.Characteristics=0;
		ImgResDir.TimeDateStamp=0;
		ImgResDir.MajorVersion=0;
		ImgResDir.MinorVersion=0;
		ImgResDir.NumberOfNamedEntries=0;
		ImgResDir.NumberOfIdEntries=XPManiResourceNum;
		memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
		i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);

		for(i3=0;i3<XPManiResourceNum;i3++){
			ImgDirEntry.Name=i3+1;
			ImgDirEntry.OffsetToData=(NextBase+i6+
				(sizeof(IMAGE_RESOURCE_DIRECTORY)+
				sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*i3)
				|0x80000000;
			memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
		}

		i6+=(sizeof(IMAGE_RESOURCE_DIRECTORY)+
			sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*XPManiResourceNum;
	}


	NextBase+=i6;

	while(i2+8192>BufSize){
		BufSize+=8192;
		buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
	}

	//3階層
	i6=0;
	if(CursorNum){
		//RT_CURSOR
		for(i3=0;i3<CursorNum;i3++){
			ImgResDir.Characteristics=0;
			ImgResDir.TimeDateStamp=0;
			ImgResDir.MajorVersion=0;
			ImgResDir.MinorVersion=0;
			ImgResDir.NumberOfNamedEntries=0;
			ImgResDir.NumberOfIdEntries=1;
			memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);

			ImgDirEntry.Name=0x411;
			ImgDirEntry.OffsetToData=NextBase+i6+
				sizeof(IMAGE_RESOURCE_DATA_ENTRY)*i3;
			memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
		}

		i6+=sizeof(IMAGE_RESOURCE_DATA_ENTRY)*CursorNum;
	}
	if(BitmapResourceNum){
		//RT_BITMAP
		for(i3=0;i3<BitmapResourceNum;i3++){
			ImgResDir.Characteristics=0;
			ImgResDir.TimeDateStamp=0;
			ImgResDir.MajorVersion=0;
			ImgResDir.MinorVersion=0;
			ImgResDir.NumberOfNamedEntries=0;
			ImgResDir.NumberOfIdEntries=1;
			memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);

			ImgDirEntry.Name=0x411;
			ImgDirEntry.OffsetToData=NextBase+i6+
				sizeof(IMAGE_RESOURCE_DATA_ENTRY)*i3;
			memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
		}

		i6+=sizeof(IMAGE_RESOURCE_DATA_ENTRY)*BitmapResourceNum;
	}
	if(IconNum){
		//RT_ICON
		for(i3=0;i3<IconNum;i3++){
			ImgResDir.Characteristics=0;
			ImgResDir.TimeDateStamp=0;
			ImgResDir.MajorVersion=0;
			ImgResDir.MinorVersion=0;
			ImgResDir.NumberOfNamedEntries=0;
			ImgResDir.NumberOfIdEntries=1;
			memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);

			ImgDirEntry.Name=0x411;
			ImgDirEntry.OffsetToData=NextBase+i6+
				sizeof(IMAGE_RESOURCE_DATA_ENTRY)*i3;
			memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
		}

		i6+=sizeof(IMAGE_RESOURCE_DATA_ENTRY)*IconNum;
	}
	if(CursorResourceNum){
		//RT_GROUP_CURSOR
		for(i3=0;i3<CursorResourceNum;i3++){
			ImgResDir.Characteristics=0;
			ImgResDir.TimeDateStamp=0;
			ImgResDir.MajorVersion=0;
			ImgResDir.MinorVersion=0;
			ImgResDir.NumberOfNamedEntries=0;
			ImgResDir.NumberOfIdEntries=1;
			memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);

			ImgDirEntry.Name=0x411;
			ImgDirEntry.OffsetToData=NextBase+i6+
				sizeof(IMAGE_RESOURCE_DATA_ENTRY)*i3;
			memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
		}

		i6+=sizeof(IMAGE_RESOURCE_DATA_ENTRY)*CursorResourceNum;
	}
	if(IconResourceNum){
		//RT_GROUP_ICON
		for(i3=0;i3<IconResourceNum;i3++){
			ImgResDir.Characteristics=0;
			ImgResDir.TimeDateStamp=0;
			ImgResDir.MajorVersion=0;
			ImgResDir.MinorVersion=0;
			ImgResDir.NumberOfNamedEntries=0;
			ImgResDir.NumberOfIdEntries=1;
			memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);

			ImgDirEntry.Name=0x411;
			ImgDirEntry.OffsetToData=NextBase+i6+
				sizeof(IMAGE_RESOURCE_DATA_ENTRY)*i3;
			memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
		}

		i6+=sizeof(IMAGE_RESOURCE_DATA_ENTRY)*IconResourceNum;
	}
	if(XPManiResourceNum){
		//RT_MANIFEST
		for(i3=0;i3<XPManiResourceNum;i3++){
			ImgResDir.Characteristics=0;
			ImgResDir.TimeDateStamp=0;
			ImgResDir.MajorVersion=0;
			ImgResDir.MinorVersion=0;
			ImgResDir.NumberOfNamedEntries=0;
			ImgResDir.NumberOfIdEntries=1;
			memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);

			ImgDirEntry.Name=0x411;
			ImgDirEntry.OffsetToData=NextBase+i6+
				sizeof(IMAGE_RESOURCE_DATA_ENTRY)*i3;
			memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
			i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
		}

		i6+=sizeof(IMAGE_RESOURCE_DATA_ENTRY)*XPManiResourceNum;
	}

	NextBase+=i6;

	while(i2+8192>BufSize){
		BufSize+=8192;
		buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
	}



	////////////////////////////////////////
	// データ エントリ
	////////////////////////////////////////

	DWORD dwDataEntrySchedule[100];
	int DataEntryScheduleNum;
	int CursorEntryBase;
	int CursorGroupEntryBase;
	int BitmapEntryBase;
	int IconEntryBase;
	int IconGroupEntryBase;

	DataEntryScheduleNum=0;

	//空のデータエントリ領域を作成

	//RT_CURSOR
	CursorEntryBase=DataEntryScheduleNum;
	for(i3=0;i3<CursorNum;i3++){
		dwDataEntrySchedule[DataEntryScheduleNum]=i2;
		DataEntryScheduleNum++;
		memset(buffer+i2,0,sizeof(IMAGE_RESOURCE_DATA_ENTRY));
		i2+=sizeof(IMAGE_RESOURCE_DATA_ENTRY);
	}

	//RT_BITMAP
	BitmapEntryBase=DataEntryScheduleNum;
	for(i3=0;i3<BitmapResourceNum;i3++){
		dwDataEntrySchedule[DataEntryScheduleNum]=i2;
		DataEntryScheduleNum++;
		memset(buffer+i2,0,sizeof(IMAGE_RESOURCE_DATA_ENTRY));
		i2+=sizeof(IMAGE_RESOURCE_DATA_ENTRY);
	}

	//RT_ICON
	IconEntryBase=DataEntryScheduleNum;
	for(i3=0;i3<IconNum;i3++){
		dwDataEntrySchedule[DataEntryScheduleNum]=i2;
		DataEntryScheduleNum++;
		memset(buffer+i2,0,sizeof(IMAGE_RESOURCE_DATA_ENTRY));
		i2+=sizeof(IMAGE_RESOURCE_DATA_ENTRY);
	}

	//RT_GROUP_CURSOR
	CursorGroupEntryBase=DataEntryScheduleNum;
	for(i3=0;i3<CursorResourceNum;i3++){
		dwDataEntrySchedule[DataEntryScheduleNum]=i2;
		DataEntryScheduleNum++;
		memset(buffer+i2,0,sizeof(IMAGE_RESOURCE_DATA_ENTRY));
		i2+=sizeof(IMAGE_RESOURCE_DATA_ENTRY);
	}

	//RT_GROUP_ICON
	IconGroupEntryBase=DataEntryScheduleNum;
	for(i3=0;i3<IconResourceNum;i3++){
		dwDataEntrySchedule[DataEntryScheduleNum]=i2;
		DataEntryScheduleNum++;
		memset(buffer+i2,0,sizeof(IMAGE_RESOURCE_DATA_ENTRY));
		i2+=sizeof(IMAGE_RESOURCE_DATA_ENTRY);
	}

	//RT_MANIFEST
	int XPManiEntryBase;
	XPManiEntryBase=DataEntryScheduleNum;
	for(i3=0;i3<XPManiResourceNum;i3++){
		dwDataEntrySchedule[DataEntryScheduleNum]=i2;
		DataEntryScheduleNum++;
		memset(buffer+i2,0,sizeof(IMAGE_RESOURCE_DATA_ENTRY));
		i2+=sizeof(IMAGE_RESOURCE_DATA_ENTRY);
	}

	i4=i2%8;
	if(i4){
		memset(buffer+i2,0,8-i4);
		i2+=8-i4;
	}

	while(i2+8192>BufSize){
		BufSize+=8192;
		buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
	}


	///////////////////////////////////////
	// バイナリ データ
	// ※データエントリの内容も変更する
	///////////////////////////////////////

	IMAGE_RESOURCE_DATA_ENTRY *pImgDataEntry;

	i7=0;

	//カーソルリソース
	for(i3=0,i6=0;i3<CursorResourceNum;i3++){
		hFile=CreateFile(pCursorResourceInfo[i3].FileName,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
		if(hFile==INVALID_HANDLE_VALUE){
			compiler.errorMessenger.Output(23,pCursorResourceInfo[i3].FileName,-1);
			return buffer;
		}
		i4=GetFileSize(hFile,NULL);
		temporary=(char *)HeapAlloc(hHeap,0,i4);
		ReadFile(hFile,temporary,i4,(DWORD *)&i5,NULL);
		CloseHandle(hFile);

		pCursorDir=(CURSORDIR *)temporary;

		for(i5=0;i5<pCursorDir->idCount;i5++,i6++){
			pCursorDirEntry=(CURSORDIRENTRY *)(temporary+sizeof(CURSORDIR)+sizeof(CURSORDIRENTRY)*i5);

			//データエントリ
			pImgDataEntry=(IMAGE_RESOURCE_DATA_ENTRY *)(buffer+dwDataEntrySchedule[CursorEntryBase+i6]);
			pImgDataEntry->OffsetToData=i2;
			pImgDataEntry->Size=pCursorDirEntry->dwBytesInRes+sizeof(WORD)*2;
			AddRSrcAddrSchedule(dwDataEntrySchedule[CursorEntryBase+i6]);

			//RT_CURSOR バイナリ データ
			*(WORD *)(buffer+i2)=0x001F;
			i2+=sizeof(WORD);
			*(WORD *)(buffer+i2)=0x001F;
			i2+=sizeof(WORD);
			memcpy(buffer+i2,temporary+pCursorDirEntry->dwImageOffset,pCursorDirEntry->dwBytesInRes);
			i2+=pCursorDirEntry->dwBytesInRes;

			i4=i2%8;
			if(i4){
				memset(buffer+i2,0,8-i4);
				i2+=8-i4;
			}

			while(i2+8192>BufSize){
				BufSize+=8192;
				buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
			}
		}

		//データエントリ
		pImgDataEntry=(IMAGE_RESOURCE_DATA_ENTRY *)(buffer+dwDataEntrySchedule[CursorGroupEntryBase+i3]);
		pImgDataEntry->OffsetToData=i2;
		pImgDataEntry->Size=sizeof(CURSORDIR)+0xE*pCursorDir->idCount;
		AddRSrcAddrSchedule(dwDataEntrySchedule[CursorGroupEntryBase+i3]);

		//RT_GROUP_CURSORヘッダデータ（CURSORDIR）
		memcpy(buffer+i2,temporary,sizeof(CURSORDIR));
		i2+=sizeof(CURSORDIR);

		for(i5=0;i5<pCursorDir->idCount;i5++,i7++){
			pCursorDirEntry=(CURSORDIRENTRY *)(temporary+sizeof(CURSORDIR)+sizeof(CURSORDIRENTRY)*i5);
			CursorDirEntry_Res.wWidth=pCursorDirEntry->bWidth;
			CursorDirEntry_Res.wHeight=CursorDirEntry_Res.wWidth*2;
			CursorDirEntry_Res.wXHotspot=pCursorDirEntry->wXHotspot;
			CursorDirEntry_Res.wYHotspot=pCursorDirEntry->wYHotspot;
			CursorDirEntry_Res.dwBytesInRes=pCursorDirEntry->dwBytesInRes+sizeof(WORD)*2;
			CursorDirEntry_Res.wCursorNum=i7+1;

			//RT_GROUP_CURSORヘッダデータ（CURSORDIRENTRY_RES）
			memcpy(buffer+i2,&CursorDirEntry_Res,0xE);
			i2+=0xE;

			while(i2+8192>BufSize){
				BufSize+=8192;
				buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
			}
		}
		i4=i2%8;
		if(i4){
			memset(buffer+i2,0,8-i4);
			i2+=8-i4;
		}

		HeapDefaultFree(temporary);
	}

	//ビットマップリソース
	for(i3=0;i3<BitmapResourceNum;i3++){
		hFile=CreateFile(pBitmapResourceInfo[i3].FileName,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
		if(hFile==INVALID_HANDLE_VALUE){
			compiler.errorMessenger.Output(23,pBitmapResourceInfo[i3].FileName,-1);
			return buffer;
		}
		i4=GetFileSize(hFile,NULL);
		temporary=(char *)HeapAlloc(hHeap,0,i4);
		ReadFile(hFile,temporary,i4,(DWORD *)&i5,NULL);
		CloseHandle(hFile);

		BufSize+=i4;
		buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);

		//データエントリ
		pImgDataEntry=(IMAGE_RESOURCE_DATA_ENTRY *)(buffer+dwDataEntrySchedule[BitmapEntryBase+i3]);
		pImgDataEntry->OffsetToData=i2;
		pImgDataEntry->Size=i4-sizeof(BITMAPFILEHEADER);
		AddRSrcAddrSchedule(dwDataEntrySchedule[BitmapEntryBase+i3]);

		//RT_BITMAP バイナリ データ
		memcpy(buffer+i2,temporary+sizeof(BITMAPFILEHEADER),i4-sizeof(BITMAPFILEHEADER));
		i2+=i4-sizeof(BITMAPFILEHEADER);

		HeapDefaultFree(temporary);
	}

	//アイコンリソース
	for(i3=0,i6=0;i3<IconResourceNum;i3++){
		hFile=CreateFile(pIconResourceInfo[i3].FileName,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
		if(hFile==INVALID_HANDLE_VALUE){
			compiler.errorMessenger.Output(23,pIconResourceInfo[i3].FileName,-1);
			return buffer;
		}
		i4=GetFileSize(hFile,NULL);
		temporary=(char *)HeapAlloc(hHeap,0,i4);
		ReadFile(hFile,temporary,i4,(DWORD *)&i5,NULL);
		CloseHandle(hFile);

		pIconDir=(ICONDIR *)temporary;

		for(i5=0;i5<pIconDir->idCount;i5++,i6++){
			pIconDirEntry=(ICONDIRENTRY *)(temporary+sizeof(ICONDIR)+sizeof(ICONDIRENTRY)*i5);

			//データエントリ
			pImgDataEntry=(IMAGE_RESOURCE_DATA_ENTRY *)(buffer+dwDataEntrySchedule[IconEntryBase+i6]);
			pImgDataEntry->OffsetToData=i2;
			pImgDataEntry->Size=pIconDirEntry->dwBytesInRes;
			AddRSrcAddrSchedule(dwDataEntrySchedule[IconEntryBase+i6]);

			//RT_ICON バイナリ データ
			memcpy(buffer+i2,temporary+pIconDirEntry->dwImageOffset,pIconDirEntry->dwBytesInRes);
			i2+=pIconDirEntry->dwBytesInRes;

			i4=i2%8;
			if(i4){
				memset(buffer+i2,0,8-i4);
				i2+=8-i4;
			}

			while(i2+8192>BufSize){
				BufSize+=8192;
				buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
			}
		}

		//データエントリ
		pImgDataEntry=(IMAGE_RESOURCE_DATA_ENTRY *)(buffer+dwDataEntrySchedule[IconGroupEntryBase+i3]);
		pImgDataEntry->OffsetToData=i2;
		pImgDataEntry->Size=sizeof(ICONDIR)+0xE*pIconDir->idCount;
		AddRSrcAddrSchedule(dwDataEntrySchedule[IconGroupEntryBase+i3]);

		//RT_GROUP_ICONヘッダデータ（ICONDIR）
		memcpy(buffer+i2,temporary,sizeof(ICONDIR));
		i2+=sizeof(ICONDIR);

		for(i5=0;i5<pIconDir->idCount;i5++,i7++){
			pIconDirEntry=(ICONDIRENTRY *)(temporary+sizeof(ICONDIR)+sizeof(ICONDIRENTRY)*i5);
			IconDirEntry_Res.bWidth=pIconDirEntry->bWidth;
			IconDirEntry_Res.bHeight=pIconDirEntry->bHeight;
			IconDirEntry_Res.bColorCount=pIconDirEntry->bColorCount;
			IconDirEntry_Res.bReserved=0;
			IconDirEntry_Res.wPlanes=1;
			if(pIconDirEntry->bColorCount==16)
				IconDirEntry_Res.wBitCount=4;
			else if(pIconDirEntry->bColorCount==0)
				IconDirEntry_Res.wBitCount=8;
			IconDirEntry_Res.dwBytesInRes=pIconDirEntry->dwBytesInRes;
			IconDirEntry_Res.wIconNum=i7+1;

			//RT_GROUP_ICONヘッダデータ（ICONDIRENTRY_RES）
			memcpy(buffer+i2,&IconDirEntry_Res,0xE);
			i2+=0xE;

			while(i2+8192>BufSize){
				BufSize+=8192;
				buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
			}
		}
		i4=i2%8;
		if(i4){
			memset(buffer+i2,0,8-i4);
			i2+=8-i4;
		}

		HeapDefaultFree(temporary);
	}

	//XPManifestリソース
	for(i3=0;i3<XPManiResourceNum;i3++){
		extern char BasicCurDir[MAX_PATH];
		extern char szManifestPath[MAX_PATH];
		char temp2[MAX_PATH];
		lstrcpy(temp2,szManifestPath);
		GetFullPath(temp2,BasicCurDir);
		hFile=CreateFile(temp2,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
		if(hFile==INVALID_HANDLE_VALUE){
			compiler.errorMessenger.Output(59,temp2,-1);
			return buffer;
		}
		i4=GetFileSize(hFile,NULL);
		temporary=(char *)HeapAlloc(hHeap,0,i4+1);
		ReadFile(hFile,temporary,i4,(DWORD *)&i5,NULL);
		temporary[i4]=0;
		CloseHandle(hFile);

		//プラットフォームをセット
#ifdef _AMD64_
		temporary=PermutationString(temporary,"#PLATFORM#","amd64");
#else
		temporary=PermutationString(temporary,"#PLATFORM#","x86");
#endif

		//アプリケーション名をセット
		extern char OutputFileName[MAX_PATH];
		char szAppliName[MAX_PATH];
		_splitpath(OutputFileName,NULL,NULL,szAppliName,temp2);
		lstrcat(szAppliName,temp2);
		temporary=PermutationString(temporary,"#APPLI_FILE_NAME#",szAppliName);

		i4=lstrlen(temporary)+1;

		BufSize+=i4;
		buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);

		//データエントリ
		pImgDataEntry=(IMAGE_RESOURCE_DATA_ENTRY *)(buffer+dwDataEntrySchedule[XPManiEntryBase+i3]);
		pImgDataEntry->OffsetToData=i2;
		pImgDataEntry->Size=i4-1;	//※NULL文字はサイズに含めない
		AddRSrcAddrSchedule(dwDataEntrySchedule[XPManiEntryBase+i3]);

		//XMLデータ
		memcpy(buffer+i2,temporary,i4);
		i2+=i4;

		HeapDefaultFree(temporary);
	}

	*pLen=i2;

	return buffer;
}