08112e87c8d1d65366a0029b82034f3b0f751d72
[reactos.git] / reactos / tools / rbuild / rbuild.h
1 #ifndef __RBUILD_H
2 #define __RBUILD_H
3
4 #include "pch.h"
5
6 #ifdef WIN32
7 #include <direct.h>
8 #include <io.h>
9 #endif
10 #include <sys/stat.h>
11 #include <time.h>
12 #ifdef _MSC_VER
13 #include <sys/utime.h>
14 #else
15 #include <utime.h>
16 #include <process.h>
17 #endif
18
19 #include "ssprintf.h"
20 #include "exception.h"
21 #include "XML.h"
22
23 #ifdef WIN32
24 #define EXEPREFIX ""
25 #define EXEPOSTFIX ".exe"
26 #define CSEP '\\'
27 #define CBAD_SEP '/'
28 #define SSEP "\\"
29 #define SBAD_SEP "/"
30 #else
31 #define EXEPREFIX "./"
32 #define EXEPOSTFIX ""
33 #define CSEP '/'
34 #define CBAD_SEP '\\'
35 #define SSEP "/"
36 #define SBAD_SEP "\\"
37 #endif
38
39 class Project;
40 class IfableData;
41 class Module;
42 class Include;
43 class Define;
44 class File;
45 class Library;
46 class Invoke;
47 class InvokeFile;
48 class Dependency;
49 class ImportLibrary;
50 class If;
51 class CompilerFlag;
52 class LinkerFlag;
53 class Property;
54 class AutomaticDependency;
55 class Bootstrap;
56 class CDFile;
57 class PchFile;
58
59 class SourceFileTest;
60
61 class IfableData
62 {
63 public:
64 std::vector<File*> files;
65 std::vector<Include*> includes;
66 std::vector<Define*> defines;
67 std::vector<Library*> libraries;
68 std::vector<Property*> properties;
69 std::vector<If*> ifs;
70
71 ~IfableData();
72 void ProcessXML();
73 };
74
75 class Project
76 {
77 std::string xmlfile;
78 XMLElement *node, *head;
79 public:
80 std::string name;
81 std::string makefile;
82 XMLIncludes xmlbuildfiles;
83 std::vector<Module*> modules;
84 std::vector<LinkerFlag*> linkerFlags;
85 std::vector<CDFile*> cdfiles;
86 IfableData non_if_data;
87
88 Project ( const std::string& filename );
89 ~Project ();
90 void WriteConfigurationFile ();
91 void ExecuteInvocations ();
92 void ProcessXML ( const std::string& path );
93 Module* LocateModule ( const std::string& name );
94 const Module* LocateModule ( const std::string& name ) const;
95 std::string GetProjectFilename () const;
96 private:
97 const Property* LookupProperty ( const std::string& name ) const;
98 void SetConfigurationOption ( char* s,
99 std::string name,
100 std::string* alternativeName );
101 void SetConfigurationOption ( char* s,
102 std::string name );
103 void WriteIfChanged ( char* outbuf,
104 std::string filename );
105 void ReadXml ();
106 void ProcessXMLSubElement ( const XMLElement& e,
107 const std::string& path,
108 If* pIf = NULL );
109
110 // disable copy semantics
111 Project ( const Project& );
112 Project& operator = ( const Project& );
113 };
114
115
116 enum ModuleType
117 {
118 BuildTool,
119 StaticLibrary,
120 ObjectLibrary,
121 Kernel,
122 KernelModeDLL,
123 KernelModeDriver,
124 NativeDLL,
125 NativeCUI,
126 Win32DLL,
127 Win32CUI,
128 Win32GUI,
129 BootLoader,
130 BootSector,
131 Iso
132 };
133
134
135 class Module
136 {
137 public:
138 const Project& project;
139 const XMLElement& node;
140 std::string name;
141 std::string extension;
142 std::string entrypoint;
143 std::string baseaddress;
144 std::string path;
145 ModuleType type;
146 ImportLibrary* importLibrary;
147 bool mangledSymbols;
148 Bootstrap* bootstrap;
149 IfableData non_if_data;
150 std::vector<Invoke*> invocations;
151 std::vector<Dependency*> dependencies;
152 std::vector<CompilerFlag*> compilerFlags;
153 std::vector<LinkerFlag*> linkerFlags;
154 PchFile* pch;
155
156 Module ( const Project& project,
157 const XMLElement& moduleNode,
158 const std::string& modulePath );
159 ~Module ();
160 ModuleType GetModuleType ( const std::string& location,
161 const XMLAttribute& attribute );
162 bool HasImportLibrary () const;
163 std::string GetTargetName () const;
164 std::string GetDependencyPath () const;
165 std::string GetBasePath () const;
166 std::string GetPath () const;
167 std::string GetPathWithPrefix ( const std::string& prefix ) const;
168 std::string GetTargets () const;
169 std::string GetInvocationTarget ( const int index ) const;
170 bool HasFileWithExtension ( const IfableData&, const std::string& extension ) const;
171 void InvokeModule () const;
172 void ProcessXML ();
173 private:
174 std::string GetDefaultModuleExtension () const;
175 std::string GetDefaultModuleEntrypoint () const;
176 std::string GetDefaultModuleBaseaddress () const;
177 void ProcessXMLSubElement ( const XMLElement& e,
178 const std::string& path,
179 If* pIf = NULL );
180 };
181
182
183 class Include
184 {
185 public:
186 const Project& project;
187 const Module* module;
188 const XMLElement& node;
189 std::string directory;
190 std::string basePath;
191
192 Include ( const Project& project,
193 const XMLElement& includeNode );
194 Include ( const Project& project,
195 const Module* module,
196 const XMLElement& includeNode );
197 ~Include ();
198 void ProcessXML();
199 private:
200 void Initialize();
201 };
202
203
204 class Define
205 {
206 public:
207 const Project& project;
208 const Module* module;
209 const XMLElement& node;
210 std::string name;
211 std::string value;
212
213 Define ( const Project& project,
214 const XMLElement& defineNode );
215 Define ( const Project& project,
216 const Module* module,
217 const XMLElement& defineNode );
218 ~Define();
219 void ProcessXML();
220 private:
221 void Initialize();
222 };
223
224
225 class File
226 {
227 public:
228 std::string name;
229 bool first;
230
231 File ( const std::string& _name, bool _first );
232
233 void ProcessXML();
234 };
235
236
237 class Library
238 {
239 public:
240 const XMLElement& node;
241 const Module& module;
242 std::string name;
243 const Module* imported_module;
244
245 Library ( const XMLElement& _node,
246 const Module& _module,
247 const std::string& _name );
248
249 void ProcessXML();
250 };
251
252
253 class Invoke
254 {
255 public:
256 const XMLElement& node;
257 const Module& module;
258 const Module* invokeModule;
259 std::vector<InvokeFile*> input;
260 std::vector<InvokeFile*> output;
261
262 Invoke ( const XMLElement& _node,
263 const Module& _module );
264
265 void ProcessXML();
266 std::string GetTargets () const;
267 std::string GetParameters () const;
268 private:
269 void ProcessXMLSubElement ( const XMLElement& e );
270 void ProcessXMLSubElementInput ( const XMLElement& e );
271 void ProcessXMLSubElementOutput ( const XMLElement& e );
272 };
273
274
275 class InvokeFile
276 {
277 public:
278 const XMLElement& node;
279 std::string name;
280 std::string switches;
281
282 InvokeFile ( const XMLElement& _node,
283 const std::string& _name );
284
285 void ProcessXML ();
286 };
287
288
289 class Dependency
290 {
291 public:
292 const XMLElement& node;
293 const Module& module;
294 const Module* dependencyModule;
295
296 Dependency ( const XMLElement& _node,
297 const Module& _module );
298
299 void ProcessXML();
300 };
301
302
303 class ImportLibrary
304 {
305 public:
306 const XMLElement& node;
307 const Module& module;
308 std::string basename;
309 std::string definition;
310
311 ImportLibrary ( const XMLElement& _node,
312 const Module& module );
313
314 void ProcessXML ();
315 };
316
317
318 class If
319 {
320 public:
321 const XMLElement& node;
322 const Project& project;
323 const Module* module;
324 std::string property, value;
325 IfableData data;
326
327 If ( const XMLElement& node_,
328 const Project& project_,
329 const Module* module_ );
330 ~If();
331
332 void ProcessXML();
333 };
334
335
336 class CompilerFlag
337 {
338 public:
339 const Project& project;
340 const Module* module;
341 const XMLElement& node;
342 std::string flag;
343
344 CompilerFlag ( const Project& project,
345 const XMLElement& compilerFlagNode );
346 CompilerFlag ( const Project& project,
347 const Module* module,
348 const XMLElement& compilerFlagNode );
349 ~CompilerFlag ();
350 void ProcessXML();
351 private:
352 void Initialize();
353 };
354
355
356 class LinkerFlag
357 {
358 public:
359 const Project& project;
360 const Module* module;
361 const XMLElement& node;
362 std::string flag;
363
364 LinkerFlag ( const Project& project,
365 const XMLElement& linkerFlagNode );
366 LinkerFlag ( const Project& project,
367 const Module* module,
368 const XMLElement& linkerFlagNode );
369 ~LinkerFlag ();
370 void ProcessXML();
371 private:
372 void Initialize();
373 };
374
375
376 class Property
377 {
378 public:
379 const XMLElement& node;
380 const Project& project;
381 const Module* module;
382 std::string name, value;
383
384 Property ( const XMLElement& node_,
385 const Project& project_,
386 const Module* module_ );
387
388 void ProcessXML();
389 };
390
391
392 class SourceFile
393 {
394 public:
395 SourceFile ( AutomaticDependency* automaticDependency,
396 Module& module,
397 const std::string& filename,
398 SourceFile* parent,
399 bool isNonAutomaticDependency );
400 SourceFile* ParseFile ( const std::string& normalizedFilename );
401 void Parse ();
402 std::string Location () const;
403 std::vector<SourceFile*> files;
404 AutomaticDependency* automaticDependency;
405 Module& module;
406 std::string filename;
407 std::string filenamePart;
408 std::string directoryPart;
409 std::vector<SourceFile*> parents; /* List of files, this file is included from */
410 bool isNonAutomaticDependency;
411 std::string cachedDependencies;
412 time_t lastWriteTime;
413 time_t youngestLastWriteTime; /* Youngest last write time of this file and all children */
414 SourceFile* youngestFile;
415 private:
416 void GetDirectoryAndFilenameParts ();
417 void Close ();
418 void Open ();
419 void SkipWhitespace ();
420 bool ReadInclude ( std::string& filename,
421 bool& includeNext );
422 bool IsIncludedFrom ( const std::string& normalizedFilename );
423 SourceFile* GetParentSourceFile ();
424 bool CanProcessFile ( const std::string& extension );
425 bool IsParentOf ( const SourceFile* parent,
426 const SourceFile* child );
427 std::string buf;
428 const char *p;
429 const char *end;
430 };
431
432
433 class AutomaticDependency
434 {
435 friend class SourceFileTest;
436 public:
437 const Project& project;
438
439 AutomaticDependency ( const Project& project );
440 ~AutomaticDependency ();
441 void Process ();
442 std::string GetFilename ( const std::string& filename );
443 bool LocateIncludedFile ( const std::string& directory,
444 const std::string& includedFilename,
445 std::string& resolvedFilename );
446 bool LocateIncludedFile ( SourceFile* sourceFile,
447 Module& module,
448 const std::string& includedFilename,
449 bool includeNext,
450 std::string& resolvedFilename );
451 SourceFile* RetrieveFromCacheOrParse ( Module& module,
452 const std::string& filename,
453 SourceFile* parentSourceFile );
454 SourceFile* RetrieveFromCache ( const std::string& filename );
455 void CheckAutomaticDependencies ();
456 void CheckAutomaticDependenciesForFile ( SourceFile* sourceFile );
457 private:
458 void ProcessModule ( Module& module );
459 void ProcessFile ( Module& module,
460 const File& file );
461 std::map<std::string, SourceFile*> sourcefile_map;
462 };
463
464
465 class Bootstrap
466 {
467 public:
468 const Project& project;
469 const Module* module;
470 const XMLElement& node;
471 std::string base;
472 std::string nameoncd;
473
474 Bootstrap ( const Project& project,
475 const Module* module,
476 const XMLElement& bootstrapNode );
477 ~Bootstrap ();
478 void ProcessXML();
479 private:
480 bool IsSupportedModuleType ( ModuleType type );
481 void Initialize();
482 };
483
484
485 class CDFile
486 {
487 public:
488 const Project& project;
489 const XMLElement& node;
490 std::string name;
491 std::string base;
492 std::string nameoncd;
493 std::string path;
494
495 CDFile ( const Project& project,
496 const XMLElement& bootstrapNode,
497 const std::string& path );
498 ~CDFile ();
499 void ProcessXML();
500 std::string GetPath () const;
501 };
502
503
504 class PchFile
505 {
506 public:
507 const XMLElement& node;
508 const Module& module;
509 std::string header;
510
511 PchFile (
512 const XMLElement& node,
513 const Module& module,
514 const std::string& header );
515 void ProcessXML();
516 };
517
518
519 extern std::string
520 FixSeparator ( const std::string& s );
521
522 extern std::string
523 GetExtension ( const std::string& filename );
524
525 extern std::string
526 GetDirectory ( const std::string& filename );
527
528 extern std::string
529 NormalizeFilename ( const std::string& filename );
530
531 #endif /* __RBUILD_H */