-Add a new module type 'cabinet' to handle .cab files generation
[reactos.git] / reactos / tools / rbuild / backend / mingw / modulehandler.h
1 /*
2 * Copyright (C) 2005 Casper S. Hornstrup
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18 #ifndef MINGW_MODULEHANDLER_H
19 #define MINGW_MODULEHANDLER_H
20
21 #include "../backend.h"
22 #include "mingw.h"
23
24 class MingwBackend;
25 class Rule;
26
27 extern std::string
28 GetTargetMacro ( const Module&, bool with_dollar = true );
29
30 extern std::string
31 PrefixFilename (
32 const std::string& filename,
33 const std::string& prefix );
34
35 class MingwModuleHandler
36 {
37 public:
38 MingwModuleHandler ( const Module& module_ );
39 virtual ~MingwModuleHandler();
40
41 static void SetBackend ( MingwBackend* backend_ );
42 static void SetMakefile ( FILE* f );
43 void EnablePreCompiledHeaderSupport ();
44
45 static const FileLocation* PassThruCacheDirectory (const FileLocation* fileLocation );
46
47 static const FileLocation* GetTargetFilename (
48 const Module& module,
49 string_list* pclean_files );
50
51 static const FileLocation* GetImportLibraryFilename (
52 const Module& module,
53 string_list* pclean_files );
54
55 static std::string GenerateGccDefineParametersFromVector ( const std::vector<Define*>& defines, std::set<std::string> &used_defs );
56 static std::string GenerateGccIncludeParametersFromVector ( const std::vector<Include*>& includes );
57
58 std::string GetModuleTargets ( const Module& module );
59 void GetObjectsVector ( const IfableData& data,
60 std::vector<FileLocation>& objectFiles ) const;
61 void GenerateSourceMacro();
62 void GenerateObjectMacro();
63 void GenerateTargetMacro();
64 void GenerateOtherMacros();
65
66 static MingwModuleHandler* InstanciateHandler ( const Module& module_,
67 MingwBackend* backend_ );
68 virtual HostType DefaultHost() = 0;
69 void GeneratePreconditionDependencies ();
70 virtual void Process () = 0;
71 virtual std::string TypeSpecificCFlags() { return ""; }
72 virtual std::string TypeSpecificNasmFlags() { return ""; }
73 virtual std::string TypeSpecificLinkerFlags() { return ""; }
74 void GenerateInvocations () const;
75 void GenerateCleanTarget () const;
76 void GenerateInstallTarget () const;
77 void GenerateDependsTarget () const;
78 static bool ReferenceObjects ( const Module& module );
79 virtual void AddImplicitLibraries ( Module& module ) { return; }
80
81 void OutputCopyCommand ( const FileLocation& source,
82 const FileLocation& destination );
83 protected:
84 virtual void GetModuleSpecificCompilationUnits ( std::vector<CompilationUnit*>& compilationUnits );
85 std::string GetWorkingDirectory () const;
86 std::string GetBasename ( const std::string& filename ) const;
87 const FileLocation* GetActualSourceFilename ( const FileLocation* file ) const;
88 std::string GetExtraDependencies ( const FileLocation *file ) const;
89 std::string GetCompilationUnitDependencies ( const CompilationUnit& compilationUnit ) const;
90 const FileLocation* GetModuleArchiveFilename () const;
91 bool IsGeneratedFile ( const File& file ) const;
92 std::string GetImportLibraryDependency ( const Module& importedModule );
93 void GetTargets ( const Module& dependencyModule,
94 string_list& targets );
95 void GetModuleDependencies ( string_list& dependencies );
96 std::string GetAllDependencies () const;
97 void GetSourceFilenames ( std::vector<FileLocation>& list,
98 bool includeGeneratedFiles ) const;
99 void GetSourceFilenamesWithoutGeneratedFiles ( std::vector<FileLocation>& list ) const;
100 const FileLocation* GetObjectFilename ( const FileLocation* sourceFile,
101 const Module& module ) const;
102
103 std::string GetObjectFilenames ();
104
105 std::string GetPreconditionDependenciesName () const;
106 std::string GetCFlagsMacro () const;
107 static std::string GetObjectsMacro ( const Module& );
108 std::string GetLinkingDependenciesMacro () const;
109 std::string GetLibsMacro () const;
110 std::string GetLinkerMacro () const;
111 void GenerateCleanObjectsAsYouGoCode () const;
112 void GenerateRunRsymCode () const;
113 void GenerateRunStripCode () const;
114 void GenerateLinkerCommand ( const std::string& dependencies,
115 const std::string& linkerParameters,
116 const std::string& pefixupParameters );
117 void GeneratePhonyTarget() const;
118 void GenerateBuildMapCode ( const FileLocation *mapTarget = NULL );
119 void GenerateRules ();
120 void GenerateImportLibraryTargetIfNeeded ();
121 void GetDefinitionDependencies ( std::vector<FileLocation>& dependencies ) const;
122 std::string GetLinkingDependencies () const;
123 static MingwBackend* backend;
124 static FILE* fMakefile;
125 bool use_pch;
126 private:
127 std::string ConcatenatePaths ( const std::string& path1,
128 const std::string& path2 ) const;
129 std::string GenerateGccDefineParameters () const;
130 std::string GenerateCompilerParametersFromVector ( const std::vector<CompilerFlag*>& compilerFlags, const CompilerType type ) const;
131 std::string GenerateLinkerParametersFromVector ( const std::vector<LinkerFlag*>& linkerFlags ) const;
132 std::string GenerateImportLibraryDependenciesFromVector ( const std::vector<Library*>& libraries );
133 std::string GenerateLinkerParameters () const;
134 void GenerateMacro ( const char* assignmentOperation,
135 const std::string& macro,
136 const IfableData& data,
137 std::set<const Define *>* used_defs,
138 bool generatingCompilerMacro );
139 void GenerateMacros ( const char* op,
140 const IfableData& data,
141 const std::vector<LinkerFlag*>* linkerFlags,
142 std::set<const Define *>& used_defs );
143 void GenerateSourceMacros ( const char* assignmentOperation,
144 const IfableData& data );
145 void GenerateObjectMacros ( const char* assignmentOperation,
146 const IfableData& data );
147 std::string GenerateGccIncludeParameters () const;
148 std::string GenerateGccParameters () const;
149 std::string GenerateNasmParameters () const;
150 const FileLocation* GetPrecompiledHeaderFilename () const;
151 void GenerateGccCommand ( const FileLocation* sourceFile,
152 const Rule *rule,
153 const std::string& extraDependencies );
154 void GenerateCommands ( const CompilationUnit& compilationUnit,
155 const std::string& extraDependencies );
156 void GenerateObjectFileTargets ( const IfableData& data );
157 void GenerateObjectFileTargets ();
158 const FileLocation* GenerateArchiveTarget ();
159 void GetMcObjectDependencies ( std::vector<FileLocation>& dependencies,
160 const FileLocation *file ) const;
161 void GetSpecObjectDependencies ( std::vector<FileLocation>& dependencies,
162 const FileLocation *file ) const;
163 void GetWidlObjectDependencies ( std::vector<FileLocation>& dependencies,
164 const FileLocation *file ) const;
165 void GetDefaultDependencies ( string_list& dependencies ) const;
166 void GetInvocationDependencies ( const Module& module, string_list& dependencies );
167 bool IsWineModule () const;
168 const FileLocation* GetDefinitionFilename () const;
169 void GenerateBuildNonSymbolStrippedCode ();
170 void CleanupCompilationUnitVector ( std::vector<CompilationUnit*>& compilationUnits );
171 void GetRpcHeaderDependencies ( std::vector<FileLocation>& dependencies ) const;
172 void GetMcHeaderDependencies ( std::vector<FileLocation>& dependencies ) const;
173 static std::string GetPropertyValue ( const Module& module, const std::string& name );
174 const FileLocation* GetRpcServerHeaderFilename ( const FileLocation *base ) const;
175 const FileLocation* GetRpcClientHeaderFilename ( const FileLocation *base ) const;
176 const FileLocation* GetRpcProxyHeaderFilename ( const FileLocation *base ) const;
177 const FileLocation* GetIdlHeaderFilename ( const FileLocation *base ) const;
178 const FileLocation* GetMcHeaderFilename ( const FileLocation *base ) const;
179 std::string GetModuleCleanTarget ( const Module& module ) const;
180 void GetReferencedObjectLibraryModuleCleanTargets ( std::vector<std::string>& moduleNames ) const;
181 public:
182 const Module& module;
183 string_list clean_files;
184 std::string cflagsMacro;
185 std::string nasmflagsMacro;
186 std::string windresflagsMacro;
187 std::string widlflagsMacro;
188 std::string linkerflagsMacro;
189 std::string sourcesMacro;
190 std::string objectsMacro;
191 std::string libsMacro;
192 std::string linkDepsMacro;
193 };
194
195
196 class MingwBuildToolModuleHandler : public MingwModuleHandler
197 {
198 public:
199 MingwBuildToolModuleHandler ( const Module& module );
200 virtual HostType DefaultHost() { return HostTrue; }
201 virtual void Process ();
202 private:
203 void GenerateBuildToolModuleTarget ();
204 };
205
206
207 class MingwKernelModuleHandler : public MingwModuleHandler
208 {
209 public:
210 MingwKernelModuleHandler ( const Module& module );
211 virtual HostType DefaultHost() { return HostFalse; }
212 virtual void Process ();
213 private:
214 void GenerateKernelModuleTarget ();
215 };
216
217
218 class MingwStaticLibraryModuleHandler : public MingwModuleHandler
219 {
220 public:
221 MingwStaticLibraryModuleHandler ( const Module& module );
222 virtual HostType DefaultHost() { return HostFalse; }
223 virtual void Process ();
224 private:
225 void GenerateStaticLibraryModuleTarget ();
226 };
227
228
229 class MingwHostStaticLibraryModuleHandler : public MingwModuleHandler
230 {
231 public:
232 MingwHostStaticLibraryModuleHandler ( const Module& module );
233 virtual HostType DefaultHost() { return HostTrue; }
234 virtual void Process ();
235 private:
236 void GenerateHostStaticLibraryModuleTarget ();
237 };
238
239
240 class MingwObjectLibraryModuleHandler : public MingwModuleHandler
241 {
242 public:
243 MingwObjectLibraryModuleHandler ( const Module& module );
244 virtual HostType DefaultHost() { return HostFalse; }
245 virtual void Process ();
246 private:
247 void GenerateObjectLibraryModuleTarget ();
248 };
249
250
251 class MingwKernelModeDLLModuleHandler : public MingwModuleHandler
252 {
253 public:
254 MingwKernelModeDLLModuleHandler ( const Module& module );
255 virtual HostType DefaultHost() { return HostFalse; }
256 virtual void Process ();
257 std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }
258 void AddImplicitLibraries ( Module& module );
259 private:
260 void GenerateKernelModeDLLModuleTarget ();
261 };
262
263
264 class MingwKernelModeDriverModuleHandler : public MingwModuleHandler
265 {
266 public:
267 MingwKernelModeDriverModuleHandler ( const Module& module );
268 virtual HostType DefaultHost() { return HostFalse; }
269 virtual void Process ();
270 std::string TypeSpecificCFlags() { return "-D__NTDRIVER__"; }
271 std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }
272 void AddImplicitLibraries ( Module& module );
273 private:
274 void GenerateKernelModeDriverModuleTarget ();
275 };
276
277
278 class MingwNativeDLLModuleHandler : public MingwModuleHandler
279 {
280 public:
281 MingwNativeDLLModuleHandler ( const Module& module );
282 virtual HostType DefaultHost() { return HostFalse; }
283 virtual void Process ();
284 std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }
285 void AddImplicitLibraries ( Module& module );
286 private:
287 void GenerateNativeDLLModuleTarget ();
288 };
289
290
291 class MingwNativeCUIModuleHandler : public MingwModuleHandler
292 {
293 public:
294 MingwNativeCUIModuleHandler ( const Module& module );
295 virtual HostType DefaultHost() { return HostFalse; }
296 virtual void Process ();
297 std::string TypeSpecificCFlags() { return "-D__NTAPP__"; }
298 std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }
299 void AddImplicitLibraries ( Module& module );
300 private:
301 void GenerateNativeCUIModuleTarget ();
302 };
303
304
305 class MingwWin32DLLModuleHandler : public MingwModuleHandler
306 {
307 public:
308 MingwWin32DLLModuleHandler ( const Module& module );
309 virtual HostType DefaultHost() { return HostFalse; }
310 virtual void Process ();
311 std::string TypeSpecificLinkerFlags() { return module.cplusplus ? "-nostartfiles -lgcc" : "-nostartfiles -nostdlib -lgcc"; }
312 void AddImplicitLibraries ( Module& module );
313 private:
314 void GenerateWin32DLLModuleTarget ();
315 };
316
317
318 class MingwWin32OCXModuleHandler : public MingwModuleHandler
319 {
320 public:
321 MingwWin32OCXModuleHandler ( const Module& module );
322 virtual HostType DefaultHost() { return HostFalse; }
323 virtual void Process ();
324 std::string TypeSpecificLinkerFlags() { return module.cplusplus ? "-nostartfiles -lgcc" : "-nostartfiles -nostdlib -lgcc"; }
325 void AddImplicitLibraries ( Module& module );
326 private:
327 void GenerateWin32OCXModuleTarget ();
328 };
329
330
331 class MingwWin32CUIModuleHandler : public MingwModuleHandler
332 {
333 public:
334 MingwWin32CUIModuleHandler ( const Module& module );
335 virtual HostType DefaultHost() { return HostFalse; }
336 virtual void Process ();
337 std::string TypeSpecificLinkerFlags() { return module.cplusplus ? "-nostartfiles -lgcc" : "-nostartfiles -nostdlib -lgcc"; }
338 void AddImplicitLibraries ( Module& module );
339 private:
340 void GenerateWin32CUIModuleTarget ();
341 };
342
343
344 class MingwWin32GUIModuleHandler : public MingwModuleHandler
345 {
346 public:
347 MingwWin32GUIModuleHandler ( const Module& module );
348 virtual HostType DefaultHost() { return HostFalse; }
349 virtual void Process ();
350 std::string TypeSpecificLinkerFlags() { return module.cplusplus ? "-nostartfiles -lgcc" : "-nostartfiles -nostdlib -lgcc"; }
351 void AddImplicitLibraries ( Module& module );
352 private:
353 void GenerateWin32GUIModuleTarget ();
354 };
355
356
357 class MingwBootLoaderModuleHandler : public MingwModuleHandler
358 {
359 public:
360 MingwBootLoaderModuleHandler ( const Module& module );
361 virtual HostType DefaultHost() { return HostFalse; }
362 virtual void Process ();
363 std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }
364 private:
365 void GenerateBootLoaderModuleTarget ();
366 };
367
368
369 class MingwBootSectorModuleHandler : public MingwModuleHandler
370 {
371 public:
372 MingwBootSectorModuleHandler ( const Module& module );
373 virtual HostType DefaultHost() { return HostFalse; }
374 virtual void Process ();
375 std::string TypeSpecificNasmFlags() { return "-f bin"; }
376 private:
377 void GenerateBootSectorModuleTarget ();
378 };
379
380
381 class MingwBootProgramModuleHandler : public MingwModuleHandler
382 {
383 public:
384 MingwBootProgramModuleHandler ( const Module& module );
385 virtual HostType DefaultHost() { return HostFalse; }
386 virtual void Process ();
387 std::string GetProgTextAddrMacro ();
388 std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }
389 private:
390 void GenerateBootProgramModuleTarget ();
391 };
392
393
394 class MingwIsoModuleHandler : public MingwModuleHandler
395 {
396 public:
397 MingwIsoModuleHandler ( const Module& module );
398 virtual HostType DefaultHost() { return HostFalse; }
399 virtual void Process ();
400 private:
401 void GenerateIsoModuleTarget ();
402 void GetBootstrapCdDirectories ( std::vector<FileLocation>& out, const std::string& bootcdDirectory );
403 void GetNonModuleCdDirectories ( std::vector<FileLocation>& out, const std::string& bootcdDirectory );
404 void GetCdDirectories ( std::vector<FileLocation>& out, const std::string& bootcdDirectory );
405 void GetBootstrapCdFiles ( std::vector<FileLocation>& out ) const;
406 void GetNonModuleCdFiles ( std::vector<FileLocation>& out ) const;
407 void GetCdFiles ( std::vector<FileLocation>& out ) const;
408 void OutputBootstrapfileCopyCommands ( const std::string& bootcdDirectory );
409 void OutputCdfileCopyCommands ( const std::string& bootcdDirectory );
410 };
411
412
413 class MingwLiveIsoModuleHandler : public MingwModuleHandler
414 {
415 public:
416 MingwLiveIsoModuleHandler ( const Module& module );
417 virtual HostType DefaultHost() { return HostFalse; }
418 virtual void Process ();
419 private:
420 void GenerateLiveIsoModuleTarget ();
421 void CreateDirectory ( const std::string& directory );
422 void OutputModuleCopyCommands ( std::string& livecdDirectory,
423 std::string& livecdReactos );
424 void OutputNonModuleCopyCommands ( std::string& livecdDirectory,
425 std::string& livecdReactos );
426 void OutputProfilesDirectoryCommands ( std::string& livecdDirectory );
427 void OutputLoaderCommands ( std::string& livecdDirectory );
428 void OutputRegistryCommands ( std::string& livecdDirectory );
429 };
430
431
432 class MingwTestModuleHandler : public MingwModuleHandler
433 {
434 public:
435 MingwTestModuleHandler ( const Module& module );
436 virtual HostType DefaultHost() { return HostFalse; }
437 virtual void Process ();
438 std::string TypeSpecificLinkerFlags() { return "-nostartfiles -nostdlib"; }
439 protected:
440 virtual void GetModuleSpecificCompilationUnits ( std::vector<CompilationUnit*>& compilationUnits );
441 private:
442 void GenerateTestModuleTarget ();
443 };
444
445
446 class MingwRpcServerModuleHandler : public MingwModuleHandler
447 {
448 public:
449 MingwRpcServerModuleHandler ( const Module& module );
450 virtual HostType DefaultHost() { return HostFalse; }
451 virtual void Process ();
452 };
453
454
455 class MingwRpcClientModuleHandler : public MingwModuleHandler
456 {
457 public:
458 MingwRpcClientModuleHandler ( const Module& module );
459 virtual HostType DefaultHost() { return HostFalse; }
460 virtual void Process ();
461 };
462
463
464 class MingwRpcProxyModuleHandler : public MingwModuleHandler
465 {
466 public:
467 MingwRpcProxyModuleHandler ( const Module& module );
468 virtual HostType DefaultHost() { return HostFalse; }
469 virtual void Process ();
470 };
471
472
473 class MingwAliasModuleHandler : public MingwModuleHandler
474 {
475 public:
476 MingwAliasModuleHandler ( const Module& module );
477 virtual HostType DefaultHost() { return HostFalse; }
478 virtual void Process ();
479 };
480
481 class MingwIdlHeaderModuleHandler : public MingwModuleHandler
482 {
483 public:
484 MingwIdlHeaderModuleHandler ( const Module& module );
485 virtual HostType DefaultHost() { return HostFalse; }
486 virtual void Process ();
487 };
488
489 class MingwCabinetModuleHandler : public MingwModuleHandler
490 {
491 public:
492 MingwCabinetModuleHandler ( const Module& module );
493 virtual HostType DefaultHost() { return HostFalse; }
494 virtual void Process ();
495 };
496
497 class MingwEmbeddedTypeLibModuleHandler : public MingwModuleHandler
498 {
499 public:
500 MingwEmbeddedTypeLibModuleHandler ( const Module& module );
501 virtual HostType DefaultHost() { return HostFalse; }
502 virtual void Process ();
503 };
504
505 class MingwElfExecutableModuleHandler : public MingwModuleHandler
506 {
507 public:
508 MingwElfExecutableModuleHandler ( const Module& module );
509 virtual HostType DefaultHost() { return HostFalse; }
510 virtual void Process ();
511 };
512
513 #endif /* MINGW_MODULEHANDLER_H */