reactos/tools/rbuild/backend/mingw/mingw.cpp

   1 /*
   2  * Copyright (C) 2005 Casper S. Hornstrup
   3  *               2006 Christoph von Wittich
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 #include "../../pch.h"
  20
  21 #include "mingw.h"
  22 #include <assert.h>
  23 #include "modulehandler.h"
  24
  25 #ifdef _MSC_VER
  26 #define popen _popen
  27 #define pclose _pclose
  28 #endif//_MSC_VER
  29
  30 using std::string;
  31 using std::vector;
  32 using std::set;
  33 using std::map;
  34
  35 typedef set<string> set_string;
  36
  37 const struct ModuleHandlerInformations ModuleHandlerInformations[] = {
  38         { HostTrue, "", "", "" }, // BuildTool
  39         { HostFalse, "", "", "" }, // StaticLibrary
  40         { HostFalse, "", "", "" }, // ObjectLibrary
  41         { HostFalse, "", "", "" }, // Kernel
  42         { HostFalse, "", "", "" }, // KernelModeDLL
  43         { HostFalse, "-D__NTDRIVER__", "", "" }, // KernelModeDriver
  44         { HostFalse, "", "", "" }, // NativeDLL
  45         { HostFalse, "-D__NTAPP__", "", "" }, // NativeCUI
  46         { HostFalse, "", "", "" }, // Win32DLL
  47         { HostFalse, "", "", "" }, // Win32OCX
  48         { HostFalse, "", "", "" }, // Win32CUI
  49         { HostFalse, "", "", "" }, // Win32GUI
  50         { HostFalse, "", "", "-nostartfiles -nostdlib" }, // BootLoader
  51         { HostFalse, "", "-f bin", "" }, // BootSector
  52         { HostFalse, "", "", "" }, // Iso
  53         { HostFalse, "", "", "" }, // LiveIso
  54         { HostFalse, "", "", "" }, // Test
  55         { HostFalse, "", "", "" }, // RpcServer
  56         { HostFalse, "", "", "" }, // RpcClient
  57         { HostFalse, "", "", "" }, // Alias
  58         { HostFalse, "", "", "-nostartfiles -nostdlib" }, // BootProgram
  59         { HostFalse, "", "", "" }, // Win32SCR
  60         { HostFalse, "", "", "" }, // IdlHeader
  61         { HostFalse, "", "", "" }, // IdlInterface
  62         { HostFalse, "", "", "" }, // EmbeddedTypeLib
  63         { HostFalse, "", "", "" }, // ElfExecutable
  64         { HostFalse, "", "", "" }, // RpcProxy
  65         { HostTrue, "", "", "" }, // HostStaticLibrary
  66         { HostFalse, "", "", "" }, // Cabinet
  67         { HostFalse, "", "", "" }, // KeyboardLayout
  68         { HostFalse, "", "", "" }, // MessageHeader
  69 };
  70
  71 static std::string mscPath;
  72 static std::string mslinkPath;
  73
  74 string
  75 MingwBackend::GetFullPath ( const FileLocation& file ) const
  76 {
  77         MingwModuleHandler::PassThruCacheDirectory ( &file );
  78
  79         string directory;
  80         switch ( file.directory )
  81         {
  82                 case SourceDirectory:
  83                         directory = "";
  84                         break;
  85                 case IntermediateDirectory:
  86                         directory = "$(INTERMEDIATE)";
  87                         break;
  88                 case OutputDirectory:
  89                         directory = "$(OUTPUT)";
  90                         break;
  91                 case InstallDirectory:
  92                         directory = "$(INSTALL)";
  93                         break;
  94                 case TemporaryDirectory:
  95                         directory = "$(TEMPORARY)";
  96                         break;
  97                 default:
  98                         throw InvalidOperationException ( __FILE__,
  99                                                           __LINE__,
 100                                                           "Invalid directory %d.",
 101                                                           file.directory );
 102         }
 103
 104         if ( file.relative_path.length () > 0 )
 105         {
 106                 if ( directory.length () > 0 )
 107                         directory += sSep;
 108                 directory += file.relative_path;
 109         }
 110         return directory;
 111 }
 112
 113 string
 114 MingwBackend::GetFullName ( const FileLocation& file ) const
 115 {
 116         string directory;
 117         switch ( file.directory )
 118         {
 119                 case SourceDirectory:
 120                         directory = "";
 121                         break;
 122                 case IntermediateDirectory:
 123                         directory = "$(INTERMEDIATE)";
 124                         break;
 125                 case OutputDirectory:
 126                         directory = "$(OUTPUT)";
 127                         break;
 128                 case InstallDirectory:
 129                         directory = "$(INSTALL)";
 130                         break;
 131                 case TemporaryDirectory:
 132                         directory = "$(TEMPORARY)";
 133                         break;
 134                 default:
 135                         throw InvalidOperationException ( __FILE__,
 136                                                           __LINE__,
 137                                                           "Invalid directory %d.",
 138                                                           file.directory );
 139         }
 140
 141         if ( file.relative_path.length () > 0 )
 142         {
 143                 if ( directory.length () > 0 )
 144                         directory += sSep;
 145                 directory += file.relative_path;
 146         }
 147
 148         if ( directory.length () > 0 )
 149                 directory += sSep;
 150
 151         return directory + file.name;
 152 }
 153
 154 string
 155 v2s ( const Backend* backend, const vector<FileLocation>& files, int wrap_at )
 156 {
 157         if ( !files.size() )
 158                 return "";
 159         string s;
 160         int wrap_count = 0;
 161         for ( size_t i = 0; i < files.size(); i++ )
 162         {
 163                 const FileLocation& file = files[i];
 164                 if ( wrap_at > 0 && wrap_count++ == wrap_at )
 165                 {
 166                         s += " \\\n\t\t";
 167                         wrap_count = 1;
 168                 }
 169                 else if ( s.size() )
 170                         s += " ";
 171                 s += backend->GetFullName ( file );
 172         }
 173         return s;
 174 }
 175
 176
 177 string
 178 v2s ( const string_list& v, int wrap_at )
 179 {
 180         if ( !v.size() )
 181                 return "";
 182         string s;
 183         int wrap_count = 0;
 184         for ( size_t i = 0; i < v.size(); i++ )
 185         {
 186                 if ( !v[i].size() )
 187                         continue;
 188                 if ( wrap_at > 0 && wrap_count++ == wrap_at )
 189                 {
 190                         s += " \\\n\t\t";
 191                         wrap_count = 1;
 192                 }
 193                 else if ( s.size() )
 194                         s += " ";
 195                 s += v[i];
 196         }
 197         return s;
 198 }
 199
 200
 201 static class MingwFactory : public Backend::Factory
 202 {
 203 public:
 204         MingwFactory() : Factory ( "mingw", "Minimalist GNU Win32" ) {}
 205         Backend* operator() ( Project& project,
 206                               Configuration& configuration )
 207         {
 208                 return new MingwBackend ( project,
 209                                           configuration );
 210         }
 211 } factory;
 212
 213
 214 MingwBackend::MingwBackend ( Project& project,
 215                              Configuration& configuration )
 216         : Backend ( project, configuration ),
 217           manualBinutilsSetting( false ),
 218           intermediateDirectory ( new Directory ( "" ) ),
 219           outputDirectory ( new Directory ( "" ) ),
 220           installDirectory ( new Directory ( "" ) )
 221 {
 222         compilerPrefix = "";
 223 }
 224
 225 MingwBackend::~MingwBackend()
 226 {
 227         delete intermediateDirectory;
 228         delete outputDirectory;
 229         delete installDirectory;
 230 }
 231
 232 string
 233 MingwBackend::AddDirectoryTarget ( const string& directory,
 234                                    Directory* directoryTree )
 235 {
 236         if ( directory.length () > 0)
 237                 directoryTree->Add ( directory.c_str() );
 238         return directoryTree->name;
 239 }
 240
 241 bool
 242 MingwBackend::CanEnablePreCompiledHeaderSupportForModule ( const Module& module )
 243 {
 244         if ( !configuration.CompilationUnitsEnabled )
 245                 return true;
 246
 247         const vector<CompilationUnit*>& compilationUnits = module.non_if_data.compilationUnits;
 248         size_t i;
 249         for ( i = 0; i < compilationUnits.size (); i++ )
 250         {
 251                 CompilationUnit& compilationUnit = *compilationUnits[i];
 252                 if ( compilationUnit.GetFiles ().size () != 1 )
 253                         return false;
 254         }
 255         return true;
 256 }
 257
 258 void
 259 MingwBackend::ProcessModules ()
 260 {
 261         printf ( "Processing modules..." );
 262
 263         vector<MingwModuleHandler*> v;
 264         size_t i;
 265
 266         for ( std::map<std::string, Module*>::iterator p = ProjectNode.modules.begin (); p != ProjectNode.modules.end (); ++ p )
 267                 fprintf ( fMakefile, "%s_TYPE:=%u\n", p->second->name.c_str(), p->second->type );
 268
 269         for ( std::map<std::string, Module*>::iterator p = ProjectNode.modules.begin (); p != ProjectNode.modules.end (); ++ p )
 270         {
 271                 Module& module = *p->second;
 272                 if ( !module.enabled )
 273                         continue;
 274                 MingwModuleHandler* h = MingwModuleHandler::InstanciateHandler (
 275                         module,
 276                         this );
 277                 h->AddImplicitLibraries ( module );
 278                 if ( use_pch && CanEnablePreCompiledHeaderSupportForModule ( module ) )
 279                         h->EnablePreCompiledHeaderSupport ();
 280                 v.push_back ( h );
 281         }
 282
 283         size_t iend = v.size ();
 284
 285         for ( i = 0; i < iend; i++ )
 286                 v[i]->GenerateSourceMacro();
 287         for ( i = 0; i < iend; i++ )
 288                 v[i]->GenerateObjectMacro();
 289         fprintf ( fMakefile, "\n" );
 290         for ( i = 0; i < iend; i++ )
 291                 v[i]->GenerateTargetMacro();
 292         fprintf ( fMakefile, "\n" );
 293
 294         GenerateAllTarget ( v );
 295         GenerateRegTestsRunTarget ();
 296
 297         for ( i = 0; i < iend; i++ )
 298                 v[i]->GenerateOtherMacros();
 299
 300         for ( i = 0; i < iend; i++ )
 301         {
 302                 MingwModuleHandler& h = *v[i];
 303                 h.GeneratePreconditionDependencies ();
 304                 h.Process ();
 305                 h.GenerateInvocations ();
 306                 h.GenerateCleanTarget ();
 307                 h.GenerateInstallTarget ();
 308                 h.GenerateDependsTarget ();
 309                 delete v[i];
 310         }
 311
 312         printf ( "done\n" );
 313 }
 314
 315 void
 316 MingwBackend::Process ()
 317 {
 318         if ( configuration.CheckDependenciesForModuleOnly )
 319                 CheckAutomaticDependenciesForModuleOnly ();
 320         else
 321                 ProcessNormal ();
 322 }
 323
 324 void
 325 MingwBackend::CheckAutomaticDependenciesForModuleOnly ()
 326 {
 327         if ( configuration.Dependencies == AutomaticDependencies )
 328         {
 329                 Module* module = ProjectNode.LocateModule ( configuration.CheckDependenciesForModuleOnlyModule );
 330                 if ( module == NULL )
 331                 {
 332                         printf ( "Module '%s' does not exist\n",
 333                                 configuration.CheckDependenciesForModuleOnlyModule.c_str () );
 334                         return;
 335                 }
 336
 337                 printf ( "Checking automatic dependencies for module '%s'...",
 338                          module->name.c_str () );
 339                 AutomaticDependency automaticDependency ( ProjectNode );
 340                 automaticDependency.CheckAutomaticDependenciesForModule ( *module,
 341                                                                           configuration.Verbose );
 342                 printf ( "done\n" );
 343         }
 344 }
 345
 346 void
 347 MingwBackend::ProcessNormal ()
 348 {
 349         assert(sizeof(ModuleHandlerInformations)/sizeof(ModuleHandlerInformations[0]) == TypeDontCare);
 350
 351         DetectCompiler ();
 352         DetectBinutils ();
 353         DetectNetwideAssembler ();
 354         DetectPipeSupport ();
 355         DetectPCHSupport ();
 356         CreateMakefile ();
 357         GenerateHeader ();
 358         GenerateGlobalVariables ();
 359         GenerateXmlBuildFilesMacro ();
 360         ProcessModules ();
 361         GenerateInstallTarget ();
 362         GenerateTestTarget ();
 363         GenerateDirectoryTargets ();
 364         GenerateDirectories ();
 365         GenerateTestSupportCode ();
 366         GenerateCompilationUnitSupportCode ();
 367         GenerateSysSetup ();
 368         GenerateProxyMakefiles ();
 369         CheckAutomaticDependencies ();
 370         CloseMakefile ();
 371 }
 372
 373 void
 374 MingwBackend::CreateMakefile ()
 375 {
 376         fMakefile = fopen ( ProjectNode.makefile.c_str (), "w" );
 377         if ( !fMakefile )
 378                 throw AccessDeniedException ( ProjectNode.makefile );
 379         MingwModuleHandler::SetBackend ( this );
 380         MingwModuleHandler::SetMakefile ( fMakefile );
 381 }
 382
 383 void
 384 MingwBackend::CloseMakefile () const
 385 {
 386         if (fMakefile)
 387                 fclose ( fMakefile );
 388 }
 389
 390 void
 391 MingwBackend::GenerateHeader () const
 392 {
 393         fprintf ( fMakefile, "# THIS FILE IS AUTOMATICALLY GENERATED, EDIT '%s' INSTEAD\n\n",
 394                 ProjectNode.GetProjectFilename ().c_str () );
 395 }
 396
 397 void
 398 MingwBackend::GenerateGlobalProperties (
 399         const char* assignmentOperation,
 400         const IfableData& data ) const
 401 {
 402         for ( std::map<std::string, Property*>::const_iterator p = data.properties.begin(); p != data.properties.end(); ++ p )
 403         {
 404                 Property& prop = *p->second;
 405
 406                 if (!prop.isInternal)
 407                 {
 408                         fprintf ( fMakefile, "%s := %s\n",
 409                                 prop.name.c_str(),
 410                                 prop.value.c_str() );
 411                 }
 412         }
 413 }
 414
 415 string
 416 MingwBackend::GenerateProjectLFLAGS () const
 417 {
 418         string lflags;
 419         for ( size_t i = 0; i < ProjectNode.linkerFlags.size (); i++ )
 420         {
 421                 LinkerFlag& linkerFlag = *ProjectNode.linkerFlags[i];
 422                 if ( lflags.length () > 0 )
 423                         lflags += " ";
 424                 lflags += linkerFlag.flag;
 425         }
 426         return lflags;
 427 }
 428
 429 void
 430 MingwBackend::GenerateGlobalVariables () const
 431 {
 432         fputs ( "include tools$(SEP)rbuild$(SEP)backend$(SEP)mingw$(SEP)rules.mak\n", fMakefile );
 433         fprintf ( fMakefile, "include tools$(SEP)rbuild$(SEP)backend$(SEP)mingw$(SEP)linkers$(SEP)%s.mak\n", ProjectNode.GetLinkerSet ().c_str () );
 434         fprintf ( fMakefile, "include tools$(SEP)rbuild$(SEP)backend$(SEP)mingw$(SEP)compilers$(SEP)%s.mak\n", ProjectNode.GetCompilerSet ().c_str () );
 435
 436         if ( mscPath.length() )
 437                 fprintf ( fMakefile, "export RBUILD_CL_PATH=%s\n", mscPath.c_str () );
 438
 439         if ( mslinkPath.length() )
 440                 fprintf ( fMakefile, "export RBUILD_LINK_PATH=%s\n", mslinkPath.c_str () );
 441
 442         if ( configuration.Dependencies == FullDependencies )
 443         {
 444                 fprintf ( fMakefile,
 445                                   "ifeq ($(ROS_BUILDDEPS),)\n"
 446                                   "ROS_BUILDDEPS:=%s\n"
 447                                   "endif\n",
 448                                   "full" );
 449         }
 450
 451         fprintf ( fMakefile,
 452                   "PREFIX := %s\n",
 453                   compilerPrefix.c_str () );
 454         fprintf ( fMakefile,
 455                   "nasm := $(Q)%s\n",
 456                   nasmCommand.c_str () );
 457
 458         GenerateGlobalProperties ( "=", ProjectNode.non_if_data );
 459
 460         if ( ProjectNode.configuration.Compiler == GnuGcc )
 461         {
 462                 fprintf ( fMakefile, "ifneq ($(OARCH),)\n" );
 463                 fprintf ( fMakefile, "PROJECT_ASFLAGS += -march=$(OARCH)\n" );
 464                 fprintf ( fMakefile, "PROJECT_CFLAGS += -march=$(OARCH)\n" );
 465                 fprintf ( fMakefile, "PROJECT_CXXFLAGS += -march=$(OARCH)\n" );
 466                 fprintf ( fMakefile, "endif\n" );
 467                 fprintf ( fMakefile, "ifneq ($(TUNE),)\n" );
 468                 fprintf ( fMakefile, "PROJECT_CFLAGS += -mtune=$(TUNE)\n" );
 469                 fprintf ( fMakefile, "PROJECT_CXXFLAGS += -mtune=$(TUNE)\n" );
 470                 fprintf ( fMakefile, "endif\n" );
 471
 472                 if ( usePipe )
 473                 {
 474                         fprintf ( fMakefile, "PROJECT_CFLAGS += -pipe\n" );
 475                         fprintf ( fMakefile, "PROJECT_CXXFLAGS += -pipe\n" );
 476                         fprintf ( fMakefile, "PROJECT_ASFLAGS += -pipe\n" );
 477                 }
 478
 479                 // Would be nice to have our own C++ runtime
 480                 fputs ( "BUILTIN_CXXINCLUDES+= $(TARGET_CPPFLAGS)\n", fMakefile );
 481         }
 482
 483         // Because RosBE gcc is built to suck
 484         fputs ( "BUILTIN_HOST_CINCLUDES+= $(HOST_CFLAGS)\n", fMakefile );
 485         fputs ( "BUILTIN_HOST_CPPINCLUDES+= $(HOST_CFLAGS)\n", fMakefile );
 486         fputs ( "BUILTIN_HOST_CXXINCLUDES+= $(HOST_CPPFLAGS)\n", fMakefile );
 487
 488         MingwModuleHandler::GenerateParameters ( "PROJECT", "+=", ProjectNode.non_if_data );
 489         MingwModuleHandler::GenerateParameters ( "PROJECT_HOST", "+=", ProjectNode.host_non_if_data );
 490
 491         // TODO: linker flags
 492         fprintf ( fMakefile, "PROJECT_LFLAGS := '$(shell ${TARGET_CC} -print-libgcc-file-name)' %s\n", GenerateProjectLFLAGS ().c_str () );
 493         fprintf ( fMakefile, "PROJECT_LPPFLAGS := '$(shell ${TARGET_CPP} -print-file-name=libstdc++.a)' '$(shell ${TARGET_CPP} -print-file-name=libgcc.a)' '$(shell ${TARGET_CPP} -print-file-name=libmingw32.a)' '$(shell ${TARGET_CPP} -print-file-name=libmingwex.a)'\n" );
 494         /* hack to get libgcc_eh.a, should check mingw version or something */
 495         if (Environment::GetArch() == "amd64")
 496         {
 497             fprintf ( fMakefile, "PROJECT_LPPFLAGS += '$(shell ${TARGET_CPP} -print-file-name=libgcc_eh.a)'\n" );
 498         }
 499
 500         // TODO: use symbolic names for module types
 501         for ( size_t i = 0; i < sizeof(ModuleHandlerInformations) / sizeof(ModuleHandlerInformations[0]); ++ i )
 502         {
 503                 if ( ModuleHandlerInformations[i].cflags && ModuleHandlerInformations[i].cflags[0] )
 504                 {
 505                                 fprintf ( fMakefile,
 506                                                   "MODULETYPE%d_%sFLAGS:=%s\n",
 507                                                   (int)i,
 508                                                   "C",
 509                                                   ModuleHandlerInformations[i].cflags );
 510                 }
 511
 512                 if ( ModuleHandlerInformations[i].cflags && ModuleHandlerInformations[i].cflags[0] )
 513                 {
 514                                 fprintf ( fMakefile,
 515                                                   "MODULETYPE%d_%sFLAGS:=%s\n",
 516                                                   (int)i,
 517                                                   "CXX",
 518                                                   ModuleHandlerInformations[i].cflags );
 519                 }
 520
 521                 if ( ModuleHandlerInformations[i].nasmflags && ModuleHandlerInformations[i].nasmflags[0] )
 522                 {
 523                                 fprintf ( fMakefile,
 524                                                   "MODULETYPE%d_%sFLAGS:=%s\n",
 525                                                   (int)i,
 526                                                   "NASM",
 527                                                   ModuleHandlerInformations[i].nasmflags );
 528                 }
 529         }
 530
 531         fprintf ( fMakefile, "\n" );
 532 }
 533
 534 bool
 535 MingwBackend::IncludeInAllTarget ( const Module& module ) const
 536 {
 537         if ( MingwModuleHandler::ReferenceObjects ( module ) )
 538                 return false;
 539         if ( module.type == BootSector )
 540                 return false;
 541         if ( module.type == Iso )
 542                 return false;
 543         if ( module.type == LiveIso )
 544                 return false;
 545         if ( module.type == Test )
 546                 return false;
 547         if ( module.type == Alias )
 548                 return false;
 549         return true;
 550 }
 551
 552 void
 553 MingwBackend::GenerateAllTarget ( const vector<MingwModuleHandler*>& handlers ) const
 554 {
 555         fprintf ( fMakefile, "all:" );
 556         int wrap_count = 0;
 557         size_t iend = handlers.size ();
 558         for ( size_t i = 0; i < iend; i++ )
 559         {
 560                 const Module& module = handlers[i]->module;
 561                 if ( IncludeInAllTarget ( module ) )
 562                 {
 563                         if ( wrap_count++ == 5 )
 564                                 fprintf ( fMakefile, " \\\n\t\t" ), wrap_count = 0;
 565                         fprintf ( fMakefile,
 566                                   " %s",
 567                                   GetTargetMacro(module).c_str () );
 568                 }
 569         }
 570         fprintf ( fMakefile, "\n\t\n\n" );
 571 }
 572
 573 void
 574 MingwBackend::GenerateRegTestsRunTarget () const
 575 {
 576         fprintf ( fMakefile,
 577                   "REGTESTS_RUN_TARGET = regtests.dll\n" );
 578         fprintf ( fMakefile,
 579                   "$(REGTESTS_RUN_TARGET): $(REGTESTS_TARGET)\n" );
 580         fprintf ( fMakefile,
 581                   "\t$(cp) $(REGTESTS_TARGET) $(REGTESTS_RUN_TARGET)\n" );
 582         fprintf ( fMakefile, "\n" );
 583 }
 584
 585 void
 586 MingwBackend::GenerateXmlBuildFilesMacro() const
 587 {
 588         fprintf ( fMakefile,
 589                   "XMLBUILDFILES = %s \\\n",
 590                   ProjectNode.GetProjectFilename ().c_str () );
 591         string xmlbuildFilenames;
 592         int numberOfExistingFiles = 0;
 593         struct stat statbuf;
 594         time_t SystemTime, lastWriteTime;
 595
 596         for ( size_t i = 0; i < ProjectNode.xmlbuildfiles.size (); i++ )
 597         {
 598                 XMLInclude& xmlbuildfile = *ProjectNode.xmlbuildfiles[i];
 599                 if ( !xmlbuildfile.fileExists )
 600                         continue;
 601                 numberOfExistingFiles++;
 602                 if ( xmlbuildFilenames.length () > 0 )
 603                         xmlbuildFilenames += " ";
 604
 605                 FILE* f = fopen ( xmlbuildfile.topIncludeFilename.c_str (), "rb" );
 606                 if ( !f )
 607                 throw FileNotFoundException ( NormalizeFilename ( xmlbuildfile.topIncludeFilename ) );
 608
 609                 if ( fstat ( fileno ( f ), &statbuf ) != 0 )
 610                 {
 611                         fclose ( f );
 612                         throw AccessDeniedException ( NormalizeFilename ( xmlbuildfile.topIncludeFilename ) );
 613                 }
 614
 615                 lastWriteTime = statbuf.st_mtime;
 616                 SystemTime = time(NULL);
 617
 618                 if (SystemTime != -1)
 619                 {
 620                         if (difftime (lastWriteTime, SystemTime) > 0)
 621                                 throw InvalidDateException ( NormalizeFilename ( xmlbuildfile.topIncludeFilename ) );
 622                 }
 623
 624                 fclose ( f );
 625
 626                 xmlbuildFilenames += NormalizeFilename ( xmlbuildfile.topIncludeFilename );
 627                 if ( numberOfExistingFiles % 5 == 4 || i == ProjectNode.xmlbuildfiles.size () - 1 )
 628                 {
 629                         fprintf ( fMakefile,
 630                                   "\t%s",
 631                                   xmlbuildFilenames.c_str ());
 632                         if ( i == ProjectNode.xmlbuildfiles.size () - 1 )
 633                         {
 634                                 fprintf ( fMakefile, "\n" );
 635                         }
 636                         else
 637                         {
 638                                 fprintf ( fMakefile,
 639                                           " \\\n" );
 640                         }
 641                         xmlbuildFilenames.resize ( 0 );
 642                 }
 643                 numberOfExistingFiles++;
 644         }
 645         fprintf ( fMakefile, "\n" );
 646 }
 647
 648 void
 649 MingwBackend::GenerateTestSupportCode ()
 650 {
 651         printf ( "Generating test support code..." );
 652         TestSupportCode testSupportCode ( ProjectNode );
 653         testSupportCode.GenerateTestSupportCode ( configuration.Verbose );
 654         printf ( "done\n" );
 655 }
 656
 657 void
 658 MingwBackend::GenerateCompilationUnitSupportCode ()
 659 {
 660         if ( configuration.CompilationUnitsEnabled )
 661         {
 662                 printf ( "Generating compilation unit support code..." );
 663                 CompilationUnitSupportCode compilationUnitSupportCode ( ProjectNode );
 664                 compilationUnitSupportCode.Generate ( configuration.Verbose );
 665                 printf ( "done\n" );
 666         }
 667 }
 668
 669 void
 670 MingwBackend::GenerateSysSetup ()
 671 {
 672         printf ( "Generating syssetup.inf..." );
 673         SysSetupGenerator sysSetupGenerator ( ProjectNode );
 674         sysSetupGenerator.Generate ();
 675         printf ( "done\n" );
 676 }
 677
 678 string
 679 MingwBackend::GetProxyMakefileTree () const
 680 {
 681         if ( configuration.GenerateProxyMakefilesInSourceTree )
 682                 return "";
 683         else
 684                 return Environment::GetOutputPath ();
 685 }
 686
 687 void
 688 MingwBackend::GenerateProxyMakefiles ()
 689 {
 690         printf ( "Generating proxy makefiles..." );
 691         ProxyMakefile proxyMakefile ( ProjectNode );
 692         proxyMakefile.GenerateProxyMakefiles ( configuration.Verbose,
 693                                                GetProxyMakefileTree () );
 694         printf ( "done\n" );
 695 }
 696
 697 void
 698 MingwBackend::CheckAutomaticDependencies ()
 699 {
 700         if ( configuration.Dependencies == AutomaticDependencies )
 701         {
 702                 printf ( "Checking automatic dependencies..." );
 703                 AutomaticDependency automaticDependency ( ProjectNode );
 704                 automaticDependency.CheckAutomaticDependencies ( configuration.Verbose );
 705                 printf ( "done\n" );
 706         }
 707 }
 708
 709 void
 710 MingwBackend::GenerateDirectories ()
 711 {
 712         printf ( "Creating directories..." );
 713         intermediateDirectory->GenerateTree ( IntermediateDirectory, configuration.Verbose );
 714         outputDirectory->GenerateTree ( OutputDirectory, configuration.Verbose );
 715         if ( !configuration.MakeHandlesInstallDirectories )
 716                 installDirectory->GenerateTree ( InstallDirectory, configuration.Verbose );
 717         printf ( "done\n" );
 718 }
 719
 720 bool
 721 MingwBackend::TryToDetectThisCompiler ( const string& compiler )
 722 {
 723         string command = ssprintf (
 724                 "%s -v 1>%s 2>%s",
 725                 FixSeparatorForSystemCommand(compiler).c_str (),
 726                 NUL,
 727                 NUL );
 728         int exitcode = system ( command.c_str () );
 729         return (bool) (exitcode == 0);
 730 }
 731
 732 void
 733 MingwBackend::DetectCompiler ()
 734 {
 735         printf ( "Detecting compiler..." );
 736
 737         bool detectedCompiler = false;
 738         bool supportedCompiler = false;
 739         string compilerVersion;
 740
 741         if ( ProjectNode.configuration.Compiler == GnuGcc )
 742         {
 743                 const string& ROS_PREFIXValue = Environment::GetVariable ( "ROS_PREFIX" );
 744                 if ( ROS_PREFIXValue.length () > 0 )
 745                 {
 746                         compilerPrefix = ROS_PREFIXValue;
 747                         compilerCommand = compilerPrefix + "-gcc";
 748                         detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
 749                 }
 750 #if defined(WIN32)
 751                 if ( !detectedCompiler )
 752                 {
 753                         compilerPrefix = "";
 754                         compilerCommand = "gcc";
 755                         detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
 756                 }
 757 #endif
 758                 if ( !detectedCompiler )
 759                 {
 760                         compilerPrefix = "mingw32";
 761                         compilerCommand = compilerPrefix + "-gcc";
 762                         detectedCompiler = TryToDetectThisCompiler ( compilerCommand );
 763                 }
 764
 765                 if ( detectedCompiler )
 766                         compilerVersion = GetCompilerVersion ( compilerCommand );
 767
 768                 supportedCompiler = IsSupportedCompilerVersion ( compilerVersion );
 769         }
 770         else if ( ProjectNode.configuration.Compiler == MicrosoftC )
 771         {
 772                 compilerCommand = "cl";
 773                 detectedCompiler = DetectMicrosoftCompiler ( compilerVersion, mscPath );
 774                 supportedCompiler = true; // TODO
 775         }
 776
 777         if ( detectedCompiler )
 778         {
 779                 if ( supportedCompiler )
 780                         printf ( "detected (%s %s)\n", compilerCommand.c_str (), compilerVersion.c_str() );
 781                 else
 782                 {
 783                         printf ( "detected (%s), but with unsupported version (%s)\n",
 784                                  compilerCommand.c_str (),
 785                                  compilerVersion.c_str () );
 786                         throw UnsupportedBuildToolException ( compilerCommand, compilerVersion );
 787                 }
 788         }
 789         else
 790                 printf ( "not detected\n" );
 791
 792 }
 793
 794 bool
 795 MingwBackend::TryToDetectThisNetwideAssembler ( const string& assembler )
 796 {
 797         string command = ssprintf (
 798                 "%s -h 1>%s 2>%s",
 799                 FixSeparatorForSystemCommand(assembler).c_str (),
 800                 NUL,
 801                 NUL );
 802         int exitcode = system ( command.c_str () );
 803         return (bool) (exitcode == 0);
 804 }
 805
 806 string
 807 MingwBackend::GetVersionString ( const string& versionCommand )
 808 {
 809         FILE *fp;
 810         int ch, i;
 811         size_t newline;
 812         char buffer[81];
 813
 814         fp = popen ( versionCommand.c_str () , "r" );
 815         for( i = 0;
 816              ( i < 80 ) &&
 817                ( feof ( fp ) == 0 &&
 818                  ( ( ch = fgetc( fp ) ) != -1 ) );
 819              i++ )
 820         {
 821                 buffer[i] = (char) ch;
 822         }
 823         buffer[i] = '\0';
 824         pclose ( fp );
 825
 826         char separators[] = " ()";
 827         char *token;
 828         char *prevtoken = NULL;
 829
 830         string version;
 831
 832         token = strtok ( buffer, separators );
 833         while ( token != NULL )
 834         {
 835                 prevtoken = token;
 836                 version = string( prevtoken );
 837                 if ( (newline = version.find('\n')) != std::string::npos )
 838                         version.erase(newline, 1);
 839                 if ( version.find('.') != std::string::npos )
 840                         break;
 841                 token = strtok ( NULL, separators );
 842         }
 843         return version;
 844 }
 845
 846 string
 847 MingwBackend::GetNetwideAssemblerVersion ( const string& nasmCommand )
 848 {
 849         string versionCommand;
 850         if ( nasmCommand.find("yasm") != std::string::npos )
 851         {
 852                 versionCommand = ssprintf ( "%s --version",
 853                                             nasmCommand.c_str (),
 854                                             NUL,
 855                                             NUL );
 856         }
 857         else
 858         {
 859                 versionCommand = ssprintf ( "%s -v",
 860                                             nasmCommand.c_str (),
 861                                             NUL,
 862                                             NUL );
 863         }
 864         return GetVersionString( versionCommand );
 865 }
 866
 867 string
 868 MingwBackend::GetCompilerVersion ( const string& compilerCommand )
 869 {
 870         string versionCommand = ssprintf ( "%s --version gcc",
 871                                            compilerCommand.c_str (),
 872                                            NUL,
 873                                            NUL );
 874         return GetVersionString( versionCommand );
 875 }
 876
 877 string
 878 MingwBackend::GetBinutilsVersion ( const string& binutilsCommand )
 879 {
 880         string versionCommand = ssprintf ( "%s -v",
 881                                            binutilsCommand.c_str (),
 882                                            NUL,
 883                                            NUL );
 884         return GetVersionString( versionCommand );
 885 }
 886
 887 bool
 888 MingwBackend::IsSupportedCompilerVersion ( const string& compilerVersion )
 889 {
 890         if ( strcmp ( compilerVersion.c_str (), "3.4.2") < 0 )
 891                 return false;
 892         else
 893                 return true;
 894 }
 895
 896 bool
 897 MingwBackend::TryToDetectThisBinutils ( const string& binutils )
 898 {
 899         string command = ssprintf (
 900                 "%s -v 1>%s 2>%s",
 901                 FixSeparatorForSystemCommand(binutils).c_str (),
 902                 NUL,
 903                 NUL );
 904         int exitcode = system ( command.c_str () );
 905         return (exitcode == 0);
 906 }
 907
 908 string
 909 MingwBackend::GetBinutilsVersionDate ( const string& binutilsCommand )
 910 {
 911         FILE *fp;
 912         int ch, i;
 913         char buffer[81];
 914
 915         string versionCommand = ssprintf ( "%s -v",
 916                                            binutilsCommand.c_str (),
 917                                            NUL,
 918                                            NUL );
 919         fp = popen ( versionCommand.c_str () , "r" );
 920         for( i = 0;
 921              ( i < 80 ) &&
 922                  ( feof ( fp ) == 0 &&
 923                    ( ( ch = fgetc( fp ) ) != -1 ) );
 924              i++ )
 925         {
 926                 buffer[i] = (char) ch;
 927         }
 928         buffer[i] = '\0';
 929         pclose ( fp );
 930
 931         char separators[] = " ";
 932         char *token;
 933         char *prevtoken = NULL;
 934
 935         token = strtok ( buffer, separators );
 936         while ( token != NULL )
 937         {
 938                 prevtoken = token;
 939                 token = strtok ( NULL, separators );
 940         }
 941         string version = string ( prevtoken );
 942         int lastDigit = version.find_last_not_of ( "\t\r\n" );
 943         if ( lastDigit != -1 )
 944                 return string ( version, 0, lastDigit+1 );
 945         else
 946                 return version;
 947 }
 948
 949 bool
 950 MingwBackend::IsSupportedBinutilsVersion ( const string& binutilsVersion )
 951 {
 952         if ( manualBinutilsSetting ) return true;
 953
 954         /* linux */
 955         if ( binutilsVersion.find('.') != std::string::npos )
 956         {
 957                 /* TODO: blacklist versions on version number instead of date */
 958                 return true;
 959         }
 960
 961         /*
 962          * - Binutils older than 2003/10/01 have broken windres which can't handle
 963          *   icons with alpha channel.
 964          * - Binutils between 2004/09/02 and 2004/10/08 have broken handling of
 965          *   forward exports in dlltool.
 966          */
 967         if ( ( ( strcmp ( binutilsVersion.c_str (), "20040902") >= 0 ) &&
 968                ( strcmp ( binutilsVersion.c_str (), "20041008") <= 0 ) ) ||
 969                ( strcmp ( binutilsVersion.c_str (), "20031001") < 0 ) )
 970                 return false;
 971         else
 972                 return true;
 973 }
 974
 975 void
 976 MingwBackend::DetectBinutils ()
 977 {
 978         printf ( "Detecting binutils..." );
 979
 980         bool detectedBinutils = false;
 981         bool supportedBinutils = false;
 982         string binutilsVersion;
 983
 984         if ( ProjectNode.configuration.Linker == GnuLd )
 985         {
 986                 const string& ROS_PREFIXValue = Environment::GetVariable ( "ROS_PREFIX" );
 987
 988                 if ( ROS_PREFIXValue.length () > 0 )
 989                 {
 990                         binutilsPrefix = ROS_PREFIXValue;
 991                         binutilsCommand = binutilsPrefix + "-ld";
 992                         manualBinutilsSetting = true;
 993                         detectedBinutils = true;
 994                 }
 995 #if defined(WIN32)
 996                 if ( !detectedBinutils )
 997                 {
 998                         binutilsPrefix = "";
 999                         binutilsCommand = "ld";
1000                         detectedBinutils = TryToDetectThisBinutils ( binutilsCommand );
1001                 }
1002 #endif
1003                 if ( !detectedBinutils )
1004                 {
1005                         binutilsPrefix = "mingw32";
1006                         binutilsCommand = binutilsPrefix + "-ld";
1007                         detectedBinutils = TryToDetectThisBinutils ( binutilsCommand );
1008                 }
1009                 if ( detectedBinutils )
1010                 {
1011                         binutilsVersion = GetBinutilsVersionDate ( binutilsCommand );
1012                         supportedBinutils = IsSupportedBinutilsVersion ( binutilsVersion );
1013                 }
1014         }
1015         else if ( ProjectNode.configuration.Linker == MicrosoftLink )
1016         {
1017                 compilerCommand = "link";
1018                 detectedBinutils = DetectMicrosoftLinker ( binutilsVersion, mslinkPath );
1019                 supportedBinutils = true; // TODO
1020         }
1021
1022         if ( detectedBinutils )
1023         {
1024                 if ( supportedBinutils )
1025                         printf ( "detected (%s %s)\n", binutilsCommand.c_str (), binutilsVersion.c_str() );
1026                 else
1027                 {
1028                         printf ( "detected (%s), but with unsupported version (%s)\n",
1029                                  binutilsCommand.c_str (),
1030                                  binutilsVersion.c_str () );
1031                         throw UnsupportedBuildToolException ( binutilsCommand, binutilsVersion );
1032                 }
1033         }
1034         else
1035                 printf ( "not detected\n" );
1036
1037 }
1038
1039 void
1040 MingwBackend::DetectNetwideAssembler ()
1041 {
1042         printf ( "Detecting netwide assembler..." );
1043
1044         nasmCommand = "nasm";
1045         bool detectedNasm = TryToDetectThisNetwideAssembler ( nasmCommand );
1046 #if defined(WIN32)
1047         if ( !detectedNasm )
1048         {
1049                 nasmCommand = "nasmw";
1050                 detectedNasm = TryToDetectThisNetwideAssembler ( nasmCommand );
1051         }
1052 #endif
1053         if ( !detectedNasm )
1054         {
1055                 nasmCommand = "yasm";
1056                 detectedNasm = TryToDetectThisNetwideAssembler ( nasmCommand );
1057         }
1058         if ( detectedNasm )
1059                 printf ( "detected (%s %s)\n", nasmCommand.c_str (), GetNetwideAssemblerVersion( nasmCommand ).c_str() );
1060         else
1061                 printf ( "not detected\n" );
1062 }
1063
1064 void
1065 MingwBackend::DetectPipeSupport ()
1066 {
1067         if ( ProjectNode.configuration.Compiler == GnuGcc )
1068         {
1069                 printf ( "Detecting compiler -pipe support..." );
1070
1071                 string pipe_detection = "tools" + sSep + "rbuild" + sSep + "backend" + sSep + "mingw" + sSep + "pipe_detection.c";
1072                 string pipe_detectionObjectFilename = ReplaceExtension ( pipe_detection,
1073                                                                                                                                  ".o" );
1074                 string command = ssprintf (
1075                         "%s -pipe -c %s -o %s 1>%s 2>%s",
1076                         FixSeparatorForSystemCommand(compilerCommand).c_str (),
1077                         pipe_detection.c_str (),
1078                         pipe_detectionObjectFilename.c_str (),
1079                         NUL,
1080                         NUL );
1081                 int exitcode = system ( command.c_str () );
1082                 FILE* f = fopen ( pipe_detectionObjectFilename.c_str (), "rb" );
1083                 if ( f )
1084                 {
1085                         usePipe = (exitcode == 0);
1086                         fclose ( f );
1087                         unlink ( pipe_detectionObjectFilename.c_str () );
1088                 }
1089                 else
1090                         usePipe = false;
1091
1092                 if ( usePipe )
1093                         printf ( "detected\n" );
1094                 else
1095                         printf ( "not detected\n" );
1096         }
1097         else
1098                 usePipe = false;
1099 }
1100
1101 void
1102 MingwBackend::DetectPCHSupport ()
1103 {
1104         printf ( "Detecting compiler pre-compiled header support..." );
1105
1106         if ( configuration.PrecompiledHeadersEnabled && ProjectNode.configuration.Compiler == GnuGcc )
1107         {
1108                 string path = "tools" + sSep + "rbuild" + sSep + "backend" + sSep + "mingw" + sSep + "pch_detection.h";
1109                 string cmd = ssprintf (
1110                         "%s -c %s 1>%s 2>%s",
1111                         FixSeparatorForSystemCommand(compilerCommand).c_str (),
1112                         path.c_str (),
1113                         NUL,
1114                         NUL );
1115                 system ( cmd.c_str () );
1116                 path += ".gch";
1117
1118                 FILE* f = fopen ( path.c_str (), "rb" );
1119                 if ( f )
1120                 {
1121                         use_pch = true;
1122                         fclose ( f );
1123                         unlink ( path.c_str () );
1124                 }
1125                 else
1126                         use_pch = false;
1127
1128                 if ( use_pch )
1129                         printf ( "detected\n" );
1130                 else
1131                         printf ( "not detected\n" );
1132         }
1133         else
1134         {
1135                 use_pch = false;
1136                 printf ( "disabled\n" );
1137         }
1138 }
1139
1140 void
1141 MingwBackend::GetNonModuleInstallTargetFiles (
1142         vector<FileLocation>& out ) const
1143 {
1144         for ( size_t i = 0; i < ProjectNode.installfiles.size (); i++ )
1145         {
1146                 const InstallFile& installfile = *ProjectNode.installfiles[i];
1147                 out.push_back ( *installfile.target );
1148         }
1149 }
1150
1151 void
1152 MingwBackend::GetModuleInstallTargetFiles (
1153         vector<FileLocation>& out ) const
1154 {
1155         for ( std::map<std::string, Module*>::const_iterator p = ProjectNode.modules.begin (); p != ProjectNode.modules.end (); ++ p )
1156         {
1157                 const Module& module = *p->second;
1158                 if ( !module.enabled )
1159                         continue;
1160                 if ( module.install )
1161                         out.push_back ( *module.install );
1162         }
1163 }
1164
1165 void
1166 MingwBackend::GetInstallTargetFiles (
1167         vector<FileLocation>& out ) const
1168 {
1169         GetNonModuleInstallTargetFiles ( out );
1170         GetModuleInstallTargetFiles ( out );
1171 }
1172
1173 void
1174 MingwBackend::OutputInstallTarget ( const FileLocation& source,
1175                                     const FileLocation& target )
1176 {
1177         fprintf ( fMakefile,
1178                   "%s: %s | %s\n",
1179                   GetFullName ( target ).c_str (),
1180                   GetFullName ( source ).c_str (),
1181                   GetFullPath ( target ).c_str () );
1182         fprintf ( fMakefile,
1183                   "\t$(ECHO_CP)\n" );
1184         fprintf ( fMakefile,
1185                   "\t${cp} %s %s 1>$(NUL)\n",
1186                   GetFullName ( source ).c_str (),
1187                   GetFullName ( target ).c_str () );
1188 }
1189
1190 void
1191 MingwBackend::OutputNonModuleInstallTargets ()
1192 {
1193         for ( size_t i = 0; i < ProjectNode.installfiles.size (); i++ )
1194         {
1195                 const InstallFile& installfile = *ProjectNode.installfiles[i];
1196                 OutputInstallTarget ( *installfile.source, *installfile.target );
1197         }
1198 }
1199
1200 const Module&
1201 MingwBackend::GetAliasedModuleOrModule ( const Module& module ) const
1202 {
1203         if ( module.aliasedModuleName.size () > 0 )
1204         {
1205                 const Module* aliasedModule = ProjectNode.LocateModule ( module.aliasedModuleName );
1206                 assert ( aliasedModule );
1207                 return *aliasedModule;
1208         }
1209         else
1210                 return module;
1211 }
1212
1213 void
1214 MingwBackend::OutputModuleInstallTargets ()
1215 {
1216         for ( std::map<std::string, Module*>::const_iterator p = ProjectNode.modules.begin (); p != ProjectNode.modules.end (); ++ p )
1217         {
1218                 const Module& module = *p->second;
1219                 if ( !module.enabled )
1220                         continue;
1221                 if ( module.install )
1222                 {
1223                         const Module& aliasedModule = GetAliasedModuleOrModule ( module );
1224                         OutputInstallTarget ( *aliasedModule.output, *module.install );
1225                 }
1226         }
1227 }
1228
1229 string
1230 MingwBackend::GetRegistrySourceFiles ()
1231 {
1232         return "boot" + sSep + "bootdata" + sSep + "hivecls_" + Environment::GetArch() + ".inf "
1233                 "boot" + sSep + "bootdata" + sSep + "hivedef_" + Environment::GetArch() + ".inf "
1234                 "boot" + sSep + "bootdata" + sSep + "hiveinst_" + Environment::GetArch() + ".inf "
1235                 "boot" + sSep + "bootdata" + sSep + "hivesft_" + Environment::GetArch() + ".inf "
1236                 "boot" + sSep + "bootdata" + sSep + "hivesys_" + Environment::GetArch() + ".inf ";
1237 }
1238
1239 string
1240 MingwBackend::GetRegistryTargetFiles ()
1241 {
1242         string system32ConfigDirectory = "system32" + sSep + "config";
1243         FileLocation system32 ( InstallDirectory, system32ConfigDirectory, "" );
1244
1245         vector<FileLocation> registry_files;
1246         registry_files.push_back ( FileLocation ( InstallDirectory, system32ConfigDirectory, "default" ) );
1247         registry_files.push_back ( FileLocation ( InstallDirectory, system32ConfigDirectory, "sam" ) );
1248         registry_files.push_back ( FileLocation ( InstallDirectory, system32ConfigDirectory, "security" ) );
1249         registry_files.push_back ( FileLocation ( InstallDirectory, system32ConfigDirectory, "software" ) );
1250         registry_files.push_back ( FileLocation ( InstallDirectory, system32ConfigDirectory, "system" ) );
1251
1252         return v2s( this, registry_files, 6 );
1253 }
1254
1255 void
1256 MingwBackend::OutputRegistryInstallTarget ()
1257 {
1258         FileLocation system32 ( InstallDirectory, "system32" + sSep + "config", "" );
1259
1260         string registrySourceFiles = GetRegistrySourceFiles ();
1261         string registryTargetFiles = GetRegistryTargetFiles ();
1262         fprintf ( fMakefile,
1263                   "install_registry: %s\n",
1264                   registryTargetFiles.c_str () );
1265         fprintf ( fMakefile,
1266                   "%s: %s %s $(MKHIVE_TARGET)\n",
1267                   registryTargetFiles.c_str (),
1268                   registrySourceFiles.c_str (),
1269                   GetFullPath ( system32 ).c_str () );
1270         fprintf ( fMakefile,
1271                   "\t$(ECHO_MKHIVE)\n" );
1272         fprintf ( fMakefile,
1273                   "\t$(MKHIVE_TARGET) boot%cbootdata %s $(ARCH) boot%cbootdata%chiveinst_$(ARCH).inf\n",
1274                   cSep, GetFullPath ( system32 ).c_str (),
1275                   cSep, cSep );
1276         fprintf ( fMakefile,
1277                   "\n" );
1278 }
1279
1280 void
1281 MingwBackend::GenerateInstallTarget ()
1282 {
1283         vector<FileLocation> vInstallTargetFiles;
1284         GetInstallTargetFiles ( vInstallTargetFiles );
1285         string installTargetFiles = v2s ( this, vInstallTargetFiles, 5 );
1286         string registryTargetFiles = GetRegistryTargetFiles ();
1287
1288         fprintf ( fMakefile,
1289                   "install: %s %s\n",
1290                   installTargetFiles.c_str (),
1291                   registryTargetFiles.c_str () );
1292         OutputNonModuleInstallTargets ();
1293         OutputModuleInstallTargets ();
1294         OutputRegistryInstallTarget ();
1295         fprintf ( fMakefile,
1296                   "\n" );
1297 }
1298
1299 void
1300 MingwBackend::GetModuleTestTargets (
1301         vector<string>& out ) const
1302 {
1303         for ( std::map<std::string, Module*>::const_iterator p = ProjectNode.modules.begin (); p != ProjectNode.modules.end (); ++ p )
1304         {
1305                 const Module& module = *p->second;
1306                 if ( !module.enabled )
1307                         continue;
1308                 if ( module.type == Test )
1309                         out.push_back ( module.name );
1310         }
1311 }
1312
1313 void
1314 MingwBackend::GenerateTestTarget ()
1315 {
1316         vector<string> vTestTargets;
1317         GetModuleTestTargets ( vTestTargets );
1318         string testTargets = v2s ( vTestTargets, 5 );
1319
1320         fprintf ( fMakefile,
1321                   "test: %s\n",
1322                   testTargets.c_str () );
1323         fprintf ( fMakefile,
1324                   "\n" );
1325 }
1326
1327 void
1328 MingwBackend::GenerateDirectoryTargets ()
1329 {
1330         intermediateDirectory->CreateRule ( fMakefile, "$(INTERMEDIATE)" );
1331         outputDirectory->CreateRule ( fMakefile, "$(OUTPUT)" );
1332         installDirectory->CreateRule ( fMakefile, "$(INSTALL)" );
1333 }