80357cf516b73ed5c50ba8d737b3a796145cfb81
[reactos.git] / reactos / tools / rbuild / rbuild.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 __RBUILD_H
19 #define __RBUILD_H
20
21 #include "pch.h"
22
23 #ifdef WIN32
24 #include <direct.h>
25 #include <io.h>
26 #endif/*WIN32*/
27 #include <sys/stat.h>
28 #include <time.h>
29 #ifdef _MSC_VER
30 #include <sys/utime.h>
31 #else/*_MSC_VER*/
32 #include <utime.h>
33 #ifdef WIN32
34 #include <process.h>
35 #endif/*WIN32*/
36 #endif/*_MSC_VER*/
37
38 #include "ssprintf.h"
39 #include "exception.h"
40 #include "XML.h"
41
42 typedef std::vector<std::string> string_list;
43
44 extern std::string ExePrefix;
45 extern std::string ExePostfix;
46 extern std::string sSep;
47 extern std::string sBadSep;
48 extern char cSep;
49 extern char cBadSep;
50
51 #ifdef WIN32
52 #define DEF_EXEPREFIX ""
53 #define DEF_EXEPOSTFIX ".exe"
54 #define DEF_CSEP '\\'
55 #define DEF_CBAD_SEP '/'
56 #define DEF_SSEP "\\"
57 #define DEF_SBAD_SEP "/"
58 #else
59 #define DEF_EXEPREFIX "./"
60 #define DEF_EXEPOSTFIX ""
61 #define DEF_CSEP '/'
62 #define DEF_CBAD_SEP '\\'
63 #define DEF_SSEP "/"
64 #define DEF_SBAD_SEP "\\"
65 #endif
66
67 #define MS_VS_DEF_VERSION "7.10"
68
69 class Directory;
70 class Project;
71 class IfableData;
72 class Module;
73 class Include;
74 class Define;
75 class File;
76 class Library;
77 class Invoke;
78 class InvokeFile;
79 class Dependency;
80 class ImportLibrary;
81 class If;
82 class CompilerFlag;
83 class LinkerFlag;
84 class LinkerScript;
85 class Property;
86 class TestSupportCode;
87 class WineResource;
88 class AutomaticDependency;
89 class Bootstrap;
90 class CDFile;
91 class InstallFile;
92 class PchFile;
93 class StubbedComponent;
94 class StubbedSymbol;
95 class CompilationUnit;
96 class FileLocation;
97
98 class SourceFileTest;
99
100
101 typedef std::map<std::string,Directory*> directory_map;
102
103 class Directory
104 {
105 public:
106 std::string name;
107 directory_map subdirs;
108 Directory ( const std::string& name );
109 void Add ( const char* subdir );
110 void GenerateTree ( const std::string& parent,
111 bool verbose );
112 std::string EscapeSpaces ( std::string path );
113 void CreateRule ( FILE* f,
114 const std::string& parent );
115 private:
116 bool mkdir_p ( const char* path );
117 std::string ReplaceVariable ( std::string name,
118 std::string value,
119 std::string path );
120 std::string GetEnvironmentVariable ( const std::string& name );
121 void ResolveVariablesInPath ( char* buf,
122 std::string path );
123 bool CreateDirectory ( std::string path );
124 };
125
126
127 class Configuration
128 {
129 public:
130 Configuration ();
131 ~Configuration ();
132 bool Verbose;
133 bool CleanAsYouGo;
134 bool AutomaticDependencies;
135 bool CheckDependenciesForModuleOnly;
136 bool CompilationUnitsEnabled;
137 std::string CheckDependenciesForModuleOnlyModule;
138 std::string VSProjectVersion;
139 bool MakeHandlesInstallDirectories;
140 bool GenerateProxyMakefilesInSourceTree;
141 };
142
143 class Environment
144 {
145 public:
146 static std::string GetVariable ( const std::string& name );
147 static std::string GetIntermediatePath ();
148 static std::string GetOutputPath ();
149 static std::string GetInstallPath ();
150 static std::string GetEnvironmentVariablePathOrDefault ( const std::string& name,
151 const std::string& defaultValue );
152 };
153
154
155 class FileSupportCode
156 {
157 public:
158 static void WriteIfChanged ( char* outbuf,
159 std::string filename );
160 };
161
162
163 class ParseContext
164 {
165 public:
166 If* ifData;
167 CompilationUnit* compilationUnit;
168 ParseContext ();
169 };
170
171
172 class IfableData
173 {
174 public:
175 std::vector<CompilationUnit*> compilationUnits;
176 std::vector<File*> files;
177 std::vector<Include*> includes;
178 std::vector<Define*> defines;
179 std::vector<Library*> libraries;
180 std::vector<Property*> properties;
181 std::vector<CompilerFlag*> compilerFlags;
182 std::vector<If*> ifs;
183
184 ~IfableData();
185 void ProcessXML();
186 };
187
188 class Project
189 {
190 std::string xmlfile;
191 XMLElement *node, *head;
192 public:
193 const Configuration& configuration;
194 std::string name;
195 std::string makefile;
196 XMLIncludes xmlbuildfiles;
197 std::vector<Module*> modules;
198 std::vector<LinkerFlag*> linkerFlags;
199 std::vector<CDFile*> cdfiles;
200 std::vector<InstallFile*> installfiles;
201 IfableData non_if_data;
202
203 Project ( const Configuration& configuration,
204 const std::string& filename );
205 ~Project ();
206 void WriteConfigurationFile ();
207 void ExecuteInvocations ();
208 void ProcessXML ( const std::string& path );
209 Module* LocateModule ( const std::string& name );
210 const Module* LocateModule ( const std::string& name ) const;
211 std::string GetProjectFilename () const;
212 std::string ResolveProperties ( const std::string& s ) const;
213 private:
214 std::string ResolveNextProperty ( std::string& s ) const;
215 const Property* LookupProperty ( const std::string& name ) const;
216 void SetConfigurationOption ( char* s,
217 std::string name,
218 std::string* alternativeName );
219 void SetConfigurationOption ( char* s,
220 std::string name );
221 void ReadXml ();
222 void ProcessXMLSubElement ( const XMLElement& e,
223 const std::string& path,
224 ParseContext& parseContext );
225
226 // disable copy semantics
227 Project ( const Project& );
228 Project& operator = ( const Project& );
229 };
230
231
232 enum ModuleType
233 {
234 BuildTool = 0,
235 StaticLibrary = 1,
236 ObjectLibrary = 2,
237 Kernel = 3,
238 KernelModeDLL = 4,
239 KernelModeDriver = 5,
240 NativeDLL = 6,
241 NativeCUI = 7,
242 Win32DLL = 8,
243 Win32CUI = 9,
244 Win32GUI = 10,
245 BootLoader = 11,
246 BootSector = 12,
247 Iso = 13,
248 LiveIso = 14,
249 Test = 15,
250 RpcServer = 16,
251 RpcClient = 17,
252 Alias = 18
253 };
254
255 enum HostType
256 {
257 HostFalse,
258 HostDefault,
259 HostTrue
260 };
261
262 class Module
263 {
264 public:
265 const Project& project;
266 const XMLElement& node;
267 std::string xmlbuildFile;
268 std::string name;
269 std::string guid;
270 std::string extension;
271 std::string entrypoint;
272 std::string baseaddress;
273 std::string path;
274 ModuleType type;
275 ImportLibrary* importLibrary;
276 bool mangledSymbols;
277 bool isUnicode;
278 Bootstrap* bootstrap;
279 IfableData non_if_data;
280 std::vector<Invoke*> invocations;
281 std::vector<Dependency*> dependencies;
282 std::vector<CompilerFlag*> compilerFlags;
283 std::vector<LinkerFlag*> linkerFlags;
284 std::vector<StubbedComponent*> stubbedComponents;
285 LinkerScript* linkerScript;
286 PchFile* pch;
287 bool cplusplus;
288 std::string prefix;
289 HostType host;
290 std::string installBase;
291 std::string installName;
292 std::string aliasedModuleName;
293 bool useWRC;
294 bool allowWarnings;
295 bool enabled;
296
297 Module ( const Project& project,
298 const XMLElement& moduleNode,
299 const std::string& modulePath );
300 ~Module ();
301 ModuleType GetModuleType ( const std::string& location,
302 const XMLAttribute& attribute );
303 bool HasImportLibrary () const;
304 bool IsDLL () const;
305 bool GenerateInOutputTree () const;
306 std::string GetTargetName () const; // "foo.exe"
307 std::string GetDependencyPath () const; // "path/foo.exe" or "path/libfoo.a"
308 std::string GetBasePath () const; // "path"
309 std::string GetPath () const; // "path/foo.exe"
310 std::string GetPathWithPrefix ( const std::string& prefix ) const; // "path/prefixfoo.exe"
311 void GetTargets ( string_list& ) const;
312 std::string GetInvocationTarget ( const int index ) const;
313 bool HasFileWithExtension ( const IfableData&, const std::string& extension ) const;
314 void InvokeModule () const;
315 void ProcessXML ();
316 void GetSourceFilenames ( string_list& list,
317 bool includeGeneratedFiles ) const;
318 private:
319 std::string GetDefaultModuleExtension () const;
320 std::string GetDefaultModuleEntrypoint () const;
321 std::string GetDefaultModuleBaseaddress () const;
322 void ProcessXMLSubElement ( const XMLElement& e,
323 const std::string& path,
324 ParseContext& parseContext );
325 };
326
327
328 class Include
329 {
330 public:
331 const Project& project;
332 const Module* module;
333 const XMLElement* node;
334 const Module* baseModule;
335 std::string directory;
336 std::string basePath;
337
338 Include ( const Project& project,
339 const XMLElement* includeNode );
340 Include ( const Project& project,
341 const Module* module,
342 const XMLElement* includeNode );
343 Include ( const Project& project,
344 std::string directory,
345 std::string basePath );
346 ~Include ();
347 void ProcessXML();
348 private:
349 };
350
351
352 class Define
353 {
354 public:
355 const Project& project;
356 const Module* module;
357 const XMLElement& node;
358 std::string name;
359 std::string value;
360
361 Define ( const Project& project,
362 const XMLElement& defineNode );
363 Define ( const Project& project,
364 const Module* module,
365 const XMLElement& defineNode );
366 ~Define();
367 void ProcessXML();
368 private:
369 void Initialize();
370 };
371
372
373 class File
374 {
375 public:
376 std::string name;
377 bool first;
378 std::string switches;
379 bool isPreCompiledHeader;
380
381 File ( const std::string& _name,
382 bool _first,
383 std::string _switches,
384 bool _isPreCompiledHeader );
385
386 void ProcessXML();
387 };
388
389
390 class Library
391 {
392 public:
393 const XMLElement& node;
394 const Module& module;
395 std::string name;
396 const Module* importedModule;
397
398 Library ( const XMLElement& _node,
399 const Module& _module,
400 const std::string& _name );
401
402 void ProcessXML();
403 };
404
405
406 class Invoke
407 {
408 public:
409 const XMLElement& node;
410 const Module& module;
411 const Module* invokeModule;
412 std::vector<InvokeFile*> input;
413 std::vector<InvokeFile*> output;
414
415 Invoke ( const XMLElement& _node,
416 const Module& _module );
417
418 void ProcessXML();
419 void GetTargets ( string_list& targets ) const;
420 std::string GetParameters () const;
421 private:
422 void ProcessXMLSubElement ( const XMLElement& e );
423 void ProcessXMLSubElementInput ( const XMLElement& e );
424 void ProcessXMLSubElementOutput ( const XMLElement& e );
425 };
426
427
428 class InvokeFile
429 {
430 public:
431 const XMLElement& node;
432 std::string name;
433 std::string switches;
434
435 InvokeFile ( const XMLElement& _node,
436 const std::string& _name );
437
438 void ProcessXML ();
439 };
440
441
442 class Dependency
443 {
444 public:
445 const XMLElement& node;
446 const Module& module;
447 const Module* dependencyModule;
448
449 Dependency ( const XMLElement& _node,
450 const Module& _module );
451
452 void ProcessXML();
453 };
454
455
456 class ImportLibrary
457 {
458 public:
459 const XMLElement& node;
460 const Module& module;
461 std::string basename;
462 std::string definition;
463
464 ImportLibrary ( const XMLElement& _node,
465 const Module& module );
466
467 void ProcessXML ();
468 };
469
470
471 class If
472 {
473 public:
474 const XMLElement& node;
475 const Project& project;
476 const Module* module;
477 const bool negated;
478 std::string property, value;
479 IfableData data;
480
481 If ( const XMLElement& node_,
482 const Project& project_,
483 const Module* module_,
484 const bool negated_ = false );
485 ~If();
486
487 void ProcessXML();
488 };
489
490
491 class CompilerFlag
492 {
493 public:
494 const Project& project;
495 const Module* module;
496 const XMLElement& node;
497 std::string flag;
498
499 CompilerFlag ( const Project& project,
500 const XMLElement& compilerFlagNode );
501 CompilerFlag ( const Project& project,
502 const Module* module,
503 const XMLElement& compilerFlagNode );
504 ~CompilerFlag ();
505 void ProcessXML();
506 private:
507 void Initialize();
508 };
509
510
511 class LinkerFlag
512 {
513 public:
514 const Project& project;
515 const Module* module;
516 const XMLElement& node;
517 std::string flag;
518
519 LinkerFlag ( const Project& project,
520 const XMLElement& linkerFlagNode );
521 LinkerFlag ( const Project& project,
522 const Module* module,
523 const XMLElement& linkerFlagNode );
524 ~LinkerFlag ();
525 void ProcessXML();
526 private:
527 void Initialize();
528 };
529
530
531 class LinkerScript
532 {
533 public:
534 const Project& project;
535 const Module* module;
536 const XMLElement& node;
537 const Module* baseModule;
538 std::string directory;
539 std::string basePath;
540
541 LinkerScript ( const Project& project,
542 const Module* module,
543 const XMLElement& node );
544 ~LinkerScript ();
545 void ProcessXML();
546 };
547
548
549 class Property
550 {
551 public:
552 const XMLElement& node;
553 const Project& project;
554 const Module* module;
555 std::string name, value;
556
557 Property ( const XMLElement& node_,
558 const Project& project_,
559 const Module* module_ );
560
561 void ProcessXML();
562 };
563
564
565 class TestSupportCode
566 {
567 public:
568 const Project& project;
569
570 TestSupportCode ( const Project& project );
571 ~TestSupportCode ();
572 void GenerateTestSupportCode ( bool verbose );
573 private:
574 bool IsTestModule ( const Module& module );
575 void GenerateTestSupportCodeForModule ( Module& module,
576 bool verbose );
577 std::string GetHooksFilename ( Module& module );
578 char* WriteStubbedSymbolToHooksFile ( char* buffer,
579 const StubbedComponent& component,
580 const StubbedSymbol& symbol );
581 char* WriteStubbedComponentToHooksFile ( char* buffer,
582 const StubbedComponent& component );
583 void WriteHooksFile ( Module& module );
584 std::string GetStubsFilename ( Module& module );
585 char* WriteStubbedSymbolToStubsFile ( char* buffer,
586 const StubbedComponent& component,
587 const StubbedSymbol& symbol,
588 int stubIndex );
589 char* WriteStubbedComponentToStubsFile ( char* buffer,
590 const StubbedComponent& component,
591 int* stubIndex );
592 void WriteStubsFile ( Module& module );
593 std::string GetStartupFilename ( Module& module );
594 bool IsUnknownCharacter ( char ch );
595 std::string GetTestDispatcherName ( std::string filename );
596 bool IsTestFile ( std::string& filename ) const;
597 void GetSourceFilenames ( string_list& list,
598 Module& module ) const;
599 char* WriteTestDispatcherPrototypesToStartupFile ( char* buffer,
600 Module& module );
601 char* WriteRegisterTestsFunctionToStartupFile ( char* buffer,
602 Module& module );
603 void WriteStartupFile ( Module& module );
604 };
605
606
607 class WineResource
608 {
609 public:
610 const Project& project;
611 std::string bin2res;
612
613 WineResource ( const Project& project,
614 std::string bin2res );
615 ~WineResource ();
616 void UnpackResources ( bool verbose );
617 private:
618 bool IsSpecFile ( const File& file );
619 bool IsWineModule ( const Module& module );
620 bool IsResourceFile ( const File& file );
621 std::string GetResourceFilename ( const Module& module );
622 void UnpackResourcesInModule ( Module& module,
623 bool verbose );
624 };
625
626
627 class SourceFile
628 {
629 public:
630 SourceFile ( AutomaticDependency* automaticDependency,
631 const Module& module,
632 const std::string& filename,
633 SourceFile* parent,
634 bool isNonAutomaticDependency );
635 SourceFile* ParseFile ( const std::string& normalizedFilename );
636 void Parse ();
637 std::string Location () const;
638 std::vector<SourceFile*> files;
639 AutomaticDependency* automaticDependency;
640 const Module& module;
641 std::string filename;
642 std::string filenamePart;
643 std::string directoryPart;
644 std::vector<SourceFile*> parents; /* List of files, this file is included from */
645 bool isNonAutomaticDependency;
646 std::string cachedDependencies;
647 time_t lastWriteTime;
648 time_t youngestLastWriteTime; /* Youngest last write time of this file and all children */
649 SourceFile* youngestFile;
650 private:
651 void GetDirectoryAndFilenameParts ();
652 void Close ();
653 void Open ();
654 void SkipWhitespace ();
655 bool ReadInclude ( std::string& filename,
656 bool& searchCurrentDirectory,
657 bool& includeNext );
658 bool IsIncludedFrom ( const std::string& normalizedFilename );
659 SourceFile* GetParentSourceFile ();
660 bool CanProcessFile ( const std::string& extension );
661 bool IsParentOf ( const SourceFile* parent,
662 const SourceFile* child );
663 std::string buf;
664 const char *p;
665 const char *end;
666 };
667
668
669 class AutomaticDependency
670 {
671 friend class SourceFileTest;
672 public:
673 const Project& project;
674
675 AutomaticDependency ( const Project& project );
676 ~AutomaticDependency ();
677 std::string GetFilename ( const std::string& filename );
678 bool LocateIncludedFile ( const std::string& directory,
679 const std::string& includedFilename,
680 std::string& resolvedFilename );
681 bool LocateIncludedFile ( SourceFile* sourceFile,
682 const Module& module,
683 const std::string& includedFilename,
684 bool searchCurrentDirectory,
685 bool includeNext,
686 std::string& resolvedFilename );
687 SourceFile* RetrieveFromCacheOrParse ( const Module& module,
688 const std::string& filename,
689 SourceFile* parentSourceFile );
690 SourceFile* RetrieveFromCache ( const std::string& filename );
691 void CheckAutomaticDependencies ( bool verbose );
692 void CheckAutomaticDependenciesForModule ( Module& module,
693 bool verbose );
694 private:
695 void GetModulesToCheck ( Module& module, std::vector<const Module*>& modules );
696 void CheckAutomaticDependencies ( const Module& module,
697 bool verbose );
698 void CheckAutomaticDependenciesForFile ( SourceFile* sourceFile );
699 void GetIncludeDirectories ( std::vector<Include*>& includes,
700 const Module& module,
701 Include& currentDirectory,
702 bool searchCurrentDirectory );
703 void GetModuleFiles ( const Module& module,
704 std::vector<File*>& files ) const;
705 void ParseFiles ();
706 void ParseFiles ( const Module& module );
707 void ParseFile ( const Module& module,
708 const File& file );
709 std::map<std::string, SourceFile*> sourcefile_map;
710 };
711
712
713 class Bootstrap
714 {
715 public:
716 const Project& project;
717 const Module* module;
718 const XMLElement& node;
719 std::string base;
720 std::string nameoncd;
721
722 Bootstrap ( const Project& project,
723 const Module* module,
724 const XMLElement& bootstrapNode );
725 ~Bootstrap ();
726 void ProcessXML();
727 private:
728 bool IsSupportedModuleType ( ModuleType type );
729 void Initialize();
730 };
731
732
733 class CDFile
734 {
735 public:
736 const Project& project;
737 const XMLElement& node;
738 std::string name;
739 std::string base;
740 std::string nameoncd;
741 std::string path;
742
743 CDFile ( const Project& project,
744 const XMLElement& bootstrapNode,
745 const std::string& path );
746 ~CDFile ();
747 void ProcessXML();
748 std::string GetPath () const;
749 };
750
751
752 class InstallFile
753 {
754 public:
755 const Project& project;
756 const XMLElement& node;
757 std::string name;
758 std::string base;
759 std::string newname;
760 std::string path;
761
762 InstallFile ( const Project& project,
763 const XMLElement& bootstrapNode,
764 const std::string& path );
765 ~InstallFile ();
766 void ProcessXML ();
767 std::string GetPath () const;
768 };
769
770
771 class PchFile
772 {
773 public:
774 const XMLElement& node;
775 const Module& module;
776 File file;
777
778 PchFile (
779 const XMLElement& node,
780 const Module& module,
781 const File file );
782 void ProcessXML();
783 };
784
785
786 class StubbedComponent
787 {
788 public:
789 const Module* module;
790 const XMLElement& node;
791 std::string name;
792 std::vector<StubbedSymbol*> symbols;
793
794 StubbedComponent ( const Module* module_,
795 const XMLElement& stubbedComponentNode );
796 ~StubbedComponent ();
797 void ProcessXML ();
798 void ProcessXMLSubElement ( const XMLElement& e );
799 };
800
801
802 class StubbedSymbol
803 {
804 public:
805 const XMLElement& node;
806 std::string symbol;
807 std::string newname;
808 std::string strippedName;
809
810 StubbedSymbol ( const XMLElement& stubbedSymbolNode );
811 ~StubbedSymbol ();
812 void ProcessXML();
813 private:
814 std::string StripSymbol ( std::string symbol );
815 };
816
817
818 class CompilationUnit
819 {
820 public:
821 const Project* project;
822 const Module* module;
823 const XMLElement* node;
824 std::string name;
825 std::vector<File*> files;
826
827 CompilationUnit ( File* file );
828 CompilationUnit ( const Project* project,
829 const Module* module,
830 const XMLElement* node );
831 ~CompilationUnit ();
832 void ProcessXML();
833 bool IsGeneratedFile () const;
834 bool HasFileWithExtension ( const std::string& extension ) const;
835 bool IsFirstFile () const;
836 FileLocation* GetFilename ( Directory* intermediateDirectory ) const;
837 std::string GetSwitches () const;
838 };
839
840
841 class CompilationUnitSupportCode
842 {
843 public:
844 const Project& project;
845
846 CompilationUnitSupportCode ( const Project& project );
847 ~CompilationUnitSupportCode ();
848 void Generate ( bool verbose );
849 private:
850 void GenerateForModule ( Module& module,
851 bool verbose );
852 std::string GetCompilationUnitFilename ( Module& module,
853 CompilationUnit& compilationUnit );
854 void WriteCompilationUnitFile ( Module& module,
855 CompilationUnit& compilationUnit );
856 };
857
858
859 class FileLocation
860 {
861 public:
862 Directory* directory;
863 std::string filename;
864 FileLocation ( Directory* directory,
865 std::string filename );
866 };
867
868
869 extern void
870 InitializeEnvironment ();
871
872 extern std::string
873 Right ( const std::string& s, size_t n );
874
875 extern std::string
876 Replace ( const std::string& s, const std::string& find, const std::string& with );
877
878 extern std::string
879 ChangeSeparator ( const std::string& s,
880 const char fromSeparator,
881 const char toSeparator );
882
883 extern std::string
884 FixSeparator ( const std::string& s );
885
886 extern std::string
887 FixSeparatorForSystemCommand ( const std::string& s );
888
889 extern std::string
890 DosSeparator ( const std::string& s );
891
892 extern std::string
893 ReplaceExtension (
894 const std::string& filename,
895 const std::string& newExtension );
896
897 extern std::string
898 GetSubPath (
899 const std::string& location,
900 const std::string& path,
901 const std::string& att_value );
902
903 extern std::string
904 GetExtension ( const std::string& filename );
905
906 extern std::string
907 GetDirectory ( const std::string& filename );
908
909 extern std::string
910 GetFilename ( const std::string& filename );
911
912 extern std::string
913 NormalizeFilename ( const std::string& filename );
914
915 #endif /* __RBUILD_H */