Context Navigation

source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/RSrcSection.cpp@ 752

Last change on this file since 752 was 750, checked in by イグトランス (egtra), 16 years ago
BOOST_FOREACHを可能なものはVC++ 2005 for eachへ置換（やや速くなる）。
File size: 28.3 KB

Line
1	#include "stdafx.h"
2
3	#include "../BasicCompiler_Common/common.h"
4
5	#ifndef RT_MANIFEST
6	#define RT_MANIFEST MAKEINTRESOURCE(24)
7	#endif
8
9	//リソースアドレススケジュール
10	DWORD *lpdwRSrcAddrSchedule;
11	int RSrcAddrScheduleNum;
12
13	void AddRSrcAddrSchedule(DWORD pos){
14	extern HANDLE hHeap;
15
16	//グローバル変数アドレススケジュールに追加する
17	lpdwRSrcAddrSchedule=(DWORD )HeapReAlloc(hHeap,0,lpdwRSrcAddrSchedule,(RSrcAddrScheduleNum+1)sizeof(DWORD));
18	lpdwRSrcAddrSchedule[RSrcAddrScheduleNum]=pos;
19	RSrcAddrScheduleNum++;
20	}
21
22	char PermutationString(char buffer,char lpszSearch,char lpszRewrite){
23	//バッファ長
24	int length;
25	length=lstrlen(buffer);
26
27	//サーチ文字列の長さ
28	int search_length;
29	search_length=lstrlen(lpszSearch);
30
31	//置換文字列の長さ
32	int write_length;
33	write_length=lstrlen(lpszRewrite);
34
35	//置換時オフセット
36	int offset;
37	offset=lstrlen(lpszRewrite)-search_length;
38
39	int i;
40	for(i=0;i<length-search_length;i++){
41	if(memcmp(buffer+i,lpszSearch,search_length)==0){
42	if(offset>0){
43	length+=offset;
44	buffer=(char *)HeapReAlloc(hHeap,0,buffer,length+1);
45	}
46
47	SlideString(buffer+i+search_length,offset);
48	memcpy(buffer+i,lpszRewrite,write_length);
49	i+=write_length-1;
50	}
51	}
52
53	return buffer;
54	}
55
56	char GetRSrcSectionBuffer(int pLen){
57	extern HANDLE hHeap;
58	char buffer,temporary;
59	int i2,i3,i4,i5,i6,i7,sw,BufSize,TypeNum,NextBase;
60	HANDLE hFile;
61
62	//カーソルリソース
63	int CursorNum;
64	CURSORDIR *pCursorDir;
65	CURSORDIRENTRY *pCursorDirEntry;
66	CURSORDIRENTRY_RES CursorDirEntry_Res;
67	CursorNum=0;
68
69	//アイコンリソース
70	int IconNum;
71	ICONDIR *pIconDir;
72	ICONDIRENTRY *pIconDirEntry;
73	ICONDIRENTRY_RES IconDirEntry_Res;
74	IconNum=0;
75
76	BufSize=8192*2;
77	buffer=(char *)HeapAlloc(hHeap,0,BufSize);
78	i2=0;
79	NextBase=0;
80
81	//リソースアドレススケジュール
82	lpdwRSrcAddrSchedule=(DWORD *)HeapAlloc(hHeap,0,1);
83	RSrcAddrScheduleNum=0;
84
85	*pLen=0;
86
87	if( compiler.resourceManager.cursorResources.empty()
88	&& compiler.resourceManager.bitmapResources.empty()
89	&& compiler.resourceManager.iconResources.empty()
90	&& compiler.resourceManager.manifestFilePath.empty() )
91	{
92	return buffer;
93	}
94
95	sw=0;
96
97	//カーソルの枚数を計算（CursorNumに格納）
98	foreach( const ActiveBasic::Common::ResourceItem &resourceItem, compiler.resourceManager.cursorResources )
99	{
100	hFile=CreateFile(resourceItem.filepath.c_str(),GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
101	if(hFile==INVALID_HANDLE_VALUE){
102	compiler.errorMessenger.Output(23,resourceItem.filepath.c_str(),-1);
103	sw=1;
104	continue;
105	}
106	i4=GetFileSize(hFile,NULL);
107	temporary=(char *)HeapAlloc(hHeap,0,i4);
108	ReadFile(hFile,temporary,i4,(DWORD *)&i5,NULL);
109	CloseHandle(hFile);
110
111	pCursorDir=(CURSORDIR *)temporary;
112	CursorNum+=pCursorDir->idCount;
113
114	HeapDefaultFree(temporary);
115	}
116
117	//ビットマップのファイルの有無を確認
118	foreach( const ActiveBasic::Common::ResourceItem &resourceItem, compiler.resourceManager.bitmapResources )
119	{
120	hFile=CreateFile(resourceItem.filepath.c_str(),GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
121	if(hFile==INVALID_HANDLE_VALUE){
122	compiler.errorMessenger.Output(23,resourceItem.filepath.c_str(),-1);
123	sw=1;
124	continue;
125	}
126	CloseHandle(hFile);
127	}
128
129	//アイコンの枚数を計算（IconNumに格納）
130	foreach( const ActiveBasic::Common::ResourceItem &resourceItem, compiler.resourceManager.iconResources )
131	{
132	hFile=CreateFile(resourceItem.filepath.c_str(),GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
133	if(hFile==INVALID_HANDLE_VALUE){
134	compiler.errorMessenger.Output(23,resourceItem.filepath.c_str(),-1);
135	sw=1;
136	continue;
137	}
138	i4=GetFileSize(hFile,NULL);
139	temporary=(char *)HeapAlloc(hHeap,0,i4);
140	ReadFile(hFile,temporary,i4,(DWORD *)&i5,NULL);
141	CloseHandle(hFile);
142
143	pIconDir=(ICONDIR *)temporary;
144	IconNum+=pIconDir->idCount;
145
146	HeapDefaultFree(temporary);
147	}
148
149	//ファイルの読み込みに失敗した場合
150	if(sw) return buffer;
151
152
153	/////////////////////////
154	// ディレクトリエントリ
155	/////////////////////////
156	TypeNum=0;
157	if( !compiler.resourceManager.cursorResources.empty() ) TypeNum+=2;
158	if( !compiler.resourceManager.bitmapResources.empty() ) TypeNum++;
159	if( !compiler.resourceManager.iconResources.empty() ) TypeNum+=2;
160	if( !compiler.resourceManager.manifestFilePath.empty() ) TypeNum++;
161
162	NextBase=sizeof(IMAGE_RESOURCE_DIRECTORY)+
163	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)*TypeNum;
164
165	//1階層
166	IMAGE_RESOURCE_DIRECTORY ImgResDir;
167	ImgResDir.Characteristics=0;
168	ImgResDir.TimeDateStamp=0;
169	ImgResDir.MajorVersion=0;
170	ImgResDir.MinorVersion=0;
171	ImgResDir.NumberOfNamedEntries=0;
172	ImgResDir.NumberOfIdEntries=TypeNum;
173	memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
174	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);
175
176	i6=0;
177	IMAGE_RESOURCE_DIRECTORY_ENTRY ImgDirEntry;
178	if(CursorNum){
179	//RT_CURSOR
180	ImgDirEntry.Name=(DWORD)(LONG_PTR)RT_CURSOR;
181	ImgDirEntry.OffsetToData=(NextBase+i6)\|0x80000000;
182	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
183	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
184
185	//2階層のサイズ
186	i6+= sizeof(IMAGE_RESOURCE_DIRECTORY)+
187	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)*CursorNum;
188	}
189	if( !compiler.resourceManager.bitmapResources.empty() ){
190	//RT_BITMAP
191	ImgDirEntry.Name=(DWORD)(LONG_PTR)RT_BITMAP;
192	ImgDirEntry.OffsetToData=(NextBase+i6)\|0x80000000;
193	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
194	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
195
196	//2階層のサイズ
197	i6+= sizeof(IMAGE_RESOURCE_DIRECTORY)+
198	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY) * compiler.resourceManager.bitmapResources.size();
199	}
200	if(IconNum){
201	//RT_ICON
202	ImgDirEntry.Name=(DWORD)(LONG_PTR)RT_ICON;
203	ImgDirEntry.OffsetToData=(NextBase+i6)\|0x80000000;
204	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
205	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
206
207	//2階層のサイズ
208	i6+= sizeof(IMAGE_RESOURCE_DIRECTORY)+
209	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)*IconNum;
210	}
211	if( !compiler.resourceManager.cursorResources.empty() )
212	{
213	//RT_GROUP_CURSOR
214	ImgDirEntry.Name=(DWORD)(LONG_PTR)RT_GROUP_CURSOR;
215	ImgDirEntry.OffsetToData=(NextBase+i6)\|0x80000000;
216	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
217	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
218
219	//2階層のサイズ
220	i6+= sizeof(IMAGE_RESOURCE_DIRECTORY)+
221	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)*CursorNum;
222	}
223	if( !compiler.resourceManager.iconResources.empty() )
224	{
225	//RT_GROUP_ICON
226	ImgDirEntry.Name=(DWORD)(LONG_PTR)RT_GROUP_ICON;
227	ImgDirEntry.OffsetToData=(NextBase+i6)\|0x80000000;
228	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
229	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
230
231	//2階層のサイズ
232	i6+= sizeof(IMAGE_RESOURCE_DIRECTORY)+
233	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY) * compiler.resourceManager.iconResources.size();
234	}
235	if( !compiler.resourceManager.manifestFilePath.empty() )
236	{
237	//RT_MANIFEST
238	ImgDirEntry.Name=(DWORD)(LONG_PTR)RT_MANIFEST;
239	ImgDirEntry.OffsetToData=(NextBase+i6)\|0x80000000;
240	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
241	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
242
243	//2階層のサイズ
244	i6+= sizeof(IMAGE_RESOURCE_DIRECTORY)+
245	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY) * 1/XPManiResourceNum/ ;
246	}
247
248	NextBase+=i6;
249
250	//2階層
251	i6=0;
252	i7=0;
253	if(CursorNum){
254	//RT_CURSOR
255	ImgResDir.Characteristics=0;
256	ImgResDir.TimeDateStamp=0;
257	ImgResDir.MajorVersion=0;
258	ImgResDir.MinorVersion=0;
259	ImgResDir.NumberOfNamedEntries=0;
260	ImgResDir.NumberOfIdEntries=CursorNum;
261	memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
262	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);
263
264	for(i3=0;i3<CursorNum;i3++,i7++){
265	ImgDirEntry.Name=i7+1;
266	ImgDirEntry.OffsetToData=(NextBase+i6+
267	(sizeof(IMAGE_RESOURCE_DIRECTORY)+
268	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*i3)
269	\|0x80000000;
270	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
271	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
272	}
273
274	//3階層のサイズ
275	i6+=(sizeof(IMAGE_RESOURCE_DIRECTORY)+
276	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*CursorNum;
277	}
278	if( !compiler.resourceManager.bitmapResources.empty() ){
279	//RT_BITMAP
280	ImgResDir.Characteristics=0;
281	ImgResDir.TimeDateStamp=0;
282	ImgResDir.MajorVersion=0;
283	ImgResDir.MinorVersion=0;
284	ImgResDir.NumberOfNamedEntries=0;
285	ImgResDir.NumberOfIdEntries = compiler.resourceManager.bitmapResources.size();
286	memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
287	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);
288
289	for(i3=0;i3<static_cast<int>(compiler.resourceManager.bitmapResources.size());i3++)
290	{
291	ImgDirEntry.Name = static_cast<DWORD>(compiler.GetObjectModule().meta.GetGlobalConsts().GetWholeData(
292	ActiveBasic::Compiler::LexicalAnalyzer::FullNameToSymbol(
293	compiler.resourceManager.bitmapResources[i3].idName
294	)
295	));
296	ImgDirEntry.OffsetToData=(NextBase+i6+
297	(sizeof(IMAGE_RESOURCE_DIRECTORY)+
298	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*i3)
299	\|0x80000000;
300	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
301	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
302	}
303
304	i6+=(sizeof(IMAGE_RESOURCE_DIRECTORY)+
305	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)) * compiler.resourceManager.bitmapResources.size();
306	}
307	if(IconNum){
308	//RT_ICON
309	ImgResDir.Characteristics=0;
310	ImgResDir.TimeDateStamp=0;
311	ImgResDir.MajorVersion=0;
312	ImgResDir.MinorVersion=0;
313	ImgResDir.NumberOfNamedEntries=0;
314	ImgResDir.NumberOfIdEntries=IconNum;
315	memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
316	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);
317
318	for(i3=0;i3<IconNum;i3++,i7++){
319	ImgDirEntry.Name=i7+1;
320	ImgDirEntry.OffsetToData=(NextBase+i6+
321	(sizeof(IMAGE_RESOURCE_DIRECTORY)+
322	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*i3)
323	\|0x80000000;
324	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
325	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
326	}
327
328	//3階層のサイズ
329	i6+=(sizeof(IMAGE_RESOURCE_DIRECTORY)+
330	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*IconNum;
331	}
332	if( !compiler.resourceManager.cursorResources.empty() )
333	{
334	//RT_GROUP_CURSOR
335	ImgResDir.Characteristics=0;
336	ImgResDir.TimeDateStamp=0;
337	ImgResDir.MajorVersion=0;
338	ImgResDir.MinorVersion=0;
339	ImgResDir.NumberOfNamedEntries=0;
340	ImgResDir.NumberOfIdEntries = compiler.resourceManager.cursorResources.size();
341	memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
342	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);
343
344	for(i3=0;i3<static_cast<int>(compiler.resourceManager.cursorResources.size());i3++){
345	ImgDirEntry.Name = static_cast<DWORD>(compiler.GetObjectModule().meta.GetGlobalConsts().GetWholeData(
346	ActiveBasic::Compiler::LexicalAnalyzer::FullNameToSymbol(
347	compiler.resourceManager.cursorResources[i3].idName
348	)
349	));
350	ImgDirEntry.OffsetToData=(NextBase+i6+
351	(sizeof(IMAGE_RESOURCE_DIRECTORY)+
352	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*i3)
353	\|0x80000000;
354	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
355	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
356	}
357
358	//3階層のサイズ
359	i6+=(sizeof(IMAGE_RESOURCE_DIRECTORY)+
360	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)) * compiler.resourceManager.cursorResources.size();
361	}
362	if( !compiler.resourceManager.iconResources.empty() )
363	{
364	//RT_GROUP_ICON
365	ImgResDir.Characteristics=0;
366	ImgResDir.TimeDateStamp=0;
367	ImgResDir.MajorVersion=0;
368	ImgResDir.MinorVersion=0;
369	ImgResDir.NumberOfNamedEntries=0;
370	ImgResDir.NumberOfIdEntries = compiler.resourceManager.iconResources.size();
371	memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
372	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);
373
374	for(i3=0;i3<static_cast<int>(compiler.resourceManager.iconResources.size());i3++){
375	ImgDirEntry.Name = static_cast<DWORD>(compiler.GetObjectModule().meta.GetGlobalConsts().GetWholeData(
376	ActiveBasic::Compiler::LexicalAnalyzer::FullNameToSymbol(
377	compiler.resourceManager.iconResources[i3].idName
378	)
379	));
380	ImgDirEntry.OffsetToData=(NextBase+i6+
381	(sizeof(IMAGE_RESOURCE_DIRECTORY)+
382	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*i3)
383	\|0x80000000;
384	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
385	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
386	}
387
388	//3階層のサイズ
389	i6+=(sizeof(IMAGE_RESOURCE_DIRECTORY)+
390	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)) * compiler.resourceManager.iconResources.size();
391	}
392	if( !compiler.resourceManager.manifestFilePath.empty() )
393	{
394	//RT_MANIFEST
395	ImgResDir.Characteristics=0;
396	ImgResDir.TimeDateStamp=0;
397	ImgResDir.MajorVersion=0;
398	ImgResDir.MinorVersion=0;
399	ImgResDir.NumberOfNamedEntries=0;
400	ImgResDir.NumberOfIdEntries = 1 /XPManiResourceNum/ ;
401	memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
402	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);
403
404	i3 = 0;
405	{
406	ImgDirEntry.Name=i3+1;
407	ImgDirEntry.OffsetToData=(NextBase+i6+
408	(sizeof(IMAGE_RESOURCE_DIRECTORY)+
409	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY))*i3)
410	\|0x80000000;
411	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
412	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
413	}
414
415	i6+=(sizeof(IMAGE_RESOURCE_DIRECTORY)+
416	sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY)) * 1 /XPManiResourceNum/ ;
417	}
418
419
420	NextBase+=i6;
421
422	while(i2+8192>BufSize){
423	BufSize+=8192;
424	buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
425	}
426
427	//3階層
428	i6=0;
429	if(CursorNum){
430	//RT_CURSOR
431	for(i3=0;i3<CursorNum;i3++){
432	ImgResDir.Characteristics=0;
433	ImgResDir.TimeDateStamp=0;
434	ImgResDir.MajorVersion=0;
435	ImgResDir.MinorVersion=0;
436	ImgResDir.NumberOfNamedEntries=0;
437	ImgResDir.NumberOfIdEntries=1;
438	memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
439	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);
440
441	ImgDirEntry.Name=0x411;
442	ImgDirEntry.OffsetToData=NextBase+i6+
443	sizeof(IMAGE_RESOURCE_DATA_ENTRY)*i3;
444	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
445	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
446	}
447
448	i6+=sizeof(IMAGE_RESOURCE_DATA_ENTRY)*CursorNum;
449	}
450	if( !compiler.resourceManager.bitmapResources.empty() ){
451	//RT_BITMAP
452	for(i3=0;i3<static_cast<int>(compiler.resourceManager.bitmapResources.size());i3++){
453	ImgResDir.Characteristics=0;
454	ImgResDir.TimeDateStamp=0;
455	ImgResDir.MajorVersion=0;
456	ImgResDir.MinorVersion=0;
457	ImgResDir.NumberOfNamedEntries=0;
458	ImgResDir.NumberOfIdEntries=1;
459	memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
460	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);
461
462	ImgDirEntry.Name=0x411;
463	ImgDirEntry.OffsetToData=NextBase+i6+
464	sizeof(IMAGE_RESOURCE_DATA_ENTRY)*i3;
465	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
466	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
467	}
468
469	i6+=sizeof(IMAGE_RESOURCE_DATA_ENTRY) * compiler.resourceManager.bitmapResources.size();
470	}
471	if(IconNum){
472	//RT_ICON
473	for(i3=0;i3<IconNum;i3++){
474	ImgResDir.Characteristics=0;
475	ImgResDir.TimeDateStamp=0;
476	ImgResDir.MajorVersion=0;
477	ImgResDir.MinorVersion=0;
478	ImgResDir.NumberOfNamedEntries=0;
479	ImgResDir.NumberOfIdEntries=1;
480	memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
481	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);
482
483	ImgDirEntry.Name=0x411;
484	ImgDirEntry.OffsetToData=NextBase+i6+
485	sizeof(IMAGE_RESOURCE_DATA_ENTRY)*i3;
486	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
487	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
488	}
489
490	i6+=sizeof(IMAGE_RESOURCE_DATA_ENTRY)*IconNum;
491	}
492	if( !compiler.resourceManager.cursorResources.empty() )
493	{
494	//RT_GROUP_CURSOR
495	for(i3=0;i3<static_cast<int>(compiler.resourceManager.cursorResources.size());i3++){
496	ImgResDir.Characteristics=0;
497	ImgResDir.TimeDateStamp=0;
498	ImgResDir.MajorVersion=0;
499	ImgResDir.MinorVersion=0;
500	ImgResDir.NumberOfNamedEntries=0;
501	ImgResDir.NumberOfIdEntries=1;
502	memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
503	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);
504
505	ImgDirEntry.Name=0x411;
506	ImgDirEntry.OffsetToData=NextBase+i6+
507	sizeof(IMAGE_RESOURCE_DATA_ENTRY)*i3;
508	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
509	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
510	}
511
512	i6+=sizeof(IMAGE_RESOURCE_DATA_ENTRY) * compiler.resourceManager.cursorResources.size();
513	}
514	if( !compiler.resourceManager.iconResources.empty() )
515	{
516	//RT_GROUP_ICON
517	for(i3=0;i3<static_cast<int>(compiler.resourceManager.iconResources.size());i3++){
518	ImgResDir.Characteristics=0;
519	ImgResDir.TimeDateStamp=0;
520	ImgResDir.MajorVersion=0;
521	ImgResDir.MinorVersion=0;
522	ImgResDir.NumberOfNamedEntries=0;
523	ImgResDir.NumberOfIdEntries=1;
524	memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
525	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);
526
527	ImgDirEntry.Name=0x411;
528	ImgDirEntry.OffsetToData=NextBase+i6+
529	sizeof(IMAGE_RESOURCE_DATA_ENTRY)*i3;
530	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
531	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
532	}
533
534	i6+=sizeof(IMAGE_RESOURCE_DATA_ENTRY)*compiler.resourceManager.iconResources.size();
535	}
536	if( !compiler.resourceManager.manifestFilePath.empty() ){
537	//RT_MANIFEST
538	i3 = 0;
539	{
540	ImgResDir.Characteristics=0;
541	ImgResDir.TimeDateStamp=0;
542	ImgResDir.MajorVersion=0;
543	ImgResDir.MinorVersion=0;
544	ImgResDir.NumberOfNamedEntries=0;
545	ImgResDir.NumberOfIdEntries=1;
546	memcpy(buffer+i2,&ImgResDir,sizeof(IMAGE_RESOURCE_DIRECTORY));
547	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY);
548
549	ImgDirEntry.Name=0x411;
550	ImgDirEntry.OffsetToData=NextBase+i6+
551	sizeof(IMAGE_RESOURCE_DATA_ENTRY)*i3;
552	memcpy(buffer+i2,&ImgDirEntry,sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY));
553	i2+=sizeof(IMAGE_RESOURCE_DIRECTORY_ENTRY);
554	}
555
556	i6+=sizeof(IMAGE_RESOURCE_DATA_ENTRY) * 1 /XPManiResourceNum/ ;
557	}
558
559	NextBase+=i6;
560
561	while(i2+8192>BufSize){
562	BufSize+=8192;
563	buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
564	}
565
566
567
568	////////////////////////////////////////
569	// データエントリ
570	////////////////////////////////////////
571
572	DWORD dwDataEntrySchedule[100];
573	int DataEntryScheduleNum;
574	int CursorEntryBase;
575	int CursorGroupEntryBase;
576	int BitmapEntryBase;
577	int IconEntryBase;
578	int IconGroupEntryBase;
579
580	DataEntryScheduleNum=0;
581
582	//空のデータエントリ領域を作成
583
584	//RT_CURSOR
585	CursorEntryBase=DataEntryScheduleNum;
586	for(i3=0;i3<CursorNum;i3++){
587	dwDataEntrySchedule[DataEntryScheduleNum]=i2;
588	DataEntryScheduleNum++;
589	memset(buffer+i2,0,sizeof(IMAGE_RESOURCE_DATA_ENTRY));
590	i2+=sizeof(IMAGE_RESOURCE_DATA_ENTRY);
591	}
592
593	//RT_BITMAP
594	BitmapEntryBase=DataEntryScheduleNum;
595	for(i3=0;i3<static_cast<int>(compiler.resourceManager.bitmapResources.size());i3++){
596	dwDataEntrySchedule[DataEntryScheduleNum]=i2;
597	DataEntryScheduleNum++;
598	memset(buffer+i2,0,sizeof(IMAGE_RESOURCE_DATA_ENTRY));
599	i2+=sizeof(IMAGE_RESOURCE_DATA_ENTRY);
600	}
601
602	//RT_ICON
603	IconEntryBase=DataEntryScheduleNum;
604	for(i3=0;i3<IconNum;i3++){
605	dwDataEntrySchedule[DataEntryScheduleNum]=i2;
606	DataEntryScheduleNum++;
607	memset(buffer+i2,0,sizeof(IMAGE_RESOURCE_DATA_ENTRY));
608	i2+=sizeof(IMAGE_RESOURCE_DATA_ENTRY);
609	}
610
611	//RT_GROUP_CURSOR
612	CursorGroupEntryBase=DataEntryScheduleNum;
613	for(i3=0;i3<static_cast<int>(compiler.resourceManager.cursorResources.size());i3++){
614	dwDataEntrySchedule[DataEntryScheduleNum]=i2;
615	DataEntryScheduleNum++;
616	memset(buffer+i2,0,sizeof(IMAGE_RESOURCE_DATA_ENTRY));
617	i2+=sizeof(IMAGE_RESOURCE_DATA_ENTRY);
618	}
619
620	//RT_GROUP_ICON
621	IconGroupEntryBase=DataEntryScheduleNum;
622	for(i3=0;i3<static_cast<int>(compiler.resourceManager.iconResources.size());i3++){
623	dwDataEntrySchedule[DataEntryScheduleNum]=i2;
624	DataEntryScheduleNum++;
625	memset(buffer+i2,0,sizeof(IMAGE_RESOURCE_DATA_ENTRY));
626	i2+=sizeof(IMAGE_RESOURCE_DATA_ENTRY);
627	}
628
629	//RT_MANIFEST
630	int XPManiEntryBase;
631	XPManiEntryBase=DataEntryScheduleNum;
632	i3 = 0;
633	{
634	dwDataEntrySchedule[DataEntryScheduleNum]=i2;
635	DataEntryScheduleNum++;
636	memset(buffer+i2,0,sizeof(IMAGE_RESOURCE_DATA_ENTRY));
637	i2+=sizeof(IMAGE_RESOURCE_DATA_ENTRY);
638	}
639
640	i4=i2%8;
641	if(i4){
642	memset(buffer+i2,0,8-i4);
643	i2+=8-i4;
644	}
645
646	while(i2+8192>BufSize){
647	BufSize+=8192;
648	buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
649	}
650
651
652	///////////////////////////////////////
653	// バイナリデータ
654	// ※データエントリの内容も変更する
655	///////////////////////////////////////
656
657	IMAGE_RESOURCE_DATA_ENTRY *pImgDataEntry;
658
659	i7=0;
660
661	//カーソルリソース
662	for(i3=0,i6=0;i3<static_cast<int>(compiler.resourceManager.cursorResources.size());i3++){
663	hFile=CreateFile(compiler.resourceManager.cursorResources[i3].filepath.c_str(),GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
664	if(hFile==INVALID_HANDLE_VALUE){
665	compiler.errorMessenger.Output(23,compiler.resourceManager.cursorResources[i3].filepath.c_str(),-1);
666	return buffer;
667	}
668	i4=GetFileSize(hFile,NULL);
669	temporary=(char *)HeapAlloc(hHeap,0,i4);
670	ReadFile(hFile,temporary,i4,(DWORD *)&i5,NULL);
671	CloseHandle(hFile);
672
673	pCursorDir=(CURSORDIR *)temporary;
674
675	for(i5=0;i5<pCursorDir->idCount;i5++,i6++){
676	pCursorDirEntry=(CURSORDIRENTRY )(temporary+sizeof(CURSORDIR)+sizeof(CURSORDIRENTRY)i5);
677
678	//データエントリ
679	pImgDataEntry=(IMAGE_RESOURCE_DATA_ENTRY *)(buffer+dwDataEntrySchedule[CursorEntryBase+i6]);
680	pImgDataEntry->OffsetToData=i2;
681	pImgDataEntry->Size=pCursorDirEntry->dwBytesInRes+sizeof(WORD)*2;
682	AddRSrcAddrSchedule(dwDataEntrySchedule[CursorEntryBase+i6]);
683
684	//RT_CURSOR バイナリデータ
685	(WORD )(buffer+i2)=0x001F;
686	i2+=sizeof(WORD);
687	(WORD )(buffer+i2)=0x001F;
688	i2+=sizeof(WORD);
689	memcpy(buffer+i2,temporary+pCursorDirEntry->dwImageOffset,pCursorDirEntry->dwBytesInRes);
690	i2+=pCursorDirEntry->dwBytesInRes;
691
692	i4=i2%8;
693	if(i4){
694	memset(buffer+i2,0,8-i4);
695	i2+=8-i4;
696	}
697
698	while(i2+8192>BufSize){
699	BufSize+=8192;
700	buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
701	}
702	}
703
704	//データエントリ
705	pImgDataEntry=(IMAGE_RESOURCE_DATA_ENTRY *)(buffer+dwDataEntrySchedule[CursorGroupEntryBase+i3]);
706	pImgDataEntry->OffsetToData=i2;
707	pImgDataEntry->Size=sizeof(CURSORDIR)+0xE*pCursorDir->idCount;
708	AddRSrcAddrSchedule(dwDataEntrySchedule[CursorGroupEntryBase+i3]);
709
710	//RT_GROUP_CURSORヘッダデータ（CURSORDIR）
711	memcpy(buffer+i2,temporary,sizeof(CURSORDIR));
712	i2+=sizeof(CURSORDIR);
713
714	for(i5=0;i5<pCursorDir->idCount;i5++,i7++){
715	pCursorDirEntry=(CURSORDIRENTRY )(temporary+sizeof(CURSORDIR)+sizeof(CURSORDIRENTRY)i5);
716	CursorDirEntry_Res.wWidth=pCursorDirEntry->bWidth;
717	CursorDirEntry_Res.wHeight=CursorDirEntry_Res.wWidth*2;
718	CursorDirEntry_Res.wXHotspot=pCursorDirEntry->wXHotspot;
719	CursorDirEntry_Res.wYHotspot=pCursorDirEntry->wYHotspot;
720	CursorDirEntry_Res.dwBytesInRes=pCursorDirEntry->dwBytesInRes+sizeof(WORD)*2;
721	CursorDirEntry_Res.wCursorNum=i7+1;
722
723	//RT_GROUP_CURSORヘッダデータ（CURSORDIRENTRY_RES）
724	memcpy(buffer+i2,&CursorDirEntry_Res,0xE);
725	i2+=0xE;
726
727	while(i2+8192>BufSize){
728	BufSize+=8192;
729	buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
730	}
731	}
732	i4=i2%8;
733	if(i4){
734	memset(buffer+i2,0,8-i4);
735	i2+=8-i4;
736	}
737
738	HeapDefaultFree(temporary);
739	}
740
741	//ビットマップリソース
742	for(i3=0;i3<static_cast<int>(compiler.resourceManager.bitmapResources.size());i3++){
743	hFile=CreateFile(compiler.resourceManager.bitmapResources[i3].filepath.c_str(),GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
744	if(hFile==INVALID_HANDLE_VALUE){
745	compiler.errorMessenger.Output(23,compiler.resourceManager.bitmapResources[i3].filepath.c_str(),-1);
746	return buffer;
747	}
748	i4=GetFileSize(hFile,NULL);
749	temporary=(char *)HeapAlloc(hHeap,0,i4);
750	ReadFile(hFile,temporary,i4,(DWORD *)&i5,NULL);
751	CloseHandle(hFile);
752
753	BufSize+=i4;
754	buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
755
756	//データエントリ
757	pImgDataEntry=(IMAGE_RESOURCE_DATA_ENTRY *)(buffer+dwDataEntrySchedule[BitmapEntryBase+i3]);
758	pImgDataEntry->OffsetToData=i2;
759	pImgDataEntry->Size=i4-sizeof(BITMAPFILEHEADER);
760	AddRSrcAddrSchedule(dwDataEntrySchedule[BitmapEntryBase+i3]);
761
762	//RT_BITMAP バイナリデータ
763	memcpy(buffer+i2,temporary+sizeof(BITMAPFILEHEADER),i4-sizeof(BITMAPFILEHEADER));
764	i2+=i4-sizeof(BITMAPFILEHEADER);
765
766	HeapDefaultFree(temporary);
767	}
768
769	//アイコンリソース
770	for(i3=0,i6=0;i3<static_cast<int>(compiler.resourceManager.iconResources.size());i3++){
771	hFile=CreateFile(compiler.resourceManager.iconResources[i3].filepath.c_str(),GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
772	if(hFile==INVALID_HANDLE_VALUE){
773	compiler.errorMessenger.Output(23,compiler.resourceManager.iconResources[i3].filepath.c_str(),-1);
774	return buffer;
775	}
776	i4=GetFileSize(hFile,NULL);
777	temporary=(char *)HeapAlloc(hHeap,0,i4);
778	ReadFile(hFile,temporary,i4,(DWORD *)&i5,NULL);
779	CloseHandle(hFile);
780
781	pIconDir=(ICONDIR *)temporary;
782
783	for(i5=0;i5<pIconDir->idCount;i5++,i6++){
784	pIconDirEntry=(ICONDIRENTRY )(temporary+sizeof(ICONDIR)+sizeof(ICONDIRENTRY)i5);
785
786	//データエントリ
787	pImgDataEntry=(IMAGE_RESOURCE_DATA_ENTRY *)(buffer+dwDataEntrySchedule[IconEntryBase+i6]);
788	pImgDataEntry->OffsetToData=i2;
789	pImgDataEntry->Size=pIconDirEntry->dwBytesInRes;
790	AddRSrcAddrSchedule(dwDataEntrySchedule[IconEntryBase+i6]);
791
792	//RT_ICON バイナリデータ
793	memcpy(buffer+i2,temporary+pIconDirEntry->dwImageOffset,pIconDirEntry->dwBytesInRes);
794	i2+=pIconDirEntry->dwBytesInRes;
795
796	i4=i2%8;
797	if(i4){
798	memset(buffer+i2,0,8-i4);
799	i2+=8-i4;
800	}
801
802	while(i2+8192>BufSize){
803	BufSize+=8192;
804	buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
805	}
806	}
807
808	//データエントリ
809	pImgDataEntry=(IMAGE_RESOURCE_DATA_ENTRY *)(buffer+dwDataEntrySchedule[IconGroupEntryBase+i3]);
810	pImgDataEntry->OffsetToData=i2;
811	pImgDataEntry->Size=sizeof(ICONDIR)+0xE*pIconDir->idCount;
812	AddRSrcAddrSchedule(dwDataEntrySchedule[IconGroupEntryBase+i3]);
813
814	//RT_GROUP_ICONヘッダデータ（ICONDIR）
815	memcpy(buffer+i2,temporary,sizeof(ICONDIR));
816	i2+=sizeof(ICONDIR);
817
818	for(i5=0;i5<pIconDir->idCount;i5++,i7++){
819	pIconDirEntry=(ICONDIRENTRY )(temporary+sizeof(ICONDIR)+sizeof(ICONDIRENTRY)i5);
820	IconDirEntry_Res.bWidth=pIconDirEntry->bWidth;
821	IconDirEntry_Res.bHeight=pIconDirEntry->bHeight;
822	IconDirEntry_Res.bColorCount=pIconDirEntry->bColorCount;
823	IconDirEntry_Res.bReserved=0;
824	IconDirEntry_Res.wPlanes=1;
825	if(pIconDirEntry->bColorCount==16)
826	IconDirEntry_Res.wBitCount=4;
827	else if(pIconDirEntry->bColorCount==0)
828	IconDirEntry_Res.wBitCount=8;
829	IconDirEntry_Res.dwBytesInRes=pIconDirEntry->dwBytesInRes;
830	IconDirEntry_Res.wIconNum=i7+1;
831
832	//RT_GROUP_ICONヘッダデータ（ICONDIRENTRY_RES）
833	memcpy(buffer+i2,&IconDirEntry_Res,0xE);
834	i2+=0xE;
835
836	while(i2+8192>BufSize){
837	BufSize+=8192;
838	buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
839	}
840	}
841	i4=i2%8;
842	if(i4){
843	memset(buffer+i2,0,8-i4);
844	i2+=8-i4;
845	}
846
847	HeapDefaultFree(temporary);
848	}
849
850	//XPManifestリソース
851	i3 = 0;
852	if( !compiler.resourceManager.manifestFilePath.empty() )
853	{
854	hFile=CreateFile(compiler.resourceManager.manifestFilePath.c_str(),GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
855	if(hFile==INVALID_HANDLE_VALUE){
856	compiler.errorMessenger.Output(59,compiler.resourceManager.manifestFilePath.c_str(),-1);
857	return buffer;
858	}
859	i4=GetFileSize(hFile,NULL);
860	temporary=(char *)HeapAlloc(hHeap,0,i4+1);
861	ReadFile(hFile,temporary,i4,(DWORD *)&i5,NULL);
862	temporary[i4]=0;
863	CloseHandle(hFile);
864
865	//プラットフォームをセット
866	#ifdef _AMD64_
867	temporary=PermutationString(temporary,"#PLATFORM#","amd64");
868	#else
869	temporary=PermutationString(temporary,"#PLATFORM#","x86");
870	#endif
871
872	//アプリケーション名をセット
873	char szAppliName[MAX_PATH];
874	char temp2[MAX_PATH];
875	_splitpath( program.GetOutputFilePath().c_str(),NULL,NULL,szAppliName,temp2);
876	lstrcat(szAppliName,temp2);
877	temporary=PermutationString(temporary,"#APPLI_FILE_NAME#",szAppliName);
878
879	i4=lstrlen(temporary)+1;
880
881	BufSize+=i4;
882	buffer=(char *)HeapReAlloc(hHeap,0,buffer,BufSize);
883
884	//データエントリ
885	pImgDataEntry=(IMAGE_RESOURCE_DATA_ENTRY *)(buffer+dwDataEntrySchedule[XPManiEntryBase+i3]);
886	pImgDataEntry->OffsetToData=i2;
887	pImgDataEntry->Size=i4-1; //※NULL文字はサイズに含めない
888	AddRSrcAddrSchedule(dwDataEntrySchedule[XPManiEntryBase+i3]);
889
890	//XMLデータ
891	memcpy(buffer+i2,temporary,i4);
892	i2+=i4;
893
894	HeapDefaultFree(temporary);
895	}
896
897	*pLen=i2;
898
899	return buffer;
900	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: