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 */